diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 85c3d29..0feecdc 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -12,30 +12,57 @@ concurrency: cancel-in-progress: true jobs: + pyright: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: astral-sh/setup-uv@v5 + - run: uv run pyright --verbose + test: - name: Test ${{ matrix.os }} py${{ matrix.python-version }} java${{ matrix.java-version }} + name: ${{ matrix.os }} py${{ matrix.python-version }} j${{ matrix.java-version }} bf${{ matrix.bioformats-version }} runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: - python-version: ["3.10", "3.11", "3.12", "3.13"] os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ["3.10", "3.11", "3.12", "3.13"] java-version: ["11"] + bioformats-version: [""] include: + # older java - os: ubuntu-latest python-version: "3.9" java-version: "8" + - os: windows-latest + python-version: "3.10" + java-version: "8" + # older bio-formats version + - os: ubuntu-latest + python-version: "3.9" + java-version: "8" + bioformats-version: "6.0.1" + # newer java - os: ubuntu-latest python-version: "3.11" java-version: "21" + # no java at all! - os: windows-latest - python-version: "3.10" - java-version: "8" + python-version: "3.13" + java-version: "" + - os: macos-latest + python-version: "3.12" + java-version: "" + - os: ubuntu-latest + python-version: "3.11" + java-version: "" + env: UV_FROZEN: "1" steps: - uses: actions/checkout@v4 - uses: actions/setup-java@v4 + if: matrix.java-version != '' with: distribution: temurin java-version: ${{ matrix.java-version }} @@ -44,6 +71,9 @@ jobs: python-version: ${{ matrix.python-version }} - name: Test run: uv run --group test --no-dev pytest -v --color yes --cov --cov-report=xml + env: + BIOFORMATS_VERSION: ${{matrix.bioformats-version}} + - uses: codecov/codecov-action@v5 with: token: ${{ secrets.CODECOV_TOKEN }} diff --git a/.gitignore b/.gitignore index 2cb584a..a50b50e 100644 --- a/.gitignore +++ b/.gitignore @@ -110,4 +110,6 @@ ENV/ .vscode/ .idea/ tests/data/ -bioformats/ \ No newline at end of file +bioformats/ +stubs/ +uv.lock diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 4fc69a6..aaa7b3e 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -30,3 +30,5 @@ repos: # you have to add the things you want to type check against here additional_dependencies: - numpy + - git+https://github.com/tlambert03/scyjava-stubs#subdirectory=packages/ome-formats-gpl-stubs + - ome-types diff --git a/README.md b/README.md index 8a6cc67..9ca0230 100644 --- a/README.md +++ b/README.md @@ -2,11 +2,15 @@ [![License](https://img.shields.io/pypi/l/bffile.svg?color=green)](https://github.com/tlambert03/bffile/raw/main/LICENSE) [![PyPI](https://img.shields.io/pypi/v/bffile.svg?color=green)](https://pypi.org/project/bffile) -[![Python Version](https://img.shields.io/pypi/pyversions/bffile.svg?color=green)](https://python.org) +[![Python +Version](https://img.shields.io/pypi/pyversions/bffile.svg?color=green)](https://python.org) [![CI](https://github.com/tlambert03/bffile/actions/workflows/ci.yml/badge.svg)](https://github.com/tlambert03/bffile/actions/workflows/ci.yml) [![codecov](https://codecov.io/gh/tlambert03/bffile/branch/main/graph/badge.svg)](https://codecov.io/gh/tlambert03/bffile) -Yet another Bio-Formats wrapper for python +Yet another [Bio-Formats](https://github.com/ome/bioformats) wrapper for python + +Bio-Formats is a Java library for reading and writing data in life sciences +image file formats. This library provides a python interface to Bio-Formats. ## Installation @@ -14,11 +18,6 @@ Yet another Bio-Formats wrapper for python pip install git+https://github.com/tlambert03/bffile ``` -### Install Java ... - -This package requires that you have java installed. -[INSERT GUIDELINES HERE] - ## Usage ```python @@ -30,3 +29,54 @@ with BioFile("tests/data/ND2_dims_p4z5t3c2y32x32.nd2") as bf: data = bf.to_numpy(series=1) print(data.shape, data.dtype) ``` + +## Notes on Java, Maven, and Bio-Formats + +Because this library wraps the Java-based Bio-Formats library, it does require a +JVM at runtime. + +> [!TIP] +> Every attempt is made to make that as easy (and customizable) as possible. +> **no additional action should be required by the user to use this package**. +> +> `pip install bffile` should be sufficient. + +Here's how it works: + +1. If you have Java installed, it will be detected and used. This respects + standard environment variables like `JAVA_HOME` and `PATH`. +2. If you don't have Java installed, the library will download a + [JRE](https://en.wikipedia.org/wiki/Java_Runtime_Environment) using the + [cjdk](https://pypi.org/project/cjdk/) package, and use it. + - By default, it will use [zulu-jre](https://www.azul.com/downloads/) version + 11, but this can be customized by using the `JAVA_VENDOR` environment + variable to specify a different vendor, and/or the `JAVA_VERSION` + environment variable to specify a different version: + + ```sh + export JAVA_VENDOR=temurin + export JAVA_VERSION=17 + ``` + +3. [`jgo`](https://github.com/scijava/jgo) is used to fetch java dependencies at + runtime. This requires that `maven` is installed and on the `PATH`. If you + don't already have `maven` installed, `cjdk` will be used to download it as + well. + - If you would like to customize the version of `maven` that is fetched, you + may use the `MAVEN_URL` and `MAVEN_SHA` variables. for example: + + ```sh + export MAVEN_URL = "https://dlcdn.apache.org/maven/maven-3/3.9.9/binaries/apache-maven-3.9.9-bin.tar.gz" + export MAVEN_SHA = "a555254d6b53d267965a3404ecb14e53c3827c09c3b94b5678835887ab404556bfaf78dcfe03ba76fa2508649dca8531c74bca4d5846513522404d48e8c4ac8b" + ``` + +4. By default, the latest version of Bio-Formats (GPL) is fetched from maven + [maven](https://mvnrepository.com/artifact/ome/formats-gpl). This + can also be customized by using the `BIOFORMATS_VERSION` environment variable + to specify a different version or license. For example + + ```sh + export BIOFORMATS_VERSION="6.13.0" + # or + export BIOFORMATS_VERSION="ome:formats-bsd:8.1" + ``` diff --git a/justfile b/justfile new file mode 100644 index 0000000..d2f75c9 --- /dev/null +++ b/justfile @@ -0,0 +1,2 @@ +build-stubs: + uv run scripts/stubgen.py 'ome:formats-gpl:RELEASE' --prefix loci --prefix ome --prefix java.io diff --git a/pyproject.toml b/pyproject.toml index 4809c39..b259166 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,14 +13,13 @@ name = "bffile" dynamic = ["version"] description = "Yet another Bio-Formats wrapper for python" readme = "README.md" -requires-python = ">=3.9" +requires-python = ">=3.10" license = { text = "BSD-3-Clause" } authors = [{ name = "Talley Lambert", email = "talley.lambert@gmail.com" }] classifiers = [ "Development Status :: 3 - Alpha", "License :: OSI Approved :: BSD License", "Programming Language :: Python :: 3", - "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", @@ -29,10 +28,11 @@ classifiers = [ ] dependencies = [ "numpy>=2.0.2", - "ome-types>=0.6.1", + "ome-types[pint,lxml]>=0.6.1", "scyjava>=1.10.2", "dask[array]>=2024.8.0", "resource-backed-dask-array>=0.1.0", + "cjdk>=0.3.0", ] [project.urls] @@ -49,15 +49,16 @@ dev = [ "mypy>=1.15.0", "pdbpp>=0.11.6 ; sys_platform != 'win32'", "pre-commit>=4.2.0", - "pyright>=1.1.399", + "pyright>=1.1.408", "rich>=14.0.0", "ruff>=0.11.6", + "types-requests>=2.32.0.20250328", ] # https://docs.astral.sh/ruff [tool.ruff] line-length = 88 -target-version = "py39" +target-version = "py310" src = ["src"] # https://docs.astral.sh/ruff/rules @@ -91,6 +92,7 @@ skip-magic-trailing-comma = false # default is false # https://mypy.readthedocs.io/en/stable/config_file.html [tool.mypy] +mypy_path = "$MYPY_CONFIG_FILE_DIR/typings" files = "src/**/" strict = true disallow_any_generics = false @@ -98,11 +100,23 @@ disallow_subclassing_any = false show_error_codes = true pretty = true +[tool.pyright] +include = ["src", "tests"] +pythonVersion = "3.10" +enableExperimentalFeatures = true +verboseOutput = true +venv = ".venv" +reportMissingModuleSource = "none" + # https://docs.pytest.org/ [tool.pytest.ini_options] minversion = "7.0" testpaths = ["tests"] -filterwarnings = ["error"] +filterwarnings = [ + "error", + "ignore:Failing to pass a value to the 'type_params' parameter", + "ignore:Failed to retrieve OME XML:RuntimeWarning", +] # https://coverage.readthedocs.io/ [tool.coverage.report] @@ -125,3 +139,6 @@ ignore = [".pre-commit-config.yaml", ".ruff_cache/**/*", "tests/**/*"] [tool.typos.default] extend-ignore-identifiers-re = ["(?i)nd2?.*", "(?i)ome", "AIMD"] + +[tool.uv.sources] +ome-formats-gpl-stubs = { git = "https://github.com/tlambert03/scyjava-stubs", subdirectory = "packages/ome-formats-gpl-stubs" } diff --git a/scripts/stubgen.py b/scripts/stubgen.py new file mode 100644 index 0000000..f6f2972 --- /dev/null +++ b/scripts/stubgen.py @@ -0,0 +1,217 @@ +#!/usr/bin/env -S uv run +# /// script +# requires-python = "==3.13" +# dependencies = [ +# "cjdk", +# "scyjava", +# "stubgenj", +# "ruff", +# ] +# /// +"""Minimal scyjava stub generator script. + +Usage: + uv run stubgen.py org.apache.commons:commons-lang3:3.12.0 + uv run stubgen.py --prefix org.apache.commons org.apache.commons:commons-lang3:3.12.0 + uv run stubgen.py --output-dir ./my-stubs org.myproject:myproject:1.0.0 +""" + +from __future__ import annotations + +import argparse +import logging +import os +import shutil +import subprocess +from importlib import import_module +from itertools import chain +from pathlib import Path, PurePath +from typing import TYPE_CHECKING, Any +from unittest.mock import patch +from zipfile import ZipFile + +import cjdk +import scyjava +import scyjava.config +from stubgenj import generateJavaStubs + +if TYPE_CHECKING: + from collections.abc import Sequence + +logger = logging.getLogger("scyjava_stubs") + + +def generate_stubs( + endpoints: Sequence[str], + prefixes: Sequence[str] = (), + output_dir: str | Path = "./typings", + convert_strings: bool = False, + include_javadoc: bool = True, +) -> None: + """Generate stubs for the given maven endpoints. + + Parameters + ---------- + endpoints : Sequence[str] + The maven endpoints to generate stubs for. This should be a list of GAV + coordinates, e.g. ["org.apache.commons:commons-lang3:3.12.0"]. + prefixes : Sequence[str], optional + The prefixes to generate stubs for. This should be a list of Java class + prefixes that you expect to find in the endpoints. For example, + ["org.apache.commons"]. If not provided, the prefixes will be + automatically determined from the jar files provided by endpoints. + output_dir : str | Path, optional + The directory to write the generated stubs to. Defaults to "./typings". + convert_strings : bool, optional + Whether to cast Java strings to Python strings in the stubs. Defaults to True. + include_javadoc : bool, optional + Whether to include Javadoc in the generated stubs. Defaults to True. + """ + import jpype.imports + + startJVM = jpype.startJVM + + scyjava.config.endpoints.extend(endpoints) + + # Use scyjava's default Java setup via cjdk + with cjdk.java_env(): + + def _patched_start(*args: Any, **kwargs: Any) -> None: + kwargs.setdefault("convertStrings", convert_strings) + startJVM(*args, **kwargs) + + with patch.object(jpype, "startJVM", new=_patched_start): + scyjava.start_jvm() + + _prefixes = set(prefixes) + if not _prefixes: + cp = jpype.getClassPath(env=False) + ep_artifacts = tuple(ep.split(":")[1] for ep in endpoints) + for j in cp.split(os.pathsep): + if Path(j).name.startswith(ep_artifacts): + _prefixes.update(list_top_level_packages(j)) + + prefixes = sorted(_prefixes) + logger.info(f"Using endpoints: {scyjava.config.endpoints!r}") + logger.info(f"Generating stubs for: {prefixes}") + logger.info(f"Writing stubs to: {output_dir}") + + jmodules = [import_module(prefix) for prefix in prefixes] + generateJavaStubs( + jmodules, + useStubsSuffix=False, + outputDir=str(output_dir), + jpypeJPackageStubs=False, + includeJavadoc=include_javadoc, + ) + + output_dir = Path(output_dir) + ruff_check(output_dir.absolute()) + ruff_format(output_dir.absolute()) + + +def ruff_check(output: Path) -> None: + """Run ruff check and format on generated stub files.""" + py_files = [str(x) for x in chain(output.rglob("*.py"), output.rglob("*.pyi"))] + if shutil.which("ruff"): + logger.info( + "Running ruff check on %d generated stubs in %s", + len(py_files), + str(output), + ) + subprocess.run( + [ + "ruff", + "check", + *py_files, + "--target-version", + "py310", + "--quiet", + "--fix-only", + "--unsafe-fixes", + "--select=E,W,F,I,UP,RUF,TC,TID", + ], + check=False, + ) + logger.info("Running ruff format") + subprocess.run(["ruff", "format", *py_files, "--quiet"], check=False) + + +def ruff_format(output: Path) -> None: + """Run ruff format on generated stub files.""" + py_files = [str(x) for x in chain(output.rglob("*.py"), output.rglob("*.pyi"))] + if shutil.which("ruff"): + logger.info( + "Running ruff format on %d generated stubs in %s", + len(py_files), + str(output), + ) + subprocess.run(["ruff", "format", *py_files, "--quiet"], check=False) + + +def list_top_level_packages(jar_path: str) -> set[str]: + """Inspect a JAR file and return the set of top-level Java package names.""" + packages: set[str] = set() + with ZipFile(jar_path, "r") as jar: + # find all classes + class_dirs = { + entry.parent + for x in jar.namelist() + if (entry := PurePath(x)).suffix == ".class" + } + + roots: set[PurePath] = set() + for p in sorted(class_dirs, key=lambda p: len(p.parts)): + # If none of the already accepted roots is a parent of p, keep p + if not any(root in p.parents for root in roots): + roots.add(p) + packages.update({str(p).replace("/", ".") for p in roots}) + + return packages + + +def main() -> None: + """The main entry point for the stub generator script.""" + logging.basicConfig(level="INFO") + parser = argparse.ArgumentParser( + description="Generate Python Type Stubs for Java classes." + ) + parser.add_argument( + "endpoints", + type=str, + nargs="+", + help="Maven endpoints to install and use (e.g. org.myproject:myproject:1.0.0)", + ) + parser.add_argument( + "-p", + "--prefix", + type=str, + help="package prefixes to generate stubs for (e.g. org.myproject), " + "may be used multiple times. If not specified, prefixes are gleaned from the " + "downloaded artifacts.", + action="append", + default=[], + metavar="PREFIX", + dest="prefix", + ) + parser.add_argument( + "--output-dir", + type=str, + default="./typings", + help="Filesystem path to write stubs to. Defaults to './typings'.", + ) + + args = parser.parse_args() + output_dir = Path(args.output_dir) + if not output_dir.exists(): + output_dir.mkdir(parents=True, exist_ok=True) + + generate_stubs( + endpoints=args.endpoints, + prefixes=args.prefix, + output_dir=output_dir, + ) + + +if __name__ == "__main__": + main() diff --git a/src/bffile/_biofile.py b/src/bffile/_biofile.py index 05251fc..bada15d 100644 --- a/src/bffile/_biofile.py +++ b/src/bffile/_biofile.py @@ -1,21 +1,24 @@ from __future__ import annotations import os +import warnings from contextlib import suppress from pathlib import Path from threading import Lock -from typing import TYPE_CHECKING, Any, ClassVar +from typing import TYPE_CHECKING, Any, ClassVar, cast import dask.array as da import numpy as np from ome_types import OME -from scyjava import jimport from typing_extensions import Self +from bffile._core_metadata import CoreMetadata, OMEShape + from . import _utils -from ._java_stuff import hide_memoization_warning, pixtype2dtype, redirect_java_logging +from ._jimports import jimport if TYPE_CHECKING: + from loci.formats import IFormatReader from resource_backed_dask_array import ResourceBackedDaskArray @@ -82,84 +85,82 @@ def __init__( dask_tiles: bool = False, tile_size: tuple[int, int] | None = None, ): - redirect_java_logging() - ImageReader = jimport("loci.formats.ImageReader") - self._path = str(Path(path).expanduser().absolute()) - self._r = ImageReader() + self._current_scene_index = series + self._lock = Lock() + self.dask_tiles = dask_tiles + + self._java_reader = jimport("loci.formats.ImageReader")() if meta: - self._r.setMetadataStore(self._create_ome_meta()) + self._java_reader.setMetadataStore(self._create_ome_meta()) if original_meta: - self._r.setOriginalMetadataPopulated(True) + self._java_reader.setOriginalMetadataPopulated(True) # memoize to save time on later re-openings of the same file. if memoize > 0: Memoizer = jimport("loci.formats.Memoizer") - hide_memoization_warning() if BIOFORMATS_MEMO_DIR is not None: - self._r = Memoizer(self._r, memoize, BIOFORMATS_MEMO_DIR) + self._java_reader = Memoizer( + self._java_reader, memoize, BIOFORMATS_MEMO_DIR + ) else: - self._r = Memoizer(self._r, memoize) + self._java_reader = Memoizer(self._java_reader, memoize) if options: DynamicMetadataOptions = jimport("loci.formats.in_.DynamicMetadataOptions") mo = DynamicMetadataOptions() for name, value in options.items(): mo.set(name, str(value)) - self._r.setMetadataOptions(mo) + self._java_reader.setMetadataOptions(mo) - self._current_scene_index = series self.open() - self._lock = Lock() self.set_series(series) - self.dask_tiles = dask_tiles if self.dask_tiles: if tile_size is None: self.tile_size = ( - self._r.getOptimalTileHeight(), - self._r.getOptimalTileWidth(), + self._java_reader.getOptimalTileHeight(), + self._java_reader.getOptimalTileWidth(), ) else: - self.tile_size = tile_size + if len(tiles := tuple(tile_size)) != 2: + raise ValueError(f"tile_size must be length 2, got {len(tiles)}") + if not all(isinstance(x, int) for x in tiles): + raise ValueError(f"tile_size must be integers, got {tiles}") + self.tile_size = cast("tuple[int, int]", tiles) def set_series(self, series: int = 0) -> None: - self._r.setSeries(series) - self._core_meta = _utils.CoreMeta( - _utils.OMEShape( - self._r.getSizeT(), - self._r.getEffectiveSizeC(), - self._r.getSizeZ(), - self._r.getSizeY(), - self._r.getSizeX(), - self._r.getRGBChannelCount(), - ), - pixtype2dtype(self._r.getPixelType(), self._r.isLittleEndian()), - self._r.getSeriesCount(), - self._r.isRGB(), - self._r.isInterleaved(), - self._r.getDimensionOrder(), - self._r.getResolutionCount(), - ) + self._java_reader.setSeries(series) self._current_scene_index = series + def java_reader(self) -> IFormatReader: + """Return the native reader object.""" + return self._java_reader + @property - def core_meta(self) -> _utils.CoreMeta: - return self._core_meta + def core_meta(self) -> CoreMetadata: + return self._core_meta_list[self._current_scene_index] @property - def shape(self) -> _utils.OMEShape: - return self._core_meta.shape + def shape(self) -> OMEShape: + return self.core_meta.shape + + @property + def dtype(self) -> np.dtype: + return self.core_meta.dtype def open(self) -> None: """Open file.""" - self._r.setId(self._path) - self._r.setSeries(self._current_scene_index) + self._java_reader.setId(self._path) + self._java_reader.setSeries(self._current_scene_index) + self._core_meta_list = [ + CoreMetadata.from_java(x) for x in self._java_reader.getCoreMetadataList() + ] def close(self) -> None: """Close file.""" with suppress(Exception): - self._r.close() + self._java_reader.close() def to_numpy(self, series: int | None = None) -> np.ndarray: """Create numpy array for the specified or current series. @@ -195,7 +196,7 @@ def to_dask(self, series: int | None = None) -> ResourceBackedDaskArray: from resource_backed_dask_array import resource_backed_dask_array if series is not None: - self._r.setSeries(series) + self._java_reader.setSeries(series) nt, nc, nz, ny, nx, nrgb = self.core_meta.shape @@ -217,7 +218,7 @@ def to_dask(self, series: int | None = None) -> ResourceBackedDaskArray: @property def closed(self) -> bool: """Whether the underlying file is currently open.""" - return not bool(self._r.getCurrentFile()) + return not bool(self._java_reader.getCurrentFile()) @property def filename(self) -> str: @@ -228,14 +229,21 @@ def filename(self) -> str: @property def ome_xml(self) -> str: """Return OME XML string.""" - if store := self._r.getMetadataStore(): - return str(store.dumpXML()) + if store := self._java_reader.getMetadataStore(): + try: + return str(store.dumpXML()) # pyright: ignore + except Exception as e: + warnings.warn( + f"Failed to retrieve OME XML: {e}", RuntimeWarning, stacklevel=2 + ) return "" @property def ome_metadata(self) -> OME: """Return OME object parsed by ome_types.""" - xml = _utils.clean_ome_xml_for_known_issues(self.ome_xml) + if not (omx_xml := self.ome_xml): + return OME() + xml = _utils.clean_ome_xml_for_known_issues(omx_xml) return OME.from_xml(xml) def __enter__(self) -> Self: @@ -281,26 +289,26 @@ def _get_plane( if not was_open: self.open() - *_, ny, nx, nrgb = self.core_meta.shape + shape = self.core_meta.shape - y = y if y is not None else slice(0, ny) - x = x if x is not None else slice(0, nx) + y = y if y is not None else slice(0, shape.y) + x = x if x is not None else slice(0, shape.x) # get bytes from bioformats - idx = self._r.getIndex(z, c, t) - ystart, ywidth = _utils.slice2width(y, ny) - xstart, xwidth = _utils.slice2width(x, nx) + idx = self._java_reader.getIndex(z, c, t) + ystart, ywidth = _utils.slice2width(y, shape.y) + xstart, xwidth = _utils.slice2width(x, shape.x) # read bytes using bioformats - buffer = self._r.openBytes(idx, xstart, ystart, xwidth, ywidth) + buffer = self._java_reader.openBytes(idx, xstart, ystart, xwidth, ywidth) # convert buffer to numpy array im = np.frombuffer(bytes(buffer), self.core_meta.dtype) # reshape - if nrgb > 1: + if shape.rgb > 1: if self.core_meta.is_interleaved: - im.shape = (ywidth, xwidth, nrgb) + im.shape = (ywidth, xwidth, shape.rgb) else: - im.shape = (nrgb, ywidth, xwidth) + im.shape = (shape.rgb, ywidth, xwidth) im = np.transpose(im, (1, 2, 0)) else: im.shape = (ywidth, xwidth) @@ -349,4 +357,4 @@ def _create_ome_meta(cls) -> Any: def bioformats_version() -> str: """Get the version of Bio-Formats.""" Version = jimport("loci.formats.FormatTools") - return getattr(Version, "VERSION", "unknown") + return str(getattr(Version, "VERSION", "unknown")) diff --git a/src/bffile/_core_metadata.py b/src/bffile/_core_metadata.py new file mode 100644 index 0000000..f5b1465 --- /dev/null +++ b/src/bffile/_core_metadata.py @@ -0,0 +1,95 @@ +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import TYPE_CHECKING, Any, NamedTuple + +if TYPE_CHECKING: + import loci.formats + import numpy as np + from typing_extensions import Self + + +class OMEShape(NamedTuple): + """NamedTuple with OME metadata shape.""" + + t: int + c: int + z: int + y: int + x: int + rgb: int + + def __repr__(self) -> str: + return ( + f"(t={self.t}, c={self.c}, z={self.z}, " + f"y={self.y}, x={self.x}, rgb={self.rgb})" + ) + + +@dataclass +class CoreMetadata: + dtype: np.dtype + shape: OMEShape + rgb_count: int = 0 + thumb_size_x: int = 0 + thumb_size_y: int = 0 + bits_per_pixel: int = 0 + image_count: int = 0 + modulo_z: Any = None + modulo_c: Any = None + modulo_t: Any = None + dimension_order: str = "" + is_order_certain: bool = False + is_rgb: bool = False + is_little_endian: bool = False + is_interleaved: bool = False + is_indexed: bool = False + is_false_color: bool = True + is_metadata_complete: bool = False + is_thumbnail_series: bool = False + series_metadata: dict[str, Any] = field(default_factory=dict) + resolution_count: int = 1 + + @classmethod + def from_java(cls, meta: loci.formats.CoreMetadata) -> Self: + from ._jimports import pixtype2dtype + + if size_zt := meta.sizeZ * meta.sizeT: + eff_size_c = meta.imageCount // size_zt + else: + eff_size_c = 1 + + if eff_size_c == 0: + rgb_count = 1 + else: + rgb_count = meta.sizeC // eff_size_c + + return cls( + dtype=pixtype2dtype(meta.pixelType, meta.littleEndian), + shape=OMEShape( + x=meta.sizeX, + y=meta.sizeY, + z=meta.sizeZ, + c=eff_size_c, + t=meta.sizeT, + rgb=rgb_count, + ), + thumb_size_x=meta.thumbSizeX, + thumb_size_y=meta.thumbSizeY, + bits_per_pixel=meta.bitsPerPixel, + image_count=meta.imageCount, + modulo_z=meta.moduloZ, + modulo_c=meta.moduloC, + modulo_t=meta.moduloT, + dimension_order=str(meta.dimensionOrder), + is_order_certain=meta.orderCertain, + is_rgb=meta.rgb, + is_little_endian=meta.littleEndian, + is_interleaved=meta.interleaved, + is_indexed=meta.indexed, + is_false_color=meta.falseColor, + is_metadata_complete=meta.metadataComplete, + is_thumbnail_series=meta.thumbnail, + series_metadata=dict(meta.seriesMetadata), + resolution_count=meta.resolutionCount, + ) diff --git a/src/bffile/_java_stuff.py b/src/bffile/_java_stuff.py index 423e121..fff66b8 100644 --- a/src/bffile/_java_stuff.py +++ b/src/bffile/_java_stuff.py @@ -1,22 +1,30 @@ from __future__ import annotations +import contextlib import logging import os +import shutil +import subprocess import warnings -from contextlib import suppress from functools import cache -from typing import Any +from subprocess import CalledProcessError +from typing import TYPE_CHECKING, Any +from unittest.mock import patch import jpype -import numpy as np import scyjava import scyjava.config +if TYPE_CHECKING: + from collections.abc import Iterator + from pathlib import Path + + MAVEN_COORDINATE = "ome:formats-gpl:RELEASE" # Check if the BIOFORMATS_VERSION environment variable is set # and if so, use it as the Maven coordinate -if (coord := os.getenv("BIOFORMATS_VERSION", None)) is not None: +if coord := os.getenv("BIOFORMATS_VERSION", ""): # allow a single version number to be passed if ":" not in coord and all(x.isdigit() for x in coord.split(".")): # if the coordinate is just a version number, use the default group and artifact @@ -55,17 +63,9 @@ if not any(isinstance(h, logging.StreamHandler) for h in LOGGER.handlers): LOGGER.addHandler(handler) -_LOGGING_REDIRECTED = False - def redirect_java_logging(logger: logging.Logger | None = None) -> None: """Redirect Java logging to Python logger.""" - global _LOGGING_REDIRECTED - if _LOGGING_REDIRECTED: - return - - scyjava.start_jvm() # won't start if already running - _logger = logger or LOGGER class PyAppender: @@ -76,6 +76,9 @@ def doAppend(self, event: Any) -> None: # dispatch to Python logger getattr(logger, level.lower(), _logger.info)(msg) + def getName(self) -> str: + return "PyAppender" + # Create a proxy for the Appender interface proxy = jpype.JProxy("ch.qos.logback.core.Appender", inst=PyAppender()) @@ -84,31 +87,13 @@ def doAppend(self, event: Any) -> None: root = Slf4jFactory.getILoggerFactory().getLogger("ROOT") # remove the console appender - for appender in root.iteratorForAppenders(): - if appender.getName() == "console": - root.detachAppender(appender) - break - - # add the Python appender - root.addAppender(proxy) - _LOGGING_REDIRECTED = True - + with contextlib.suppress(AttributeError): + for appender in root.iteratorForAppenders(): + if appender.getName() in ("console", "PyAppender"): + root.detachAppender(appender) -def pixtype2dtype(pixeltype: int, little_endian: bool) -> np.dtype: - """Convert a loci.formats PixelType integer into a numpy dtype.""" - FormatTools = scyjava.jimport("loci.formats.FormatTools") - - fmt2type: dict[int, str] = { - FormatTools.INT8: "i1", - FormatTools.UINT8: "u1", - FormatTools.INT16: "i2", - FormatTools.UINT16: "u2", - FormatTools.INT32: "i4", - FormatTools.UINT32: "u4", - FormatTools.FLOAT: "f4", - FormatTools.DOUBLE: "f8", - } - return np.dtype(("<" if little_endian else ">") + fmt2type[pixeltype]) + # add the Python appender + root.addAppender(proxy) @cache @@ -118,8 +103,104 @@ def hide_memoization_warning() -> None: An illegal reflective access operation has occurred https://github.com/ome/bioformats/issues/3659 """ - with suppress(Exception): + with contextlib.suppress(Exception): import jpype System = jpype.JPackage("java").lang.System System.err.close() + + +@contextlib.contextmanager +def path_prepended(path: Path | str) -> Iterator[None]: + """ + Context manager to temporarily prepend the given path to PATH. + """ + save_path = os.environ.get("PATH", "") + os.environ["PATH"] = os.pathsep.join([str(path), save_path]) + try: + yield + finally: + os.environ["PATH"] = save_path + + +@cache +def start_jvm() -> None: + """Start the JVM if not already running.""" + with _setup_java(): + scyjava.start_jvm() # won't repeat if already running + redirect_java_logging() + hide_memoization_warning() + + +subprocess_check_output = subprocess.check_output + + +def _silent_check_output(*args: Any, **kwargs: Any) -> Any: + # also suppress stderr on calls to subprocess.check_output + kwargs.setdefault("stderr", subprocess.DEVNULL) + return subprocess_check_output(*args, **kwargs) + + +if MAVEN_URL := os.getenv("MAVEN_URL", ""): + MAVEN_SHA = os.getenv("MAVEN_SHA", "") + if MAVEN_URL.endswith("tar.gz") and MAVEN_URL.startswith("http"): + MAVEN_URL = MAVEN_URL.replace("http", "tgz+http") +else: + MAVEN_URL = "tgz+https://dlcdn.apache.org/maven/maven-3/3.9.9/binaries/apache-maven-3.9.9-bin.tar.gz" + MAVEN_SHA = "a555254d6b53d267965a3404ecb14e53c3827c09c3b94b5678835887ab404556bfaf78dcfe03ba76fa2508649dca8531c74bca4d5846513522404d48e8c4ac8b" # noqa: E501 + + +@contextlib.contextmanager +def _setup_java() -> Iterator[str]: + """Ensure we have a capable JVM and maven on the path.""" + try: + with patch.object(subprocess, "check_output", new=_silent_check_output): + jpype.getDefaultJVMPath() + java_ctx: contextlib.AbstractContextManager = contextlib.nullcontext() + # on Darwin, may raise a CalledProcessError on `/user/libexec/java_home` + except (jpype.JVMNotFoundException, CalledProcessError): + try: + import cjdk + except ImportError: + raise ImportError( + "No JVM found and cjdk is not installed (so we can't install one for " + "you).\n\nPlease either install java manually " + "(e.g. https://adoptium.net/installation/),\nor `pip install cjdk` to " + "allow us to install one automatically for you." + ) from None + + LOGGER.info("No JVM found, installing Zulu JRE 11 via cjdk...") + vendor = os.getenv("JAVA_VENDOR", "zulu-jre") + version = os.getenv("JAVA_VERSION", "11") + java_ctx = cjdk.java_env(vendor=vendor, version=version) + + with java_ctx: + if not shutil.which("mvn"): + try: + import cjdk + except ImportError: + raise ImportError( + "Maven not found on PATH and cjdk is not installed.\n\n" + "Maven is required to fetch the Bio-Formats JAR and other java " + "dependencies.\nPlease either install maven manually, or " + "`pip install cjdk` to allow us to install it for you." + ) from None + + # determine sha length based on MAVEN_SHA + kwargs = {} + if sha_len := len(MAVEN_SHA): + # assuming hex-encoded SHA, length should be 40, 64, or 128 + sha_lengths = {40: "sha1", 64: "sha256", 128: "sha512"} + if sha_len not in sha_lengths: + raise ValueError( + "MAVEN_SHA be a valid sha1, sha256, or sha512 hash." + f"Got invalid SHA length: {sha_len}. " + ) + kwargs = {sha_lengths[sha_len]: MAVEN_SHA} + + maven_dir = cjdk.cache_package("Maven", MAVEN_URL, **kwargs) + if _mvn := next(maven_dir.rglob("apache-maven-*/**/mvn"), None): + with path_prepended(_mvn.parent): + scyjava.start_jvm() + + yield jpype.getDefaultJVMPath() diff --git a/src/bffile/_jimports.py b/src/bffile/_jimports.py new file mode 100644 index 0000000..1094500 --- /dev/null +++ b/src/bffile/_jimports.py @@ -0,0 +1,125 @@ +from __future__ import annotations + +from collections.abc import Mapping, Sequence, Set +from typing import TYPE_CHECKING, Any, Literal, cast, overload + +import jpype +import numpy as np +import scyjava + +from ._java_stuff import start_jvm + +if TYPE_CHECKING: + from loci.common.services import ServiceFactory + from loci.formats import FormatTools, ImageReader, Memoizer, Modulo + from loci.formats.in_ import DynamicMetadataOptions + from loci.formats.ome import OMEPyramidStore + from loci.formats.services import OMEXMLService + from ome.units.quantity import Quantity as OMEQuantity + from pint.facets.plain import PlainQuantity + + +@jpype.JImplementationFor("java.util.Map") +class _Map(Mapping): + def __repr__(self) -> str: + return f"{self.__class__.__name__}({dict(self)})" + + +@jpype.JImplementationFor("java.util.List") +class _ArrayList(Sequence): + def __repr__(self) -> str: + return f"{self.__class__.__name__}({list(self)})" + + +@jpype.JImplementationFor("java.util.Set") +class _Set(Set): + def __repr__(self) -> str: + return f"{self.__class__.__name__}({set(self)})" + + +@jpype.JImplementationFor("ome.units.quantity.Quantity") +class Quantity: + def __repr__(self) -> str: + obj = cast("OMEQuantity", self) + return f"{obj.value()} {obj.unit().getSymbol()}" + + def to_pint(self) -> PlainQuantity: + """Convert to pint Quantity.""" + from ome_types.units import ureg + + obj = cast("OMEQuantity", self) + symbol = str(obj.unit().getSymbol()).replace(" ", "_") + return ureg.Quantity(obj.value(), symbol) + + +@jpype.JImplementationFor("loci.formats.Modulo") +class _Modulo: + def __repr__(self) -> str: + obj = cast("Modulo", self) + fields = [] + for name in ["start", "end", "step", "labels", "type", "unit"]: + if (attr := getattr(obj, name)) is not None: + fields.append(f"{name}={attr!r}") + return f"Modulo(parentDimension={obj.parentDimension!r}, {', '.join(fields)})" + + +@jpype.JImplementationFor("loci.formats.CoreMetadata") +class _CoreMetadata: + def __repr__(self) -> str: + return f"\n{self}\n" + + +def pixtype2dtype(pixeltype: int, little_endian: bool) -> np.dtype: + """Convert a loci.formats PixelType integer into a numpy dtype.""" + FormatTools = jimport("loci.formats.FormatTools") + + fmt2type: dict[int, str] = { + FormatTools.INT8: "i1", + FormatTools.UINT8: "u1", + FormatTools.INT16: "i2", + FormatTools.UINT16: "u2", + FormatTools.INT32: "i4", + FormatTools.UINT32: "u4", + FormatTools.FLOAT: "f4", + FormatTools.DOUBLE: "f8", + FormatTools.BIT: "b1", + } + return np.dtype(("<" if little_endian else ">") + fmt2type[pixeltype]) + + +# ------------------------ jimport casts ------------------------------ + + +@overload +def jimport( + classname: Literal["ome.units.quantity.Quantity"], +) -> type[Quantity]: ... +@overload +def jimport( + classname: Literal["loci.formats.ome.OMEPyramidStore"], +) -> type[OMEPyramidStore]: ... +@overload +def jimport( + classname: Literal["loci.formats.in_.DynamicMetadataOptions"], +) -> type[DynamicMetadataOptions]: ... +@overload +def jimport( + classname: Literal["loci.formats.FormatTools"], +) -> type[FormatTools]: ... +@overload +def jimport( + classname: Literal["loci.formats.services.OMEXMLService"], +) -> type[OMEXMLService]: ... +@overload +def jimport( + classname: Literal["loci.common.services.ServiceFactory"], +) -> type[ServiceFactory]: ... +@overload +def jimport(classname: Literal["loci.formats.ImageReader"]) -> type[ImageReader]: ... +@overload +def jimport(classname: Literal["loci.formats.Memoizer"]) -> type[Memoizer]: ... +@overload +def jimport(classname: str) -> Any: ... +def jimport(classname: str) -> Any: + start_jvm() + return scyjava.jimport(classname) diff --git a/src/bffile/_utils.py b/src/bffile/_utils.py index 2d9b4fa..a0f1265 100644 --- a/src/bffile/_utils.py +++ b/src/bffile/_utils.py @@ -7,7 +7,6 @@ from xml.etree import ElementTree as ET import numpy as np -import numpy.typing as npt if TYPE_CHECKING: from collections.abc import Mapping @@ -67,7 +66,7 @@ class DimensionNames: def get_coords_from_ome( ome: OME, scene_index: int -) -> Mapping[str, list[Any] | npt.ArrayLike | Any]: +) -> Mapping[str, list[Any] | np.ndarray | Any]: """ Process the OME metadata to retrieve the coordinate planes. diff --git a/tests/conftest.py b/tests/conftest.py index 06a1bf5..cb0574a 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,15 +1,29 @@ +from __future__ import annotations + +import atexit import os import shutil import sys +import tempfile from io import BytesIO from pathlib import Path +from typing import TYPE_CHECKING from zipfile import ZipFile +import jpype import pytest import requests +import scyjava +import scyjava.config + +from bffile import _biofile + +if TYPE_CHECKING: + from collections.abc import Iterator URL = "https://www.dropbox.com/scl/fi/d3ape29urgt15iaue73om/bioformats_test_data.zip?rlkey=3j0bl9ef0rolb2k7pydr3jvw7&st=ylf7g4oh&dl=1" TEST_DATA = Path(__file__).parent / "data" +IGNORE_EXTENSIONS = {".bfmemo"} SKIP_EXTENSIONS = {".sldy"} URL_TXT = TEST_DATA / "url.txt" @@ -30,11 +44,11 @@ def download() -> None: f.write(response.content) else: dl = 0 - total_length = int(total_length) - for data in response.iter_content(chunk_size=total_length // 100): + total_length_i = int(total_length) + for data in response.iter_content(chunk_size=total_length_i // 100): dl += len(data) f.write(data) - done = int(50 * dl / total_length) + done = int(50 * dl / total_length_i) sys.stdout.write(f"\r[{'=' * done}{' ' * (50 - done)}]") sys.stdout.flush() @@ -46,7 +60,13 @@ def download() -> None: download() -DATA_FILES = sorted([x for x in TEST_DATA.iterdir() if x != URL_TXT]) +DATA_FILES = sorted( + [ + x + for x in TEST_DATA.iterdir() + if x != URL_TXT and x.suffix not in IGNORE_EXTENSIONS + ] +) @pytest.fixture(scope="session", params=DATA_FILES, ids=lambda x: x.name) @@ -68,3 +88,57 @@ def pytest_sessionstart() -> None: faulthandler.enable() faulthandler.disable() + + +# register pytest --allow-cache option +def pytest_addoption(parser: pytest.Parser) -> None: + parser.addoption( + "--allow-cache", + action="store_true", + default=False, + help="Allow cache to be used for tests", + ) + + +@pytest.fixture(autouse=True, scope="session") +def memo_dir(request: pytest.FixtureRequest) -> Iterator[Path | None]: + """Ensure we test on a clean cache, and don't pollute the user's cache.""" + tmp_path = Path(tempfile.mkdtemp()) + atexit.register(lambda: shutil.rmtree(tmp_path, ignore_errors=True)) + _biofile.BIOFORMATS_MEMO_DIR = tmp_path / "memo" + yield tmp_path + + +@pytest.fixture(autouse=True, scope="session") +def cache_dirs(request: pytest.FixtureRequest) -> Iterator[Path | None]: + """Ensure we test on a clean cache, and don't pollute the user's cache.""" + + # caching significantly speeds up tests, but we want to ensure that + # we test on a clean cache, and don't pollute the user's cache. + # If the user has set ALLOW_CACHE, we will use the actual cache directories. + # Otherwise, we will use a temporary directory. + if request.config.getoption("--allow-cache") or os.getenv("ALLOW_CACHE", ""): + print("Reading/writing to actual user cache directories") + yield None + return + + tmp_path = Path(tempfile.mkdtemp()) + os.environ["CJDK_CACHE_DIR"] = str(tmp_path / "cjdk") + + os.environ["JGO_CACHE_DIR"] = jgo = str(tmp_path / "jgo") + scyjava.config.set_cache_dir(jgo) + + m2_repo = tmp_path / "m2" / "repository" + m2_repo.mkdir(parents=True, exist_ok=True) + os.environ["M2_REPO"] = _m2_repo = str(m2_repo) + os.environ["MAVEN_OPTS"] = f"-Dmaven.repo.local={_m2_repo}" + scyjava.config.set_m2_repo(_m2_repo) + + # doing manual cleanup here to avoid windows file locks on jars during teardown + @atexit.register + def _cleanup() -> None: + if jpype.isJVMStarted(): + jpype.shutdownJVM() + shutil.rmtree(tmp_path, ignore_errors=True) + + yield tmp_path diff --git a/tests/test_bffile.py b/tests/test_bffile.py index 74a9922..18d99d6 100644 --- a/tests/test_bffile.py +++ b/tests/test_bffile.py @@ -1,10 +1,13 @@ from pathlib import Path +import ome_types + from bffile import BioFile def test_bffile(test_file: Path) -> None: - with BioFile(test_file) as bf: + with BioFile(test_file, original_meta=True) as bf: assert bf.to_numpy() is not None assert bf.to_dask() is not None + assert isinstance(bf.ome_metadata, ome_types.OME) assert bf.shape diff --git a/typings/java/__init__.pyi b/typings/java/__init__.pyi new file mode 100644 index 0000000..05fd4ef --- /dev/null +++ b/typings/java/__init__.pyi @@ -0,0 +1,8 @@ +from typing import Protocol + +import java.io + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java")``. + + io: java.io.__module_protocol__ diff --git a/typings/java/applet/__init__.pyi b/typings/java/applet/__init__.pyi new file mode 100644 index 0000000..c114399 --- /dev/null +++ b/typings/java/applet/__init__.pyi @@ -0,0 +1,91 @@ +import typing +from typing import Protocol + +import java.awt +import java.io +import java.lang +import java.net +import java.util +import javax.accessibility + +class Applet(java.awt.Panel): + def __init__(self): ... + def destroy(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getAppletContext(self) -> AppletContext: ... + def getAppletInfo(self) -> java.lang.String: ... + @typing.overload + def getAudioClip(self, uRL: java.net.URL) -> AudioClip: ... + @typing.overload + def getAudioClip( + self, uRL: java.net.URL, string: java.lang.String | str + ) -> AudioClip: ... + def getCodeBase(self) -> java.net.URL: ... + def getDocumentBase(self) -> java.net.URL: ... + @typing.overload + def getImage(self, uRL: java.net.URL) -> java.awt.Image: ... + @typing.overload + def getImage( + self, uRL: java.net.URL, string: java.lang.String | str + ) -> java.awt.Image: ... + def getLocale(self) -> java.util.Locale: ... + def getParameter(self, string: java.lang.String | str) -> java.lang.String: ... + def getParameterInfo( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def init(self) -> None: ... + def isActive(self) -> bool: ... + def isValidateRoot(self) -> bool: ... + @staticmethod + def newAudioClip(uRL: java.net.URL) -> AudioClip: ... + @typing.overload + def play(self, uRL: java.net.URL) -> None: ... + @typing.overload + def play(self, uRL: java.net.URL, string: java.lang.String | str) -> None: ... + @typing.overload + def resize(self, int: int, int2: int) -> None: ... + @typing.overload + def resize(self, dimension: java.awt.Dimension) -> None: ... + def setStub(self, appletStub: AppletStub) -> None: ... + def showStatus(self, string: java.lang.String | str) -> None: ... + def start(self) -> None: ... + def stop(self) -> None: ... + +class AppletContext: + def getApplet(self, string: java.lang.String | str) -> Applet: ... + def getApplets(self) -> java.util.Enumeration[Applet]: ... + def getAudioClip(self, uRL: java.net.URL) -> AudioClip: ... + def getImage(self, uRL: java.net.URL) -> java.awt.Image: ... + def getStream(self, string: java.lang.String | str) -> java.io.InputStream: ... + def getStreamKeys(self) -> java.util.Iterator[java.lang.String]: ... + def setStream( + self, string: java.lang.String | str, inputStream: java.io.InputStream + ) -> None: ... + @typing.overload + def showDocument(self, uRL: java.net.URL) -> None: ... + @typing.overload + def showDocument( + self, uRL: java.net.URL, string: java.lang.String | str + ) -> None: ... + def showStatus(self, string: java.lang.String | str) -> None: ... + +class AppletStub: + def appletResize(self, int: int, int2: int) -> None: ... + def getAppletContext(self) -> AppletContext: ... + def getCodeBase(self) -> java.net.URL: ... + def getDocumentBase(self) -> java.net.URL: ... + def getParameter(self, string: java.lang.String | str) -> java.lang.String: ... + def isActive(self) -> bool: ... + +class AudioClip: + def loop(self) -> None: ... + def play(self) -> None: ... + def stop(self) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.applet")``. + + Applet: type[Applet] + AppletContext: type[AppletContext] + AppletStub: type[AppletStub] + AudioClip: type[AudioClip] diff --git a/typings/java/awt/__init__.pyi b/typings/java/awt/__init__.pyi new file mode 100644 index 0000000..9b5ebb8 --- /dev/null +++ b/typings/java/awt/__init__.pyi @@ -0,0 +1,5217 @@ +import typing +from typing import Protocol + +import java +import java.awt.color +import java.awt.datatransfer +import java.awt.desktop +import java.awt.dnd +import java.awt.event +import java.awt.font +import java.awt.geom +import java.awt.im +import java.awt.image +import java.awt.image.renderable +import java.awt.peer +import java.awt.print_ +import java.beans +import java.io +import java.lang +import java.net +import java.security +import java.text +import java.util +import javax.accessibility +import javax.swing +import jpype +import jpype.protocol + +class AWTError(java.lang.Error): + def __init__(self, string: java.lang.String | str): ... + +class AWTEvent(java.util.EventObject): + COMPONENT_EVENT_MASK: typing.ClassVar[int] = ... + CONTAINER_EVENT_MASK: typing.ClassVar[int] = ... + FOCUS_EVENT_MASK: typing.ClassVar[int] = ... + KEY_EVENT_MASK: typing.ClassVar[int] = ... + MOUSE_EVENT_MASK: typing.ClassVar[int] = ... + MOUSE_MOTION_EVENT_MASK: typing.ClassVar[int] = ... + WINDOW_EVENT_MASK: typing.ClassVar[int] = ... + ACTION_EVENT_MASK: typing.ClassVar[int] = ... + ADJUSTMENT_EVENT_MASK: typing.ClassVar[int] = ... + ITEM_EVENT_MASK: typing.ClassVar[int] = ... + TEXT_EVENT_MASK: typing.ClassVar[int] = ... + INPUT_METHOD_EVENT_MASK: typing.ClassVar[int] = ... + PAINT_EVENT_MASK: typing.ClassVar[int] = ... + INVOCATION_EVENT_MASK: typing.ClassVar[int] = ... + HIERARCHY_EVENT_MASK: typing.ClassVar[int] = ... + HIERARCHY_BOUNDS_EVENT_MASK: typing.ClassVar[int] = ... + MOUSE_WHEEL_EVENT_MASK: typing.ClassVar[int] = ... + WINDOW_STATE_EVENT_MASK: typing.ClassVar[int] = ... + WINDOW_FOCUS_EVENT_MASK: typing.ClassVar[int] = ... + RESERVED_ID_MAX: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, event: Event): ... + @typing.overload + def __init__(self, object: typing.Any, int: int): ... + def getID(self) -> int: ... + def paramString(self) -> java.lang.String: ... + def setSource(self, object: typing.Any) -> None: ... + def toString(self) -> java.lang.String: ... + +class AWTEventMulticaster( + java.awt.event.ComponentListener, + java.awt.event.ContainerListener, + java.awt.event.FocusListener, + java.awt.event.KeyListener, + java.awt.event.MouseListener, + java.awt.event.MouseMotionListener, + java.awt.event.WindowListener, + java.awt.event.WindowFocusListener, + java.awt.event.WindowStateListener, + java.awt.event.ActionListener, + java.awt.event.ItemListener, + java.awt.event.AdjustmentListener, + java.awt.event.TextListener, + java.awt.event.InputMethodListener, + java.awt.event.HierarchyListener, + java.awt.event.HierarchyBoundsListener, + java.awt.event.MouseWheelListener, +): + def actionPerformed(self, actionEvent: java.awt.event.ActionEvent) -> None: ... + @typing.overload + @staticmethod + def add( + actionListener: java.awt.event.ActionListener | typing.Callable, + actionListener2: java.awt.event.ActionListener | typing.Callable, + ) -> java.awt.event.ActionListener: ... + @typing.overload + @staticmethod + def add( + adjustmentListener: java.awt.event.AdjustmentListener | typing.Callable, + adjustmentListener2: java.awt.event.AdjustmentListener | typing.Callable, + ) -> java.awt.event.AdjustmentListener: ... + @typing.overload + @staticmethod + def add( + componentListener: java.awt.event.ComponentListener, + componentListener2: java.awt.event.ComponentListener, + ) -> java.awt.event.ComponentListener: ... + @typing.overload + @staticmethod + def add( + containerListener: java.awt.event.ContainerListener, + containerListener2: java.awt.event.ContainerListener, + ) -> java.awt.event.ContainerListener: ... + @typing.overload + @staticmethod + def add( + focusListener: java.awt.event.FocusListener, + focusListener2: java.awt.event.FocusListener, + ) -> java.awt.event.FocusListener: ... + @typing.overload + @staticmethod + def add( + hierarchyBoundsListener: java.awt.event.HierarchyBoundsListener, + hierarchyBoundsListener2: java.awt.event.HierarchyBoundsListener, + ) -> java.awt.event.HierarchyBoundsListener: ... + @typing.overload + @staticmethod + def add( + hierarchyListener: java.awt.event.HierarchyListener | typing.Callable, + hierarchyListener2: java.awt.event.HierarchyListener | typing.Callable, + ) -> java.awt.event.HierarchyListener: ... + @typing.overload + @staticmethod + def add( + inputMethodListener: java.awt.event.InputMethodListener, + inputMethodListener2: java.awt.event.InputMethodListener, + ) -> java.awt.event.InputMethodListener: ... + @typing.overload + @staticmethod + def add( + itemListener: java.awt.event.ItemListener | typing.Callable, + itemListener2: java.awt.event.ItemListener | typing.Callable, + ) -> java.awt.event.ItemListener: ... + @typing.overload + @staticmethod + def add( + keyListener: java.awt.event.KeyListener, + keyListener2: java.awt.event.KeyListener, + ) -> java.awt.event.KeyListener: ... + @typing.overload + @staticmethod + def add( + mouseListener: java.awt.event.MouseListener, + mouseListener2: java.awt.event.MouseListener, + ) -> java.awt.event.MouseListener: ... + @typing.overload + @staticmethod + def add( + mouseMotionListener: java.awt.event.MouseMotionListener, + mouseMotionListener2: java.awt.event.MouseMotionListener, + ) -> java.awt.event.MouseMotionListener: ... + @typing.overload + @staticmethod + def add( + mouseWheelListener: java.awt.event.MouseWheelListener | typing.Callable, + mouseWheelListener2: java.awt.event.MouseWheelListener | typing.Callable, + ) -> java.awt.event.MouseWheelListener: ... + @typing.overload + @staticmethod + def add( + textListener: java.awt.event.TextListener | typing.Callable, + textListener2: java.awt.event.TextListener | typing.Callable, + ) -> java.awt.event.TextListener: ... + @typing.overload + @staticmethod + def add( + windowFocusListener: java.awt.event.WindowFocusListener, + windowFocusListener2: java.awt.event.WindowFocusListener, + ) -> java.awt.event.WindowFocusListener: ... + @typing.overload + @staticmethod + def add( + windowListener: java.awt.event.WindowListener, + windowListener2: java.awt.event.WindowListener, + ) -> java.awt.event.WindowListener: ... + @typing.overload + @staticmethod + def add( + windowStateListener: java.awt.event.WindowStateListener | typing.Callable, + windowStateListener2: java.awt.event.WindowStateListener | typing.Callable, + ) -> java.awt.event.WindowStateListener: ... + def adjustmentValueChanged( + self, adjustmentEvent: java.awt.event.AdjustmentEvent + ) -> None: ... + def ancestorMoved(self, hierarchyEvent: java.awt.event.HierarchyEvent) -> None: ... + def ancestorResized( + self, hierarchyEvent: java.awt.event.HierarchyEvent + ) -> None: ... + def caretPositionChanged( + self, inputMethodEvent: java.awt.event.InputMethodEvent + ) -> None: ... + def componentAdded(self, containerEvent: java.awt.event.ContainerEvent) -> None: ... + def componentHidden( + self, componentEvent: java.awt.event.ComponentEvent + ) -> None: ... + def componentMoved(self, componentEvent: java.awt.event.ComponentEvent) -> None: ... + def componentRemoved( + self, containerEvent: java.awt.event.ContainerEvent + ) -> None: ... + def componentResized( + self, componentEvent: java.awt.event.ComponentEvent + ) -> None: ... + def componentShown(self, componentEvent: java.awt.event.ComponentEvent) -> None: ... + def focusGained(self, focusEvent: java.awt.event.FocusEvent) -> None: ... + def focusLost(self, focusEvent: java.awt.event.FocusEvent) -> None: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + @staticmethod + def getListeners( + eventListener: java.util.EventListener, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def hierarchyChanged( + self, hierarchyEvent: java.awt.event.HierarchyEvent + ) -> None: ... + def inputMethodTextChanged( + self, inputMethodEvent: java.awt.event.InputMethodEvent + ) -> None: ... + def itemStateChanged(self, itemEvent: java.awt.event.ItemEvent) -> None: ... + def keyPressed(self, keyEvent: java.awt.event.KeyEvent) -> None: ... + def keyReleased(self, keyEvent: java.awt.event.KeyEvent) -> None: ... + def keyTyped(self, keyEvent: java.awt.event.KeyEvent) -> None: ... + def mouseClicked(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseDragged(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseEntered(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseExited(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseMoved(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mousePressed(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseReleased(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseWheelMoved( + self, mouseWheelEvent: java.awt.event.MouseWheelEvent + ) -> None: ... + @typing.overload + @staticmethod + def remove( + actionListener: java.awt.event.ActionListener | typing.Callable, + actionListener2: java.awt.event.ActionListener | typing.Callable, + ) -> java.awt.event.ActionListener: ... + @typing.overload + @staticmethod + def remove( + adjustmentListener: java.awt.event.AdjustmentListener | typing.Callable, + adjustmentListener2: java.awt.event.AdjustmentListener | typing.Callable, + ) -> java.awt.event.AdjustmentListener: ... + @typing.overload + @staticmethod + def remove( + componentListener: java.awt.event.ComponentListener, + componentListener2: java.awt.event.ComponentListener, + ) -> java.awt.event.ComponentListener: ... + @typing.overload + @staticmethod + def remove( + containerListener: java.awt.event.ContainerListener, + containerListener2: java.awt.event.ContainerListener, + ) -> java.awt.event.ContainerListener: ... + @typing.overload + @staticmethod + def remove( + focusListener: java.awt.event.FocusListener, + focusListener2: java.awt.event.FocusListener, + ) -> java.awt.event.FocusListener: ... + @typing.overload + @staticmethod + def remove( + hierarchyBoundsListener: java.awt.event.HierarchyBoundsListener, + hierarchyBoundsListener2: java.awt.event.HierarchyBoundsListener, + ) -> java.awt.event.HierarchyBoundsListener: ... + @typing.overload + @staticmethod + def remove( + hierarchyListener: java.awt.event.HierarchyListener | typing.Callable, + hierarchyListener2: java.awt.event.HierarchyListener | typing.Callable, + ) -> java.awt.event.HierarchyListener: ... + @typing.overload + @staticmethod + def remove( + inputMethodListener: java.awt.event.InputMethodListener, + inputMethodListener2: java.awt.event.InputMethodListener, + ) -> java.awt.event.InputMethodListener: ... + @typing.overload + @staticmethod + def remove( + itemListener: java.awt.event.ItemListener | typing.Callable, + itemListener2: java.awt.event.ItemListener | typing.Callable, + ) -> java.awt.event.ItemListener: ... + @typing.overload + @staticmethod + def remove( + keyListener: java.awt.event.KeyListener, + keyListener2: java.awt.event.KeyListener, + ) -> java.awt.event.KeyListener: ... + @typing.overload + @staticmethod + def remove( + mouseListener: java.awt.event.MouseListener, + mouseListener2: java.awt.event.MouseListener, + ) -> java.awt.event.MouseListener: ... + @typing.overload + @staticmethod + def remove( + mouseMotionListener: java.awt.event.MouseMotionListener, + mouseMotionListener2: java.awt.event.MouseMotionListener, + ) -> java.awt.event.MouseMotionListener: ... + @typing.overload + @staticmethod + def remove( + mouseWheelListener: java.awt.event.MouseWheelListener | typing.Callable, + mouseWheelListener2: java.awt.event.MouseWheelListener | typing.Callable, + ) -> java.awt.event.MouseWheelListener: ... + @typing.overload + @staticmethod + def remove( + textListener: java.awt.event.TextListener | typing.Callable, + textListener2: java.awt.event.TextListener | typing.Callable, + ) -> java.awt.event.TextListener: ... + @typing.overload + @staticmethod + def remove( + windowFocusListener: java.awt.event.WindowFocusListener, + windowFocusListener2: java.awt.event.WindowFocusListener, + ) -> java.awt.event.WindowFocusListener: ... + @typing.overload + @staticmethod + def remove( + windowListener: java.awt.event.WindowListener, + windowListener2: java.awt.event.WindowListener, + ) -> java.awt.event.WindowListener: ... + @typing.overload + @staticmethod + def remove( + windowStateListener: java.awt.event.WindowStateListener | typing.Callable, + windowStateListener2: java.awt.event.WindowStateListener | typing.Callable, + ) -> java.awt.event.WindowStateListener: ... + def textValueChanged(self, textEvent: java.awt.event.TextEvent) -> None: ... + def windowActivated(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowClosed(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowClosing(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowDeactivated(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowDeiconified(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowGainedFocus(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowIconified(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowLostFocus(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowOpened(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowStateChanged(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + +class AWTException(java.lang.Exception): + def __init__(self, string: java.lang.String | str): ... + +class AWTKeyStroke(java.io.Serializable): + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + @staticmethod + def getAWTKeyStroke(char: str) -> AWTKeyStroke: ... + @typing.overload + @staticmethod + def getAWTKeyStroke(int: int, int2: int) -> AWTKeyStroke: ... + @typing.overload + @staticmethod + def getAWTKeyStroke(int: int, int2: int, boolean: bool) -> AWTKeyStroke: ... + @typing.overload + @staticmethod + def getAWTKeyStroke(character: str, int: int) -> AWTKeyStroke: ... + @typing.overload + @staticmethod + def getAWTKeyStroke(string: java.lang.String | str) -> AWTKeyStroke: ... + @staticmethod + def getAWTKeyStrokeForEvent(keyEvent: java.awt.event.KeyEvent) -> AWTKeyStroke: ... + def getKeyChar(self) -> str: ... + def getKeyCode(self) -> int: ... + def getKeyEventType(self) -> int: ... + def getModifiers(self) -> int: ... + def hashCode(self) -> int: ... + def isOnKeyRelease(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class AWTPermission(java.security.BasicPermission): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class ActiveEvent: + def dispatch(self) -> None: ... + +class Adjustable: + HORIZONTAL: typing.ClassVar[int] = ... + VERTICAL: typing.ClassVar[int] = ... + NO_ORIENTATION: typing.ClassVar[int] = ... + def addAdjustmentListener( + self, adjustmentListener: java.awt.event.AdjustmentListener | typing.Callable + ) -> None: ... + def getBlockIncrement(self) -> int: ... + def getMaximum(self) -> int: ... + def getMinimum(self) -> int: ... + def getOrientation(self) -> int: ... + def getUnitIncrement(self) -> int: ... + def getValue(self) -> int: ... + def getVisibleAmount(self) -> int: ... + def removeAdjustmentListener( + self, adjustmentListener: java.awt.event.AdjustmentListener | typing.Callable + ) -> None: ... + def setBlockIncrement(self, int: int) -> None: ... + def setMaximum(self, int: int) -> None: ... + def setMinimum(self, int: int) -> None: ... + def setUnitIncrement(self, int: int) -> None: ... + def setValue(self, int: int) -> None: ... + def setVisibleAmount(self, int: int) -> None: ... + +class CheckboxGroup(java.io.Serializable): + def __init__(self): ... + def getCurrent(self) -> Checkbox: ... + def getSelectedCheckbox(self) -> Checkbox: ... + def setCurrent(self, checkbox: Checkbox) -> None: ... + def setSelectedCheckbox(self, checkbox: Checkbox) -> None: ... + def toString(self) -> java.lang.String: ... + +class ComponentOrientation(java.io.Serializable): + LEFT_TO_RIGHT: typing.ClassVar[ComponentOrientation] = ... + RIGHT_TO_LEFT: typing.ClassVar[ComponentOrientation] = ... + UNKNOWN: typing.ClassVar[ComponentOrientation] = ... + @typing.overload + @staticmethod + def getOrientation(locale: java.util.Locale) -> ComponentOrientation: ... + @typing.overload + @staticmethod + def getOrientation( + resourceBundle: java.util.ResourceBundle, + ) -> ComponentOrientation: ... + def isHorizontal(self) -> bool: ... + def isLeftToRight(self) -> bool: ... + +class Composite: + def createContext( + self, + colorModel: java.awt.image.ColorModel, + colorModel2: java.awt.image.ColorModel, + renderingHints: RenderingHints, + ) -> CompositeContext: ... + +class CompositeContext: + def compose( + self, + raster: java.awt.image.Raster, + raster2: java.awt.image.Raster, + writableRaster: java.awt.image.WritableRaster, + ) -> None: ... + def dispose(self) -> None: ... + +class Cursor(java.io.Serializable): + DEFAULT_CURSOR: typing.ClassVar[int] = ... + CROSSHAIR_CURSOR: typing.ClassVar[int] = ... + TEXT_CURSOR: typing.ClassVar[int] = ... + WAIT_CURSOR: typing.ClassVar[int] = ... + SW_RESIZE_CURSOR: typing.ClassVar[int] = ... + SE_RESIZE_CURSOR: typing.ClassVar[int] = ... + NW_RESIZE_CURSOR: typing.ClassVar[int] = ... + NE_RESIZE_CURSOR: typing.ClassVar[int] = ... + N_RESIZE_CURSOR: typing.ClassVar[int] = ... + S_RESIZE_CURSOR: typing.ClassVar[int] = ... + W_RESIZE_CURSOR: typing.ClassVar[int] = ... + E_RESIZE_CURSOR: typing.ClassVar[int] = ... + HAND_CURSOR: typing.ClassVar[int] = ... + MOVE_CURSOR: typing.ClassVar[int] = ... + CUSTOM_CURSOR: typing.ClassVar[int] = ... + def __init__(self, int: int): ... + @staticmethod + def getDefaultCursor() -> Cursor: ... + def getName(self) -> java.lang.String: ... + @staticmethod + def getPredefinedCursor(int: int) -> Cursor: ... + @staticmethod + def getSystemCustomCursor(string: java.lang.String | str) -> Cursor: ... + def getType(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class Desktop: + def addAppEventListener( + self, systemEventListener: java.awt.desktop.SystemEventListener + ) -> None: ... + def browse(self, uRI: java.net.URI) -> None: ... + def browseFileDirectory( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> None: ... + def disableSuddenTermination(self) -> None: ... + def edit(self, file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + def enableSuddenTermination(self) -> None: ... + @staticmethod + def getDesktop() -> Desktop: ... + @staticmethod + def isDesktopSupported() -> bool: ... + def isSupported(self, action: Desktop.Action) -> bool: ... + @typing.overload + def mail(self) -> None: ... + @typing.overload + def mail(self, uRI: java.net.URI) -> None: ... + def moveToTrash(self, file: java.io.File | jpype.protocol.SupportsPath) -> bool: ... + def open(self, file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + def openHelpViewer(self) -> None: ... + def print_(self, file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + def removeAppEventListener( + self, systemEventListener: java.awt.desktop.SystemEventListener + ) -> None: ... + def requestForeground(self, boolean: bool) -> None: ... + def setAboutHandler( + self, aboutHandler: java.awt.desktop.AboutHandler | typing.Callable + ) -> None: ... + def setDefaultMenuBar(self, jMenuBar: javax.swing.JMenuBar) -> None: ... + def setOpenFileHandler( + self, openFilesHandler: java.awt.desktop.OpenFilesHandler | typing.Callable + ) -> None: ... + def setOpenURIHandler( + self, openURIHandler: java.awt.desktop.OpenURIHandler | typing.Callable + ) -> None: ... + def setPreferencesHandler( + self, preferencesHandler: java.awt.desktop.PreferencesHandler | typing.Callable + ) -> None: ... + def setPrintFileHandler( + self, printFilesHandler: java.awt.desktop.PrintFilesHandler | typing.Callable + ) -> None: ... + def setQuitHandler( + self, quitHandler: java.awt.desktop.QuitHandler | typing.Callable + ) -> None: ... + def setQuitStrategy(self, quitStrategy: java.awt.desktop.QuitStrategy) -> None: ... + class Action(java.lang.Enum["Desktop.Action"]): + OPEN: typing.ClassVar[Desktop.Action] = ... + EDIT: typing.ClassVar[Desktop.Action] = ... + PRINT: typing.ClassVar[Desktop.Action] = ... + MAIL: typing.ClassVar[Desktop.Action] = ... + BROWSE: typing.ClassVar[Desktop.Action] = ... + APP_EVENT_FOREGROUND: typing.ClassVar[Desktop.Action] = ... + APP_EVENT_HIDDEN: typing.ClassVar[Desktop.Action] = ... + APP_EVENT_REOPENED: typing.ClassVar[Desktop.Action] = ... + APP_EVENT_SCREEN_SLEEP: typing.ClassVar[Desktop.Action] = ... + APP_EVENT_SYSTEM_SLEEP: typing.ClassVar[Desktop.Action] = ... + APP_EVENT_USER_SESSION: typing.ClassVar[Desktop.Action] = ... + APP_ABOUT: typing.ClassVar[Desktop.Action] = ... + APP_PREFERENCES: typing.ClassVar[Desktop.Action] = ... + APP_OPEN_FILE: typing.ClassVar[Desktop.Action] = ... + APP_PRINT_FILE: typing.ClassVar[Desktop.Action] = ... + APP_OPEN_URI: typing.ClassVar[Desktop.Action] = ... + APP_QUIT_HANDLER: typing.ClassVar[Desktop.Action] = ... + APP_QUIT_STRATEGY: typing.ClassVar[Desktop.Action] = ... + APP_SUDDEN_TERMINATION: typing.ClassVar[Desktop.Action] = ... + APP_REQUEST_FOREGROUND: typing.ClassVar[Desktop.Action] = ... + APP_HELP_VIEWER: typing.ClassVar[Desktop.Action] = ... + APP_MENU_BAR: typing.ClassVar[Desktop.Action] = ... + BROWSE_FILE_DIR: typing.ClassVar[Desktop.Action] = ... + MOVE_TO_TRASH: typing.ClassVar[Desktop.Action] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Desktop.Action: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[Desktop.Action]: ... + +class Dimension(java.awt.geom.Dimension2D, java.io.Serializable): + width: int = ... + height: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, dimension: Dimension): ... + def equals(self, object: typing.Any) -> bool: ... + def getHeight(self) -> float: ... + def getSize(self) -> Dimension: ... + def getWidth(self) -> float: ... + def hashCode(self) -> int: ... + @typing.overload + def setSize(self, double: float, double2: float) -> None: ... + @typing.overload + def setSize(self, int: int, int2: int) -> None: ... + @typing.overload + def setSize(self, dimension: Dimension) -> None: ... + @typing.overload + def setSize(self, dimension2D: java.awt.geom.Dimension2D) -> None: ... + def toString(self) -> java.lang.String: ... + +class DisplayMode: + BIT_DEPTH_MULTI: typing.ClassVar[int] = ... + REFRESH_RATE_UNKNOWN: typing.ClassVar[int] = ... + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + @typing.overload + def equals(self, displayMode: DisplayMode) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + def getBitDepth(self) -> int: ... + def getHeight(self) -> int: ... + def getRefreshRate(self) -> int: ... + def getWidth(self) -> int: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class Event(java.io.Serializable): + SHIFT_MASK: typing.ClassVar[int] = ... + CTRL_MASK: typing.ClassVar[int] = ... + META_MASK: typing.ClassVar[int] = ... + ALT_MASK: typing.ClassVar[int] = ... + HOME: typing.ClassVar[int] = ... + END: typing.ClassVar[int] = ... + PGUP: typing.ClassVar[int] = ... + PGDN: typing.ClassVar[int] = ... + UP: typing.ClassVar[int] = ... + DOWN: typing.ClassVar[int] = ... + LEFT: typing.ClassVar[int] = ... + RIGHT: typing.ClassVar[int] = ... + F1: typing.ClassVar[int] = ... + F2: typing.ClassVar[int] = ... + F3: typing.ClassVar[int] = ... + F4: typing.ClassVar[int] = ... + F5: typing.ClassVar[int] = ... + F6: typing.ClassVar[int] = ... + F7: typing.ClassVar[int] = ... + F8: typing.ClassVar[int] = ... + F9: typing.ClassVar[int] = ... + F10: typing.ClassVar[int] = ... + F11: typing.ClassVar[int] = ... + F12: typing.ClassVar[int] = ... + PRINT_SCREEN: typing.ClassVar[int] = ... + SCROLL_LOCK: typing.ClassVar[int] = ... + CAPS_LOCK: typing.ClassVar[int] = ... + NUM_LOCK: typing.ClassVar[int] = ... + PAUSE: typing.ClassVar[int] = ... + INSERT: typing.ClassVar[int] = ... + ENTER: typing.ClassVar[int] = ... + BACK_SPACE: typing.ClassVar[int] = ... + TAB: typing.ClassVar[int] = ... + ESCAPE: typing.ClassVar[int] = ... + DELETE: typing.ClassVar[int] = ... + WINDOW_DESTROY: typing.ClassVar[int] = ... + WINDOW_EXPOSE: typing.ClassVar[int] = ... + WINDOW_ICONIFY: typing.ClassVar[int] = ... + WINDOW_DEICONIFY: typing.ClassVar[int] = ... + WINDOW_MOVED: typing.ClassVar[int] = ... + KEY_PRESS: typing.ClassVar[int] = ... + KEY_RELEASE: typing.ClassVar[int] = ... + KEY_ACTION: typing.ClassVar[int] = ... + KEY_ACTION_RELEASE: typing.ClassVar[int] = ... + MOUSE_DOWN: typing.ClassVar[int] = ... + MOUSE_UP: typing.ClassVar[int] = ... + MOUSE_MOVE: typing.ClassVar[int] = ... + MOUSE_ENTER: typing.ClassVar[int] = ... + MOUSE_EXIT: typing.ClassVar[int] = ... + MOUSE_DRAG: typing.ClassVar[int] = ... + SCROLL_LINE_UP: typing.ClassVar[int] = ... + SCROLL_LINE_DOWN: typing.ClassVar[int] = ... + SCROLL_PAGE_UP: typing.ClassVar[int] = ... + SCROLL_PAGE_DOWN: typing.ClassVar[int] = ... + SCROLL_ABSOLUTE: typing.ClassVar[int] = ... + SCROLL_BEGIN: typing.ClassVar[int] = ... + SCROLL_END: typing.ClassVar[int] = ... + LIST_SELECT: typing.ClassVar[int] = ... + LIST_DESELECT: typing.ClassVar[int] = ... + ACTION_EVENT: typing.ClassVar[int] = ... + LOAD_FILE: typing.ClassVar[int] = ... + SAVE_FILE: typing.ClassVar[int] = ... + GOT_FOCUS: typing.ClassVar[int] = ... + LOST_FOCUS: typing.ClassVar[int] = ... + target: typing.Any = ... + when: int = ... + id: int = ... + x: int = ... + y: int = ... + key: int = ... + modifiers: int = ... + clickCount: int = ... + arg: typing.Any = ... + evt: Event = ... + @typing.overload + def __init__(self, object: typing.Any, int: int, object2: typing.Any): ... + @typing.overload + def __init__( + self, + object: typing.Any, + long: int, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + ): ... + @typing.overload + def __init__( + self, + object: typing.Any, + long: int, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + object2: typing.Any, + ): ... + def controlDown(self) -> bool: ... + def metaDown(self) -> bool: ... + def shiftDown(self) -> bool: ... + def toString(self) -> java.lang.String: ... + def translate(self, int: int, int2: int) -> None: ... + +class EventQueue: + def __init__(self): ... + def createSecondaryLoop(self) -> SecondaryLoop: ... + @staticmethod + def getCurrentEvent() -> AWTEvent: ... + @staticmethod + def getMostRecentEventTime() -> int: ... + def getNextEvent(self) -> AWTEvent: ... + @staticmethod + def invokeAndWait(runnable: java.lang.Runnable | typing.Callable) -> None: ... + @staticmethod + def invokeLater(runnable: java.lang.Runnable | typing.Callable) -> None: ... + @staticmethod + def isDispatchThread() -> bool: ... + @typing.overload + def peekEvent(self) -> AWTEvent: ... + @typing.overload + def peekEvent(self, int: int) -> AWTEvent: ... + def postEvent(self, aWTEvent: AWTEvent) -> None: ... + def push(self, eventQueue: EventQueue) -> None: ... + +class FocusTraversalPolicy: + def getComponentAfter( + self, container: Container, component: Component + ) -> Component: ... + def getComponentBefore( + self, container: Container, component: Component + ) -> Component: ... + def getDefaultComponent(self, container: Container) -> Component: ... + def getFirstComponent(self, container: Container) -> Component: ... + def getInitialComponent(self, window: Window) -> Component: ... + def getLastComponent(self, container: Container) -> Component: ... + +class Font(java.io.Serializable): + DIALOG: typing.ClassVar[java.lang.String] = ... + DIALOG_INPUT: typing.ClassVar[java.lang.String] = ... + SANS_SERIF: typing.ClassVar[java.lang.String] = ... + SERIF: typing.ClassVar[java.lang.String] = ... + MONOSPACED: typing.ClassVar[java.lang.String] = ... + PLAIN: typing.ClassVar[int] = ... + BOLD: typing.ClassVar[int] = ... + ITALIC: typing.ClassVar[int] = ... + ROMAN_BASELINE: typing.ClassVar[int] = ... + CENTER_BASELINE: typing.ClassVar[int] = ... + HANGING_BASELINE: typing.ClassVar[int] = ... + TRUETYPE_FONT: typing.ClassVar[int] = ... + TYPE1_FONT: typing.ClassVar[int] = ... + LAYOUT_LEFT_TO_RIGHT: typing.ClassVar[int] = ... + LAYOUT_RIGHT_TO_LEFT: typing.ClassVar[int] = ... + LAYOUT_NO_START_CONTEXT: typing.ClassVar[int] = ... + LAYOUT_NO_LIMIT_CONTEXT: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int, int2: int): ... + @typing.overload + def __init__( + self, + map: java.util.Map[java.text.AttributedCharacterIterator.Attribute, typing.Any] + | typing.Mapping[java.text.AttributedCharacterIterator.Attribute, typing.Any], + ): ... + @typing.overload + def canDisplay(self, char: str) -> bool: ... + @typing.overload + def canDisplay(self, int: int) -> bool: ... + @typing.overload + def canDisplayUpTo( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> int: ... + @typing.overload + def canDisplayUpTo(self, string: java.lang.String | str) -> int: ... + @typing.overload + def canDisplayUpTo( + self, characterIterator: java.text.CharacterIterator, int: int, int2: int + ) -> int: ... + @typing.overload + @staticmethod + def createFont( + int: int, file: java.io.File | jpype.protocol.SupportsPath + ) -> Font: ... + @typing.overload + @staticmethod + def createFont(int: int, inputStream: java.io.InputStream) -> Font: ... + @typing.overload + @staticmethod + def createFonts( + file: java.io.File | jpype.protocol.SupportsPath, + ) -> typing.MutableSequence[Font]: ... + @typing.overload + @staticmethod + def createFonts( + inputStream: java.io.InputStream, + ) -> typing.MutableSequence[Font]: ... + @typing.overload + def createGlyphVector( + self, + fontRenderContext: java.awt.font.FontRenderContext, + charArray: list[str] | jpype.JArray, + ) -> java.awt.font.GlyphVector: ... + @typing.overload + def createGlyphVector( + self, + fontRenderContext: java.awt.font.FontRenderContext, + intArray: list[int] | jpype.JArray, + ) -> java.awt.font.GlyphVector: ... + @typing.overload + def createGlyphVector( + self, + fontRenderContext: java.awt.font.FontRenderContext, + string: java.lang.String | str, + ) -> java.awt.font.GlyphVector: ... + @typing.overload + def createGlyphVector( + self, + fontRenderContext: java.awt.font.FontRenderContext, + characterIterator: java.text.CharacterIterator, + ) -> java.awt.font.GlyphVector: ... + @staticmethod + def decode(string: java.lang.String | str) -> Font: ... + @typing.overload + def deriveFont(self, float: float) -> Font: ... + @typing.overload + def deriveFont(self, int: int) -> Font: ... + @typing.overload + def deriveFont(self, int: int, float: float) -> Font: ... + @typing.overload + def deriveFont( + self, int: int, affineTransform: java.awt.geom.AffineTransform + ) -> Font: ... + @typing.overload + def deriveFont(self, affineTransform: java.awt.geom.AffineTransform) -> Font: ... + @typing.overload + def deriveFont( + self, + map: java.util.Map[java.text.AttributedCharacterIterator.Attribute, typing.Any] + | typing.Mapping[java.text.AttributedCharacterIterator.Attribute, typing.Any], + ) -> Font: ... + def equals(self, object: typing.Any) -> bool: ... + def getAttributes( + self, + ) -> java.util.Map[java.awt.font.TextAttribute, typing.Any]: ... + def getAvailableAttributes( + self, + ) -> typing.MutableSequence[java.text.AttributedCharacterIterator.Attribute]: ... + def getBaselineFor(self, char: str) -> int: ... + @typing.overload + def getFamily(self) -> java.lang.String: ... + @typing.overload + def getFamily(self, locale: java.util.Locale) -> java.lang.String: ... + @typing.overload + @staticmethod + def getFont(string: java.lang.String | str) -> Font: ... + @typing.overload + @staticmethod + def getFont(string: java.lang.String | str, font: Font) -> Font: ... + @typing.overload + @staticmethod + def getFont( + map: java.util.Map[java.text.AttributedCharacterIterator.Attribute, typing.Any] + | typing.Mapping[java.text.AttributedCharacterIterator.Attribute, typing.Any], + ) -> Font: ... + @typing.overload + def getFontName(self) -> java.lang.String: ... + @typing.overload + def getFontName(self, locale: java.util.Locale) -> java.lang.String: ... + def getItalicAngle(self) -> float: ... + @typing.overload + def getLineMetrics( + self, + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + fontRenderContext: java.awt.font.FontRenderContext, + ) -> java.awt.font.LineMetrics: ... + @typing.overload + def getLineMetrics( + self, + string: java.lang.String | str, + int: int, + int2: int, + fontRenderContext: java.awt.font.FontRenderContext, + ) -> java.awt.font.LineMetrics: ... + @typing.overload + def getLineMetrics( + self, + string: java.lang.String | str, + fontRenderContext: java.awt.font.FontRenderContext, + ) -> java.awt.font.LineMetrics: ... + @typing.overload + def getLineMetrics( + self, + characterIterator: java.text.CharacterIterator, + int: int, + int2: int, + fontRenderContext: java.awt.font.FontRenderContext, + ) -> java.awt.font.LineMetrics: ... + def getMaxCharBounds( + self, fontRenderContext: java.awt.font.FontRenderContext + ) -> java.awt.geom.Rectangle2D: ... + def getMissingGlyphCode(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getNumGlyphs(self) -> int: ... + def getPSName(self) -> java.lang.String: ... + def getSize(self) -> int: ... + def getSize2D(self) -> float: ... + @typing.overload + def getStringBounds( + self, + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + fontRenderContext: java.awt.font.FontRenderContext, + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getStringBounds( + self, + string: java.lang.String | str, + int: int, + int2: int, + fontRenderContext: java.awt.font.FontRenderContext, + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getStringBounds( + self, + string: java.lang.String | str, + fontRenderContext: java.awt.font.FontRenderContext, + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getStringBounds( + self, + characterIterator: java.text.CharacterIterator, + int: int, + int2: int, + fontRenderContext: java.awt.font.FontRenderContext, + ) -> java.awt.geom.Rectangle2D: ... + def getStyle(self) -> int: ... + def getTransform(self) -> java.awt.geom.AffineTransform: ... + def hasLayoutAttributes(self) -> bool: ... + def hasUniformLineMetrics(self) -> bool: ... + def hashCode(self) -> int: ... + def isBold(self) -> bool: ... + def isItalic(self) -> bool: ... + def isPlain(self) -> bool: ... + def isTransformed(self) -> bool: ... + def layoutGlyphVector( + self, + fontRenderContext: java.awt.font.FontRenderContext, + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + int3: int, + ) -> java.awt.font.GlyphVector: ... + @staticmethod + def textRequiresLayout( + charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> bool: ... + def toString(self) -> java.lang.String: ... + +class FontFormatException(java.lang.Exception): + def __init__(self, string: java.lang.String | str): ... + +class FontMetrics(java.io.Serializable): + def bytesWidth( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def charWidth(self, char: str) -> int: ... + @typing.overload + def charWidth(self, int: int) -> int: ... + def charsWidth( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> int: ... + def getAscent(self) -> int: ... + def getDescent(self) -> int: ... + def getFont(self) -> Font: ... + def getFontRenderContext(self) -> java.awt.font.FontRenderContext: ... + def getHeight(self) -> int: ... + def getLeading(self) -> int: ... + @typing.overload + def getLineMetrics( + self, + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + graphics: Graphics, + ) -> java.awt.font.LineMetrics: ... + @typing.overload + def getLineMetrics( + self, string: java.lang.String | str, int: int, int2: int, graphics: Graphics + ) -> java.awt.font.LineMetrics: ... + @typing.overload + def getLineMetrics( + self, string: java.lang.String | str, graphics: Graphics + ) -> java.awt.font.LineMetrics: ... + @typing.overload + def getLineMetrics( + self, + characterIterator: java.text.CharacterIterator, + int: int, + int2: int, + graphics: Graphics, + ) -> java.awt.font.LineMetrics: ... + def getMaxAdvance(self) -> int: ... + def getMaxAscent(self) -> int: ... + def getMaxCharBounds(self, graphics: Graphics) -> java.awt.geom.Rectangle2D: ... + def getMaxDecent(self) -> int: ... + def getMaxDescent(self) -> int: ... + @typing.overload + def getStringBounds( + self, + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + graphics: Graphics, + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getStringBounds( + self, string: java.lang.String | str, int: int, int2: int, graphics: Graphics + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getStringBounds( + self, string: java.lang.String | str, graphics: Graphics + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getStringBounds( + self, + characterIterator: java.text.CharacterIterator, + int: int, + int2: int, + graphics: Graphics, + ) -> java.awt.geom.Rectangle2D: ... + def getWidths(self) -> typing.MutableSequence[int]: ... + def hasUniformLineMetrics(self) -> bool: ... + def stringWidth(self, string: java.lang.String | str) -> int: ... + def toString(self) -> java.lang.String: ... + +class Graphics: + def clearRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def clipRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def copyArea( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def create(self) -> Graphics: ... + @typing.overload + def create(self, int: int, int2: int, int3: int, int4: int) -> Graphics: ... + def dispose(self) -> None: ... + def draw3DRect( + self, int: int, int2: int, int3: int, int4: int, boolean: bool + ) -> None: ... + def drawArc( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def drawBytes( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + int4: int, + ) -> None: ... + def drawChars( + self, + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + int3: int, + int4: int, + ) -> None: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + color: Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + int3: int, + int4: int, + color: Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + int3: int, + int4: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + color: Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + def drawLine(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def drawOval(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def drawPolygon( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + @typing.overload + def drawPolygon(self, polygon: Polygon) -> None: ... + def drawPolyline( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + def drawRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def drawRoundRect( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def drawString( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + @typing.overload + def drawString( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int: int, + int2: int, + ) -> None: ... + def fill3DRect( + self, int: int, int2: int, int3: int, int4: int, boolean: bool + ) -> None: ... + def fillArc( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def fillOval(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def fillPolygon( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + @typing.overload + def fillPolygon(self, polygon: Polygon) -> None: ... + def fillRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def fillRoundRect( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def finalize(self) -> None: ... + def getClip(self) -> Shape: ... + @typing.overload + def getClipBounds(self) -> Rectangle: ... + @typing.overload + def getClipBounds(self, rectangle: Rectangle) -> Rectangle: ... + def getClipRect(self) -> Rectangle: ... + def getColor(self) -> Color: ... + def getFont(self) -> Font: ... + @typing.overload + def getFontMetrics(self, font: Font) -> FontMetrics: ... + @typing.overload + def getFontMetrics(self) -> FontMetrics: ... + def hitClip(self, int: int, int2: int, int3: int, int4: int) -> bool: ... + @typing.overload + def setClip(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setClip(self, shape: Shape) -> None: ... + def setColor(self, color: Color) -> None: ... + def setFont(self, font: Font) -> None: ... + def setPaintMode(self) -> None: ... + def setXORMode(self, color: Color) -> None: ... + def toString(self) -> java.lang.String: ... + def translate(self, int: int, int2: int) -> None: ... + +class GraphicsConfigTemplate(java.io.Serializable): + REQUIRED: typing.ClassVar[int] = ... + PREFERRED: typing.ClassVar[int] = ... + UNNECESSARY: typing.ClassVar[int] = ... + def __init__(self): ... + def getBestConfiguration( + self, graphicsConfigurationArray: list[GraphicsConfiguration] | jpype.JArray + ) -> GraphicsConfiguration: ... + def isGraphicsConfigSupported( + self, graphicsConfiguration: GraphicsConfiguration + ) -> bool: ... + +class GraphicsConfiguration: + @typing.overload + def createCompatibleImage( + self, int: int, int2: int + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def createCompatibleImage( + self, int: int, int2: int, int3: int + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def createCompatibleVolatileImage( + self, int: int, int2: int + ) -> java.awt.image.VolatileImage: ... + @typing.overload + def createCompatibleVolatileImage( + self, int: int, int2: int, int3: int + ) -> java.awt.image.VolatileImage: ... + @typing.overload + def createCompatibleVolatileImage( + self, int: int, int2: int, imageCapabilities: ImageCapabilities + ) -> java.awt.image.VolatileImage: ... + @typing.overload + def createCompatibleVolatileImage( + self, int: int, int2: int, imageCapabilities: ImageCapabilities, int3: int + ) -> java.awt.image.VolatileImage: ... + def getBounds(self) -> Rectangle: ... + def getBufferCapabilities(self) -> BufferCapabilities: ... + @typing.overload + def getColorModel(self) -> java.awt.image.ColorModel: ... + @typing.overload + def getColorModel(self, int: int) -> java.awt.image.ColorModel: ... + def getDefaultTransform(self) -> java.awt.geom.AffineTransform: ... + def getDevice(self) -> GraphicsDevice: ... + def getImageCapabilities(self) -> ImageCapabilities: ... + def getNormalizingTransform(self) -> java.awt.geom.AffineTransform: ... + def isTranslucencyCapable(self) -> bool: ... + +class GraphicsDevice: + TYPE_RASTER_SCREEN: typing.ClassVar[int] = ... + TYPE_PRINTER: typing.ClassVar[int] = ... + TYPE_IMAGE_BUFFER: typing.ClassVar[int] = ... + def getAvailableAcceleratedMemory(self) -> int: ... + def getBestConfiguration( + self, graphicsConfigTemplate: GraphicsConfigTemplate + ) -> GraphicsConfiguration: ... + def getConfigurations(self) -> typing.MutableSequence[GraphicsConfiguration]: ... + def getDefaultConfiguration(self) -> GraphicsConfiguration: ... + def getDisplayMode(self) -> DisplayMode: ... + def getDisplayModes(self) -> typing.MutableSequence[DisplayMode]: ... + def getFullScreenWindow(self) -> Window: ... + def getIDstring(self) -> java.lang.String: ... + def getType(self) -> int: ... + def isDisplayChangeSupported(self) -> bool: ... + def isFullScreenSupported(self) -> bool: ... + def isWindowTranslucencySupported( + self, windowTranslucency: GraphicsDevice.WindowTranslucency + ) -> bool: ... + def setDisplayMode(self, displayMode: DisplayMode) -> None: ... + def setFullScreenWindow(self, window: Window) -> None: ... + class WindowTranslucency(java.lang.Enum["GraphicsDevice.WindowTranslucency"]): + PERPIXEL_TRANSPARENT: typing.ClassVar[GraphicsDevice.WindowTranslucency] = ... + TRANSLUCENT: typing.ClassVar[GraphicsDevice.WindowTranslucency] = ... + PERPIXEL_TRANSLUCENT: typing.ClassVar[GraphicsDevice.WindowTranslucency] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> GraphicsDevice.WindowTranslucency: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[GraphicsDevice.WindowTranslucency]: ... + +class GraphicsEnvironment: + def createGraphics( + self, bufferedImage: java.awt.image.BufferedImage + ) -> Graphics2D: ... + def getAllFonts(self) -> typing.MutableSequence[Font]: ... + @typing.overload + def getAvailableFontFamilyNames( + self, + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getAvailableFontFamilyNames( + self, locale: java.util.Locale + ) -> typing.MutableSequence[java.lang.String]: ... + def getCenterPoint(self) -> Point: ... + def getDefaultScreenDevice(self) -> GraphicsDevice: ... + @staticmethod + def getLocalGraphicsEnvironment() -> GraphicsEnvironment: ... + def getMaximumWindowBounds(self) -> Rectangle: ... + def getScreenDevices(self) -> typing.MutableSequence[GraphicsDevice]: ... + @staticmethod + def isHeadless() -> bool: ... + def isHeadlessInstance(self) -> bool: ... + def preferLocaleFonts(self) -> None: ... + def preferProportionalFonts(self) -> None: ... + def registerFont(self, font: Font) -> bool: ... + +class GridBagConstraints(java.lang.Cloneable, java.io.Serializable): + RELATIVE: typing.ClassVar[int] = ... + REMAINDER: typing.ClassVar[int] = ... + NONE: typing.ClassVar[int] = ... + BOTH: typing.ClassVar[int] = ... + HORIZONTAL: typing.ClassVar[int] = ... + VERTICAL: typing.ClassVar[int] = ... + CENTER: typing.ClassVar[int] = ... + NORTH: typing.ClassVar[int] = ... + NORTHEAST: typing.ClassVar[int] = ... + EAST: typing.ClassVar[int] = ... + SOUTHEAST: typing.ClassVar[int] = ... + SOUTH: typing.ClassVar[int] = ... + SOUTHWEST: typing.ClassVar[int] = ... + WEST: typing.ClassVar[int] = ... + NORTHWEST: typing.ClassVar[int] = ... + PAGE_START: typing.ClassVar[int] = ... + PAGE_END: typing.ClassVar[int] = ... + LINE_START: typing.ClassVar[int] = ... + LINE_END: typing.ClassVar[int] = ... + FIRST_LINE_START: typing.ClassVar[int] = ... + FIRST_LINE_END: typing.ClassVar[int] = ... + LAST_LINE_START: typing.ClassVar[int] = ... + LAST_LINE_END: typing.ClassVar[int] = ... + BASELINE: typing.ClassVar[int] = ... + BASELINE_LEADING: typing.ClassVar[int] = ... + BASELINE_TRAILING: typing.ClassVar[int] = ... + ABOVE_BASELINE: typing.ClassVar[int] = ... + ABOVE_BASELINE_LEADING: typing.ClassVar[int] = ... + ABOVE_BASELINE_TRAILING: typing.ClassVar[int] = ... + BELOW_BASELINE: typing.ClassVar[int] = ... + BELOW_BASELINE_LEADING: typing.ClassVar[int] = ... + BELOW_BASELINE_TRAILING: typing.ClassVar[int] = ... + gridx: int = ... + gridy: int = ... + gridwidth: int = ... + gridheight: int = ... + weightx: float = ... + weighty: float = ... + anchor: int = ... + fill: int = ... + insets: Insets = ... + ipadx: int = ... + ipady: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + int3: int, + int4: int, + double: float, + double2: float, + int5: int, + int6: int, + insets: Insets, + int7: int, + int8: int, + ): ... + def clone(self) -> typing.Any: ... + +class GridBagLayoutInfo(java.io.Serializable): ... + +class HeadlessException(java.lang.UnsupportedOperationException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def getMessage(self) -> java.lang.String: ... + +class IllegalComponentStateException(java.lang.IllegalStateException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Image: + UndefinedProperty: typing.ClassVar[typing.Any] = ... + SCALE_DEFAULT: typing.ClassVar[int] = ... + SCALE_FAST: typing.ClassVar[int] = ... + SCALE_SMOOTH: typing.ClassVar[int] = ... + SCALE_REPLICATE: typing.ClassVar[int] = ... + SCALE_AREA_AVERAGING: typing.ClassVar[int] = ... + def flush(self) -> None: ... + def getAccelerationPriority(self) -> float: ... + def getCapabilities( + self, graphicsConfiguration: GraphicsConfiguration + ) -> ImageCapabilities: ... + def getGraphics(self) -> Graphics: ... + def getHeight( + self, imageObserver: java.awt.image.ImageObserver | typing.Callable + ) -> int: ... + def getProperty( + self, + string: java.lang.String | str, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> typing.Any: ... + def getScaledInstance(self, int: int, int2: int, int3: int) -> Image: ... + def getSource(self) -> java.awt.image.ImageProducer: ... + def getWidth( + self, imageObserver: java.awt.image.ImageObserver | typing.Callable + ) -> int: ... + def setAccelerationPriority(self, float: float) -> None: ... + +class ImageCapabilities(java.lang.Cloneable): + def __init__(self, boolean: bool): ... + def clone(self) -> typing.Any: ... + def isAccelerated(self) -> bool: ... + def isTrueVolatile(self) -> bool: ... + +class Insets(java.lang.Cloneable, java.io.Serializable): + top: int = ... + left: int = ... + bottom: int = ... + right: int = ... + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def set(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ItemSelectable: + def addItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + def getSelectedObjects(self) -> typing.MutableSequence[typing.Any]: ... + def removeItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + +class KeyEventDispatcher: + def dispatchKeyEvent(self, keyEvent: java.awt.event.KeyEvent) -> bool: ... + +class KeyEventPostProcessor: + def postProcessKeyEvent(self, keyEvent: java.awt.event.KeyEvent) -> bool: ... + +class LayoutManager: + def addLayoutComponent( + self, string: java.lang.String | str, component: Component + ) -> None: ... + def layoutContainer(self, container: Container) -> None: ... + def minimumLayoutSize(self, container: Container) -> Dimension: ... + def preferredLayoutSize(self, container: Container) -> Dimension: ... + def removeLayoutComponent(self, component: Component) -> None: ... + +class MediaTracker(java.io.Serializable): + LOADING: typing.ClassVar[int] = ... + ABORTED: typing.ClassVar[int] = ... + ERRORED: typing.ClassVar[int] = ... + COMPLETE: typing.ClassVar[int] = ... + def __init__(self, component: Component): ... + @typing.overload + def addImage(self, image: Image, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def addImage(self, image: Image, int: int) -> None: ... + @typing.overload + def checkAll(self) -> bool: ... + @typing.overload + def checkAll(self, boolean: bool) -> bool: ... + @typing.overload + def checkID(self, int: int) -> bool: ... + @typing.overload + def checkID(self, int: int, boolean: bool) -> bool: ... + def getErrorsAny(self) -> typing.MutableSequence[typing.Any]: ... + def getErrorsID(self, int: int) -> typing.MutableSequence[typing.Any]: ... + def isErrorAny(self) -> bool: ... + def isErrorID(self, int: int) -> bool: ... + @typing.overload + def removeImage(self, image: Image) -> None: ... + @typing.overload + def removeImage(self, image: Image, int: int) -> None: ... + @typing.overload + def removeImage(self, image: Image, int: int, int2: int, int3: int) -> None: ... + def statusAll(self, boolean: bool) -> int: ... + def statusID(self, int: int, boolean: bool) -> int: ... + @typing.overload + def waitForAll(self, long: int) -> bool: ... + @typing.overload + def waitForAll(self) -> None: ... + @typing.overload + def waitForID(self, int: int, long: int) -> bool: ... + @typing.overload + def waitForID(self, int: int) -> None: ... + +class MenuComponent(java.io.Serializable): + def __init__(self): ... + def dispatchEvent(self, aWTEvent: AWTEvent) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getFont(self) -> Font: ... + def getName(self) -> java.lang.String: ... + def getParent(self) -> MenuContainer: ... + def postEvent(self, event: Event) -> bool: ... + def removeNotify(self) -> None: ... + def setFont(self, font: Font) -> None: ... + def setName(self, string: java.lang.String | str) -> None: ... + def toString(self) -> java.lang.String: ... + +class MenuContainer: + def getFont(self) -> Font: ... + def postEvent(self, event: Event) -> bool: ... + def remove(self, menuComponent: MenuComponent) -> None: ... + +class MenuShortcut(java.io.Serializable): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, boolean: bool): ... + @typing.overload + def equals(self, menuShortcut: MenuShortcut) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + def getKey(self) -> int: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def usesShiftModifier(self) -> bool: ... + +class MouseInfo: + @staticmethod + def getNumberOfButtons() -> int: ... + @staticmethod + def getPointerInfo() -> PointerInfo: ... + +class PaintContext: + def dispose(self) -> None: ... + def getColorModel(self) -> java.awt.image.ColorModel: ... + def getRaster( + self, int: int, int2: int, int3: int, int4: int + ) -> java.awt.image.Raster: ... + +class Point(java.awt.geom.Point2D, java.io.Serializable): + x: int = ... + y: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, point: Point): ... + def equals(self, object: typing.Any) -> bool: ... + def getLocation(self) -> Point: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def move(self, int: int, int2: int) -> None: ... + @typing.overload + def setLocation(self, double: float, double2: float) -> None: ... + @typing.overload + def setLocation(self, int: int, int2: int) -> None: ... + @typing.overload + def setLocation(self, point: Point) -> None: ... + @typing.overload + def setLocation(self, point2D: java.awt.geom.Point2D) -> None: ... + def toString(self) -> java.lang.String: ... + def translate(self, int: int, int2: int) -> None: ... + +class PointerInfo: + def getDevice(self) -> GraphicsDevice: ... + def getLocation(self) -> Point: ... + +class PrintGraphics: + def getPrintJob(self) -> PrintJob: ... + +class PrintJob: + def end(self) -> None: ... + def finalize(self) -> None: ... + def getGraphics(self) -> Graphics: ... + def getPageDimension(self) -> Dimension: ... + def getPageResolution(self) -> int: ... + def lastPageFirst(self) -> bool: ... + +class RenderingHints(java.util.Map[typing.Any, typing.Any], java.lang.Cloneable): + KEY_ANTIALIASING: typing.ClassVar[RenderingHints.Key] = ... + VALUE_ANTIALIAS_ON: typing.ClassVar[typing.Any] = ... + VALUE_ANTIALIAS_OFF: typing.ClassVar[typing.Any] = ... + VALUE_ANTIALIAS_DEFAULT: typing.ClassVar[typing.Any] = ... + KEY_RENDERING: typing.ClassVar[RenderingHints.Key] = ... + VALUE_RENDER_SPEED: typing.ClassVar[typing.Any] = ... + VALUE_RENDER_QUALITY: typing.ClassVar[typing.Any] = ... + VALUE_RENDER_DEFAULT: typing.ClassVar[typing.Any] = ... + KEY_DITHERING: typing.ClassVar[RenderingHints.Key] = ... + VALUE_DITHER_DISABLE: typing.ClassVar[typing.Any] = ... + VALUE_DITHER_ENABLE: typing.ClassVar[typing.Any] = ... + VALUE_DITHER_DEFAULT: typing.ClassVar[typing.Any] = ... + KEY_TEXT_ANTIALIASING: typing.ClassVar[RenderingHints.Key] = ... + VALUE_TEXT_ANTIALIAS_ON: typing.ClassVar[typing.Any] = ... + VALUE_TEXT_ANTIALIAS_OFF: typing.ClassVar[typing.Any] = ... + VALUE_TEXT_ANTIALIAS_DEFAULT: typing.ClassVar[typing.Any] = ... + VALUE_TEXT_ANTIALIAS_GASP: typing.ClassVar[typing.Any] = ... + VALUE_TEXT_ANTIALIAS_LCD_HRGB: typing.ClassVar[typing.Any] = ... + VALUE_TEXT_ANTIALIAS_LCD_HBGR: typing.ClassVar[typing.Any] = ... + VALUE_TEXT_ANTIALIAS_LCD_VRGB: typing.ClassVar[typing.Any] = ... + VALUE_TEXT_ANTIALIAS_LCD_VBGR: typing.ClassVar[typing.Any] = ... + KEY_TEXT_LCD_CONTRAST: typing.ClassVar[RenderingHints.Key] = ... + KEY_FRACTIONALMETRICS: typing.ClassVar[RenderingHints.Key] = ... + VALUE_FRACTIONALMETRICS_OFF: typing.ClassVar[typing.Any] = ... + VALUE_FRACTIONALMETRICS_ON: typing.ClassVar[typing.Any] = ... + VALUE_FRACTIONALMETRICS_DEFAULT: typing.ClassVar[typing.Any] = ... + KEY_INTERPOLATION: typing.ClassVar[RenderingHints.Key] = ... + VALUE_INTERPOLATION_NEAREST_NEIGHBOR: typing.ClassVar[typing.Any] = ... + VALUE_INTERPOLATION_BILINEAR: typing.ClassVar[typing.Any] = ... + VALUE_INTERPOLATION_BICUBIC: typing.ClassVar[typing.Any] = ... + KEY_ALPHA_INTERPOLATION: typing.ClassVar[RenderingHints.Key] = ... + VALUE_ALPHA_INTERPOLATION_SPEED: typing.ClassVar[typing.Any] = ... + VALUE_ALPHA_INTERPOLATION_QUALITY: typing.ClassVar[typing.Any] = ... + VALUE_ALPHA_INTERPOLATION_DEFAULT: typing.ClassVar[typing.Any] = ... + KEY_COLOR_RENDERING: typing.ClassVar[RenderingHints.Key] = ... + VALUE_COLOR_RENDER_SPEED: typing.ClassVar[typing.Any] = ... + VALUE_COLOR_RENDER_QUALITY: typing.ClassVar[typing.Any] = ... + VALUE_COLOR_RENDER_DEFAULT: typing.ClassVar[typing.Any] = ... + KEY_STROKE_CONTROL: typing.ClassVar[RenderingHints.Key] = ... + VALUE_STROKE_DEFAULT: typing.ClassVar[typing.Any] = ... + VALUE_STROKE_NORMALIZE: typing.ClassVar[typing.Any] = ... + VALUE_STROKE_PURE: typing.ClassVar[typing.Any] = ... + KEY_RESOLUTION_VARIANT: typing.ClassVar[RenderingHints.Key] = ... + VALUE_RESOLUTION_VARIANT_DEFAULT: typing.ClassVar[typing.Any] = ... + VALUE_RESOLUTION_VARIANT_BASE: typing.ClassVar[typing.Any] = ... + VALUE_RESOLUTION_VARIANT_SIZE_FIT: typing.ClassVar[typing.Any] = ... + VALUE_RESOLUTION_VARIANT_DPI_FIT: typing.ClassVar[typing.Any] = ... + @typing.overload + def __init__(self, key: RenderingHints.Key, object: typing.Any): ... + @typing.overload + def __init__( + self, + map: java.util.Map[RenderingHints.Key, typing.Any] + | typing.Mapping[RenderingHints.Key, typing.Any], + ): ... + def add(self, renderingHints: RenderingHints) -> None: ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def entrySet( + self, + ) -> java.util.Set[java.util.Map.Entry[typing.Any, typing.Any]]: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, object: typing.Any) -> typing.Any: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> java.util.Set[typing.Any]: ... + def put(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + def putAll( + self, + map: java.util.Map[typing.Any, typing.Any] + | typing.Mapping[typing.Any, typing.Any], + ) -> None: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> typing.Any: ... + def size(self) -> int: ... + def toString(self) -> java.lang.String: ... + def values(self) -> java.util.Collection[typing.Any]: ... + class Key: + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def isCompatibleValue(self, object: typing.Any) -> bool: ... + +class Robot: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, graphicsDevice: GraphicsDevice): ... + def createMultiResolutionScreenCapture( + self, rectangle: Rectangle + ) -> java.awt.image.MultiResolutionImage: ... + def createScreenCapture( + self, rectangle: Rectangle + ) -> java.awt.image.BufferedImage: ... + def delay(self, int: int) -> None: ... + def getAutoDelay(self) -> int: ... + def getPixelColor(self, int: int, int2: int) -> Color: ... + def isAutoWaitForIdle(self) -> bool: ... + def keyPress(self, int: int) -> None: ... + def keyRelease(self, int: int) -> None: ... + def mouseMove(self, int: int, int2: int) -> None: ... + def mousePress(self, int: int) -> None: ... + def mouseRelease(self, int: int) -> None: ... + def mouseWheel(self, int: int) -> None: ... + def setAutoDelay(self, int: int) -> None: ... + def setAutoWaitForIdle(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + def waitForIdle(self) -> None: ... + +class SecondaryLoop: + def enter(self) -> bool: ... + def exit(self) -> bool: ... + +class Shape: + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: java.awt.geom.Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: java.awt.geom.Rectangle2D) -> bool: ... + def getBounds(self) -> Rectangle: ... + def getBounds2D(self) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getPathIterator( + self, affineTransform: java.awt.geom.AffineTransform + ) -> java.awt.geom.PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: java.awt.geom.AffineTransform, double: float + ) -> java.awt.geom.PathIterator: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: java.awt.geom.Rectangle2D) -> bool: ... + +class SplashScreen: + def close(self) -> None: ... + def createGraphics(self) -> Graphics2D: ... + def getBounds(self) -> Rectangle: ... + def getImageURL(self) -> java.net.URL: ... + def getSize(self) -> Dimension: ... + @staticmethod + def getSplashScreen() -> SplashScreen: ... + def isVisible(self) -> bool: ... + def setImageURL(self, uRL: java.net.URL) -> None: ... + def update(self) -> None: ... + +class Stroke: + def createStrokedShape(self, shape: Shape) -> Shape: ... + +class SystemTray: + def add(self, trayIcon: TrayIcon) -> None: ... + def addPropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def getPropertyChangeListeners( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.beans.PropertyChangeListener]: ... + @staticmethod + def getSystemTray() -> SystemTray: ... + def getTrayIconSize(self) -> Dimension: ... + def getTrayIcons(self) -> typing.MutableSequence[TrayIcon]: ... + @staticmethod + def isSupported() -> bool: ... + def remove(self, trayIcon: TrayIcon) -> None: ... + def removePropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + +class Taskbar: + def getIconImage(self) -> Image: ... + def getMenu(self) -> PopupMenu: ... + @staticmethod + def getTaskbar() -> Taskbar: ... + def isSupported(self, feature: Taskbar.Feature) -> bool: ... + @staticmethod + def isTaskbarSupported() -> bool: ... + def requestUserAttention(self, boolean: bool, boolean2: bool) -> None: ... + def requestWindowUserAttention(self, window: Window) -> None: ... + def setIconBadge(self, string: java.lang.String | str) -> None: ... + def setIconImage(self, image: Image) -> None: ... + def setMenu(self, popupMenu: PopupMenu) -> None: ... + def setProgressValue(self, int: int) -> None: ... + def setWindowIconBadge(self, window: Window, image: Image) -> None: ... + def setWindowProgressState(self, window: Window, state: Taskbar.State) -> None: ... + def setWindowProgressValue(self, window: Window, int: int) -> None: ... + class Feature(java.lang.Enum["Taskbar.Feature"]): + ICON_BADGE_TEXT: typing.ClassVar[Taskbar.Feature] = ... + ICON_BADGE_NUMBER: typing.ClassVar[Taskbar.Feature] = ... + ICON_BADGE_IMAGE_WINDOW: typing.ClassVar[Taskbar.Feature] = ... + ICON_IMAGE: typing.ClassVar[Taskbar.Feature] = ... + MENU: typing.ClassVar[Taskbar.Feature] = ... + PROGRESS_STATE_WINDOW: typing.ClassVar[Taskbar.Feature] = ... + PROGRESS_VALUE: typing.ClassVar[Taskbar.Feature] = ... + PROGRESS_VALUE_WINDOW: typing.ClassVar[Taskbar.Feature] = ... + USER_ATTENTION: typing.ClassVar[Taskbar.Feature] = ... + USER_ATTENTION_WINDOW: typing.ClassVar[Taskbar.Feature] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Taskbar.Feature: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[Taskbar.Feature]: ... + + class State(java.lang.Enum["Taskbar.State"]): + OFF: typing.ClassVar[Taskbar.State] = ... + NORMAL: typing.ClassVar[Taskbar.State] = ... + PAUSED: typing.ClassVar[Taskbar.State] = ... + INDETERMINATE: typing.ClassVar[Taskbar.State] = ... + ERROR: typing.ClassVar[Taskbar.State] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Taskbar.State: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[Taskbar.State]: ... + +class Toolkit: + def addAWTEventListener( + self, + aWTEventListener: java.awt.event.AWTEventListener | typing.Callable, + long: int, + ) -> None: ... + def addPropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def areExtraMouseButtonsEnabled(self) -> bool: ... + def beep(self) -> None: ... + def checkImage( + self, + image: Image, + int: int, + int2: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> int: ... + def createCustomCursor( + self, image: Image, point: Point, string: java.lang.String | str + ) -> Cursor: ... + _createDragGestureRecognizer__T = typing.TypeVar( + "_createDragGestureRecognizer__T", bound=java.awt.dnd.DragGestureRecognizer + ) # + def createDragGestureRecognizer( + self, + class_: type[_createDragGestureRecognizer__T], + dragSource: java.awt.dnd.DragSource, + component: Component, + int: int, + dragGestureListener: java.awt.dnd.DragGestureListener | typing.Callable, + ) -> _createDragGestureRecognizer__T: ... + @typing.overload + def createImage( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> Image: ... + @typing.overload + def createImage(self, imageProducer: java.awt.image.ImageProducer) -> Image: ... + @typing.overload + def createImage(self, string: java.lang.String | str) -> Image: ... + @typing.overload + def createImage(self, uRL: java.net.URL) -> Image: ... + @typing.overload + def createImage(self, byteArray: list[int] | jpype.JArray | bytes) -> Image: ... + @typing.overload + def getAWTEventListeners( + self, + ) -> typing.MutableSequence[java.awt.event.AWTEventListener]: ... + @typing.overload + def getAWTEventListeners( + self, long: int + ) -> typing.MutableSequence[java.awt.event.AWTEventListener]: ... + def getBestCursorSize(self, int: int, int2: int) -> Dimension: ... + def getColorModel(self) -> java.awt.image.ColorModel: ... + @staticmethod + def getDefaultToolkit() -> Toolkit: ... + def getDesktopProperty(self, string: java.lang.String | str) -> typing.Any: ... + def getFontList(self) -> typing.MutableSequence[java.lang.String]: ... + def getFontMetrics(self, font: Font) -> FontMetrics: ... + @typing.overload + def getImage(self, string: java.lang.String | str) -> Image: ... + @typing.overload + def getImage(self, uRL: java.net.URL) -> Image: ... + def getLockingKeyState(self, int: int) -> bool: ... + def getMaximumCursorColors(self) -> int: ... + def getMenuShortcutKeyMask(self) -> int: ... + def getMenuShortcutKeyMaskEx(self) -> int: ... + @typing.overload + def getPrintJob( + self, + frame: Frame, + string: java.lang.String | str, + properties: java.util.Properties, + ) -> PrintJob: ... + @typing.overload + def getPrintJob( + self, + frame: Frame, + string: java.lang.String | str, + jobAttributes: JobAttributes, + pageAttributes: PageAttributes, + ) -> PrintJob: ... + @staticmethod + def getProperty( + string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def getPropertyChangeListeners( + self, + ) -> typing.MutableSequence[java.beans.PropertyChangeListener]: ... + @typing.overload + def getPropertyChangeListeners( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.beans.PropertyChangeListener]: ... + def getScreenInsets( + self, graphicsConfiguration: GraphicsConfiguration + ) -> Insets: ... + def getScreenResolution(self) -> int: ... + def getScreenSize(self) -> Dimension: ... + def getSystemClipboard(self) -> java.awt.datatransfer.Clipboard: ... + def getSystemEventQueue(self) -> EventQueue: ... + def getSystemSelection(self) -> java.awt.datatransfer.Clipboard: ... + def isAlwaysOnTopSupported(self) -> bool: ... + def isDynamicLayoutActive(self) -> bool: ... + def isFrameStateSupported(self, int: int) -> bool: ... + def isModalExclusionTypeSupported( + self, modalExclusionType: Dialog.ModalExclusionType + ) -> bool: ... + def isModalityTypeSupported(self, modalityType: Dialog.ModalityType) -> bool: ... + def mapInputMethodHighlight( + self, inputMethodHighlight: java.awt.im.InputMethodHighlight + ) -> java.util.Map[java.awt.font.TextAttribute, typing.Any]: ... + def prepareImage( + self, + image: Image, + int: int, + int2: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + def removeAWTEventListener( + self, aWTEventListener: java.awt.event.AWTEventListener | typing.Callable + ) -> None: ... + def removePropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def setDynamicLayout(self, boolean: bool) -> None: ... + def setLockingKeyState(self, int: int, boolean: bool) -> None: ... + def sync(self) -> None: ... + +class Transparency: + OPAQUE: typing.ClassVar[int] = ... + BITMASK: typing.ClassVar[int] = ... + TRANSLUCENT: typing.ClassVar[int] = ... + def getTransparency(self) -> int: ... + +class TrayIcon: + @typing.overload + def __init__(self, image: Image): ... + @typing.overload + def __init__(self, image: Image, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, image: Image, string: java.lang.String | str, popupMenu: PopupMenu + ): ... + def addActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + def addMouseListener(self, mouseListener: java.awt.event.MouseListener) -> None: ... + def addMouseMotionListener( + self, mouseMotionListener: java.awt.event.MouseMotionListener + ) -> None: ... + def displayMessage( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + messageType: TrayIcon.MessageType, + ) -> None: ... + def getActionCommand(self) -> java.lang.String: ... + def getActionListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ActionListener]: ... + def getImage(self) -> Image: ... + def getMouseListeners( + self, + ) -> typing.MutableSequence[java.awt.event.MouseListener]: ... + def getMouseMotionListeners( + self, + ) -> typing.MutableSequence[java.awt.event.MouseMotionListener]: ... + def getPopupMenu(self) -> PopupMenu: ... + def getSize(self) -> Dimension: ... + def getToolTip(self) -> java.lang.String: ... + def isImageAutoSize(self) -> bool: ... + def removeActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + def removeMouseListener( + self, mouseListener: java.awt.event.MouseListener + ) -> None: ... + def removeMouseMotionListener( + self, mouseMotionListener: java.awt.event.MouseMotionListener + ) -> None: ... + def setActionCommand(self, string: java.lang.String | str) -> None: ... + def setImage(self, image: Image) -> None: ... + def setImageAutoSize(self, boolean: bool) -> None: ... + def setPopupMenu(self, popupMenu: PopupMenu) -> None: ... + def setToolTip(self, string: java.lang.String | str) -> None: ... + class MessageType(java.lang.Enum["TrayIcon.MessageType"]): + ERROR: typing.ClassVar[TrayIcon.MessageType] = ... + WARNING: typing.ClassVar[TrayIcon.MessageType] = ... + INFO: typing.ClassVar[TrayIcon.MessageType] = ... + NONE: typing.ClassVar[TrayIcon.MessageType] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> TrayIcon.MessageType: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[TrayIcon.MessageType]: ... + +class AlphaComposite(Composite): + CLEAR: typing.ClassVar[int] = ... + SRC: typing.ClassVar[int] = ... + DST: typing.ClassVar[int] = ... + SRC_OVER: typing.ClassVar[int] = ... + DST_OVER: typing.ClassVar[int] = ... + SRC_IN: typing.ClassVar[int] = ... + DST_IN: typing.ClassVar[int] = ... + SRC_OUT: typing.ClassVar[int] = ... + DST_OUT: typing.ClassVar[int] = ... + SRC_ATOP: typing.ClassVar[int] = ... + DST_ATOP: typing.ClassVar[int] = ... + XOR: typing.ClassVar[int] = ... + Clear: typing.ClassVar[AlphaComposite] = ... + Src: typing.ClassVar[AlphaComposite] = ... + Dst: typing.ClassVar[AlphaComposite] = ... + SrcOver: typing.ClassVar[AlphaComposite] = ... + DstOver: typing.ClassVar[AlphaComposite] = ... + SrcIn: typing.ClassVar[AlphaComposite] = ... + DstIn: typing.ClassVar[AlphaComposite] = ... + SrcOut: typing.ClassVar[AlphaComposite] = ... + DstOut: typing.ClassVar[AlphaComposite] = ... + SrcAtop: typing.ClassVar[AlphaComposite] = ... + DstAtop: typing.ClassVar[AlphaComposite] = ... + Xor: typing.ClassVar[AlphaComposite] = ... + def createContext( + self, + colorModel: java.awt.image.ColorModel, + colorModel2: java.awt.image.ColorModel, + renderingHints: RenderingHints, + ) -> CompositeContext: ... + @typing.overload + def derive(self, float: float) -> AlphaComposite: ... + @typing.overload + def derive(self, int: int) -> AlphaComposite: ... + def equals(self, object: typing.Any) -> bool: ... + def getAlpha(self) -> float: ... + @typing.overload + @staticmethod + def getInstance(int: int) -> AlphaComposite: ... + @typing.overload + @staticmethod + def getInstance(int: int, float: float) -> AlphaComposite: ... + def getRule(self) -> int: ... + def hashCode(self) -> int: ... + +class BasicStroke(Stroke): + JOIN_MITER: typing.ClassVar[int] = ... + JOIN_ROUND: typing.ClassVar[int] = ... + JOIN_BEVEL: typing.ClassVar[int] = ... + CAP_BUTT: typing.ClassVar[int] = ... + CAP_ROUND: typing.ClassVar[int] = ... + CAP_SQUARE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, float: float): ... + @typing.overload + def __init__(self, float: float, int: int, int2: int): ... + @typing.overload + def __init__(self, float: float, int: int, int2: int, float2: float): ... + @typing.overload + def __init__( + self, + float: float, + int: int, + int2: int, + float2: float, + floatArray: list[float] | jpype.JArray, + float4: float, + ): ... + def createStrokedShape(self, shape: Shape) -> Shape: ... + def equals(self, object: typing.Any) -> bool: ... + def getDashArray(self) -> typing.MutableSequence[float]: ... + def getDashPhase(self) -> float: ... + def getEndCap(self) -> int: ... + def getLineJoin(self) -> int: ... + def getLineWidth(self) -> float: ... + def getMiterLimit(self) -> float: ... + def hashCode(self) -> int: ... + +class Component(java.awt.image.ImageObserver, MenuContainer, java.io.Serializable): + TOP_ALIGNMENT: typing.ClassVar[float] = ... + CENTER_ALIGNMENT: typing.ClassVar[float] = ... + BOTTOM_ALIGNMENT: typing.ClassVar[float] = ... + LEFT_ALIGNMENT: typing.ClassVar[float] = ... + RIGHT_ALIGNMENT: typing.ClassVar[float] = ... + def action(self, event: Event, object: typing.Any) -> bool: ... + def add(self, popupMenu: PopupMenu) -> None: ... + def addComponentListener( + self, componentListener: java.awt.event.ComponentListener + ) -> None: ... + def addFocusListener(self, focusListener: java.awt.event.FocusListener) -> None: ... + def addHierarchyBoundsListener( + self, hierarchyBoundsListener: java.awt.event.HierarchyBoundsListener + ) -> None: ... + def addHierarchyListener( + self, hierarchyListener: java.awt.event.HierarchyListener | typing.Callable + ) -> None: ... + def addInputMethodListener( + self, inputMethodListener: java.awt.event.InputMethodListener + ) -> None: ... + def addKeyListener(self, keyListener: java.awt.event.KeyListener) -> None: ... + def addMouseListener(self, mouseListener: java.awt.event.MouseListener) -> None: ... + def addMouseMotionListener( + self, mouseMotionListener: java.awt.event.MouseMotionListener + ) -> None: ... + def addMouseWheelListener( + self, mouseWheelListener: java.awt.event.MouseWheelListener | typing.Callable + ) -> None: ... + def addNotify(self) -> None: ... + @typing.overload + def addPropertyChangeListener( + self, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def addPropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def applyComponentOrientation( + self, componentOrientation: ComponentOrientation + ) -> None: ... + def areFocusTraversalKeysSet(self, int: int) -> bool: ... + def bounds(self) -> Rectangle: ... + @typing.overload + def checkImage( + self, + image: Image, + int: int, + int2: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> int: ... + @typing.overload + def checkImage( + self, + image: Image, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> int: ... + @typing.overload + def contains(self, int: int, int2: int) -> bool: ... + @typing.overload + def contains(self, point: Point) -> bool: ... + @typing.overload + def createImage(self, int: int, int2: int) -> Image: ... + @typing.overload + def createImage(self, imageProducer: java.awt.image.ImageProducer) -> Image: ... + @typing.overload + def createVolatileImage( + self, int: int, int2: int + ) -> java.awt.image.VolatileImage: ... + @typing.overload + def createVolatileImage( + self, int: int, int2: int, imageCapabilities: ImageCapabilities + ) -> java.awt.image.VolatileImage: ... + def deliverEvent(self, event: Event) -> None: ... + def disable(self) -> None: ... + def dispatchEvent(self, aWTEvent: AWTEvent) -> None: ... + def doLayout(self) -> None: ... + @typing.overload + def enable(self) -> None: ... + @typing.overload + def enable(self, boolean: bool) -> None: ... + def enableInputMethods(self, boolean: bool) -> None: ... + @typing.overload + def firePropertyChange( + self, string: java.lang.String | str, byte: int, byte2: int + ) -> None: ... + @typing.overload + def firePropertyChange( + self, string: java.lang.String | str, char: str, char2: str + ) -> None: ... + @typing.overload + def firePropertyChange( + self, string: java.lang.String | str, double: float, double2: float + ) -> None: ... + @typing.overload + def firePropertyChange( + self, string: java.lang.String | str, float: float, float2: float + ) -> None: ... + @typing.overload + def firePropertyChange( + self, string: java.lang.String | str, long: int, long2: int + ) -> None: ... + @typing.overload + def firePropertyChange( + self, string: java.lang.String | str, short: int, short2: int + ) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getAlignmentX(self) -> float: ... + def getAlignmentY(self) -> float: ... + def getBackground(self) -> Color: ... + def getBaseline(self, int: int, int2: int) -> int: ... + def getBaselineResizeBehavior(self) -> Component.BaselineResizeBehavior: ... + @typing.overload + def getBounds(self) -> Rectangle: ... + @typing.overload + def getBounds(self, rectangle: Rectangle) -> Rectangle: ... + def getColorModel(self) -> java.awt.image.ColorModel: ... + @typing.overload + def getComponentAt(self, int: int, int2: int) -> Component: ... + @typing.overload + def getComponentAt(self, point: Point) -> Component: ... + def getComponentListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ComponentListener]: ... + def getComponentOrientation(self) -> ComponentOrientation: ... + def getCursor(self) -> Cursor: ... + def getDropTarget(self) -> java.awt.dnd.DropTarget: ... + def getFocusCycleRootAncestor(self) -> Container: ... + def getFocusListeners( + self, + ) -> typing.MutableSequence[java.awt.event.FocusListener]: ... + def getFocusTraversalKeys(self, int: int) -> java.util.Set[AWTKeyStroke]: ... + def getFocusTraversalKeysEnabled(self) -> bool: ... + def getFont(self) -> Font: ... + def getFontMetrics(self, font: Font) -> FontMetrics: ... + def getForeground(self) -> Color: ... + def getGraphics(self) -> Graphics: ... + def getGraphicsConfiguration(self) -> GraphicsConfiguration: ... + def getHeight(self) -> int: ... + def getHierarchyBoundsListeners( + self, + ) -> typing.MutableSequence[java.awt.event.HierarchyBoundsListener]: ... + def getHierarchyListeners( + self, + ) -> typing.MutableSequence[java.awt.event.HierarchyListener]: ... + def getIgnoreRepaint(self) -> bool: ... + def getInputContext(self) -> java.awt.im.InputContext: ... + def getInputMethodListeners( + self, + ) -> typing.MutableSequence[java.awt.event.InputMethodListener]: ... + def getInputMethodRequests(self) -> java.awt.im.InputMethodRequests: ... + def getKeyListeners(self) -> typing.MutableSequence[java.awt.event.KeyListener]: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def getLocale(self) -> java.util.Locale: ... + @typing.overload + def getLocation(self) -> Point: ... + @typing.overload + def getLocation(self, point: Point) -> Point: ... + def getLocationOnScreen(self) -> Point: ... + def getMaximumSize(self) -> Dimension: ... + def getMinimumSize(self) -> Dimension: ... + def getMouseListeners( + self, + ) -> typing.MutableSequence[java.awt.event.MouseListener]: ... + def getMouseMotionListeners( + self, + ) -> typing.MutableSequence[java.awt.event.MouseMotionListener]: ... + def getMousePosition(self) -> Point: ... + def getMouseWheelListeners( + self, + ) -> typing.MutableSequence[java.awt.event.MouseWheelListener]: ... + def getName(self) -> java.lang.String: ... + def getParent(self) -> Container: ... + def getPreferredSize(self) -> Dimension: ... + @typing.overload + def getPropertyChangeListeners( + self, + ) -> typing.MutableSequence[java.beans.PropertyChangeListener]: ... + @typing.overload + def getPropertyChangeListeners( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.beans.PropertyChangeListener]: ... + @typing.overload + def getSize(self) -> Dimension: ... + @typing.overload + def getSize(self, dimension: Dimension) -> Dimension: ... + def getToolkit(self) -> Toolkit: ... + def getTreeLock(self) -> typing.Any: ... + def getWidth(self) -> int: ... + def getX(self) -> int: ... + def getY(self) -> int: ... + def gotFocus(self, event: Event, object: typing.Any) -> bool: ... + def handleEvent(self, event: Event) -> bool: ... + def hasFocus(self) -> bool: ... + def hide(self) -> None: ... + def imageUpdate( + self, image: Image, int: int, int2: int, int3: int, int4: int, int5: int + ) -> bool: ... + def inside(self, int: int, int2: int) -> bool: ... + def invalidate(self) -> None: ... + def isBackgroundSet(self) -> bool: ... + def isCursorSet(self) -> bool: ... + def isDisplayable(self) -> bool: ... + def isDoubleBuffered(self) -> bool: ... + def isEnabled(self) -> bool: ... + def isFocusCycleRoot(self, container: Container) -> bool: ... + def isFocusOwner(self) -> bool: ... + def isFocusTraversable(self) -> bool: ... + def isFocusable(self) -> bool: ... + def isFontSet(self) -> bool: ... + def isForegroundSet(self) -> bool: ... + def isLightweight(self) -> bool: ... + def isMaximumSizeSet(self) -> bool: ... + def isMinimumSizeSet(self) -> bool: ... + def isOpaque(self) -> bool: ... + def isPreferredSizeSet(self) -> bool: ... + def isShowing(self) -> bool: ... + def isValid(self) -> bool: ... + def isVisible(self) -> bool: ... + def keyDown(self, event: Event, int: int) -> bool: ... + def keyUp(self, event: Event, int: int) -> bool: ... + def layout(self) -> None: ... + @typing.overload + def list(self) -> None: ... + @typing.overload + def list(self, printStream: java.io.PrintStream) -> None: ... + @typing.overload + def list(self, printStream: java.io.PrintStream, int: int) -> None: ... + @typing.overload + def list(self, printWriter: java.io.PrintWriter) -> None: ... + @typing.overload + def list(self, printWriter: java.io.PrintWriter, int: int) -> None: ... + def locate(self, int: int, int2: int) -> Component: ... + def location(self) -> Point: ... + def lostFocus(self, event: Event, object: typing.Any) -> bool: ... + def minimumSize(self) -> Dimension: ... + def mouseDown(self, event: Event, int: int, int2: int) -> bool: ... + def mouseDrag(self, event: Event, int: int, int2: int) -> bool: ... + def mouseEnter(self, event: Event, int: int, int2: int) -> bool: ... + def mouseExit(self, event: Event, int: int, int2: int) -> bool: ... + def mouseMove(self, event: Event, int: int, int2: int) -> bool: ... + def mouseUp(self, event: Event, int: int, int2: int) -> bool: ... + def move(self, int: int, int2: int) -> None: ... + def nextFocus(self) -> None: ... + def paint(self, graphics: Graphics) -> None: ... + def paintAll(self, graphics: Graphics) -> None: ... + def postEvent(self, event: Event) -> bool: ... + def preferredSize(self) -> Dimension: ... + @typing.overload + def prepareImage( + self, + image: Image, + int: int, + int2: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def prepareImage( + self, + image: Image, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + def printAll(self, graphics: Graphics) -> None: ... + def print_(self, graphics: Graphics) -> None: ... + def remove(self, menuComponent: MenuComponent) -> None: ... + def removeComponentListener( + self, componentListener: java.awt.event.ComponentListener + ) -> None: ... + def removeFocusListener( + self, focusListener: java.awt.event.FocusListener + ) -> None: ... + def removeHierarchyBoundsListener( + self, hierarchyBoundsListener: java.awt.event.HierarchyBoundsListener + ) -> None: ... + def removeHierarchyListener( + self, hierarchyListener: java.awt.event.HierarchyListener | typing.Callable + ) -> None: ... + def removeInputMethodListener( + self, inputMethodListener: java.awt.event.InputMethodListener + ) -> None: ... + def removeKeyListener(self, keyListener: java.awt.event.KeyListener) -> None: ... + def removeMouseListener( + self, mouseListener: java.awt.event.MouseListener + ) -> None: ... + def removeMouseMotionListener( + self, mouseMotionListener: java.awt.event.MouseMotionListener + ) -> None: ... + def removeMouseWheelListener( + self, mouseWheelListener: java.awt.event.MouseWheelListener | typing.Callable + ) -> None: ... + def removeNotify(self) -> None: ... + @typing.overload + def removePropertyChangeListener( + self, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def removePropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def repaint(self) -> None: ... + @typing.overload + def repaint(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def repaint(self, long: int) -> None: ... + @typing.overload + def repaint(self, long: int, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def requestFocus(self) -> None: ... + @typing.overload + def requestFocus(self, cause: java.awt.event.FocusEvent.Cause) -> None: ... + @typing.overload + def requestFocusInWindow(self) -> bool: ... + @typing.overload + def requestFocusInWindow(self, cause: java.awt.event.FocusEvent.Cause) -> bool: ... + def reshape(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def resize(self, int: int, int2: int) -> None: ... + @typing.overload + def resize(self, dimension: Dimension) -> None: ... + def revalidate(self) -> None: ... + def setBackground(self, color: Color) -> None: ... + @typing.overload + def setBounds(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setBounds(self, rectangle: Rectangle) -> None: ... + def setComponentOrientation( + self, componentOrientation: ComponentOrientation + ) -> None: ... + def setCursor(self, cursor: Cursor) -> None: ... + def setDropTarget(self, dropTarget: java.awt.dnd.DropTarget) -> None: ... + def setEnabled(self, boolean: bool) -> None: ... + def setFocusTraversalKeys( + self, int: int, set: java.util.Set[AWTKeyStroke] + ) -> None: ... + def setFocusTraversalKeysEnabled(self, boolean: bool) -> None: ... + def setFocusable(self, boolean: bool) -> None: ... + def setFont(self, font: Font) -> None: ... + def setForeground(self, color: Color) -> None: ... + def setIgnoreRepaint(self, boolean: bool) -> None: ... + def setLocale(self, locale: java.util.Locale) -> None: ... + @typing.overload + def setLocation(self, int: int, int2: int) -> None: ... + @typing.overload + def setLocation(self, point: Point) -> None: ... + def setMaximumSize(self, dimension: Dimension) -> None: ... + def setMinimumSize(self, dimension: Dimension) -> None: ... + def setMixingCutoutShape(self, shape: Shape) -> None: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setPreferredSize(self, dimension: Dimension) -> None: ... + @typing.overload + def setSize(self, int: int, int2: int) -> None: ... + @typing.overload + def setSize(self, dimension: Dimension) -> None: ... + def setVisible(self, boolean: bool) -> None: ... + @typing.overload + def show(self) -> None: ... + @typing.overload + def show(self, boolean: bool) -> None: ... + def size(self) -> Dimension: ... + def toString(self) -> java.lang.String: ... + def transferFocus(self) -> None: ... + def transferFocusBackward(self) -> None: ... + def transferFocusUpCycle(self) -> None: ... + def update(self, graphics: Graphics) -> None: ... + def validate(self) -> None: ... + class BaselineResizeBehavior(java.lang.Enum["Component.BaselineResizeBehavior"]): + CONSTANT_ASCENT: typing.ClassVar[Component.BaselineResizeBehavior] = ... + CONSTANT_DESCENT: typing.ClassVar[Component.BaselineResizeBehavior] = ... + CENTER_OFFSET: typing.ClassVar[Component.BaselineResizeBehavior] = ... + OTHER: typing.ClassVar[Component.BaselineResizeBehavior] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> Component.BaselineResizeBehavior: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[Component.BaselineResizeBehavior]: ... + +class ContainerOrderFocusTraversalPolicy(FocusTraversalPolicy, java.io.Serializable): + def __init__(self): ... + def getComponentAfter( + self, container: Container, component: Component + ) -> Component: ... + def getComponentBefore( + self, container: Container, component: Component + ) -> Component: ... + def getDefaultComponent(self, container: Container) -> Component: ... + def getFirstComponent(self, container: Container) -> Component: ... + def getImplicitDownCycleTraversal(self) -> bool: ... + def getLastComponent(self, container: Container) -> Component: ... + def setImplicitDownCycleTraversal(self, boolean: bool) -> None: ... + +class FlowLayout(LayoutManager, java.io.Serializable): + LEFT: typing.ClassVar[int] = ... + CENTER: typing.ClassVar[int] = ... + RIGHT: typing.ClassVar[int] = ... + LEADING: typing.ClassVar[int] = ... + TRAILING: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int): ... + def addLayoutComponent( + self, string: java.lang.String | str, component: Component + ) -> None: ... + def getAlignOnBaseline(self) -> bool: ... + def getAlignment(self) -> int: ... + def getHgap(self) -> int: ... + def getVgap(self) -> int: ... + def layoutContainer(self, container: Container) -> None: ... + def minimumLayoutSize(self, container: Container) -> Dimension: ... + def preferredLayoutSize(self, container: Container) -> Dimension: ... + def removeLayoutComponent(self, component: Component) -> None: ... + def setAlignOnBaseline(self, boolean: bool) -> None: ... + def setAlignment(self, int: int) -> None: ... + def setHgap(self, int: int) -> None: ... + def setVgap(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class Graphics2D(Graphics): + def addRenderingHints( + self, + map: java.util.Map[typing.Any, typing.Any] + | typing.Mapping[typing.Any, typing.Any], + ) -> None: ... + def clip(self, shape: Shape) -> None: ... + def draw(self, shape: Shape) -> None: ... + def draw3DRect( + self, int: int, int2: int, int3: int, int4: int, boolean: bool + ) -> None: ... + def drawGlyphVector( + self, glyphVector: java.awt.font.GlyphVector, float: float, float2: float + ) -> None: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + color: Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + int3: int, + int4: int, + color: Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + int3: int, + int4: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + color: Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + int: int, + int2: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: Image, + affineTransform: java.awt.geom.AffineTransform, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + bufferedImage: java.awt.image.BufferedImage, + bufferedImageOp: java.awt.image.BufferedImageOp, + int: int, + int2: int, + ) -> None: ... + def drawRenderableImage( + self, + renderableImage: java.awt.image.renderable.RenderableImage, + affineTransform: java.awt.geom.AffineTransform, + ) -> None: ... + def drawRenderedImage( + self, + renderedImage: java.awt.image.RenderedImage, + affineTransform: java.awt.geom.AffineTransform, + ) -> None: ... + @typing.overload + def drawString( + self, string: java.lang.String | str, float: float, float2: float + ) -> None: ... + @typing.overload + def drawString( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + @typing.overload + def drawString( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + float: float, + float2: float, + ) -> None: ... + @typing.overload + def drawString( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int: int, + int2: int, + ) -> None: ... + def fill(self, shape: Shape) -> None: ... + def fill3DRect( + self, int: int, int2: int, int3: int, int4: int, boolean: bool + ) -> None: ... + def getBackground(self) -> Color: ... + def getComposite(self) -> Composite: ... + def getDeviceConfiguration(self) -> GraphicsConfiguration: ... + def getFontRenderContext(self) -> java.awt.font.FontRenderContext: ... + def getPaint(self) -> Paint: ... + def getRenderingHint(self, key: RenderingHints.Key) -> typing.Any: ... + def getRenderingHints(self) -> RenderingHints: ... + def getStroke(self) -> Stroke: ... + def getTransform(self) -> java.awt.geom.AffineTransform: ... + def hit(self, rectangle: Rectangle, shape: Shape, boolean: bool) -> bool: ... + @typing.overload + def rotate(self, double: float) -> None: ... + @typing.overload + def rotate(self, double: float, double2: float, double3: float) -> None: ... + def scale(self, double: float, double2: float) -> None: ... + def setBackground(self, color: Color) -> None: ... + def setComposite(self, composite: Composite | typing.Callable) -> None: ... + def setPaint(self, paint: Paint) -> None: ... + def setRenderingHint(self, key: RenderingHints.Key, object: typing.Any) -> None: ... + def setRenderingHints( + self, + map: java.util.Map[typing.Any, typing.Any] + | typing.Mapping[typing.Any, typing.Any], + ) -> None: ... + def setStroke(self, stroke: Stroke | typing.Callable) -> None: ... + def setTransform(self, affineTransform: java.awt.geom.AffineTransform) -> None: ... + def shear(self, double: float, double2: float) -> None: ... + def transform(self, affineTransform: java.awt.geom.AffineTransform) -> None: ... + @typing.overload + def translate(self, double: float, double2: float) -> None: ... + @typing.overload + def translate(self, int: int, int2: int) -> None: ... + +class GridLayout(LayoutManager, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + def addLayoutComponent( + self, string: java.lang.String | str, component: Component + ) -> None: ... + def getColumns(self) -> int: ... + def getHgap(self) -> int: ... + def getRows(self) -> int: ... + def getVgap(self) -> int: ... + def layoutContainer(self, container: Container) -> None: ... + def minimumLayoutSize(self, container: Container) -> Dimension: ... + def preferredLayoutSize(self, container: Container) -> Dimension: ... + def removeLayoutComponent(self, component: Component) -> None: ... + def setColumns(self, int: int) -> None: ... + def setHgap(self, int: int) -> None: ... + def setRows(self, int: int) -> None: ... + def setVgap(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class KeyboardFocusManager(KeyEventDispatcher, KeyEventPostProcessor): + FORWARD_TRAVERSAL_KEYS: typing.ClassVar[int] = ... + BACKWARD_TRAVERSAL_KEYS: typing.ClassVar[int] = ... + UP_CYCLE_TRAVERSAL_KEYS: typing.ClassVar[int] = ... + DOWN_CYCLE_TRAVERSAL_KEYS: typing.ClassVar[int] = ... + def __init__(self): ... + def addKeyEventDispatcher( + self, keyEventDispatcher: KeyEventDispatcher | typing.Callable + ) -> None: ... + def addKeyEventPostProcessor( + self, keyEventPostProcessor: KeyEventPostProcessor | typing.Callable + ) -> None: ... + @typing.overload + def addPropertyChangeListener( + self, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def addPropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def addVetoableChangeListener( + self, + vetoableChangeListener: java.beans.VetoableChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def addVetoableChangeListener( + self, + string: java.lang.String | str, + vetoableChangeListener: java.beans.VetoableChangeListener | typing.Callable, + ) -> None: ... + def clearFocusOwner(self) -> None: ... + def clearGlobalFocusOwner(self) -> None: ... + def dispatchEvent(self, aWTEvent: AWTEvent) -> bool: ... + def dispatchKeyEvent(self, keyEvent: java.awt.event.KeyEvent) -> bool: ... + @typing.overload + def downFocusCycle(self, container: Container) -> None: ... + @typing.overload + def downFocusCycle(self) -> None: ... + @typing.overload + def focusNextComponent(self, component: Component) -> None: ... + @typing.overload + def focusNextComponent(self) -> None: ... + @typing.overload + def focusPreviousComponent(self, component: Component) -> None: ... + @typing.overload + def focusPreviousComponent(self) -> None: ... + def getActiveWindow(self) -> Window: ... + def getCurrentFocusCycleRoot(self) -> Container: ... + @staticmethod + def getCurrentKeyboardFocusManager() -> KeyboardFocusManager: ... + def getDefaultFocusTraversalKeys(self, int: int) -> java.util.Set[AWTKeyStroke]: ... + def getDefaultFocusTraversalPolicy(self) -> FocusTraversalPolicy: ... + def getFocusOwner(self) -> Component: ... + def getFocusedWindow(self) -> Window: ... + def getPermanentFocusOwner(self) -> Component: ... + @typing.overload + def getPropertyChangeListeners( + self, + ) -> typing.MutableSequence[java.beans.PropertyChangeListener]: ... + @typing.overload + def getPropertyChangeListeners( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.beans.PropertyChangeListener]: ... + @typing.overload + def getVetoableChangeListeners( + self, + ) -> typing.MutableSequence[java.beans.VetoableChangeListener]: ... + @typing.overload + def getVetoableChangeListeners( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.beans.VetoableChangeListener]: ... + def postProcessKeyEvent(self, keyEvent: java.awt.event.KeyEvent) -> bool: ... + def processKeyEvent( + self, component: Component, keyEvent: java.awt.event.KeyEvent + ) -> None: ... + def redispatchEvent(self, component: Component, aWTEvent: AWTEvent) -> None: ... + def removeKeyEventDispatcher( + self, keyEventDispatcher: KeyEventDispatcher | typing.Callable + ) -> None: ... + def removeKeyEventPostProcessor( + self, keyEventPostProcessor: KeyEventPostProcessor | typing.Callable + ) -> None: ... + @typing.overload + def removePropertyChangeListener( + self, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def removePropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def removeVetoableChangeListener( + self, + vetoableChangeListener: java.beans.VetoableChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def removeVetoableChangeListener( + self, + string: java.lang.String | str, + vetoableChangeListener: java.beans.VetoableChangeListener | typing.Callable, + ) -> None: ... + @staticmethod + def setCurrentKeyboardFocusManager( + keyboardFocusManager: KeyboardFocusManager, + ) -> None: ... + def setDefaultFocusTraversalKeys( + self, int: int, set: java.util.Set[AWTKeyStroke] + ) -> None: ... + def setDefaultFocusTraversalPolicy( + self, focusTraversalPolicy: FocusTraversalPolicy + ) -> None: ... + def setGlobalCurrentFocusCycleRoot(self, container: Container) -> None: ... + @typing.overload + def upFocusCycle(self, component: Component) -> None: ... + @typing.overload + def upFocusCycle(self) -> None: ... + +class LayoutManager2(LayoutManager): + @typing.overload + def addLayoutComponent( + self, string: java.lang.String | str, component: Component + ) -> None: ... + @typing.overload + def addLayoutComponent(self, component: Component, object: typing.Any) -> None: ... + def getLayoutAlignmentX(self, container: Container) -> float: ... + def getLayoutAlignmentY(self, container: Container) -> float: ... + def invalidateLayout(self, container: Container) -> None: ... + def maximumLayoutSize(self, container: Container) -> Dimension: ... + +class MenuBar(MenuComponent, MenuContainer, javax.accessibility.Accessible): + def __init__(self): ... + def add(self, menu: Menu) -> Menu: ... + def addNotify(self) -> None: ... + def countMenus(self) -> int: ... + def deleteShortcut(self, menuShortcut: MenuShortcut) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getHelpMenu(self) -> Menu: ... + def getMenu(self, int: int) -> Menu: ... + def getMenuCount(self) -> int: ... + def getShortcutMenuItem(self, menuShortcut: MenuShortcut) -> MenuItem: ... + @typing.overload + def remove(self, int: int) -> None: ... + @typing.overload + def remove(self, menuComponent: MenuComponent) -> None: ... + def removeNotify(self) -> None: ... + def setHelpMenu(self, menu: Menu) -> None: ... + def shortcuts(self) -> java.util.Enumeration[MenuShortcut]: ... + +class MenuItem(MenuComponent, javax.accessibility.Accessible): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, menuShortcut: MenuShortcut): ... + def addActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + def addNotify(self) -> None: ... + def deleteShortcut(self) -> None: ... + def disable(self) -> None: ... + @typing.overload + def enable(self) -> None: ... + @typing.overload + def enable(self, boolean: bool) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getActionCommand(self) -> java.lang.String: ... + def getActionListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ActionListener]: ... + def getLabel(self) -> java.lang.String: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def getShortcut(self) -> MenuShortcut: ... + def isEnabled(self) -> bool: ... + def paramString(self) -> java.lang.String: ... + def removeActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + def setActionCommand(self, string: java.lang.String | str) -> None: ... + def setEnabled(self, boolean: bool) -> None: ... + def setLabel(self, string: java.lang.String | str) -> None: ... + def setShortcut(self, menuShortcut: MenuShortcut) -> None: ... + +class Paint(Transparency): + def createContext( + self, + colorModel: java.awt.image.ColorModel, + rectangle: Rectangle, + rectangle2D: java.awt.geom.Rectangle2D, + affineTransform: java.awt.geom.AffineTransform, + renderingHints: RenderingHints, + ) -> PaintContext: ... + +class Polygon(Shape, java.io.Serializable): + npoints: int = ... + xpoints: typing.MutableSequence[int] = ... + ypoints: typing.MutableSequence[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ): ... + def addPoint(self, int: int, int2: int) -> None: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, int: int, int2: int) -> bool: ... + @typing.overload + def contains(self, point: Point) -> bool: ... + @typing.overload + def contains(self, point2D: java.awt.geom.Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: java.awt.geom.Rectangle2D) -> bool: ... + def getBoundingBox(self) -> Rectangle: ... + def getBounds(self) -> Rectangle: ... + def getBounds2D(self) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getPathIterator( + self, affineTransform: java.awt.geom.AffineTransform + ) -> java.awt.geom.PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: java.awt.geom.AffineTransform, double: float + ) -> java.awt.geom.PathIterator: ... + def inside(self, int: int, int2: int) -> bool: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: java.awt.geom.Rectangle2D) -> bool: ... + def invalidate(self) -> None: ... + def reset(self) -> None: ... + def translate(self, int: int, int2: int) -> None: ... + +class Rectangle(java.awt.geom.Rectangle2D, Shape, java.io.Serializable): + x: int = ... + y: int = ... + width: int = ... + height: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + @typing.overload + def __init__(self, dimension: Dimension): ... + @typing.overload + def __init__(self, point: Point): ... + @typing.overload + def __init__(self, point: Point, dimension: Dimension): ... + @typing.overload + def __init__(self, rectangle: Rectangle): ... + @typing.overload + def add(self, int: int, int2: int) -> None: ... + @typing.overload + def add(self, point: Point) -> None: ... + @typing.overload + def add(self, rectangle: Rectangle) -> None: ... + @typing.overload + def add(self, double: float, double2: float) -> None: ... + @typing.overload + def add(self, point2D: java.awt.geom.Point2D) -> None: ... + @typing.overload + def add(self, rectangle2D: java.awt.geom.Rectangle2D) -> None: ... + @typing.overload + def contains(self, int: int, int2: int) -> bool: ... + @typing.overload + def contains(self, int: int, int2: int, int3: int, int4: int) -> bool: ... + @typing.overload + def contains(self, point: Point) -> bool: ... + @typing.overload + def contains(self, rectangle: Rectangle) -> bool: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: java.awt.geom.Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: java.awt.geom.Rectangle2D) -> bool: ... + def createIntersection( + self, rectangle2D: java.awt.geom.Rectangle2D + ) -> java.awt.geom.Rectangle2D: ... + def createUnion( + self, rectangle2D: java.awt.geom.Rectangle2D + ) -> java.awt.geom.Rectangle2D: ... + def equals(self, object: typing.Any) -> bool: ... + def getBounds(self) -> Rectangle: ... + def getBounds2D(self) -> java.awt.geom.Rectangle2D: ... + def getHeight(self) -> float: ... + def getLocation(self) -> Point: ... + def getSize(self) -> Dimension: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def grow(self, int: int, int2: int) -> None: ... + def inside(self, int: int, int2: int) -> bool: ... + def intersection(self, rectangle: Rectangle) -> Rectangle: ... + @typing.overload + def intersects(self, rectangle: Rectangle) -> bool: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: java.awt.geom.Rectangle2D) -> bool: ... + def isEmpty(self) -> bool: ... + def move(self, int: int, int2: int) -> None: ... + @typing.overload + def outcode(self, double: float, double2: float) -> int: ... + @typing.overload + def outcode(self, point2D: java.awt.geom.Point2D) -> int: ... + def reshape(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def resize(self, int: int, int2: int) -> None: ... + @typing.overload + def setBounds(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setBounds(self, rectangle: Rectangle) -> None: ... + @typing.overload + def setLocation(self, int: int, int2: int) -> None: ... + @typing.overload + def setLocation(self, point: Point) -> None: ... + @typing.overload + def setRect( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setRect(self, rectangle2D: java.awt.geom.Rectangle2D) -> None: ... + @typing.overload + def setSize(self, int: int, int2: int) -> None: ... + @typing.overload + def setSize(self, dimension: Dimension) -> None: ... + def toString(self) -> java.lang.String: ... + def translate(self, int: int, int2: int) -> None: ... + @typing.overload + def union(self, rectangle: Rectangle) -> Rectangle: ... + @typing.overload + @staticmethod + def union( + rectangle2D: java.awt.geom.Rectangle2D, + rectangle2D2: java.awt.geom.Rectangle2D, + rectangle2D3: java.awt.geom.Rectangle2D, + ) -> None: ... + +class ScrollPaneAdjustable(Adjustable, java.io.Serializable): + def addAdjustmentListener( + self, adjustmentListener: java.awt.event.AdjustmentListener | typing.Callable + ) -> None: ... + def getAdjustmentListeners( + self, + ) -> typing.MutableSequence[java.awt.event.AdjustmentListener]: ... + def getBlockIncrement(self) -> int: ... + def getMaximum(self) -> int: ... + def getMinimum(self) -> int: ... + def getOrientation(self) -> int: ... + def getUnitIncrement(self) -> int: ... + def getValue(self) -> int: ... + def getValueIsAdjusting(self) -> bool: ... + def getVisibleAmount(self) -> int: ... + def paramString(self) -> java.lang.String: ... + def removeAdjustmentListener( + self, adjustmentListener: java.awt.event.AdjustmentListener | typing.Callable + ) -> None: ... + def setBlockIncrement(self, int: int) -> None: ... + def setMaximum(self, int: int) -> None: ... + def setMinimum(self, int: int) -> None: ... + def setUnitIncrement(self, int: int) -> None: ... + def setValue(self, int: int) -> None: ... + def setValueIsAdjusting(self, boolean: bool) -> None: ... + def setVisibleAmount(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class BorderLayout(LayoutManager2, java.io.Serializable): + NORTH: typing.ClassVar[java.lang.String] = ... + SOUTH: typing.ClassVar[java.lang.String] = ... + EAST: typing.ClassVar[java.lang.String] = ... + WEST: typing.ClassVar[java.lang.String] = ... + CENTER: typing.ClassVar[java.lang.String] = ... + BEFORE_FIRST_LINE: typing.ClassVar[java.lang.String] = ... + AFTER_LAST_LINE: typing.ClassVar[java.lang.String] = ... + BEFORE_LINE_BEGINS: typing.ClassVar[java.lang.String] = ... + AFTER_LINE_ENDS: typing.ClassVar[java.lang.String] = ... + PAGE_START: typing.ClassVar[java.lang.String] = ... + PAGE_END: typing.ClassVar[java.lang.String] = ... + LINE_START: typing.ClassVar[java.lang.String] = ... + LINE_END: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def addLayoutComponent(self, component: Component, object: typing.Any) -> None: ... + @typing.overload + def addLayoutComponent( + self, string: java.lang.String | str, component: Component + ) -> None: ... + def getConstraints(self, component: Component) -> typing.Any: ... + def getHgap(self) -> int: ... + def getLayoutAlignmentX(self, container: Container) -> float: ... + def getLayoutAlignmentY(self, container: Container) -> float: ... + @typing.overload + def getLayoutComponent( + self, container: Container, object: typing.Any + ) -> Component: ... + @typing.overload + def getLayoutComponent(self, object: typing.Any) -> Component: ... + def getVgap(self) -> int: ... + def invalidateLayout(self, container: Container) -> None: ... + def layoutContainer(self, container: Container) -> None: ... + def maximumLayoutSize(self, container: Container) -> Dimension: ... + def minimumLayoutSize(self, container: Container) -> Dimension: ... + def preferredLayoutSize(self, container: Container) -> Dimension: ... + def removeLayoutComponent(self, component: Component) -> None: ... + def setHgap(self, int: int) -> None: ... + def setVgap(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class Button(Component, javax.accessibility.Accessible): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def addActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + def addNotify(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getActionCommand(self) -> java.lang.String: ... + def getActionListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ActionListener]: ... + def getLabel(self) -> java.lang.String: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def removeActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + def setActionCommand(self, string: java.lang.String | str) -> None: ... + def setLabel(self, string: java.lang.String | str) -> None: ... + +class Canvas(Component, javax.accessibility.Accessible): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, graphicsConfiguration: GraphicsConfiguration): ... + def addNotify(self) -> None: ... + @typing.overload + def createBufferStrategy(self, int: int) -> None: ... + @typing.overload + def createBufferStrategy( + self, int: int, bufferCapabilities: BufferCapabilities + ) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getBufferStrategy(self) -> java.awt.image.BufferStrategy: ... + def paint(self, graphics: Graphics) -> None: ... + def update(self, graphics: Graphics) -> None: ... + +class CardLayout(LayoutManager2, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def addLayoutComponent(self, component: Component, object: typing.Any) -> None: ... + @typing.overload + def addLayoutComponent( + self, string: java.lang.String | str, component: Component + ) -> None: ... + def first(self, container: Container) -> None: ... + def getHgap(self) -> int: ... + def getLayoutAlignmentX(self, container: Container) -> float: ... + def getLayoutAlignmentY(self, container: Container) -> float: ... + def getVgap(self) -> int: ... + def invalidateLayout(self, container: Container) -> None: ... + def last(self, container: Container) -> None: ... + def layoutContainer(self, container: Container) -> None: ... + def maximumLayoutSize(self, container: Container) -> Dimension: ... + def minimumLayoutSize(self, container: Container) -> Dimension: ... + def next(self, container: Container) -> None: ... + def preferredLayoutSize(self, container: Container) -> Dimension: ... + def previous(self, container: Container) -> None: ... + def removeLayoutComponent(self, component: Component) -> None: ... + def setHgap(self, int: int) -> None: ... + def setVgap(self, int: int) -> None: ... + def show(self, container: Container, string: java.lang.String | str) -> None: ... + def toString(self) -> java.lang.String: ... + +class Checkbox(Component, ItemSelectable, javax.accessibility.Accessible): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + boolean: bool, + checkboxGroup: CheckboxGroup, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + checkboxGroup: CheckboxGroup, + boolean: bool, + ): ... + def addItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + def addNotify(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getCheckboxGroup(self) -> CheckboxGroup: ... + def getItemListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ItemListener]: ... + def getLabel(self) -> java.lang.String: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def getSelectedObjects(self) -> typing.MutableSequence[typing.Any]: ... + def getState(self) -> bool: ... + def removeItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + def setCheckboxGroup(self, checkboxGroup: CheckboxGroup) -> None: ... + def setLabel(self, string: java.lang.String | str) -> None: ... + def setState(self, boolean: bool) -> None: ... + +class CheckboxMenuItem(MenuItem, ItemSelectable, javax.accessibility.Accessible): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + def addItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + def addNotify(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getItemListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ItemListener]: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def getSelectedObjects(self) -> typing.MutableSequence[typing.Any]: ... + def getState(self) -> bool: ... + def paramString(self) -> java.lang.String: ... + def removeItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + def setState(self, boolean: bool) -> None: ... + +class Choice(Component, ItemSelectable, javax.accessibility.Accessible): + def __init__(self): ... + @typing.overload + def add(self, string: java.lang.String | str) -> None: ... + @typing.overload + def add(self, popupMenu: PopupMenu) -> None: ... + def addItem(self, string: java.lang.String | str) -> None: ... + def addItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + def addNotify(self) -> None: ... + def countItems(self) -> int: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getItem(self, int: int) -> java.lang.String: ... + def getItemCount(self) -> int: ... + def getItemListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ItemListener]: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def getSelectedIndex(self) -> int: ... + def getSelectedItem(self) -> java.lang.String: ... + def getSelectedObjects(self) -> typing.MutableSequence[typing.Any]: ... + def insert(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def remove(self, int: int) -> None: ... + @typing.overload + def remove(self, string: java.lang.String | str) -> None: ... + @typing.overload + def remove(self, menuComponent: MenuComponent) -> None: ... + def removeAll(self) -> None: ... + def removeItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + @typing.overload + def select(self, int: int) -> None: ... + @typing.overload + def select(self, string: java.lang.String | str) -> None: ... + +class Color(Paint, java.io.Serializable): + white: typing.ClassVar[Color] = ... + WHITE: typing.ClassVar[Color] = ... + lightGray: typing.ClassVar[Color] = ... + LIGHT_GRAY: typing.ClassVar[Color] = ... + gray: typing.ClassVar[Color] = ... + GRAY: typing.ClassVar[Color] = ... + darkGray: typing.ClassVar[Color] = ... + DARK_GRAY: typing.ClassVar[Color] = ... + black: typing.ClassVar[Color] = ... + BLACK: typing.ClassVar[Color] = ... + red: typing.ClassVar[Color] = ... + RED: typing.ClassVar[Color] = ... + pink: typing.ClassVar[Color] = ... + PINK: typing.ClassVar[Color] = ... + orange: typing.ClassVar[Color] = ... + ORANGE: typing.ClassVar[Color] = ... + yellow: typing.ClassVar[Color] = ... + YELLOW: typing.ClassVar[Color] = ... + green: typing.ClassVar[Color] = ... + GREEN: typing.ClassVar[Color] = ... + magenta: typing.ClassVar[Color] = ... + MAGENTA: typing.ClassVar[Color] = ... + cyan: typing.ClassVar[Color] = ... + CYAN: typing.ClassVar[Color] = ... + blue: typing.ClassVar[Color] = ... + BLUE: typing.ClassVar[Color] = ... + @typing.overload + def __init__(self, float: float, float2: float, float3: float): ... + @typing.overload + def __init__(self, float: float, float2: float, float3: float, float4: float): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, boolean: bool): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + @typing.overload + def __init__( + self, + colorSpace: java.awt.color.ColorSpace, + floatArray: list[float] | jpype.JArray, + float2: float, + ): ... + @staticmethod + def HSBtoRGB(float: float, float2: float, float3: float) -> int: ... + @staticmethod + def RGBtoHSB( + int: int, int2: int, int3: int, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def brighter(self) -> Color: ... + def createContext( + self, + colorModel: java.awt.image.ColorModel, + rectangle: Rectangle, + rectangle2D: java.awt.geom.Rectangle2D, + affineTransform: java.awt.geom.AffineTransform, + renderingHints: RenderingHints, + ) -> PaintContext: ... + def darker(self) -> Color: ... + @staticmethod + def decode(string: java.lang.String | str) -> Color: ... + def equals(self, object: typing.Any) -> bool: ... + def getAlpha(self) -> int: ... + def getBlue(self) -> int: ... + @typing.overload + @staticmethod + def getColor(string: java.lang.String | str) -> Color: ... + @typing.overload + @staticmethod + def getColor(string: java.lang.String | str, int: int) -> Color: ... + @typing.overload + @staticmethod + def getColor(string: java.lang.String | str, color: Color) -> Color: ... + @typing.overload + def getColorComponents( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getColorComponents( + self, + colorSpace: java.awt.color.ColorSpace, + floatArray: list[float] | jpype.JArray, + ) -> typing.MutableSequence[float]: ... + def getColorSpace(self) -> java.awt.color.ColorSpace: ... + @typing.overload + def getComponents( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getComponents( + self, + colorSpace: java.awt.color.ColorSpace, + floatArray: list[float] | jpype.JArray, + ) -> typing.MutableSequence[float]: ... + def getGreen(self) -> int: ... + @staticmethod + def getHSBColor(float: float, float2: float, float3: float) -> Color: ... + def getRGB(self) -> int: ... + def getRGBColorComponents( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def getRGBComponents( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def getRed(self) -> int: ... + def getTransparency(self) -> int: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class Container(Component): + def __init__(self): ... + @typing.overload + def add(self, component: Component) -> Component: ... + @typing.overload + def add(self, component: Component, int: int) -> Component: ... + @typing.overload + def add( + self, string: java.lang.String | str, component: Component + ) -> Component: ... + @typing.overload + def add(self, popupMenu: PopupMenu) -> None: ... + @typing.overload + def add(self, component: Component, object: typing.Any) -> None: ... + @typing.overload + def add(self, component: Component, object: typing.Any, int: int) -> None: ... + def addContainerListener( + self, containerListener: java.awt.event.ContainerListener + ) -> None: ... + def addNotify(self) -> None: ... + @typing.overload + def addPropertyChangeListener( + self, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def addPropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def applyComponentOrientation( + self, componentOrientation: ComponentOrientation + ) -> None: ... + def areFocusTraversalKeysSet(self, int: int) -> bool: ... + def countComponents(self) -> int: ... + def deliverEvent(self, event: Event) -> None: ... + def doLayout(self) -> None: ... + @typing.overload + def findComponentAt(self, int: int, int2: int) -> Component: ... + @typing.overload + def findComponentAt(self, point: Point) -> Component: ... + def getAlignmentX(self) -> float: ... + def getAlignmentY(self) -> float: ... + def getComponent(self, int: int) -> Component: ... + @typing.overload + def getComponentAt(self, int: int, int2: int) -> Component: ... + @typing.overload + def getComponentAt(self, point: Point) -> Component: ... + def getComponentCount(self) -> int: ... + def getComponentZOrder(self, component: Component) -> int: ... + def getComponents(self) -> typing.MutableSequence[Component]: ... + def getContainerListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ContainerListener]: ... + def getFocusTraversalKeys(self, int: int) -> java.util.Set[AWTKeyStroke]: ... + def getFocusTraversalPolicy(self) -> FocusTraversalPolicy: ... + def getInsets(self) -> Insets: ... + def getLayout(self) -> LayoutManager: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def getMaximumSize(self) -> Dimension: ... + def getMinimumSize(self) -> Dimension: ... + @typing.overload + def getMousePosition(self) -> Point: ... + @typing.overload + def getMousePosition(self, boolean: bool) -> Point: ... + def getPreferredSize(self) -> Dimension: ... + def insets(self) -> Insets: ... + def invalidate(self) -> None: ... + def isAncestorOf(self, component: Component) -> bool: ... + @typing.overload + def isFocusCycleRoot(self) -> bool: ... + @typing.overload + def isFocusCycleRoot(self, container: Container) -> bool: ... + def isFocusTraversalPolicyProvider(self) -> bool: ... + def isFocusTraversalPolicySet(self) -> bool: ... + def isValidateRoot(self) -> bool: ... + def layout(self) -> None: ... + @typing.overload + def list(self) -> None: ... + @typing.overload + def list(self, printStream: java.io.PrintStream) -> None: ... + @typing.overload + def list(self, printWriter: java.io.PrintWriter) -> None: ... + @typing.overload + def list(self, printStream: java.io.PrintStream, int: int) -> None: ... + @typing.overload + def list(self, printWriter: java.io.PrintWriter, int: int) -> None: ... + def locate(self, int: int, int2: int) -> Component: ... + def minimumSize(self) -> Dimension: ... + def paint(self, graphics: Graphics) -> None: ... + def paintComponents(self, graphics: Graphics) -> None: ... + def preferredSize(self) -> Dimension: ... + def printComponents(self, graphics: Graphics) -> None: ... + def print_(self, graphics: Graphics) -> None: ... + @typing.overload + def remove(self, menuComponent: MenuComponent) -> None: ... + @typing.overload + def remove(self, int: int) -> None: ... + @typing.overload + def remove(self, component: Component) -> None: ... + def removeAll(self) -> None: ... + def removeContainerListener( + self, containerListener: java.awt.event.ContainerListener + ) -> None: ... + def removeNotify(self) -> None: ... + def setComponentZOrder(self, component: Component, int: int) -> None: ... + def setFocusCycleRoot(self, boolean: bool) -> None: ... + def setFocusTraversalKeys( + self, int: int, set: java.util.Set[AWTKeyStroke] + ) -> None: ... + def setFocusTraversalPolicy( + self, focusTraversalPolicy: FocusTraversalPolicy + ) -> None: ... + def setFocusTraversalPolicyProvider(self, boolean: bool) -> None: ... + def setFont(self, font: Font) -> None: ... + def setLayout(self, layoutManager: LayoutManager) -> None: ... + def transferFocusDownCycle(self) -> None: ... + def update(self, graphics: Graphics) -> None: ... + def validate(self) -> None: ... + +class DefaultFocusTraversalPolicy(ContainerOrderFocusTraversalPolicy): + def __init__(self): ... + +class DefaultKeyboardFocusManager(KeyboardFocusManager): + def __init__(self): ... + def dispatchEvent(self, aWTEvent: AWTEvent) -> bool: ... + def dispatchKeyEvent(self, keyEvent: java.awt.event.KeyEvent) -> bool: ... + @typing.overload + def downFocusCycle(self) -> None: ... + @typing.overload + def downFocusCycle(self, container: Container) -> None: ... + @typing.overload + def focusNextComponent(self) -> None: ... + @typing.overload + def focusNextComponent(self, component: Component) -> None: ... + @typing.overload + def focusPreviousComponent(self) -> None: ... + @typing.overload + def focusPreviousComponent(self, component: Component) -> None: ... + def postProcessKeyEvent(self, keyEvent: java.awt.event.KeyEvent) -> bool: ... + def processKeyEvent( + self, component: Component, keyEvent: java.awt.event.KeyEvent + ) -> None: ... + @typing.overload + def upFocusCycle(self) -> None: ... + @typing.overload + def upFocusCycle(self, component: Component) -> None: ... + +class GradientPaint(Paint): + @typing.overload + def __init__( + self, + float: float, + float2: float, + color: Color, + float3: float, + float4: float, + color2: Color, + ): ... + @typing.overload + def __init__( + self, + float: float, + float2: float, + color: Color, + float3: float, + float4: float, + color2: Color, + boolean: bool, + ): ... + @typing.overload + def __init__( + self, + point2D: java.awt.geom.Point2D, + color: Color, + point2D2: java.awt.geom.Point2D, + color2: Color, + ): ... + @typing.overload + def __init__( + self, + point2D: java.awt.geom.Point2D, + color: Color, + point2D2: java.awt.geom.Point2D, + color2: Color, + boolean: bool, + ): ... + def createContext( + self, + colorModel: java.awt.image.ColorModel, + rectangle: Rectangle, + rectangle2D: java.awt.geom.Rectangle2D, + affineTransform: java.awt.geom.AffineTransform, + renderingHints: RenderingHints, + ) -> PaintContext: ... + def getColor1(self) -> Color: ... + def getColor2(self) -> Color: ... + def getPoint1(self) -> java.awt.geom.Point2D: ... + def getPoint2(self) -> java.awt.geom.Point2D: ... + def getTransparency(self) -> int: ... + def isCyclic(self) -> bool: ... + +class GridBagLayout(LayoutManager2, java.io.Serializable): + columnWidths: typing.MutableSequence[int] = ... + rowHeights: typing.MutableSequence[int] = ... + columnWeights: typing.MutableSequence[float] = ... + rowWeights: typing.MutableSequence[float] = ... + def __init__(self): ... + @typing.overload + def addLayoutComponent(self, component: Component, object: typing.Any) -> None: ... + @typing.overload + def addLayoutComponent( + self, string: java.lang.String | str, component: Component + ) -> None: ... + def getConstraints(self, component: Component) -> GridBagConstraints: ... + def getLayoutAlignmentX(self, container: Container) -> float: ... + def getLayoutAlignmentY(self, container: Container) -> float: ... + def getLayoutDimensions( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getLayoutOrigin(self) -> Point: ... + def getLayoutWeights( + self, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def invalidateLayout(self, container: Container) -> None: ... + def layoutContainer(self, container: Container) -> None: ... + def location(self, int: int, int2: int) -> Point: ... + def maximumLayoutSize(self, container: Container) -> Dimension: ... + def minimumLayoutSize(self, container: Container) -> Dimension: ... + def preferredLayoutSize(self, container: Container) -> Dimension: ... + def removeLayoutComponent(self, component: Component) -> None: ... + def setConstraints( + self, component: Component, gridBagConstraints: GridBagConstraints + ) -> None: ... + def toString(self) -> java.lang.String: ... + +class Label(Component, javax.accessibility.Accessible): + LEFT: typing.ClassVar[int] = ... + CENTER: typing.ClassVar[int] = ... + RIGHT: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + def addNotify(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getAlignment(self) -> int: ... + def getText(self) -> java.lang.String: ... + def setAlignment(self, int: int) -> None: ... + def setText(self, string: java.lang.String | str) -> None: ... + +class List(Component, ItemSelectable, javax.accessibility.Accessible): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, boolean: bool): ... + @typing.overload + def add(self, popupMenu: PopupMenu) -> None: ... + @typing.overload + def add(self, string: java.lang.String | str) -> None: ... + @typing.overload + def add(self, string: java.lang.String | str, int: int) -> None: ... + def addActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + @typing.overload + def addItem(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def addItem(self, string: java.lang.String | str) -> None: ... + def addItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + def addNotify(self) -> None: ... + def allowsMultipleSelections(self) -> bool: ... + def clear(self) -> None: ... + def countItems(self) -> int: ... + def delItem(self, int: int) -> None: ... + def delItems(self, int: int, int2: int) -> None: ... + def deselect(self, int: int) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getActionListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ActionListener]: ... + def getItem(self, int: int) -> java.lang.String: ... + def getItemCount(self) -> int: ... + def getItemListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ItemListener]: ... + def getItems(self) -> typing.MutableSequence[java.lang.String]: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + @typing.overload + def getMinimumSize(self) -> Dimension: ... + @typing.overload + def getMinimumSize(self, int: int) -> Dimension: ... + @typing.overload + def getPreferredSize(self) -> Dimension: ... + @typing.overload + def getPreferredSize(self, int: int) -> Dimension: ... + def getRows(self) -> int: ... + def getSelectedIndex(self) -> int: ... + def getSelectedIndexes(self) -> typing.MutableSequence[int]: ... + def getSelectedItem(self) -> java.lang.String: ... + def getSelectedItems(self) -> typing.MutableSequence[java.lang.String]: ... + def getSelectedObjects(self) -> typing.MutableSequence[typing.Any]: ... + def getVisibleIndex(self) -> int: ... + def isIndexSelected(self, int: int) -> bool: ... + def isMultipleMode(self) -> bool: ... + def isSelected(self, int: int) -> bool: ... + def makeVisible(self, int: int) -> None: ... + @typing.overload + def minimumSize(self) -> Dimension: ... + @typing.overload + def minimumSize(self, int: int) -> Dimension: ... + @typing.overload + def preferredSize(self) -> Dimension: ... + @typing.overload + def preferredSize(self, int: int) -> Dimension: ... + @typing.overload + def remove(self, string: java.lang.String | str) -> None: ... + @typing.overload + def remove(self, menuComponent: MenuComponent) -> None: ... + @typing.overload + def remove(self, int: int) -> None: ... + def removeActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + def removeAll(self) -> None: ... + def removeItemListener( + self, itemListener: java.awt.event.ItemListener | typing.Callable + ) -> None: ... + def removeNotify(self) -> None: ... + def replaceItem(self, string: java.lang.String | str, int: int) -> None: ... + def select(self, int: int) -> None: ... + def setMultipleMode(self, boolean: bool) -> None: ... + def setMultipleSelections(self, boolean: bool) -> None: ... + +class Menu(MenuItem, MenuContainer, javax.accessibility.Accessible): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + @typing.overload + def add(self, menuItem: MenuItem) -> MenuItem: ... + @typing.overload + def add(self, string: java.lang.String | str) -> None: ... + def addNotify(self) -> None: ... + def addSeparator(self) -> None: ... + def countItems(self) -> int: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getItem(self, int: int) -> MenuItem: ... + def getItemCount(self) -> int: ... + @typing.overload + def insert(self, menuItem: MenuItem, int: int) -> None: ... + @typing.overload + def insert(self, string: java.lang.String | str, int: int) -> None: ... + def insertSeparator(self, int: int) -> None: ... + def isTearOff(self) -> bool: ... + def paramString(self) -> java.lang.String: ... + @typing.overload + def remove(self, int: int) -> None: ... + @typing.overload + def remove(self, menuComponent: MenuComponent) -> None: ... + def removeAll(self) -> None: ... + def removeNotify(self) -> None: ... + +class MultipleGradientPaint(Paint): + def getColorSpace(self) -> MultipleGradientPaint.ColorSpaceType: ... + def getColors(self) -> typing.MutableSequence[Color]: ... + def getCycleMethod(self) -> MultipleGradientPaint.CycleMethod: ... + def getFractions(self) -> typing.MutableSequence[float]: ... + def getTransform(self) -> java.awt.geom.AffineTransform: ... + def getTransparency(self) -> int: ... + class ColorSpaceType(java.lang.Enum["MultipleGradientPaint.ColorSpaceType"]): + SRGB: typing.ClassVar[MultipleGradientPaint.ColorSpaceType] = ... + LINEAR_RGB: typing.ClassVar[MultipleGradientPaint.ColorSpaceType] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> MultipleGradientPaint.ColorSpaceType: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[ + MultipleGradientPaint.ColorSpaceType + ]: ... + + class CycleMethod(java.lang.Enum["MultipleGradientPaint.CycleMethod"]): + NO_CYCLE: typing.ClassVar[MultipleGradientPaint.CycleMethod] = ... + REFLECT: typing.ClassVar[MultipleGradientPaint.CycleMethod] = ... + REPEAT: typing.ClassVar[MultipleGradientPaint.CycleMethod] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> MultipleGradientPaint.CycleMethod: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[MultipleGradientPaint.CycleMethod]: ... + +class Scrollbar(Component, Adjustable, javax.accessibility.Accessible): + HORIZONTAL: typing.ClassVar[int] = ... + VERTICAL: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int, int5: int): ... + def addAdjustmentListener( + self, adjustmentListener: java.awt.event.AdjustmentListener | typing.Callable + ) -> None: ... + def addNotify(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getAdjustmentListeners( + self, + ) -> typing.MutableSequence[java.awt.event.AdjustmentListener]: ... + def getBlockIncrement(self) -> int: ... + def getLineIncrement(self) -> int: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def getMaximum(self) -> int: ... + def getMinimum(self) -> int: ... + def getOrientation(self) -> int: ... + def getPageIncrement(self) -> int: ... + def getUnitIncrement(self) -> int: ... + def getValue(self) -> int: ... + def getValueIsAdjusting(self) -> bool: ... + def getVisible(self) -> int: ... + def getVisibleAmount(self) -> int: ... + def removeAdjustmentListener( + self, adjustmentListener: java.awt.event.AdjustmentListener | typing.Callable + ) -> None: ... + def setBlockIncrement(self, int: int) -> None: ... + def setLineIncrement(self, int: int) -> None: ... + def setMaximum(self, int: int) -> None: ... + def setMinimum(self, int: int) -> None: ... + def setOrientation(self, int: int) -> None: ... + def setPageIncrement(self, int: int) -> None: ... + def setUnitIncrement(self, int: int) -> None: ... + def setValue(self, int: int) -> None: ... + def setValueIsAdjusting(self, boolean: bool) -> None: ... + def setValues(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def setVisibleAmount(self, int: int) -> None: ... + +class TextComponent(Component, javax.accessibility.Accessible): + def addNotify(self) -> None: ... + def addTextListener( + self, textListener: java.awt.event.TextListener | typing.Callable + ) -> None: ... + def enableInputMethods(self, boolean: bool) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getBackground(self) -> Color: ... + def getCaretPosition(self) -> int: ... + def getInputMethodRequests(self) -> java.awt.im.InputMethodRequests: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def getSelectedText(self) -> java.lang.String: ... + def getSelectionEnd(self) -> int: ... + def getSelectionStart(self) -> int: ... + def getText(self) -> java.lang.String: ... + def getTextListeners( + self, + ) -> typing.MutableSequence[java.awt.event.TextListener]: ... + def isEditable(self) -> bool: ... + def removeNotify(self) -> None: ... + def removeTextListener( + self, textListener: java.awt.event.TextListener | typing.Callable + ) -> None: ... + def select(self, int: int, int2: int) -> None: ... + def selectAll(self) -> None: ... + def setBackground(self, color: Color) -> None: ... + def setCaretPosition(self, int: int) -> None: ... + def setEditable(self, boolean: bool) -> None: ... + def setSelectionEnd(self, int: int) -> None: ... + def setSelectionStart(self, int: int) -> None: ... + def setText(self, string: java.lang.String | str) -> None: ... + +class TexturePaint(Paint): + def __init__( + self, + bufferedImage: java.awt.image.BufferedImage, + rectangle2D: java.awt.geom.Rectangle2D, + ): ... + def createContext( + self, + colorModel: java.awt.image.ColorModel, + rectangle: Rectangle, + rectangle2D: java.awt.geom.Rectangle2D, + affineTransform: java.awt.geom.AffineTransform, + renderingHints: RenderingHints, + ) -> PaintContext: ... + def getAnchorRect(self) -> java.awt.geom.Rectangle2D: ... + def getImage(self) -> java.awt.image.BufferedImage: ... + def getTransparency(self) -> int: ... + +class LinearGradientPaint(MultipleGradientPaint): + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + float4: float, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + float4: float, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + cycleMethod: MultipleGradientPaint.CycleMethod, + ): ... + @typing.overload + def __init__( + self, + point2D: java.awt.geom.Point2D, + point2D2: java.awt.geom.Point2D, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + point2D: java.awt.geom.Point2D, + point2D2: java.awt.geom.Point2D, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + cycleMethod: MultipleGradientPaint.CycleMethod, + ): ... + @typing.overload + def __init__( + self, + point2D: java.awt.geom.Point2D, + point2D2: java.awt.geom.Point2D, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + cycleMethod: MultipleGradientPaint.CycleMethod, + colorSpaceType: MultipleGradientPaint.ColorSpaceType, + affineTransform: java.awt.geom.AffineTransform, + ): ... + def createContext( + self, + colorModel: java.awt.image.ColorModel, + rectangle: Rectangle, + rectangle2D: java.awt.geom.Rectangle2D, + affineTransform: java.awt.geom.AffineTransform, + renderingHints: RenderingHints, + ) -> PaintContext: ... + def getEndPoint(self) -> java.awt.geom.Point2D: ... + def getStartPoint(self) -> java.awt.geom.Point2D: ... + +class Panel(Container, javax.accessibility.Accessible): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, layoutManager: LayoutManager): ... + def addNotify(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + +class PopupMenu(Menu): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def addNotify(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getParent(self) -> MenuContainer: ... + def show(self, component: Component, int: int, int2: int) -> None: ... + +class RadialGradientPaint(MultipleGradientPaint): + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + cycleMethod: MultipleGradientPaint.CycleMethod, + ): ... + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + cycleMethod: MultipleGradientPaint.CycleMethod, + ): ... + @typing.overload + def __init__( + self, + point2D: java.awt.geom.Point2D, + float: float, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + point2D: java.awt.geom.Point2D, + float: float, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + cycleMethod: MultipleGradientPaint.CycleMethod, + ): ... + @typing.overload + def __init__( + self, + point2D: java.awt.geom.Point2D, + float: float, + point2D2: java.awt.geom.Point2D, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + cycleMethod: MultipleGradientPaint.CycleMethod, + ): ... + @typing.overload + def __init__( + self, + point2D: java.awt.geom.Point2D, + float: float, + point2D2: java.awt.geom.Point2D, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + cycleMethod: MultipleGradientPaint.CycleMethod, + colorSpaceType: MultipleGradientPaint.ColorSpaceType, + affineTransform: java.awt.geom.AffineTransform, + ): ... + @typing.overload + def __init__( + self, + rectangle2D: java.awt.geom.Rectangle2D, + floatArray: list[float] | jpype.JArray, + colorArray: list[Color] | jpype.JArray, + cycleMethod: MultipleGradientPaint.CycleMethod, + ): ... + def createContext( + self, + colorModel: java.awt.image.ColorModel, + rectangle: Rectangle, + rectangle2D: java.awt.geom.Rectangle2D, + affineTransform: java.awt.geom.AffineTransform, + renderingHints: RenderingHints, + ) -> PaintContext: ... + def getCenterPoint(self) -> java.awt.geom.Point2D: ... + def getFocusPoint(self) -> java.awt.geom.Point2D: ... + def getRadius(self) -> float: ... + +class ScrollPane(Container, javax.accessibility.Accessible): + SCROLLBARS_AS_NEEDED: typing.ClassVar[int] = ... + SCROLLBARS_ALWAYS: typing.ClassVar[int] = ... + SCROLLBARS_NEVER: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + def addNotify(self) -> None: ... + def doLayout(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getHAdjustable(self) -> Adjustable: ... + def getHScrollbarHeight(self) -> int: ... + def getScrollPosition(self) -> Point: ... + def getScrollbarDisplayPolicy(self) -> int: ... + def getVAdjustable(self) -> Adjustable: ... + def getVScrollbarWidth(self) -> int: ... + def getViewportSize(self) -> Dimension: ... + def isWheelScrollingEnabled(self) -> bool: ... + def layout(self) -> None: ... + def paramString(self) -> java.lang.String: ... + def printComponents(self, graphics: Graphics) -> None: ... + def setLayout(self, layoutManager: LayoutManager) -> None: ... + @typing.overload + def setScrollPosition(self, int: int, int2: int) -> None: ... + @typing.overload + def setScrollPosition(self, point: Point) -> None: ... + def setWheelScrollingEnabled(self, boolean: bool) -> None: ... + +class SystemColor(Color, java.io.Serializable): + DESKTOP: typing.ClassVar[int] = ... + ACTIVE_CAPTION: typing.ClassVar[int] = ... + ACTIVE_CAPTION_TEXT: typing.ClassVar[int] = ... + ACTIVE_CAPTION_BORDER: typing.ClassVar[int] = ... + INACTIVE_CAPTION: typing.ClassVar[int] = ... + INACTIVE_CAPTION_TEXT: typing.ClassVar[int] = ... + INACTIVE_CAPTION_BORDER: typing.ClassVar[int] = ... + WINDOW: typing.ClassVar[int] = ... + WINDOW_BORDER: typing.ClassVar[int] = ... + WINDOW_TEXT: typing.ClassVar[int] = ... + MENU: typing.ClassVar[int] = ... + MENU_TEXT: typing.ClassVar[int] = ... + TEXT: typing.ClassVar[int] = ... + TEXT_TEXT: typing.ClassVar[int] = ... + TEXT_HIGHLIGHT: typing.ClassVar[int] = ... + TEXT_HIGHLIGHT_TEXT: typing.ClassVar[int] = ... + TEXT_INACTIVE_TEXT: typing.ClassVar[int] = ... + CONTROL: typing.ClassVar[int] = ... + CONTROL_TEXT: typing.ClassVar[int] = ... + CONTROL_HIGHLIGHT: typing.ClassVar[int] = ... + CONTROL_LT_HIGHLIGHT: typing.ClassVar[int] = ... + CONTROL_SHADOW: typing.ClassVar[int] = ... + CONTROL_DK_SHADOW: typing.ClassVar[int] = ... + SCROLLBAR: typing.ClassVar[int] = ... + INFO: typing.ClassVar[int] = ... + INFO_TEXT: typing.ClassVar[int] = ... + NUM_COLORS: typing.ClassVar[int] = ... + desktop: typing.ClassVar[SystemColor] = ... + activeCaption: typing.ClassVar[SystemColor] = ... + activeCaptionText: typing.ClassVar[SystemColor] = ... + activeCaptionBorder: typing.ClassVar[SystemColor] = ... + inactiveCaption: typing.ClassVar[SystemColor] = ... + inactiveCaptionText: typing.ClassVar[SystemColor] = ... + inactiveCaptionBorder: typing.ClassVar[SystemColor] = ... + window: typing.ClassVar[SystemColor] = ... + windowBorder: typing.ClassVar[SystemColor] = ... + windowText: typing.ClassVar[SystemColor] = ... + menu: typing.ClassVar[SystemColor] = ... + menuText: typing.ClassVar[SystemColor] = ... + text: typing.ClassVar[SystemColor] = ... + textText: typing.ClassVar[SystemColor] = ... + textHighlight: typing.ClassVar[SystemColor] = ... + textHighlightText: typing.ClassVar[SystemColor] = ... + textInactiveText: typing.ClassVar[SystemColor] = ... + control: typing.ClassVar[SystemColor] = ... + controlText: typing.ClassVar[SystemColor] = ... + controlHighlight: typing.ClassVar[SystemColor] = ... + controlLtHighlight: typing.ClassVar[SystemColor] = ... + controlShadow: typing.ClassVar[SystemColor] = ... + controlDkShadow: typing.ClassVar[SystemColor] = ... + scrollbar: typing.ClassVar[SystemColor] = ... + info: typing.ClassVar[SystemColor] = ... + infoText: typing.ClassVar[SystemColor] = ... + def toString(self) -> java.lang.String: ... + +class TextArea(TextComponent): + SCROLLBARS_BOTH: typing.ClassVar[int] = ... + SCROLLBARS_VERTICAL_ONLY: typing.ClassVar[int] = ... + SCROLLBARS_HORIZONTAL_ONLY: typing.ClassVar[int] = ... + SCROLLBARS_NONE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int, int2: int): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ): ... + def addNotify(self) -> None: ... + def append(self, string: java.lang.String | str) -> None: ... + def appendText(self, string: java.lang.String | str) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getColumns(self) -> int: ... + @typing.overload + def getMinimumSize(self) -> Dimension: ... + @typing.overload + def getMinimumSize(self, int: int, int2: int) -> Dimension: ... + @typing.overload + def getPreferredSize(self) -> Dimension: ... + @typing.overload + def getPreferredSize(self, int: int, int2: int) -> Dimension: ... + def getRows(self) -> int: ... + def getScrollbarVisibility(self) -> int: ... + def insert(self, string: java.lang.String | str, int: int) -> None: ... + def insertText(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def minimumSize(self) -> Dimension: ... + @typing.overload + def minimumSize(self, int: int, int2: int) -> Dimension: ... + @typing.overload + def preferredSize(self) -> Dimension: ... + @typing.overload + def preferredSize(self, int: int, int2: int) -> Dimension: ... + def replaceRange( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def replaceText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setColumns(self, int: int) -> None: ... + def setRows(self, int: int) -> None: ... + +class TextField(TextComponent): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + def addActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + def addNotify(self) -> None: ... + def echoCharIsSet(self) -> bool: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getActionListeners( + self, + ) -> typing.MutableSequence[java.awt.event.ActionListener]: ... + def getColumns(self) -> int: ... + def getEchoChar(self) -> str: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + @typing.overload + def getMinimumSize(self) -> Dimension: ... + @typing.overload + def getMinimumSize(self, int: int) -> Dimension: ... + @typing.overload + def getPreferredSize(self) -> Dimension: ... + @typing.overload + def getPreferredSize(self, int: int) -> Dimension: ... + @typing.overload + def minimumSize(self) -> Dimension: ... + @typing.overload + def minimumSize(self, int: int) -> Dimension: ... + @typing.overload + def preferredSize(self) -> Dimension: ... + @typing.overload + def preferredSize(self, int: int) -> Dimension: ... + def removeActionListener( + self, actionListener: java.awt.event.ActionListener | typing.Callable + ) -> None: ... + def setColumns(self, int: int) -> None: ... + def setEchoChar(self, char: str) -> None: ... + def setEchoCharacter(self, char: str) -> None: ... + def setText(self, string: java.lang.String | str) -> None: ... + +class Window(Container, javax.accessibility.Accessible): + @typing.overload + def __init__(self, frame: Frame): ... + @typing.overload + def __init__(self, window: Window): ... + @typing.overload + def __init__( + self, window: Window, graphicsConfiguration: GraphicsConfiguration + ): ... + def addNotify(self) -> None: ... + @typing.overload + def addPropertyChangeListener( + self, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def addPropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def addWindowFocusListener( + self, windowFocusListener: java.awt.event.WindowFocusListener + ) -> None: ... + def addWindowListener( + self, windowListener: java.awt.event.WindowListener + ) -> None: ... + def addWindowStateListener( + self, windowStateListener: java.awt.event.WindowStateListener | typing.Callable + ) -> None: ... + @typing.overload + def applyResourceBundle(self, string: java.lang.String | str) -> None: ... + @typing.overload + def applyResourceBundle(self, resourceBundle: java.util.ResourceBundle) -> None: ... + @typing.overload + def createBufferStrategy(self, int: int) -> None: ... + @typing.overload + def createBufferStrategy( + self, int: int, bufferCapabilities: BufferCapabilities + ) -> None: ... + def dispose(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getBackground(self) -> Color: ... + def getBufferStrategy(self) -> java.awt.image.BufferStrategy: ... + def getFocusCycleRootAncestor(self) -> Container: ... + def getFocusOwner(self) -> Component: ... + def getFocusTraversalKeys(self, int: int) -> java.util.Set[AWTKeyStroke]: ... + def getFocusableWindowState(self) -> bool: ... + def getIconImages(self) -> java.util.List[Image]: ... + def getInputContext(self) -> java.awt.im.InputContext: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + def getLocale(self) -> java.util.Locale: ... + def getModalExclusionType(self) -> Dialog.ModalExclusionType: ... + def getMostRecentFocusOwner(self) -> Component: ... + def getOpacity(self) -> float: ... + def getOwnedWindows(self) -> typing.MutableSequence[Window]: ... + def getOwner(self) -> Window: ... + @staticmethod + def getOwnerlessWindows() -> typing.MutableSequence[Window]: ... + def getShape(self) -> Shape: ... + def getToolkit(self) -> Toolkit: ... + def getType(self) -> Window.Type: ... + def getWarningString(self) -> java.lang.String: ... + def getWindowFocusListeners( + self, + ) -> typing.MutableSequence[java.awt.event.WindowFocusListener]: ... + def getWindowListeners( + self, + ) -> typing.MutableSequence[java.awt.event.WindowListener]: ... + def getWindowStateListeners( + self, + ) -> typing.MutableSequence[java.awt.event.WindowStateListener]: ... + @staticmethod + def getWindows() -> typing.MutableSequence[Window]: ... + def hide(self) -> None: ... + def isActive(self) -> bool: ... + def isAlwaysOnTop(self) -> bool: ... + def isAlwaysOnTopSupported(self) -> bool: ... + def isAutoRequestFocus(self) -> bool: ... + @typing.overload + def isFocusCycleRoot(self, container: Container) -> bool: ... + @typing.overload + def isFocusCycleRoot(self) -> bool: ... + def isFocusableWindow(self) -> bool: ... + def isFocused(self) -> bool: ... + def isLocationByPlatform(self) -> bool: ... + def isOpaque(self) -> bool: ... + def isShowing(self) -> bool: ... + def isValidateRoot(self) -> bool: ... + def pack(self) -> None: ... + def paint(self, graphics: Graphics) -> None: ... + def postEvent(self, event: Event) -> bool: ... + def removeNotify(self) -> None: ... + def removeWindowFocusListener( + self, windowFocusListener: java.awt.event.WindowFocusListener + ) -> None: ... + def removeWindowListener( + self, windowListener: java.awt.event.WindowListener + ) -> None: ... + def removeWindowStateListener( + self, windowStateListener: java.awt.event.WindowStateListener | typing.Callable + ) -> None: ... + def reshape(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def setAlwaysOnTop(self, boolean: bool) -> None: ... + def setAutoRequestFocus(self, boolean: bool) -> None: ... + def setBackground(self, color: Color) -> None: ... + @typing.overload + def setBounds(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setBounds(self, rectangle: Rectangle) -> None: ... + def setCursor(self, cursor: Cursor) -> None: ... + def setFocusCycleRoot(self, boolean: bool) -> None: ... + def setFocusableWindowState(self, boolean: bool) -> None: ... + def setIconImage(self, image: Image) -> None: ... + def setIconImages(self, list: java.util.List[Image]) -> None: ... + @typing.overload + def setLocation(self, int: int, int2: int) -> None: ... + @typing.overload + def setLocation(self, point: Point) -> None: ... + def setLocationByPlatform(self, boolean: bool) -> None: ... + def setLocationRelativeTo(self, component: Component) -> None: ... + def setMinimumSize(self, dimension: Dimension) -> None: ... + def setModalExclusionType( + self, modalExclusionType: Dialog.ModalExclusionType + ) -> None: ... + def setOpacity(self, float: float) -> None: ... + def setShape(self, shape: Shape) -> None: ... + @typing.overload + def setSize(self, int: int, int2: int) -> None: ... + @typing.overload + def setSize(self, dimension: Dimension) -> None: ... + def setType(self, type: Window.Type) -> None: ... + def setVisible(self, boolean: bool) -> None: ... + @typing.overload + def show(self, boolean: bool) -> None: ... + @typing.overload + def show(self) -> None: ... + def toBack(self) -> None: ... + def toFront(self) -> None: ... + class Type(java.lang.Enum["Window.Type"]): + NORMAL: typing.ClassVar[Window.Type] = ... + UTILITY: typing.ClassVar[Window.Type] = ... + POPUP: typing.ClassVar[Window.Type] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Window.Type: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[Window.Type]: ... + +class Dialog(Window): + DEFAULT_MODALITY_TYPE: typing.ClassVar[Dialog.ModalityType] = ... + @typing.overload + def __init__(self, dialog: Dialog): ... + @typing.overload + def __init__(self, dialog: Dialog, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, dialog: Dialog, string: java.lang.String | str, boolean: bool + ): ... + @typing.overload + def __init__( + self, + dialog: Dialog, + string: java.lang.String | str, + boolean: bool, + graphicsConfiguration: GraphicsConfiguration, + ): ... + @typing.overload + def __init__(self, frame: Frame): ... + @typing.overload + def __init__(self, frame: Frame, boolean: bool): ... + @typing.overload + def __init__(self, frame: Frame, string: java.lang.String | str): ... + @typing.overload + def __init__(self, frame: Frame, string: java.lang.String | str, boolean: bool): ... + @typing.overload + def __init__( + self, + frame: Frame, + string: java.lang.String | str, + boolean: bool, + graphicsConfiguration: GraphicsConfiguration, + ): ... + @typing.overload + def __init__(self, window: Window): ... + @typing.overload + def __init__(self, window: Window, modalityType: Dialog.ModalityType): ... + @typing.overload + def __init__(self, window: Window, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + window: Window, + string: java.lang.String | str, + modalityType: Dialog.ModalityType, + ): ... + @typing.overload + def __init__( + self, + window: Window, + string: java.lang.String | str, + modalityType: Dialog.ModalityType, + graphicsConfiguration: GraphicsConfiguration, + ): ... + def addNotify(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getModalityType(self) -> Dialog.ModalityType: ... + def getTitle(self) -> java.lang.String: ... + def hide(self) -> None: ... + def isModal(self) -> bool: ... + def isResizable(self) -> bool: ... + def isUndecorated(self) -> bool: ... + def setBackground(self, color: Color) -> None: ... + def setModal(self, boolean: bool) -> None: ... + def setModalityType(self, modalityType: Dialog.ModalityType) -> None: ... + def setOpacity(self, float: float) -> None: ... + def setResizable(self, boolean: bool) -> None: ... + def setShape(self, shape: Shape) -> None: ... + def setTitle(self, string: java.lang.String | str) -> None: ... + def setUndecorated(self, boolean: bool) -> None: ... + def setVisible(self, boolean: bool) -> None: ... + @typing.overload + def show(self, boolean: bool) -> None: ... + @typing.overload + def show(self) -> None: ... + def toBack(self) -> None: ... + class ModalExclusionType(java.lang.Enum["Dialog.ModalExclusionType"]): + NO_EXCLUDE: typing.ClassVar[Dialog.ModalExclusionType] = ... + APPLICATION_EXCLUDE: typing.ClassVar[Dialog.ModalExclusionType] = ... + TOOLKIT_EXCLUDE: typing.ClassVar[Dialog.ModalExclusionType] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Dialog.ModalExclusionType: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[Dialog.ModalExclusionType]: ... + + class ModalityType(java.lang.Enum["Dialog.ModalityType"]): + MODELESS: typing.ClassVar[Dialog.ModalityType] = ... + DOCUMENT_MODAL: typing.ClassVar[Dialog.ModalityType] = ... + APPLICATION_MODAL: typing.ClassVar[Dialog.ModalityType] = ... + TOOLKIT_MODAL: typing.ClassVar[Dialog.ModalityType] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Dialog.ModalityType: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[Dialog.ModalityType]: ... + +class Frame(Window, MenuContainer): + DEFAULT_CURSOR: typing.ClassVar[int] = ... + CROSSHAIR_CURSOR: typing.ClassVar[int] = ... + TEXT_CURSOR: typing.ClassVar[int] = ... + WAIT_CURSOR: typing.ClassVar[int] = ... + SW_RESIZE_CURSOR: typing.ClassVar[int] = ... + SE_RESIZE_CURSOR: typing.ClassVar[int] = ... + NW_RESIZE_CURSOR: typing.ClassVar[int] = ... + NE_RESIZE_CURSOR: typing.ClassVar[int] = ... + N_RESIZE_CURSOR: typing.ClassVar[int] = ... + S_RESIZE_CURSOR: typing.ClassVar[int] = ... + W_RESIZE_CURSOR: typing.ClassVar[int] = ... + E_RESIZE_CURSOR: typing.ClassVar[int] = ... + HAND_CURSOR: typing.ClassVar[int] = ... + MOVE_CURSOR: typing.ClassVar[int] = ... + NORMAL: typing.ClassVar[int] = ... + ICONIFIED: typing.ClassVar[int] = ... + MAXIMIZED_HORIZ: typing.ClassVar[int] = ... + MAXIMIZED_VERT: typing.ClassVar[int] = ... + MAXIMIZED_BOTH: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, graphicsConfiguration: GraphicsConfiguration): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + graphicsConfiguration: GraphicsConfiguration, + ): ... + def addNotify(self) -> None: ... + def getAccessibleContext(self) -> javax.accessibility.AccessibleContext: ... + def getCursorType(self) -> int: ... + def getExtendedState(self) -> int: ... + @staticmethod + def getFrames() -> typing.MutableSequence[Frame]: ... + def getIconImage(self) -> Image: ... + def getMaximizedBounds(self) -> Rectangle: ... + def getMenuBar(self) -> MenuBar: ... + def getState(self) -> int: ... + def getTitle(self) -> java.lang.String: ... + def isResizable(self) -> bool: ... + def isUndecorated(self) -> bool: ... + @typing.overload + def remove(self, int: int) -> None: ... + @typing.overload + def remove(self, component: Component) -> None: ... + @typing.overload + def remove(self, menuComponent: MenuComponent) -> None: ... + def removeNotify(self) -> None: ... + def setBackground(self, color: Color) -> None: ... + @typing.overload + def setCursor(self, int: int) -> None: ... + @typing.overload + def setCursor(self, cursor: Cursor) -> None: ... + def setExtendedState(self, int: int) -> None: ... + def setIconImage(self, image: Image) -> None: ... + def setMaximizedBounds(self, rectangle: Rectangle) -> None: ... + def setMenuBar(self, menuBar: MenuBar) -> None: ... + def setOpacity(self, float: float) -> None: ... + def setResizable(self, boolean: bool) -> None: ... + def setShape(self, shape: Shape) -> None: ... + def setState(self, int: int) -> None: ... + def setTitle(self, string: java.lang.String | str) -> None: ... + def setUndecorated(self, boolean: bool) -> None: ... + +class FileDialog(Dialog): + LOAD: typing.ClassVar[int] = ... + SAVE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, dialog: Dialog): ... + @typing.overload + def __init__(self, dialog: Dialog, string: java.lang.String | str): ... + @typing.overload + def __init__(self, dialog: Dialog, string: java.lang.String | str, int: int): ... + @typing.overload + def __init__(self, frame: Frame): ... + @typing.overload + def __init__(self, frame: Frame, string: java.lang.String | str): ... + @typing.overload + def __init__(self, frame: Frame, string: java.lang.String | str, int: int): ... + def addNotify(self) -> None: ... + def getDirectory(self) -> java.lang.String: ... + def getFile(self) -> java.lang.String: ... + def getFilenameFilter(self) -> java.io.FilenameFilter: ... + def getFiles(self) -> typing.MutableSequence[java.io.File]: ... + def getMode(self) -> int: ... + def isMultipleMode(self) -> bool: ... + def setDirectory(self, string: java.lang.String | str) -> None: ... + def setFile(self, string: java.lang.String | str) -> None: ... + def setFilenameFilter( + self, filenameFilter: java.io.FilenameFilter | typing.Callable + ) -> None: ... + def setMode(self, int: int) -> None: ... + def setMultipleMode(self, boolean: bool) -> None: ... + def setTitle(self, string: java.lang.String | str) -> None: ... + +class BufferCapabilities(java.lang.Cloneable): + def __init__( + self, + imageCapabilities: ImageCapabilities, + imageCapabilities2: ImageCapabilities, + flipContents: BufferCapabilities.FlipContents, + ): ... + def clone(self) -> typing.Any: ... + def getBackBufferCapabilities(self) -> ImageCapabilities: ... + def getFlipContents(self) -> BufferCapabilities.FlipContents: ... + def getFrontBufferCapabilities(self) -> ImageCapabilities: ... + def isFullScreenRequired(self) -> bool: ... + def isMultiBufferAvailable(self) -> bool: ... + def isPageFlipping(self) -> bool: ... + class FlipContents(java.awt.AttributeValue): + UNDEFINED: typing.ClassVar[BufferCapabilities.FlipContents] = ... + BACKGROUND: typing.ClassVar[BufferCapabilities.FlipContents] = ... + PRIOR: typing.ClassVar[BufferCapabilities.FlipContents] = ... + COPIED: typing.ClassVar[BufferCapabilities.FlipContents] = ... + +class JobAttributes(java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + int: int, + defaultSelectionType: JobAttributes.DefaultSelectionType, + destinationType: JobAttributes.DestinationType, + dialogType: JobAttributes.DialogType, + string: java.lang.String | str, + int2: int, + int3: int, + multipleDocumentHandlingType: JobAttributes.MultipleDocumentHandlingType, + intArray: list[typing.MutableSequence[int]] | jpype.JArray, + string2: java.lang.String | str, + sidesType: JobAttributes.SidesType, + ): ... + @typing.overload + def __init__(self, jobAttributes: JobAttributes): ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + def getCopies(self) -> int: ... + def getDefaultSelection(self) -> JobAttributes.DefaultSelectionType: ... + def getDestination(self) -> JobAttributes.DestinationType: ... + def getDialog(self) -> JobAttributes.DialogType: ... + def getFileName(self) -> java.lang.String: ... + def getFromPage(self) -> int: ... + def getMaxPage(self) -> int: ... + def getMinPage(self) -> int: ... + def getMultipleDocumentHandling( + self, + ) -> JobAttributes.MultipleDocumentHandlingType: ... + def getPageRanges(self) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getPrinter(self) -> java.lang.String: ... + def getSides(self) -> JobAttributes.SidesType: ... + def getToPage(self) -> int: ... + def hashCode(self) -> int: ... + def set(self, jobAttributes: JobAttributes) -> None: ... + def setCopies(self, int: int) -> None: ... + def setCopiesToDefault(self) -> None: ... + def setDefaultSelection( + self, defaultSelectionType: JobAttributes.DefaultSelectionType + ) -> None: ... + def setDestination( + self, destinationType: JobAttributes.DestinationType + ) -> None: ... + def setDialog(self, dialogType: JobAttributes.DialogType) -> None: ... + def setFileName(self, string: java.lang.String | str) -> None: ... + def setFromPage(self, int: int) -> None: ... + def setMaxPage(self, int: int) -> None: ... + def setMinPage(self, int: int) -> None: ... + def setMultipleDocumentHandling( + self, multipleDocumentHandlingType: JobAttributes.MultipleDocumentHandlingType + ) -> None: ... + def setMultipleDocumentHandlingToDefault(self) -> None: ... + def setPageRanges( + self, intArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> None: ... + def setPrinter(self, string: java.lang.String | str) -> None: ... + def setSides(self, sidesType: JobAttributes.SidesType) -> None: ... + def setSidesToDefault(self) -> None: ... + def setToPage(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + class DefaultSelectionType(java.awt.AttributeValue): + ALL: typing.ClassVar[JobAttributes.DefaultSelectionType] = ... + RANGE: typing.ClassVar[JobAttributes.DefaultSelectionType] = ... + SELECTION: typing.ClassVar[JobAttributes.DefaultSelectionType] = ... + + class DestinationType(java.awt.AttributeValue): + FILE: typing.ClassVar[JobAttributes.DestinationType] = ... + PRINTER: typing.ClassVar[JobAttributes.DestinationType] = ... + + class DialogType(java.awt.AttributeValue): + COMMON: typing.ClassVar[JobAttributes.DialogType] = ... + NATIVE: typing.ClassVar[JobAttributes.DialogType] = ... + NONE: typing.ClassVar[JobAttributes.DialogType] = ... + + class MultipleDocumentHandlingType(java.awt.AttributeValue): + SEPARATE_DOCUMENTS_COLLATED_COPIES: typing.ClassVar[ + JobAttributes.MultipleDocumentHandlingType + ] = ... + SEPARATE_DOCUMENTS_UNCOLLATED_COPIES: typing.ClassVar[ + JobAttributes.MultipleDocumentHandlingType + ] = ... + + class SidesType(java.awt.AttributeValue): + ONE_SIDED: typing.ClassVar[JobAttributes.SidesType] = ... + TWO_SIDED_LONG_EDGE: typing.ClassVar[JobAttributes.SidesType] = ... + TWO_SIDED_SHORT_EDGE: typing.ClassVar[JobAttributes.SidesType] = ... + +class PageAttributes(java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + colorType: PageAttributes.ColorType, + mediaType: PageAttributes.MediaType, + orientationRequestedType: PageAttributes.OrientationRequestedType, + originType: PageAttributes.OriginType, + printQualityType: PageAttributes.PrintQualityType, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def __init__(self, pageAttributes: PageAttributes): ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + def getColor(self) -> PageAttributes.ColorType: ... + def getMedia(self) -> PageAttributes.MediaType: ... + def getOrientationRequested(self) -> PageAttributes.OrientationRequestedType: ... + def getOrigin(self) -> PageAttributes.OriginType: ... + def getPrintQuality(self) -> PageAttributes.PrintQualityType: ... + def getPrinterResolution(self) -> typing.MutableSequence[int]: ... + def hashCode(self) -> int: ... + def set(self, pageAttributes: PageAttributes) -> None: ... + def setColor(self, colorType: PageAttributes.ColorType) -> None: ... + def setMedia(self, mediaType: PageAttributes.MediaType) -> None: ... + def setMediaToDefault(self) -> None: ... + @typing.overload + def setOrientationRequested(self, int: int) -> None: ... + @typing.overload + def setOrientationRequested( + self, orientationRequestedType: PageAttributes.OrientationRequestedType + ) -> None: ... + def setOrientationRequestedToDefault(self) -> None: ... + def setOrigin(self, originType: PageAttributes.OriginType) -> None: ... + @typing.overload + def setPrintQuality(self, int: int) -> None: ... + @typing.overload + def setPrintQuality( + self, printQualityType: PageAttributes.PrintQualityType + ) -> None: ... + def setPrintQualityToDefault(self) -> None: ... + @typing.overload + def setPrinterResolution(self, int: int) -> None: ... + @typing.overload + def setPrinterResolution(self, intArray: list[int] | jpype.JArray) -> None: ... + def setPrinterResolutionToDefault(self) -> None: ... + def toString(self) -> java.lang.String: ... + class ColorType(java.awt.AttributeValue): + COLOR: typing.ClassVar[PageAttributes.ColorType] = ... + MONOCHROME: typing.ClassVar[PageAttributes.ColorType] = ... + + class MediaType(java.awt.AttributeValue): + ISO_4A0: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_2A0: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A0: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A1: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A2: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A3: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A4: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A5: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A6: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A7: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A8: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A9: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_A10: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B0: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B1: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B2: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B3: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B4: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B5: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B6: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B7: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B8: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B9: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B10: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B0: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B1: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B2: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B3: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B4: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B5: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B6: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B7: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B8: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B9: typing.ClassVar[PageAttributes.MediaType] = ... + JIS_B10: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C0: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C1: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C2: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C3: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C4: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C5: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C6: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C7: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C8: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C9: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C10: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_DESIGNATED_LONG: typing.ClassVar[PageAttributes.MediaType] = ... + EXECUTIVE: typing.ClassVar[PageAttributes.MediaType] = ... + FOLIO: typing.ClassVar[PageAttributes.MediaType] = ... + INVOICE: typing.ClassVar[PageAttributes.MediaType] = ... + LEDGER: typing.ClassVar[PageAttributes.MediaType] = ... + NA_LETTER: typing.ClassVar[PageAttributes.MediaType] = ... + NA_LEGAL: typing.ClassVar[PageAttributes.MediaType] = ... + QUARTO: typing.ClassVar[PageAttributes.MediaType] = ... + A: typing.ClassVar[PageAttributes.MediaType] = ... + B: typing.ClassVar[PageAttributes.MediaType] = ... + C: typing.ClassVar[PageAttributes.MediaType] = ... + D: typing.ClassVar[PageAttributes.MediaType] = ... + E: typing.ClassVar[PageAttributes.MediaType] = ... + NA_10X15_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_10X14_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_10X13_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_9X12_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_9X11_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_7X9_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_6X9_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_NUMBER_9_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_NUMBER_10_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_NUMBER_11_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_NUMBER_12_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + NA_NUMBER_14_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + INVITE_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + ITALY_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + MONARCH_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + PERSONAL_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + A0: typing.ClassVar[PageAttributes.MediaType] = ... + A1: typing.ClassVar[PageAttributes.MediaType] = ... + A2: typing.ClassVar[PageAttributes.MediaType] = ... + A3: typing.ClassVar[PageAttributes.MediaType] = ... + A4: typing.ClassVar[PageAttributes.MediaType] = ... + A5: typing.ClassVar[PageAttributes.MediaType] = ... + A6: typing.ClassVar[PageAttributes.MediaType] = ... + A7: typing.ClassVar[PageAttributes.MediaType] = ... + A8: typing.ClassVar[PageAttributes.MediaType] = ... + A9: typing.ClassVar[PageAttributes.MediaType] = ... + A10: typing.ClassVar[PageAttributes.MediaType] = ... + B0: typing.ClassVar[PageAttributes.MediaType] = ... + B1: typing.ClassVar[PageAttributes.MediaType] = ... + B2: typing.ClassVar[PageAttributes.MediaType] = ... + B3: typing.ClassVar[PageAttributes.MediaType] = ... + B4: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B4_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + B5: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_B5_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + B6: typing.ClassVar[PageAttributes.MediaType] = ... + B7: typing.ClassVar[PageAttributes.MediaType] = ... + B8: typing.ClassVar[PageAttributes.MediaType] = ... + B9: typing.ClassVar[PageAttributes.MediaType] = ... + B10: typing.ClassVar[PageAttributes.MediaType] = ... + C0: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C0_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C1: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C1_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C2: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C2_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C3: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C3_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C4: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C4_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C5: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C5_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C6: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C6_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C7: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C7_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C8: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C8_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C9: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C9_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + C10: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_C10_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + ISO_DESIGNATED_LONG_ENVELOPE: typing.ClassVar[PageAttributes.MediaType] = ... + STATEMENT: typing.ClassVar[PageAttributes.MediaType] = ... + TABLOID: typing.ClassVar[PageAttributes.MediaType] = ... + LETTER: typing.ClassVar[PageAttributes.MediaType] = ... + NOTE: typing.ClassVar[PageAttributes.MediaType] = ... + LEGAL: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_10X15: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_10X14: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_10X13: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_9X12: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_9X11: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_7X9: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_6X9: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_9: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_10: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_11: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_12: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_14: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_INVITE: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_ITALY: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_MONARCH: typing.ClassVar[PageAttributes.MediaType] = ... + ENV_PERSONAL: typing.ClassVar[PageAttributes.MediaType] = ... + INVITE: typing.ClassVar[PageAttributes.MediaType] = ... + ITALY: typing.ClassVar[PageAttributes.MediaType] = ... + MONARCH: typing.ClassVar[PageAttributes.MediaType] = ... + PERSONAL: typing.ClassVar[PageAttributes.MediaType] = ... + + class OrientationRequestedType(java.awt.AttributeValue): + PORTRAIT: typing.ClassVar[PageAttributes.OrientationRequestedType] = ... + LANDSCAPE: typing.ClassVar[PageAttributes.OrientationRequestedType] = ... + + class OriginType(java.awt.AttributeValue): + PHYSICAL: typing.ClassVar[PageAttributes.OriginType] = ... + PRINTABLE: typing.ClassVar[PageAttributes.OriginType] = ... + + class PrintQualityType(java.awt.AttributeValue): + HIGH: typing.ClassVar[PageAttributes.PrintQualityType] = ... + NORMAL: typing.ClassVar[PageAttributes.PrintQualityType] = ... + DRAFT: typing.ClassVar[PageAttributes.PrintQualityType] = ... + +class AttributeValue: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt")``. + + AWTError: type[AWTError] + AWTEvent: type[AWTEvent] + AWTEventMulticaster: type[AWTEventMulticaster] + AWTException: type[AWTException] + AWTKeyStroke: type[AWTKeyStroke] + AWTPermission: type[AWTPermission] + ActiveEvent: type[ActiveEvent] + Adjustable: type[Adjustable] + AlphaComposite: type[AlphaComposite] + AttributeValue: type[AttributeValue] + BasicStroke: type[BasicStroke] + BorderLayout: type[BorderLayout] + BufferCapabilities: type[BufferCapabilities] + Button: type[Button] + Canvas: type[Canvas] + CardLayout: type[CardLayout] + Checkbox: type[Checkbox] + CheckboxGroup: type[CheckboxGroup] + CheckboxMenuItem: type[CheckboxMenuItem] + Choice: type[Choice] + Color: type[Color] + Component: type[Component] + ComponentOrientation: type[ComponentOrientation] + Composite: type[Composite] + CompositeContext: type[CompositeContext] + Container: type[Container] + ContainerOrderFocusTraversalPolicy: type[ContainerOrderFocusTraversalPolicy] + Cursor: type[Cursor] + DefaultFocusTraversalPolicy: type[DefaultFocusTraversalPolicy] + DefaultKeyboardFocusManager: type[DefaultKeyboardFocusManager] + Desktop: type[Desktop] + Dialog: type[Dialog] + Dimension: type[Dimension] + DisplayMode: type[DisplayMode] + Event: type[Event] + EventQueue: type[EventQueue] + FileDialog: type[FileDialog] + FlowLayout: type[FlowLayout] + FocusTraversalPolicy: type[FocusTraversalPolicy] + Font: type[Font] + FontFormatException: type[FontFormatException] + FontMetrics: type[FontMetrics] + Frame: type[Frame] + GradientPaint: type[GradientPaint] + Graphics: type[Graphics] + Graphics2D: type[Graphics2D] + GraphicsConfigTemplate: type[GraphicsConfigTemplate] + GraphicsConfiguration: type[GraphicsConfiguration] + GraphicsDevice: type[GraphicsDevice] + GraphicsEnvironment: type[GraphicsEnvironment] + GridBagConstraints: type[GridBagConstraints] + GridBagLayout: type[GridBagLayout] + GridBagLayoutInfo: type[GridBagLayoutInfo] + GridLayout: type[GridLayout] + HeadlessException: type[HeadlessException] + IllegalComponentStateException: type[IllegalComponentStateException] + Image: type[Image] + ImageCapabilities: type[ImageCapabilities] + Insets: type[Insets] + ItemSelectable: type[ItemSelectable] + JobAttributes: type[JobAttributes] + KeyEventDispatcher: type[KeyEventDispatcher] + KeyEventPostProcessor: type[KeyEventPostProcessor] + KeyboardFocusManager: type[KeyboardFocusManager] + Label: type[Label] + LayoutManager: type[LayoutManager] + LayoutManager2: type[LayoutManager2] + LinearGradientPaint: type[LinearGradientPaint] + List: type[List] + MediaTracker: type[MediaTracker] + Menu: type[Menu] + MenuBar: type[MenuBar] + MenuComponent: type[MenuComponent] + MenuContainer: type[MenuContainer] + MenuItem: type[MenuItem] + MenuShortcut: type[MenuShortcut] + MouseInfo: type[MouseInfo] + MultipleGradientPaint: type[MultipleGradientPaint] + PageAttributes: type[PageAttributes] + Paint: type[Paint] + PaintContext: type[PaintContext] + Panel: type[Panel] + Point: type[Point] + PointerInfo: type[PointerInfo] + Polygon: type[Polygon] + PopupMenu: type[PopupMenu] + PrintGraphics: type[PrintGraphics] + PrintJob: type[PrintJob] + RadialGradientPaint: type[RadialGradientPaint] + Rectangle: type[Rectangle] + RenderingHints: type[RenderingHints] + Robot: type[Robot] + ScrollPane: type[ScrollPane] + ScrollPaneAdjustable: type[ScrollPaneAdjustable] + Scrollbar: type[Scrollbar] + SecondaryLoop: type[SecondaryLoop] + Shape: type[Shape] + SplashScreen: type[SplashScreen] + Stroke: type[Stroke] + SystemColor: type[SystemColor] + SystemTray: type[SystemTray] + Taskbar: type[Taskbar] + TextArea: type[TextArea] + TextComponent: type[TextComponent] + TextField: type[TextField] + TexturePaint: type[TexturePaint] + Toolkit: type[Toolkit] + Transparency: type[Transparency] + TrayIcon: type[TrayIcon] + Window: type[Window] + color: java.awt.color.__module_protocol__ + datatransfer: java.awt.datatransfer.__module_protocol__ + desktop: java.awt.desktop.__module_protocol__ + dnd: java.awt.dnd.__module_protocol__ + event: java.awt.event.__module_protocol__ + font: java.awt.font.__module_protocol__ + geom: java.awt.geom.__module_protocol__ + im: java.awt.im.__module_protocol__ + image: java.awt.image.__module_protocol__ + peer: java.awt.peer.__module_protocol__ + print_: java.awt.print_.__module_protocol__ diff --git a/typings/java/awt/color/__init__.pyi b/typings/java/awt/color/__init__.pyi new file mode 100644 index 0000000..569c4fa --- /dev/null +++ b/typings/java/awt/color/__init__.pyi @@ -0,0 +1,257 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import jpype + +class CMMException(java.lang.RuntimeException): + def __init__(self, string: java.lang.String | str): ... + +class ColorSpace(java.io.Serializable): + TYPE_XYZ: typing.ClassVar[int] = ... + TYPE_Lab: typing.ClassVar[int] = ... + TYPE_Luv: typing.ClassVar[int] = ... + TYPE_YCbCr: typing.ClassVar[int] = ... + TYPE_Yxy: typing.ClassVar[int] = ... + TYPE_RGB: typing.ClassVar[int] = ... + TYPE_GRAY: typing.ClassVar[int] = ... + TYPE_HSV: typing.ClassVar[int] = ... + TYPE_HLS: typing.ClassVar[int] = ... + TYPE_CMYK: typing.ClassVar[int] = ... + TYPE_CMY: typing.ClassVar[int] = ... + TYPE_2CLR: typing.ClassVar[int] = ... + TYPE_3CLR: typing.ClassVar[int] = ... + TYPE_4CLR: typing.ClassVar[int] = ... + TYPE_5CLR: typing.ClassVar[int] = ... + TYPE_6CLR: typing.ClassVar[int] = ... + TYPE_7CLR: typing.ClassVar[int] = ... + TYPE_8CLR: typing.ClassVar[int] = ... + TYPE_9CLR: typing.ClassVar[int] = ... + TYPE_ACLR: typing.ClassVar[int] = ... + TYPE_BCLR: typing.ClassVar[int] = ... + TYPE_CCLR: typing.ClassVar[int] = ... + TYPE_DCLR: typing.ClassVar[int] = ... + TYPE_ECLR: typing.ClassVar[int] = ... + TYPE_FCLR: typing.ClassVar[int] = ... + CS_sRGB: typing.ClassVar[int] = ... + CS_LINEAR_RGB: typing.ClassVar[int] = ... + CS_CIEXYZ: typing.ClassVar[int] = ... + CS_PYCC: typing.ClassVar[int] = ... + CS_GRAY: typing.ClassVar[int] = ... + def fromCIEXYZ( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def fromRGB( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + @staticmethod + def getInstance(int: int) -> ColorSpace: ... + def getMaxValue(self, int: int) -> float: ... + def getMinValue(self, int: int) -> float: ... + def getName(self, int: int) -> java.lang.String: ... + def getNumComponents(self) -> int: ... + def getType(self) -> int: ... + def isCS_sRGB(self) -> bool: ... + def toCIEXYZ( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def toRGB( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + +class ICC_Profile(java.io.Serializable): + CLASS_INPUT: typing.ClassVar[int] = ... + CLASS_DISPLAY: typing.ClassVar[int] = ... + CLASS_OUTPUT: typing.ClassVar[int] = ... + CLASS_DEVICELINK: typing.ClassVar[int] = ... + CLASS_COLORSPACECONVERSION: typing.ClassVar[int] = ... + CLASS_ABSTRACT: typing.ClassVar[int] = ... + CLASS_NAMEDCOLOR: typing.ClassVar[int] = ... + icSigXYZData: typing.ClassVar[int] = ... + icSigLabData: typing.ClassVar[int] = ... + icSigLuvData: typing.ClassVar[int] = ... + icSigYCbCrData: typing.ClassVar[int] = ... + icSigYxyData: typing.ClassVar[int] = ... + icSigRgbData: typing.ClassVar[int] = ... + icSigGrayData: typing.ClassVar[int] = ... + icSigHsvData: typing.ClassVar[int] = ... + icSigHlsData: typing.ClassVar[int] = ... + icSigCmykData: typing.ClassVar[int] = ... + icSigCmyData: typing.ClassVar[int] = ... + icSigSpace2CLR: typing.ClassVar[int] = ... + icSigSpace3CLR: typing.ClassVar[int] = ... + icSigSpace4CLR: typing.ClassVar[int] = ... + icSigSpace5CLR: typing.ClassVar[int] = ... + icSigSpace6CLR: typing.ClassVar[int] = ... + icSigSpace7CLR: typing.ClassVar[int] = ... + icSigSpace8CLR: typing.ClassVar[int] = ... + icSigSpace9CLR: typing.ClassVar[int] = ... + icSigSpaceACLR: typing.ClassVar[int] = ... + icSigSpaceBCLR: typing.ClassVar[int] = ... + icSigSpaceCCLR: typing.ClassVar[int] = ... + icSigSpaceDCLR: typing.ClassVar[int] = ... + icSigSpaceECLR: typing.ClassVar[int] = ... + icSigSpaceFCLR: typing.ClassVar[int] = ... + icSigInputClass: typing.ClassVar[int] = ... + icSigDisplayClass: typing.ClassVar[int] = ... + icSigOutputClass: typing.ClassVar[int] = ... + icSigLinkClass: typing.ClassVar[int] = ... + icSigAbstractClass: typing.ClassVar[int] = ... + icSigColorSpaceClass: typing.ClassVar[int] = ... + icSigNamedColorClass: typing.ClassVar[int] = ... + icPerceptual: typing.ClassVar[int] = ... + icRelativeColorimetric: typing.ClassVar[int] = ... + icMediaRelativeColorimetric: typing.ClassVar[int] = ... + icSaturation: typing.ClassVar[int] = ... + icAbsoluteColorimetric: typing.ClassVar[int] = ... + icICCAbsoluteColorimetric: typing.ClassVar[int] = ... + icSigHead: typing.ClassVar[int] = ... + icSigAToB0Tag: typing.ClassVar[int] = ... + icSigAToB1Tag: typing.ClassVar[int] = ... + icSigAToB2Tag: typing.ClassVar[int] = ... + icSigBlueColorantTag: typing.ClassVar[int] = ... + icSigBlueMatrixColumnTag: typing.ClassVar[int] = ... + icSigBlueTRCTag: typing.ClassVar[int] = ... + icSigBToA0Tag: typing.ClassVar[int] = ... + icSigBToA1Tag: typing.ClassVar[int] = ... + icSigBToA2Tag: typing.ClassVar[int] = ... + icSigCalibrationDateTimeTag: typing.ClassVar[int] = ... + icSigCharTargetTag: typing.ClassVar[int] = ... + icSigCopyrightTag: typing.ClassVar[int] = ... + icSigCrdInfoTag: typing.ClassVar[int] = ... + icSigDeviceMfgDescTag: typing.ClassVar[int] = ... + icSigDeviceModelDescTag: typing.ClassVar[int] = ... + icSigDeviceSettingsTag: typing.ClassVar[int] = ... + icSigGamutTag: typing.ClassVar[int] = ... + icSigGrayTRCTag: typing.ClassVar[int] = ... + icSigGreenColorantTag: typing.ClassVar[int] = ... + icSigGreenMatrixColumnTag: typing.ClassVar[int] = ... + icSigGreenTRCTag: typing.ClassVar[int] = ... + icSigLuminanceTag: typing.ClassVar[int] = ... + icSigMeasurementTag: typing.ClassVar[int] = ... + icSigMediaBlackPointTag: typing.ClassVar[int] = ... + icSigMediaWhitePointTag: typing.ClassVar[int] = ... + icSigNamedColor2Tag: typing.ClassVar[int] = ... + icSigOutputResponseTag: typing.ClassVar[int] = ... + icSigPreview0Tag: typing.ClassVar[int] = ... + icSigPreview1Tag: typing.ClassVar[int] = ... + icSigPreview2Tag: typing.ClassVar[int] = ... + icSigProfileDescriptionTag: typing.ClassVar[int] = ... + icSigProfileSequenceDescTag: typing.ClassVar[int] = ... + icSigPs2CRD0Tag: typing.ClassVar[int] = ... + icSigPs2CRD1Tag: typing.ClassVar[int] = ... + icSigPs2CRD2Tag: typing.ClassVar[int] = ... + icSigPs2CRD3Tag: typing.ClassVar[int] = ... + icSigPs2CSATag: typing.ClassVar[int] = ... + icSigPs2RenderingIntentTag: typing.ClassVar[int] = ... + icSigRedColorantTag: typing.ClassVar[int] = ... + icSigRedMatrixColumnTag: typing.ClassVar[int] = ... + icSigRedTRCTag: typing.ClassVar[int] = ... + icSigScreeningDescTag: typing.ClassVar[int] = ... + icSigScreeningTag: typing.ClassVar[int] = ... + icSigTechnologyTag: typing.ClassVar[int] = ... + icSigUcrBgTag: typing.ClassVar[int] = ... + icSigViewingCondDescTag: typing.ClassVar[int] = ... + icSigViewingConditionsTag: typing.ClassVar[int] = ... + icSigChromaticityTag: typing.ClassVar[int] = ... + icSigChromaticAdaptationTag: typing.ClassVar[int] = ... + icSigColorantOrderTag: typing.ClassVar[int] = ... + icSigColorantTableTag: typing.ClassVar[int] = ... + icHdrSize: typing.ClassVar[int] = ... + icHdrCmmId: typing.ClassVar[int] = ... + icHdrVersion: typing.ClassVar[int] = ... + icHdrDeviceClass: typing.ClassVar[int] = ... + icHdrColorSpace: typing.ClassVar[int] = ... + icHdrPcs: typing.ClassVar[int] = ... + icHdrDate: typing.ClassVar[int] = ... + icHdrMagic: typing.ClassVar[int] = ... + icHdrPlatform: typing.ClassVar[int] = ... + icHdrFlags: typing.ClassVar[int] = ... + icHdrManufacturer: typing.ClassVar[int] = ... + icHdrModel: typing.ClassVar[int] = ... + icHdrAttributes: typing.ClassVar[int] = ... + icHdrRenderingIntent: typing.ClassVar[int] = ... + icHdrIlluminant: typing.ClassVar[int] = ... + icHdrCreator: typing.ClassVar[int] = ... + icHdrProfileID: typing.ClassVar[int] = ... + icTagType: typing.ClassVar[int] = ... + icTagReserved: typing.ClassVar[int] = ... + icCurveCount: typing.ClassVar[int] = ... + icCurveData: typing.ClassVar[int] = ... + icXYZNumberX: typing.ClassVar[int] = ... + def getColorSpaceType(self) -> int: ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def getInstance(byteArray: list[int] | jpype.JArray | bytes) -> ICC_Profile: ... + @typing.overload + @staticmethod + def getInstance(int: int) -> ICC_Profile: ... + @typing.overload + @staticmethod + def getInstance(inputStream: java.io.InputStream) -> ICC_Profile: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> ICC_Profile: ... + def getMajorVersion(self) -> int: ... + def getMinorVersion(self) -> int: ... + def getNumComponents(self) -> int: ... + def getPCSType(self) -> int: ... + def getProfileClass(self) -> int: ... + def setData( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def write(self, outputStream: java.io.OutputStream) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + +class ProfileDataException(java.lang.RuntimeException): + def __init__(self, string: java.lang.String | str): ... + +class ICC_ColorSpace(ColorSpace): + def __init__(self, iCC_Profile: ICC_Profile): ... + def fromCIEXYZ( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def fromRGB( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def getMaxValue(self, int: int) -> float: ... + def getMinValue(self, int: int) -> float: ... + def getProfile(self) -> ICC_Profile: ... + def toCIEXYZ( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def toRGB( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + +class ICC_ProfileGray(ICC_Profile): + def getGamma(self) -> float: ... + def getMediaWhitePoint(self) -> typing.MutableSequence[float]: ... + def getTRC(self) -> typing.MutableSequence[int]: ... + +class ICC_ProfileRGB(ICC_Profile): + REDCOMPONENT: typing.ClassVar[int] = ... + GREENCOMPONENT: typing.ClassVar[int] = ... + BLUECOMPONENT: typing.ClassVar[int] = ... + def getGamma(self, int: int) -> float: ... + def getMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getMediaWhitePoint(self) -> typing.MutableSequence[float]: ... + def getTRC(self, int: int) -> typing.MutableSequence[int]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.color")``. + + CMMException: type[CMMException] + ColorSpace: type[ColorSpace] + ICC_ColorSpace: type[ICC_ColorSpace] + ICC_Profile: type[ICC_Profile] + ICC_ProfileGray: type[ICC_ProfileGray] + ICC_ProfileRGB: type[ICC_ProfileRGB] + ProfileDataException: type[ProfileDataException] diff --git a/typings/java/awt/datatransfer/__init__.pyi b/typings/java/awt/datatransfer/__init__.pyi new file mode 100644 index 0000000..ffbf932 --- /dev/null +++ b/typings/java/awt/datatransfer/__init__.pyi @@ -0,0 +1,205 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import jpype + +class Clipboard: + def __init__(self, string: java.lang.String | str): ... + def addFlavorListener( + self, flavorListener: FlavorListener | typing.Callable + ) -> None: ... + def getAvailableDataFlavors(self) -> typing.MutableSequence[DataFlavor]: ... + def getContents(self, object: typing.Any) -> Transferable: ... + def getData(self, dataFlavor: DataFlavor) -> typing.Any: ... + def getFlavorListeners(self) -> typing.MutableSequence[FlavorListener]: ... + def getName(self) -> java.lang.String: ... + def isDataFlavorAvailable(self, dataFlavor: DataFlavor) -> bool: ... + def removeFlavorListener( + self, flavorListener: FlavorListener | typing.Callable + ) -> None: ... + def setContents( + self, + transferable: Transferable, + clipboardOwner: ClipboardOwner | typing.Callable, + ) -> None: ... + +class ClipboardOwner: + def lostOwnership( + self, clipboard: Clipboard, transferable: Transferable + ) -> None: ... + +class DataFlavor(java.io.Externalizable, java.lang.Cloneable): + stringFlavor: typing.ClassVar[DataFlavor] = ... + imageFlavor: typing.ClassVar[DataFlavor] = ... + plainTextFlavor: typing.ClassVar[DataFlavor] = ... + javaSerializedObjectMimeType: typing.ClassVar[java.lang.String] = ... + javaFileListFlavor: typing.ClassVar[DataFlavor] = ... + javaJVMLocalObjectMimeType: typing.ClassVar[java.lang.String] = ... + javaRemoteObjectMimeType: typing.ClassVar[java.lang.String] = ... + selectionHtmlFlavor: typing.ClassVar[DataFlavor] = ... + fragmentHtmlFlavor: typing.ClassVar[DataFlavor] = ... + allHtmlFlavor: typing.ClassVar[DataFlavor] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, class_: type[typing.Any], string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + classLoader: java.lang.ClassLoader, + ): ... + def clone(self) -> typing.Any: ... + @typing.overload + def equals(self, dataFlavor: DataFlavor) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def equals(self, string: java.lang.String | str) -> bool: ... + def getDefaultRepresentationClass(self) -> type[typing.Any]: ... + def getDefaultRepresentationClassAsString(self) -> java.lang.String: ... + def getHumanPresentableName(self) -> java.lang.String: ... + def getMimeType(self) -> java.lang.String: ... + def getParameter(self, string: java.lang.String | str) -> java.lang.String: ... + def getPrimaryType(self) -> java.lang.String: ... + def getReaderForText(self, transferable: Transferable) -> java.io.Reader: ... + def getRepresentationClass(self) -> type[typing.Any]: ... + def getSubType(self) -> java.lang.String: ... + @staticmethod + def getTextPlainUnicodeFlavor() -> DataFlavor: ... + def hashCode(self) -> int: ... + def isFlavorJavaFileListType(self) -> bool: ... + def isFlavorRemoteObjectType(self) -> bool: ... + def isFlavorSerializedObjectType(self) -> bool: ... + def isFlavorTextType(self) -> bool: ... + @typing.overload + def isMimeTypeEqual(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isMimeTypeEqual(self, dataFlavor: DataFlavor) -> bool: ... + def isMimeTypeSerializedObject(self) -> bool: ... + def isRepresentationClassByteBuffer(self) -> bool: ... + def isRepresentationClassCharBuffer(self) -> bool: ... + def isRepresentationClassInputStream(self) -> bool: ... + def isRepresentationClassReader(self) -> bool: ... + def isRepresentationClassRemote(self) -> bool: ... + def isRepresentationClassSerializable(self) -> bool: ... + def match(self, dataFlavor: DataFlavor) -> bool: ... + def readExternal(self, objectInput: java.io.ObjectInput) -> None: ... + @staticmethod + def selectBestTextFlavor( + dataFlavorArray: list[DataFlavor] | jpype.JArray, + ) -> DataFlavor: ... + def setHumanPresentableName(self, string: java.lang.String | str) -> None: ... + def toString(self) -> java.lang.String: ... + def writeExternal(self, objectOutput: java.io.ObjectOutput) -> None: ... + +class FlavorEvent(java.util.EventObject): + def __init__(self, clipboard: Clipboard): ... + +class FlavorListener(java.util.EventListener): + def flavorsChanged(self, flavorEvent: FlavorEvent) -> None: ... + +class FlavorMap: + def getFlavorsForNatives( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.util.Map[java.lang.String, DataFlavor]: ... + def getNativesForFlavors( + self, dataFlavorArray: list[DataFlavor] | jpype.JArray + ) -> java.util.Map[DataFlavor, java.lang.String]: ... + +class MimeTypeParseException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Transferable: + def getTransferData(self, dataFlavor: DataFlavor) -> typing.Any: ... + def getTransferDataFlavors(self) -> typing.MutableSequence[DataFlavor]: ... + def isDataFlavorSupported(self, dataFlavor: DataFlavor) -> bool: ... + +class UnsupportedFlavorException(java.lang.Exception): + def __init__(self, dataFlavor: DataFlavor): ... + +class FlavorTable(FlavorMap): + def getFlavorsForNative( + self, string: java.lang.String | str + ) -> java.util.List[DataFlavor]: ... + def getNativesForFlavor( + self, dataFlavor: DataFlavor + ) -> java.util.List[java.lang.String]: ... + +class StringSelection(Transferable, ClipboardOwner): + def __init__(self, string: java.lang.String | str): ... + def getTransferData(self, dataFlavor: DataFlavor) -> typing.Any: ... + def getTransferDataFlavors(self) -> typing.MutableSequence[DataFlavor]: ... + def isDataFlavorSupported(self, dataFlavor: DataFlavor) -> bool: ... + def lostOwnership( + self, clipboard: Clipboard, transferable: Transferable + ) -> None: ... + +class SystemFlavorMap(FlavorMap, FlavorTable): + def addFlavorForUnencodedNative( + self, string: java.lang.String | str, dataFlavor: DataFlavor + ) -> None: ... + def addUnencodedNativeForFlavor( + self, dataFlavor: DataFlavor, string: java.lang.String | str + ) -> None: ... + @staticmethod + def decodeDataFlavor(string: java.lang.String | str) -> DataFlavor: ... + @staticmethod + def decodeJavaMIMEType(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def encodeDataFlavor(dataFlavor: DataFlavor) -> java.lang.String: ... + @staticmethod + def encodeJavaMIMEType(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def getDefaultFlavorMap() -> FlavorMap: ... + def getFlavorsForNative( + self, string: java.lang.String | str + ) -> java.util.List[DataFlavor]: ... + def getFlavorsForNatives( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.util.Map[java.lang.String, DataFlavor]: ... + def getNativesForFlavor( + self, dataFlavor: DataFlavor + ) -> java.util.List[java.lang.String]: ... + def getNativesForFlavors( + self, dataFlavorArray: list[DataFlavor] | jpype.JArray + ) -> java.util.Map[DataFlavor, java.lang.String]: ... + @staticmethod + def isJavaMIMEType(string: java.lang.String | str) -> bool: ... + def setFlavorsForNative( + self, + string: java.lang.String | str, + dataFlavorArray: list[DataFlavor] | jpype.JArray, + ) -> None: ... + def setNativesForFlavor( + self, dataFlavor: DataFlavor, stringArray: list[java.lang.String] | jpype.JArray + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.datatransfer")``. + + Clipboard: type[Clipboard] + ClipboardOwner: type[ClipboardOwner] + DataFlavor: type[DataFlavor] + FlavorEvent: type[FlavorEvent] + FlavorListener: type[FlavorListener] + FlavorMap: type[FlavorMap] + FlavorTable: type[FlavorTable] + MimeTypeParseException: type[MimeTypeParseException] + StringSelection: type[StringSelection] + SystemFlavorMap: type[SystemFlavorMap] + Transferable: type[Transferable] + UnsupportedFlavorException: type[UnsupportedFlavorException] diff --git a/typings/java/awt/desktop/__init__.pyi b/typings/java/awt/desktop/__init__.pyi new file mode 100644 index 0000000..632532f --- /dev/null +++ b/typings/java/awt/desktop/__init__.pyi @@ -0,0 +1,171 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.net +import java.util +import jpype.protocol + +class AboutHandler: + def handleAbout(self, aboutEvent: AboutEvent) -> None: ... + +class AppEvent(java.util.EventObject): ... + +class OpenFilesHandler: + def openFiles(self, openFilesEvent: OpenFilesEvent) -> None: ... + +class OpenURIHandler: + def openURI(self, openURIEvent: OpenURIEvent) -> None: ... + +class PreferencesHandler: + def handlePreferences(self, preferencesEvent: PreferencesEvent) -> None: ... + +class PrintFilesHandler: + def printFiles(self, printFilesEvent: PrintFilesEvent) -> None: ... + +class QuitHandler: + def handleQuitRequestWith( + self, quitEvent: QuitEvent, quitResponse: QuitResponse + ) -> None: ... + +class QuitResponse: + def cancelQuit(self) -> None: ... + def performQuit(self) -> None: ... + +class QuitStrategy(java.lang.Enum["QuitStrategy"]): + NORMAL_EXIT: typing.ClassVar[QuitStrategy] = ... + CLOSE_ALL_WINDOWS: typing.ClassVar[QuitStrategy] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> QuitStrategy: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[QuitStrategy]: ... + +class SystemEventListener(java.util.EventListener): ... + +class AboutEvent(AppEvent): + def __init__(self): ... + +class AppForegroundEvent(AppEvent): + def __init__(self): ... + +class AppForegroundListener(SystemEventListener): + def appMovedToBackground(self, appForegroundEvent: AppForegroundEvent) -> None: ... + def appRaisedToForeground(self, appForegroundEvent: AppForegroundEvent) -> None: ... + +class AppHiddenEvent(AppEvent): + def __init__(self): ... + +class AppHiddenListener(SystemEventListener): + def appHidden(self, appHiddenEvent: AppHiddenEvent) -> None: ... + def appUnhidden(self, appHiddenEvent: AppHiddenEvent) -> None: ... + +class AppReopenedEvent(AppEvent): + def __init__(self): ... + +class AppReopenedListener(SystemEventListener): + def appReopened(self, appReopenedEvent: AppReopenedEvent) -> None: ... + +class FilesEvent(AppEvent): + def getFiles(self) -> java.util.List[java.io.File]: ... + +class OpenURIEvent(AppEvent): + def __init__(self, uRI: java.net.URI): ... + def getURI(self) -> java.net.URI: ... + +class PreferencesEvent(AppEvent): + def __init__(self): ... + +class QuitEvent(AppEvent): + def __init__(self): ... + +class ScreenSleepEvent(AppEvent): + def __init__(self): ... + +class ScreenSleepListener(SystemEventListener): + def screenAboutToSleep(self, screenSleepEvent: ScreenSleepEvent) -> None: ... + def screenAwoke(self, screenSleepEvent: ScreenSleepEvent) -> None: ... + +class SystemSleepEvent(AppEvent): + def __init__(self): ... + +class SystemSleepListener(SystemEventListener): + def systemAboutToSleep(self, systemSleepEvent: SystemSleepEvent) -> None: ... + def systemAwoke(self, systemSleepEvent: SystemSleepEvent) -> None: ... + +class UserSessionEvent(AppEvent): + def __init__(self, reason: UserSessionEvent.Reason): ... + def getReason(self) -> UserSessionEvent.Reason: ... + class Reason(java.lang.Enum["UserSessionEvent.Reason"]): + UNSPECIFIED: typing.ClassVar[UserSessionEvent.Reason] = ... + CONSOLE: typing.ClassVar[UserSessionEvent.Reason] = ... + REMOTE: typing.ClassVar[UserSessionEvent.Reason] = ... + LOCK: typing.ClassVar[UserSessionEvent.Reason] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> UserSessionEvent.Reason: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[UserSessionEvent.Reason]: ... + +class UserSessionListener(SystemEventListener): + def userSessionActivated(self, userSessionEvent: UserSessionEvent) -> None: ... + def userSessionDeactivated(self, userSessionEvent: UserSessionEvent) -> None: ... + +class OpenFilesEvent(FilesEvent): + def __init__( + self, + list: java.util.List[java.io.File | jpype.protocol.SupportsPath], + string: java.lang.String | str, + ): ... + def getSearchTerm(self) -> java.lang.String: ... + +class PrintFilesEvent(FilesEvent): + def __init__( + self, list: java.util.List[java.io.File | jpype.protocol.SupportsPath] + ): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.desktop")``. + + AboutEvent: type[AboutEvent] + AboutHandler: type[AboutHandler] + AppEvent: type[AppEvent] + AppForegroundEvent: type[AppForegroundEvent] + AppForegroundListener: type[AppForegroundListener] + AppHiddenEvent: type[AppHiddenEvent] + AppHiddenListener: type[AppHiddenListener] + AppReopenedEvent: type[AppReopenedEvent] + AppReopenedListener: type[AppReopenedListener] + FilesEvent: type[FilesEvent] + OpenFilesEvent: type[OpenFilesEvent] + OpenFilesHandler: type[OpenFilesHandler] + OpenURIEvent: type[OpenURIEvent] + OpenURIHandler: type[OpenURIHandler] + PreferencesEvent: type[PreferencesEvent] + PreferencesHandler: type[PreferencesHandler] + PrintFilesEvent: type[PrintFilesEvent] + PrintFilesHandler: type[PrintFilesHandler] + QuitEvent: type[QuitEvent] + QuitHandler: type[QuitHandler] + QuitResponse: type[QuitResponse] + QuitStrategy: type[QuitStrategy] + ScreenSleepEvent: type[ScreenSleepEvent] + ScreenSleepListener: type[ScreenSleepListener] + SystemEventListener: type[SystemEventListener] + SystemSleepEvent: type[SystemSleepEvent] + SystemSleepListener: type[SystemSleepListener] + UserSessionEvent: type[UserSessionEvent] + UserSessionListener: type[UserSessionListener] diff --git a/typings/java/awt/dnd/__init__.pyi b/typings/java/awt/dnd/__init__.pyi new file mode 100644 index 0000000..aac6a7f --- /dev/null +++ b/typings/java/awt/dnd/__init__.pyi @@ -0,0 +1,452 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.datatransfer +import java.awt.dnd.peer +import java.awt.event +import java.io +import java.lang +import java.util +import jpype + +class Autoscroll: + def autoscroll(self, point: java.awt.Point) -> None: ... + def getAutoscrollInsets(self) -> java.awt.Insets: ... + +class DnDConstants: + ACTION_NONE: typing.ClassVar[int] = ... + ACTION_COPY: typing.ClassVar[int] = ... + ACTION_MOVE: typing.ClassVar[int] = ... + ACTION_COPY_OR_MOVE: typing.ClassVar[int] = ... + ACTION_LINK: typing.ClassVar[int] = ... + ACTION_REFERENCE: typing.ClassVar[int] = ... + +class DragGestureEvent(java.util.EventObject): + def __init__( + self, + dragGestureRecognizer: DragGestureRecognizer, + int: int, + point: java.awt.Point, + list: java.util.List[java.awt.event.InputEvent], + ): ... + def getComponent(self) -> java.awt.Component: ... + def getDragAction(self) -> int: ... + def getDragOrigin(self) -> java.awt.Point: ... + def getDragSource(self) -> DragSource: ... + def getSourceAsDragGestureRecognizer(self) -> DragGestureRecognizer: ... + def getTriggerEvent(self) -> java.awt.event.InputEvent: ... + def iterator(self) -> java.util.Iterator[java.awt.event.InputEvent]: ... + @typing.overload + def startDrag( + self, + cursor: java.awt.Cursor, + image: java.awt.Image, + point: java.awt.Point, + transferable: java.awt.datatransfer.Transferable, + dragSourceListener: DragSourceListener, + ) -> None: ... + @typing.overload + def startDrag( + self, cursor: java.awt.Cursor, transferable: java.awt.datatransfer.Transferable + ) -> None: ... + @typing.overload + def startDrag( + self, + cursor: java.awt.Cursor, + transferable: java.awt.datatransfer.Transferable, + dragSourceListener: DragSourceListener, + ) -> None: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, objectArray: list[typing.Any] | jpype.JArray + ) -> typing.MutableSequence[typing.Any]: ... + +class DragGestureListener(java.util.EventListener): + def dragGestureRecognized(self, dragGestureEvent: DragGestureEvent) -> None: ... + +class DragGestureRecognizer(java.io.Serializable): + def addDragGestureListener( + self, dragGestureListener: DragGestureListener | typing.Callable + ) -> None: ... + def getComponent(self) -> java.awt.Component: ... + def getDragSource(self) -> DragSource: ... + def getSourceActions(self) -> int: ... + def getTriggerEvent(self) -> java.awt.event.InputEvent: ... + def removeDragGestureListener( + self, dragGestureListener: DragGestureListener | typing.Callable + ) -> None: ... + def resetRecognizer(self) -> None: ... + def setComponent(self, component: java.awt.Component) -> None: ... + def setSourceActions(self, int: int) -> None: ... + +class DragSource(java.io.Serializable): + DefaultCopyDrop: typing.ClassVar[java.awt.Cursor] = ... + DefaultMoveDrop: typing.ClassVar[java.awt.Cursor] = ... + DefaultLinkDrop: typing.ClassVar[java.awt.Cursor] = ... + DefaultCopyNoDrop: typing.ClassVar[java.awt.Cursor] = ... + DefaultMoveNoDrop: typing.ClassVar[java.awt.Cursor] = ... + DefaultLinkNoDrop: typing.ClassVar[java.awt.Cursor] = ... + def __init__(self): ... + def addDragSourceListener(self, dragSourceListener: DragSourceListener) -> None: ... + def addDragSourceMotionListener( + self, dragSourceMotionListener: DragSourceMotionListener | typing.Callable + ) -> None: ... + def createDefaultDragGestureRecognizer( + self, + component: java.awt.Component, + int: int, + dragGestureListener: DragGestureListener | typing.Callable, + ) -> DragGestureRecognizer: ... + _createDragGestureRecognizer__T = typing.TypeVar( + "_createDragGestureRecognizer__T", bound=DragGestureRecognizer + ) # + def createDragGestureRecognizer( + self, + class_: type[_createDragGestureRecognizer__T], + component: java.awt.Component, + int: int, + dragGestureListener: DragGestureListener | typing.Callable, + ) -> _createDragGestureRecognizer__T: ... + @staticmethod + def getDefaultDragSource() -> DragSource: ... + def getDragSourceListeners(self) -> typing.MutableSequence[DragSourceListener]: ... + def getDragSourceMotionListeners( + self, + ) -> typing.MutableSequence[DragSourceMotionListener]: ... + @staticmethod + def getDragThreshold() -> int: ... + def getFlavorMap(self) -> java.awt.datatransfer.FlavorMap: ... + _getListeners__T = typing.TypeVar( + "_getListeners__T", bound=java.util.EventListener + ) # + def getListeners( + self, class_: type[_getListeners__T] + ) -> typing.MutableSequence[_getListeners__T]: ... + @staticmethod + def isDragImageSupported() -> bool: ... + def removeDragSourceListener( + self, dragSourceListener: DragSourceListener + ) -> None: ... + def removeDragSourceMotionListener( + self, dragSourceMotionListener: DragSourceMotionListener | typing.Callable + ) -> None: ... + @typing.overload + def startDrag( + self, + dragGestureEvent: DragGestureEvent, + cursor: java.awt.Cursor, + image: java.awt.Image, + point: java.awt.Point, + transferable: java.awt.datatransfer.Transferable, + dragSourceListener: DragSourceListener, + ) -> None: ... + @typing.overload + def startDrag( + self, + dragGestureEvent: DragGestureEvent, + cursor: java.awt.Cursor, + image: java.awt.Image, + point: java.awt.Point, + transferable: java.awt.datatransfer.Transferable, + dragSourceListener: DragSourceListener, + flavorMap: java.awt.datatransfer.FlavorMap, + ) -> None: ... + @typing.overload + def startDrag( + self, + dragGestureEvent: DragGestureEvent, + cursor: java.awt.Cursor, + transferable: java.awt.datatransfer.Transferable, + dragSourceListener: DragSourceListener, + ) -> None: ... + @typing.overload + def startDrag( + self, + dragGestureEvent: DragGestureEvent, + cursor: java.awt.Cursor, + transferable: java.awt.datatransfer.Transferable, + dragSourceListener: DragSourceListener, + flavorMap: java.awt.datatransfer.FlavorMap, + ) -> None: ... + +class DragSourceEvent(java.util.EventObject): + @typing.overload + def __init__(self, dragSourceContext: DragSourceContext): ... + @typing.overload + def __init__(self, dragSourceContext: DragSourceContext, int: int, int2: int): ... + def getDragSourceContext(self) -> DragSourceContext: ... + def getLocation(self) -> java.awt.Point: ... + def getX(self) -> int: ... + def getY(self) -> int: ... + +class DragSourceListener(java.util.EventListener): + def dragDropEnd(self, dragSourceDropEvent: DragSourceDropEvent) -> None: ... + def dragEnter(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + def dragExit(self, dragSourceEvent: DragSourceEvent) -> None: ... + def dragOver(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + def dropActionChanged(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + +class DragSourceMotionListener(java.util.EventListener): + def dragMouseMoved(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + +class DropTargetContext(java.io.Serializable): + def dropComplete(self, boolean: bool) -> None: ... + def getComponent(self) -> java.awt.Component: ... + def getDropTarget(self) -> DropTarget: ... + +class DropTargetEvent(java.util.EventObject): + def __init__(self, dropTargetContext: DropTargetContext): ... + def getDropTargetContext(self) -> DropTargetContext: ... + +class DropTargetListener(java.util.EventListener): + def dragEnter(self, dropTargetDragEvent: DropTargetDragEvent) -> None: ... + def dragExit(self, dropTargetEvent: DropTargetEvent) -> None: ... + def dragOver(self, dropTargetDragEvent: DropTargetDragEvent) -> None: ... + def drop(self, dropTargetDropEvent: DropTargetDropEvent) -> None: ... + def dropActionChanged(self, dropTargetDragEvent: DropTargetDragEvent) -> None: ... + +class InvalidDnDOperationException(java.lang.IllegalStateException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class DragSourceAdapter(DragSourceListener, DragSourceMotionListener): + def dragDropEnd(self, dragSourceDropEvent: DragSourceDropEvent) -> None: ... + def dragEnter(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + def dragExit(self, dragSourceEvent: DragSourceEvent) -> None: ... + def dragMouseMoved(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + def dragOver(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + def dropActionChanged(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + +class DragSourceContext( + DragSourceListener, DragSourceMotionListener, java.io.Serializable +): + def __init__( + self, + dragGestureEvent: DragGestureEvent, + cursor: java.awt.Cursor, + image: java.awt.Image, + point: java.awt.Point, + transferable: java.awt.datatransfer.Transferable, + dragSourceListener: DragSourceListener, + ): ... + def addDragSourceListener(self, dragSourceListener: DragSourceListener) -> None: ... + def dragDropEnd(self, dragSourceDropEvent: DragSourceDropEvent) -> None: ... + def dragEnter(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + def dragExit(self, dragSourceEvent: DragSourceEvent) -> None: ... + def dragMouseMoved(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + def dragOver(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + def dropActionChanged(self, dragSourceDragEvent: DragSourceDragEvent) -> None: ... + def getComponent(self) -> java.awt.Component: ... + def getCursor(self) -> java.awt.Cursor: ... + def getDragSource(self) -> DragSource: ... + def getSourceActions(self) -> int: ... + def getTransferable(self) -> java.awt.datatransfer.Transferable: ... + def getTrigger(self) -> DragGestureEvent: ... + def removeDragSourceListener( + self, dragSourceListener: DragSourceListener + ) -> None: ... + def setCursor(self, cursor: java.awt.Cursor) -> None: ... + def transferablesFlavorsChanged(self) -> None: ... + +class DragSourceDragEvent(DragSourceEvent): + @typing.overload + def __init__( + self, dragSourceContext: DragSourceContext, int: int, int2: int, int3: int + ): ... + @typing.overload + def __init__( + self, + dragSourceContext: DragSourceContext, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + ): ... + def getDropAction(self) -> int: ... + def getGestureModifiers(self) -> int: ... + def getGestureModifiersEx(self) -> int: ... + def getTargetActions(self) -> int: ... + def getUserAction(self) -> int: ... + +class DragSourceDropEvent(DragSourceEvent): + @typing.overload + def __init__(self, dragSourceContext: DragSourceContext): ... + @typing.overload + def __init__( + self, dragSourceContext: DragSourceContext, int: int, boolean: bool + ): ... + @typing.overload + def __init__( + self, + dragSourceContext: DragSourceContext, + int: int, + boolean: bool, + int2: int, + int3: int, + ): ... + def getDropAction(self) -> int: ... + def getDropSuccess(self) -> bool: ... + +class DropTarget(DropTargetListener, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + dropTargetListener: DropTargetListener, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + dropTargetListener: DropTargetListener, + boolean: bool, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + dropTargetListener: DropTargetListener, + boolean: bool, + flavorMap: java.awt.datatransfer.FlavorMap, + ): ... + @typing.overload + def __init__( + self, component: java.awt.Component, dropTargetListener: DropTargetListener + ): ... + def addDropTargetListener(self, dropTargetListener: DropTargetListener) -> None: ... + def addNotify(self) -> None: ... + def dragEnter(self, dropTargetDragEvent: DropTargetDragEvent) -> None: ... + def dragExit(self, dropTargetEvent: DropTargetEvent) -> None: ... + def dragOver(self, dropTargetDragEvent: DropTargetDragEvent) -> None: ... + def drop(self, dropTargetDropEvent: DropTargetDropEvent) -> None: ... + def dropActionChanged(self, dropTargetDragEvent: DropTargetDragEvent) -> None: ... + def getComponent(self) -> java.awt.Component: ... + def getDefaultActions(self) -> int: ... + def getDropTargetContext(self) -> DropTargetContext: ... + def getFlavorMap(self) -> java.awt.datatransfer.FlavorMap: ... + def isActive(self) -> bool: ... + def removeDropTargetListener( + self, dropTargetListener: DropTargetListener + ) -> None: ... + def removeNotify(self) -> None: ... + def setActive(self, boolean: bool) -> None: ... + def setComponent(self, component: java.awt.Component) -> None: ... + def setDefaultActions(self, int: int) -> None: ... + def setFlavorMap(self, flavorMap: java.awt.datatransfer.FlavorMap) -> None: ... + +class DropTargetAdapter(DropTargetListener): + def dragEnter(self, dropTargetDragEvent: DropTargetDragEvent) -> None: ... + def dragExit(self, dropTargetEvent: DropTargetEvent) -> None: ... + def dragOver(self, dropTargetDragEvent: DropTargetDragEvent) -> None: ... + def dropActionChanged(self, dropTargetDragEvent: DropTargetDragEvent) -> None: ... + +class DropTargetDragEvent(DropTargetEvent): + def __init__( + self, + dropTargetContext: DropTargetContext, + point: java.awt.Point, + int: int, + int2: int, + ): ... + def acceptDrag(self, int: int) -> None: ... + def getCurrentDataFlavors( + self, + ) -> typing.MutableSequence[java.awt.datatransfer.DataFlavor]: ... + def getCurrentDataFlavorsAsList( + self, + ) -> java.util.List[java.awt.datatransfer.DataFlavor]: ... + def getDropAction(self) -> int: ... + def getLocation(self) -> java.awt.Point: ... + def getSourceActions(self) -> int: ... + def getTransferable(self) -> java.awt.datatransfer.Transferable: ... + def isDataFlavorSupported( + self, dataFlavor: java.awt.datatransfer.DataFlavor + ) -> bool: ... + def rejectDrag(self) -> None: ... + +class DropTargetDropEvent(DropTargetEvent): + @typing.overload + def __init__( + self, + dropTargetContext: DropTargetContext, + point: java.awt.Point, + int: int, + int2: int, + ): ... + @typing.overload + def __init__( + self, + dropTargetContext: DropTargetContext, + point: java.awt.Point, + int: int, + int2: int, + boolean: bool, + ): ... + def acceptDrop(self, int: int) -> None: ... + def dropComplete(self, boolean: bool) -> None: ... + def getCurrentDataFlavors( + self, + ) -> typing.MutableSequence[java.awt.datatransfer.DataFlavor]: ... + def getCurrentDataFlavorsAsList( + self, + ) -> java.util.List[java.awt.datatransfer.DataFlavor]: ... + def getDropAction(self) -> int: ... + def getLocation(self) -> java.awt.Point: ... + def getSourceActions(self) -> int: ... + def getTransferable(self) -> java.awt.datatransfer.Transferable: ... + def isDataFlavorSupported( + self, dataFlavor: java.awt.datatransfer.DataFlavor + ) -> bool: ... + def isLocalTransfer(self) -> bool: ... + def rejectDrop(self) -> None: ... + +class MouseDragGestureRecognizer( + DragGestureRecognizer, + java.awt.event.MouseListener, + java.awt.event.MouseMotionListener, +): + def mouseClicked(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseDragged(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseEntered(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseExited(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseMoved(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mousePressed(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseReleased(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.dnd")``. + + Autoscroll: type[Autoscroll] + DnDConstants: type[DnDConstants] + DragGestureEvent: type[DragGestureEvent] + DragGestureListener: type[DragGestureListener] + DragGestureRecognizer: type[DragGestureRecognizer] + DragSource: type[DragSource] + DragSourceAdapter: type[DragSourceAdapter] + DragSourceContext: type[DragSourceContext] + DragSourceDragEvent: type[DragSourceDragEvent] + DragSourceDropEvent: type[DragSourceDropEvent] + DragSourceEvent: type[DragSourceEvent] + DragSourceListener: type[DragSourceListener] + DragSourceMotionListener: type[DragSourceMotionListener] + DropTarget: type[DropTarget] + DropTargetAdapter: type[DropTargetAdapter] + DropTargetContext: type[DropTargetContext] + DropTargetDragEvent: type[DropTargetDragEvent] + DropTargetDropEvent: type[DropTargetDropEvent] + DropTargetEvent: type[DropTargetEvent] + DropTargetListener: type[DropTargetListener] + InvalidDnDOperationException: type[InvalidDnDOperationException] + MouseDragGestureRecognizer: type[MouseDragGestureRecognizer] + peer: java.awt.dnd.peer.__module_protocol__ diff --git a/typings/java/awt/dnd/peer/__init__.pyi b/typings/java/awt/dnd/peer/__init__.pyi new file mode 100644 index 0000000..b2f913d --- /dev/null +++ b/typings/java/awt/dnd/peer/__init__.pyi @@ -0,0 +1,44 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.datatransfer +import java.awt.dnd + +class DragSourceContextPeer: + def getCursor(self) -> java.awt.Cursor: ... + def setCursor(self, cursor: java.awt.Cursor) -> None: ... + def startDrag( + self, + dragSourceContext: java.awt.dnd.DragSourceContext, + cursor: java.awt.Cursor, + image: java.awt.Image, + point: java.awt.Point, + ) -> None: ... + def transferablesFlavorsChanged(self) -> None: ... + +class DropTargetContextPeer: + def acceptDrag(self, int: int) -> None: ... + def acceptDrop(self, int: int) -> None: ... + def dropComplete(self, boolean: bool) -> None: ... + def getDropTarget(self) -> java.awt.dnd.DropTarget: ... + def getTargetActions(self) -> int: ... + def getTransferDataFlavors( + self, + ) -> typing.MutableSequence[java.awt.datatransfer.DataFlavor]: ... + def getTransferable(self) -> java.awt.datatransfer.Transferable: ... + def isTransferableJVMLocal(self) -> bool: ... + def rejectDrag(self) -> None: ... + def rejectDrop(self) -> None: ... + def setTargetActions(self, int: int) -> None: ... + +class DropTargetPeer: + def addDropTarget(self, dropTarget: java.awt.dnd.DropTarget) -> None: ... + def removeDropTarget(self, dropTarget: java.awt.dnd.DropTarget) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.dnd.peer")``. + + DragSourceContextPeer: type[DragSourceContextPeer] + DropTargetContextPeer: type[DropTargetContextPeer] + DropTargetPeer: type[DropTargetPeer] diff --git a/typings/java/awt/event/__init__.pyi b/typings/java/awt/event/__init__.pyi new file mode 100644 index 0000000..5fb1bcb --- /dev/null +++ b/typings/java/awt/event/__init__.pyi @@ -0,0 +1,904 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.font +import java.lang +import java.text +import java.util + +class AWTEventListener(java.util.EventListener): + def eventDispatched(self, aWTEvent: java.awt.AWTEvent) -> None: ... + +class ActionEvent(java.awt.AWTEvent): + SHIFT_MASK: typing.ClassVar[int] = ... + CTRL_MASK: typing.ClassVar[int] = ... + META_MASK: typing.ClassVar[int] = ... + ALT_MASK: typing.ClassVar[int] = ... + ACTION_FIRST: typing.ClassVar[int] = ... + ACTION_LAST: typing.ClassVar[int] = ... + ACTION_PERFORMED: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, object: typing.Any, int: int, string: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, object: typing.Any, int: int, string: java.lang.String | str, int2: int + ): ... + @typing.overload + def __init__( + self, + object: typing.Any, + int: int, + string: java.lang.String | str, + long: int, + int2: int, + ): ... + def getActionCommand(self) -> java.lang.String: ... + def getModifiers(self) -> int: ... + def getWhen(self) -> int: ... + def paramString(self) -> java.lang.String: ... + +class ActionListener(java.util.EventListener): + def actionPerformed(self, actionEvent: ActionEvent) -> None: ... + +class AdjustmentEvent(java.awt.AWTEvent): + ADJUSTMENT_FIRST: typing.ClassVar[int] = ... + ADJUSTMENT_LAST: typing.ClassVar[int] = ... + ADJUSTMENT_VALUE_CHANGED: typing.ClassVar[int] = ... + UNIT_INCREMENT: typing.ClassVar[int] = ... + UNIT_DECREMENT: typing.ClassVar[int] = ... + BLOCK_DECREMENT: typing.ClassVar[int] = ... + BLOCK_INCREMENT: typing.ClassVar[int] = ... + TRACK: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, adjustable: java.awt.Adjustable, int: int, int2: int, int3: int + ): ... + @typing.overload + def __init__( + self, + adjustable: java.awt.Adjustable, + int: int, + int2: int, + int3: int, + boolean: bool, + ): ... + def getAdjustable(self) -> java.awt.Adjustable: ... + def getAdjustmentType(self) -> int: ... + def getValue(self) -> int: ... + def getValueIsAdjusting(self) -> bool: ... + def paramString(self) -> java.lang.String: ... + +class AdjustmentListener(java.util.EventListener): + def adjustmentValueChanged(self, adjustmentEvent: AdjustmentEvent) -> None: ... + +class ComponentEvent(java.awt.AWTEvent): + COMPONENT_FIRST: typing.ClassVar[int] = ... + COMPONENT_LAST: typing.ClassVar[int] = ... + COMPONENT_MOVED: typing.ClassVar[int] = ... + COMPONENT_RESIZED: typing.ClassVar[int] = ... + COMPONENT_SHOWN: typing.ClassVar[int] = ... + COMPONENT_HIDDEN: typing.ClassVar[int] = ... + def __init__(self, component: java.awt.Component, int: int): ... + def getComponent(self) -> java.awt.Component: ... + def paramString(self) -> java.lang.String: ... + +class ComponentListener(java.util.EventListener): + def componentHidden(self, componentEvent: ComponentEvent) -> None: ... + def componentMoved(self, componentEvent: ComponentEvent) -> None: ... + def componentResized(self, componentEvent: ComponentEvent) -> None: ... + def componentShown(self, componentEvent: ComponentEvent) -> None: ... + +class ContainerListener(java.util.EventListener): + def componentAdded(self, containerEvent: ContainerEvent) -> None: ... + def componentRemoved(self, containerEvent: ContainerEvent) -> None: ... + +class FocusListener(java.util.EventListener): + def focusGained(self, focusEvent: FocusEvent) -> None: ... + def focusLost(self, focusEvent: FocusEvent) -> None: ... + +class HierarchyBoundsListener(java.util.EventListener): + def ancestorMoved(self, hierarchyEvent: HierarchyEvent) -> None: ... + def ancestorResized(self, hierarchyEvent: HierarchyEvent) -> None: ... + +class HierarchyEvent(java.awt.AWTEvent): + HIERARCHY_FIRST: typing.ClassVar[int] = ... + HIERARCHY_CHANGED: typing.ClassVar[int] = ... + ANCESTOR_MOVED: typing.ClassVar[int] = ... + ANCESTOR_RESIZED: typing.ClassVar[int] = ... + HIERARCHY_LAST: typing.ClassVar[int] = ... + PARENT_CHANGED: typing.ClassVar[int] = ... + DISPLAYABILITY_CHANGED: typing.ClassVar[int] = ... + SHOWING_CHANGED: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + component2: java.awt.Component, + container: java.awt.Container, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + component2: java.awt.Component, + container: java.awt.Container, + long: int, + ): ... + def getChangeFlags(self) -> int: ... + def getChanged(self) -> java.awt.Component: ... + def getChangedParent(self) -> java.awt.Container: ... + def getComponent(self) -> java.awt.Component: ... + def paramString(self) -> java.lang.String: ... + +class HierarchyListener(java.util.EventListener): + def hierarchyChanged(self, hierarchyEvent: HierarchyEvent) -> None: ... + +class InputMethodEvent(java.awt.AWTEvent): + INPUT_METHOD_FIRST: typing.ClassVar[int] = ... + INPUT_METHOD_TEXT_CHANGED: typing.ClassVar[int] = ... + CARET_POSITION_CHANGED: typing.ClassVar[int] = ... + INPUT_METHOD_LAST: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + textHitInfo: java.awt.font.TextHitInfo, + textHitInfo2: java.awt.font.TextHitInfo, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int2: int, + textHitInfo: java.awt.font.TextHitInfo, + textHitInfo2: java.awt.font.TextHitInfo, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + long: int, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int2: int, + textHitInfo: java.awt.font.TextHitInfo, + textHitInfo2: java.awt.font.TextHitInfo, + ): ... + def consume(self) -> None: ... + def getCaret(self) -> java.awt.font.TextHitInfo: ... + def getCommittedCharacterCount(self) -> int: ... + def getText(self) -> java.text.AttributedCharacterIterator: ... + def getVisiblePosition(self) -> java.awt.font.TextHitInfo: ... + def getWhen(self) -> int: ... + def isConsumed(self) -> bool: ... + def paramString(self) -> java.lang.String: ... + +class InputMethodListener(java.util.EventListener): + def caretPositionChanged(self, inputMethodEvent: InputMethodEvent) -> None: ... + def inputMethodTextChanged(self, inputMethodEvent: InputMethodEvent) -> None: ... + +class InvocationEvent(java.awt.AWTEvent, java.awt.ActiveEvent): + INVOCATION_FIRST: typing.ClassVar[int] = ... + INVOCATION_DEFAULT: typing.ClassVar[int] = ... + INVOCATION_LAST: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, object: typing.Any, runnable: java.lang.Runnable | typing.Callable + ): ... + @typing.overload + def __init__( + self, + object: typing.Any, + runnable: java.lang.Runnable | typing.Callable, + object2: typing.Any, + boolean: bool, + ): ... + @typing.overload + def __init__( + self, + object: typing.Any, + runnable: java.lang.Runnable | typing.Callable, + runnable2: java.lang.Runnable | typing.Callable, + boolean: bool, + ): ... + def dispatch(self) -> None: ... + def getException(self) -> java.lang.Exception: ... + def getThrowable(self) -> java.lang.Throwable: ... + def getWhen(self) -> int: ... + def isDispatched(self) -> bool: ... + def paramString(self) -> java.lang.String: ... + +class ItemEvent(java.awt.AWTEvent): + ITEM_FIRST: typing.ClassVar[int] = ... + ITEM_LAST: typing.ClassVar[int] = ... + ITEM_STATE_CHANGED: typing.ClassVar[int] = ... + SELECTED: typing.ClassVar[int] = ... + DESELECTED: typing.ClassVar[int] = ... + def __init__( + self, + itemSelectable: java.awt.ItemSelectable, + int: int, + object: typing.Any, + int2: int, + ): ... + def getItem(self) -> typing.Any: ... + def getItemSelectable(self) -> java.awt.ItemSelectable: ... + def getStateChange(self) -> int: ... + def paramString(self) -> java.lang.String: ... + +class ItemListener(java.util.EventListener): + def itemStateChanged(self, itemEvent: ItemEvent) -> None: ... + +class KeyListener(java.util.EventListener): + def keyPressed(self, keyEvent: KeyEvent) -> None: ... + def keyReleased(self, keyEvent: KeyEvent) -> None: ... + def keyTyped(self, keyEvent: KeyEvent) -> None: ... + +class MouseListener(java.util.EventListener): + def mouseClicked(self, mouseEvent: MouseEvent) -> None: ... + def mouseEntered(self, mouseEvent: MouseEvent) -> None: ... + def mouseExited(self, mouseEvent: MouseEvent) -> None: ... + def mousePressed(self, mouseEvent: MouseEvent) -> None: ... + def mouseReleased(self, mouseEvent: MouseEvent) -> None: ... + +class MouseMotionListener(java.util.EventListener): + def mouseDragged(self, mouseEvent: MouseEvent) -> None: ... + def mouseMoved(self, mouseEvent: MouseEvent) -> None: ... + +class MouseWheelListener(java.util.EventListener): + def mouseWheelMoved(self, mouseWheelEvent: MouseWheelEvent) -> None: ... + +class TextEvent(java.awt.AWTEvent): + TEXT_FIRST: typing.ClassVar[int] = ... + TEXT_LAST: typing.ClassVar[int] = ... + TEXT_VALUE_CHANGED: typing.ClassVar[int] = ... + def __init__(self, object: typing.Any, int: int): ... + def paramString(self) -> java.lang.String: ... + +class TextListener(java.util.EventListener): + def textValueChanged(self, textEvent: TextEvent) -> None: ... + +class WindowFocusListener(java.util.EventListener): + def windowGainedFocus(self, windowEvent: WindowEvent) -> None: ... + def windowLostFocus(self, windowEvent: WindowEvent) -> None: ... + +class WindowListener(java.util.EventListener): + def windowActivated(self, windowEvent: WindowEvent) -> None: ... + def windowClosed(self, windowEvent: WindowEvent) -> None: ... + def windowClosing(self, windowEvent: WindowEvent) -> None: ... + def windowDeactivated(self, windowEvent: WindowEvent) -> None: ... + def windowDeiconified(self, windowEvent: WindowEvent) -> None: ... + def windowIconified(self, windowEvent: WindowEvent) -> None: ... + def windowOpened(self, windowEvent: WindowEvent) -> None: ... + +class WindowStateListener(java.util.EventListener): + def windowStateChanged(self, windowEvent: WindowEvent) -> None: ... + +class AWTEventListenerProxy( + java.util.EventListenerProxy[AWTEventListener], AWTEventListener +): + def __init__( + self, long: int, aWTEventListener: AWTEventListener | typing.Callable + ): ... + def eventDispatched(self, aWTEvent: java.awt.AWTEvent) -> None: ... + def getEventMask(self) -> int: ... + +class ComponentAdapter(ComponentListener): + def componentHidden(self, componentEvent: ComponentEvent) -> None: ... + def componentMoved(self, componentEvent: ComponentEvent) -> None: ... + def componentResized(self, componentEvent: ComponentEvent) -> None: ... + def componentShown(self, componentEvent: ComponentEvent) -> None: ... + +class ContainerAdapter(ContainerListener): + def componentAdded(self, containerEvent: ContainerEvent) -> None: ... + def componentRemoved(self, containerEvent: ContainerEvent) -> None: ... + +class ContainerEvent(ComponentEvent): + CONTAINER_FIRST: typing.ClassVar[int] = ... + CONTAINER_LAST: typing.ClassVar[int] = ... + COMPONENT_ADDED: typing.ClassVar[int] = ... + COMPONENT_REMOVED: typing.ClassVar[int] = ... + def __init__( + self, component: java.awt.Component, int: int, component2: java.awt.Component + ): ... + def getChild(self) -> java.awt.Component: ... + def getContainer(self) -> java.awt.Container: ... + def paramString(self) -> java.lang.String: ... + +class FocusAdapter(FocusListener): + def focusGained(self, focusEvent: FocusEvent) -> None: ... + def focusLost(self, focusEvent: FocusEvent) -> None: ... + +class FocusEvent(ComponentEvent): + FOCUS_FIRST: typing.ClassVar[int] = ... + FOCUS_LAST: typing.ClassVar[int] = ... + FOCUS_GAINED: typing.ClassVar[int] = ... + FOCUS_LOST: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, component: java.awt.Component, int: int): ... + @typing.overload + def __init__(self, component: java.awt.Component, int: int, boolean: bool): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + boolean: bool, + component2: java.awt.Component, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + boolean: bool, + component2: java.awt.Component, + cause: FocusEvent.Cause, + ): ... + def getCause(self) -> FocusEvent.Cause: ... + def getOppositeComponent(self) -> java.awt.Component: ... + def isTemporary(self) -> bool: ... + def paramString(self) -> java.lang.String: ... + class Cause(java.lang.Enum["FocusEvent.Cause"]): + UNKNOWN: typing.ClassVar[FocusEvent.Cause] = ... + MOUSE_EVENT: typing.ClassVar[FocusEvent.Cause] = ... + TRAVERSAL: typing.ClassVar[FocusEvent.Cause] = ... + TRAVERSAL_UP: typing.ClassVar[FocusEvent.Cause] = ... + TRAVERSAL_DOWN: typing.ClassVar[FocusEvent.Cause] = ... + TRAVERSAL_FORWARD: typing.ClassVar[FocusEvent.Cause] = ... + TRAVERSAL_BACKWARD: typing.ClassVar[FocusEvent.Cause] = ... + ROLLBACK: typing.ClassVar[FocusEvent.Cause] = ... + UNEXPECTED: typing.ClassVar[FocusEvent.Cause] = ... + ACTIVATION: typing.ClassVar[FocusEvent.Cause] = ... + CLEAR_GLOBAL_FOCUS_OWNER: typing.ClassVar[FocusEvent.Cause] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> FocusEvent.Cause: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[FocusEvent.Cause]: ... + +class HierarchyBoundsAdapter(HierarchyBoundsListener): + def ancestorMoved(self, hierarchyEvent: HierarchyEvent) -> None: ... + def ancestorResized(self, hierarchyEvent: HierarchyEvent) -> None: ... + +class InputEvent(ComponentEvent): + SHIFT_MASK: typing.ClassVar[int] = ... + CTRL_MASK: typing.ClassVar[int] = ... + META_MASK: typing.ClassVar[int] = ... + ALT_MASK: typing.ClassVar[int] = ... + ALT_GRAPH_MASK: typing.ClassVar[int] = ... + BUTTON1_MASK: typing.ClassVar[int] = ... + BUTTON2_MASK: typing.ClassVar[int] = ... + BUTTON3_MASK: typing.ClassVar[int] = ... + SHIFT_DOWN_MASK: typing.ClassVar[int] = ... + CTRL_DOWN_MASK: typing.ClassVar[int] = ... + META_DOWN_MASK: typing.ClassVar[int] = ... + ALT_DOWN_MASK: typing.ClassVar[int] = ... + BUTTON1_DOWN_MASK: typing.ClassVar[int] = ... + BUTTON2_DOWN_MASK: typing.ClassVar[int] = ... + BUTTON3_DOWN_MASK: typing.ClassVar[int] = ... + ALT_GRAPH_DOWN_MASK: typing.ClassVar[int] = ... + def consume(self) -> None: ... + @staticmethod + def getMaskForButton(int: int) -> int: ... + def getModifiers(self) -> int: ... + def getModifiersEx(self) -> int: ... + @staticmethod + def getModifiersExText(int: int) -> java.lang.String: ... + def getWhen(self) -> int: ... + def isAltDown(self) -> bool: ... + def isAltGraphDown(self) -> bool: ... + def isConsumed(self) -> bool: ... + def isControlDown(self) -> bool: ... + def isMetaDown(self) -> bool: ... + def isShiftDown(self) -> bool: ... + +class KeyAdapter(KeyListener): + def keyPressed(self, keyEvent: KeyEvent) -> None: ... + def keyReleased(self, keyEvent: KeyEvent) -> None: ... + def keyTyped(self, keyEvent: KeyEvent) -> None: ... + +class MouseAdapter(MouseListener, MouseWheelListener, MouseMotionListener): + def mouseClicked(self, mouseEvent: MouseEvent) -> None: ... + def mouseDragged(self, mouseEvent: MouseEvent) -> None: ... + def mouseEntered(self, mouseEvent: MouseEvent) -> None: ... + def mouseExited(self, mouseEvent: MouseEvent) -> None: ... + def mouseMoved(self, mouseEvent: MouseEvent) -> None: ... + def mousePressed(self, mouseEvent: MouseEvent) -> None: ... + def mouseReleased(self, mouseEvent: MouseEvent) -> None: ... + def mouseWheelMoved(self, mouseWheelEvent: MouseWheelEvent) -> None: ... + +class MouseMotionAdapter(MouseMotionListener): + def mouseDragged(self, mouseEvent: MouseEvent) -> None: ... + def mouseMoved(self, mouseEvent: MouseEvent) -> None: ... + +class PaintEvent(ComponentEvent): + PAINT_FIRST: typing.ClassVar[int] = ... + PAINT_LAST: typing.ClassVar[int] = ... + PAINT: typing.ClassVar[int] = ... + UPDATE: typing.ClassVar[int] = ... + def __init__( + self, component: java.awt.Component, int: int, rectangle: java.awt.Rectangle + ): ... + def getUpdateRect(self) -> java.awt.Rectangle: ... + def paramString(self) -> java.lang.String: ... + def setUpdateRect(self, rectangle: java.awt.Rectangle) -> None: ... + +class WindowAdapter(WindowListener, WindowStateListener, WindowFocusListener): + def windowActivated(self, windowEvent: WindowEvent) -> None: ... + def windowClosed(self, windowEvent: WindowEvent) -> None: ... + def windowClosing(self, windowEvent: WindowEvent) -> None: ... + def windowDeactivated(self, windowEvent: WindowEvent) -> None: ... + def windowDeiconified(self, windowEvent: WindowEvent) -> None: ... + def windowGainedFocus(self, windowEvent: WindowEvent) -> None: ... + def windowIconified(self, windowEvent: WindowEvent) -> None: ... + def windowLostFocus(self, windowEvent: WindowEvent) -> None: ... + def windowOpened(self, windowEvent: WindowEvent) -> None: ... + def windowStateChanged(self, windowEvent: WindowEvent) -> None: ... + +class WindowEvent(ComponentEvent): + WINDOW_FIRST: typing.ClassVar[int] = ... + WINDOW_OPENED: typing.ClassVar[int] = ... + WINDOW_CLOSING: typing.ClassVar[int] = ... + WINDOW_CLOSED: typing.ClassVar[int] = ... + WINDOW_ICONIFIED: typing.ClassVar[int] = ... + WINDOW_DEICONIFIED: typing.ClassVar[int] = ... + WINDOW_ACTIVATED: typing.ClassVar[int] = ... + WINDOW_DEACTIVATED: typing.ClassVar[int] = ... + WINDOW_GAINED_FOCUS: typing.ClassVar[int] = ... + WINDOW_LOST_FOCUS: typing.ClassVar[int] = ... + WINDOW_STATE_CHANGED: typing.ClassVar[int] = ... + WINDOW_LAST: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, window: java.awt.Window, int: int): ... + @typing.overload + def __init__(self, window: java.awt.Window, int: int, int2: int, int3: int): ... + @typing.overload + def __init__(self, window: java.awt.Window, int: int, window2: java.awt.Window): ... + @typing.overload + def __init__( + self, + window: java.awt.Window, + int: int, + window2: java.awt.Window, + int2: int, + int3: int, + ): ... + def getNewState(self) -> int: ... + def getOldState(self) -> int: ... + def getOppositeWindow(self) -> java.awt.Window: ... + def getWindow(self) -> java.awt.Window: ... + def paramString(self) -> java.lang.String: ... + +class KeyEvent(InputEvent): + KEY_FIRST: typing.ClassVar[int] = ... + KEY_LAST: typing.ClassVar[int] = ... + KEY_TYPED: typing.ClassVar[int] = ... + KEY_PRESSED: typing.ClassVar[int] = ... + KEY_RELEASED: typing.ClassVar[int] = ... + VK_ENTER: typing.ClassVar[int] = ... + VK_BACK_SPACE: typing.ClassVar[int] = ... + VK_TAB: typing.ClassVar[int] = ... + VK_CANCEL: typing.ClassVar[int] = ... + VK_CLEAR: typing.ClassVar[int] = ... + VK_SHIFT: typing.ClassVar[int] = ... + VK_CONTROL: typing.ClassVar[int] = ... + VK_ALT: typing.ClassVar[int] = ... + VK_PAUSE: typing.ClassVar[int] = ... + VK_CAPS_LOCK: typing.ClassVar[int] = ... + VK_ESCAPE: typing.ClassVar[int] = ... + VK_SPACE: typing.ClassVar[int] = ... + VK_PAGE_UP: typing.ClassVar[int] = ... + VK_PAGE_DOWN: typing.ClassVar[int] = ... + VK_END: typing.ClassVar[int] = ... + VK_HOME: typing.ClassVar[int] = ... + VK_LEFT: typing.ClassVar[int] = ... + VK_UP: typing.ClassVar[int] = ... + VK_RIGHT: typing.ClassVar[int] = ... + VK_DOWN: typing.ClassVar[int] = ... + VK_COMMA: typing.ClassVar[int] = ... + VK_MINUS: typing.ClassVar[int] = ... + VK_PERIOD: typing.ClassVar[int] = ... + VK_SLASH: typing.ClassVar[int] = ... + VK_0: typing.ClassVar[int] = ... + VK_1: typing.ClassVar[int] = ... + VK_2: typing.ClassVar[int] = ... + VK_3: typing.ClassVar[int] = ... + VK_4: typing.ClassVar[int] = ... + VK_5: typing.ClassVar[int] = ... + VK_6: typing.ClassVar[int] = ... + VK_7: typing.ClassVar[int] = ... + VK_8: typing.ClassVar[int] = ... + VK_9: typing.ClassVar[int] = ... + VK_SEMICOLON: typing.ClassVar[int] = ... + VK_EQUALS: typing.ClassVar[int] = ... + VK_A: typing.ClassVar[int] = ... + VK_B: typing.ClassVar[int] = ... + VK_C: typing.ClassVar[int] = ... + VK_D: typing.ClassVar[int] = ... + VK_E: typing.ClassVar[int] = ... + VK_F: typing.ClassVar[int] = ... + VK_G: typing.ClassVar[int] = ... + VK_H: typing.ClassVar[int] = ... + VK_I: typing.ClassVar[int] = ... + VK_J: typing.ClassVar[int] = ... + VK_K: typing.ClassVar[int] = ... + VK_L: typing.ClassVar[int] = ... + VK_M: typing.ClassVar[int] = ... + VK_N: typing.ClassVar[int] = ... + VK_O: typing.ClassVar[int] = ... + VK_P: typing.ClassVar[int] = ... + VK_Q: typing.ClassVar[int] = ... + VK_R: typing.ClassVar[int] = ... + VK_S: typing.ClassVar[int] = ... + VK_T: typing.ClassVar[int] = ... + VK_U: typing.ClassVar[int] = ... + VK_V: typing.ClassVar[int] = ... + VK_W: typing.ClassVar[int] = ... + VK_X: typing.ClassVar[int] = ... + VK_Y: typing.ClassVar[int] = ... + VK_Z: typing.ClassVar[int] = ... + VK_OPEN_BRACKET: typing.ClassVar[int] = ... + VK_BACK_SLASH: typing.ClassVar[int] = ... + VK_CLOSE_BRACKET: typing.ClassVar[int] = ... + VK_NUMPAD0: typing.ClassVar[int] = ... + VK_NUMPAD1: typing.ClassVar[int] = ... + VK_NUMPAD2: typing.ClassVar[int] = ... + VK_NUMPAD3: typing.ClassVar[int] = ... + VK_NUMPAD4: typing.ClassVar[int] = ... + VK_NUMPAD5: typing.ClassVar[int] = ... + VK_NUMPAD6: typing.ClassVar[int] = ... + VK_NUMPAD7: typing.ClassVar[int] = ... + VK_NUMPAD8: typing.ClassVar[int] = ... + VK_NUMPAD9: typing.ClassVar[int] = ... + VK_MULTIPLY: typing.ClassVar[int] = ... + VK_ADD: typing.ClassVar[int] = ... + VK_SEPARATER: typing.ClassVar[int] = ... + VK_SEPARATOR: typing.ClassVar[int] = ... + VK_SUBTRACT: typing.ClassVar[int] = ... + VK_DECIMAL: typing.ClassVar[int] = ... + VK_DIVIDE: typing.ClassVar[int] = ... + VK_DELETE: typing.ClassVar[int] = ... + VK_NUM_LOCK: typing.ClassVar[int] = ... + VK_SCROLL_LOCK: typing.ClassVar[int] = ... + VK_F1: typing.ClassVar[int] = ... + VK_F2: typing.ClassVar[int] = ... + VK_F3: typing.ClassVar[int] = ... + VK_F4: typing.ClassVar[int] = ... + VK_F5: typing.ClassVar[int] = ... + VK_F6: typing.ClassVar[int] = ... + VK_F7: typing.ClassVar[int] = ... + VK_F8: typing.ClassVar[int] = ... + VK_F9: typing.ClassVar[int] = ... + VK_F10: typing.ClassVar[int] = ... + VK_F11: typing.ClassVar[int] = ... + VK_F12: typing.ClassVar[int] = ... + VK_F13: typing.ClassVar[int] = ... + VK_F14: typing.ClassVar[int] = ... + VK_F15: typing.ClassVar[int] = ... + VK_F16: typing.ClassVar[int] = ... + VK_F17: typing.ClassVar[int] = ... + VK_F18: typing.ClassVar[int] = ... + VK_F19: typing.ClassVar[int] = ... + VK_F20: typing.ClassVar[int] = ... + VK_F21: typing.ClassVar[int] = ... + VK_F22: typing.ClassVar[int] = ... + VK_F23: typing.ClassVar[int] = ... + VK_F24: typing.ClassVar[int] = ... + VK_PRINTSCREEN: typing.ClassVar[int] = ... + VK_INSERT: typing.ClassVar[int] = ... + VK_HELP: typing.ClassVar[int] = ... + VK_META: typing.ClassVar[int] = ... + VK_BACK_QUOTE: typing.ClassVar[int] = ... + VK_QUOTE: typing.ClassVar[int] = ... + VK_KP_UP: typing.ClassVar[int] = ... + VK_KP_DOWN: typing.ClassVar[int] = ... + VK_KP_LEFT: typing.ClassVar[int] = ... + VK_KP_RIGHT: typing.ClassVar[int] = ... + VK_DEAD_GRAVE: typing.ClassVar[int] = ... + VK_DEAD_ACUTE: typing.ClassVar[int] = ... + VK_DEAD_CIRCUMFLEX: typing.ClassVar[int] = ... + VK_DEAD_TILDE: typing.ClassVar[int] = ... + VK_DEAD_MACRON: typing.ClassVar[int] = ... + VK_DEAD_BREVE: typing.ClassVar[int] = ... + VK_DEAD_ABOVEDOT: typing.ClassVar[int] = ... + VK_DEAD_DIAERESIS: typing.ClassVar[int] = ... + VK_DEAD_ABOVERING: typing.ClassVar[int] = ... + VK_DEAD_DOUBLEACUTE: typing.ClassVar[int] = ... + VK_DEAD_CARON: typing.ClassVar[int] = ... + VK_DEAD_CEDILLA: typing.ClassVar[int] = ... + VK_DEAD_OGONEK: typing.ClassVar[int] = ... + VK_DEAD_IOTA: typing.ClassVar[int] = ... + VK_DEAD_VOICED_SOUND: typing.ClassVar[int] = ... + VK_DEAD_SEMIVOICED_SOUND: typing.ClassVar[int] = ... + VK_AMPERSAND: typing.ClassVar[int] = ... + VK_ASTERISK: typing.ClassVar[int] = ... + VK_QUOTEDBL: typing.ClassVar[int] = ... + VK_LESS: typing.ClassVar[int] = ... + VK_GREATER: typing.ClassVar[int] = ... + VK_BRACELEFT: typing.ClassVar[int] = ... + VK_BRACERIGHT: typing.ClassVar[int] = ... + VK_AT: typing.ClassVar[int] = ... + VK_COLON: typing.ClassVar[int] = ... + VK_CIRCUMFLEX: typing.ClassVar[int] = ... + VK_DOLLAR: typing.ClassVar[int] = ... + VK_EURO_SIGN: typing.ClassVar[int] = ... + VK_EXCLAMATION_MARK: typing.ClassVar[int] = ... + VK_INVERTED_EXCLAMATION_MARK: typing.ClassVar[int] = ... + VK_LEFT_PARENTHESIS: typing.ClassVar[int] = ... + VK_NUMBER_SIGN: typing.ClassVar[int] = ... + VK_PLUS: typing.ClassVar[int] = ... + VK_RIGHT_PARENTHESIS: typing.ClassVar[int] = ... + VK_UNDERSCORE: typing.ClassVar[int] = ... + VK_WINDOWS: typing.ClassVar[int] = ... + VK_CONTEXT_MENU: typing.ClassVar[int] = ... + VK_FINAL: typing.ClassVar[int] = ... + VK_CONVERT: typing.ClassVar[int] = ... + VK_NONCONVERT: typing.ClassVar[int] = ... + VK_ACCEPT: typing.ClassVar[int] = ... + VK_MODECHANGE: typing.ClassVar[int] = ... + VK_KANA: typing.ClassVar[int] = ... + VK_KANJI: typing.ClassVar[int] = ... + VK_ALPHANUMERIC: typing.ClassVar[int] = ... + VK_KATAKANA: typing.ClassVar[int] = ... + VK_HIRAGANA: typing.ClassVar[int] = ... + VK_FULL_WIDTH: typing.ClassVar[int] = ... + VK_HALF_WIDTH: typing.ClassVar[int] = ... + VK_ROMAN_CHARACTERS: typing.ClassVar[int] = ... + VK_ALL_CANDIDATES: typing.ClassVar[int] = ... + VK_PREVIOUS_CANDIDATE: typing.ClassVar[int] = ... + VK_CODE_INPUT: typing.ClassVar[int] = ... + VK_JAPANESE_KATAKANA: typing.ClassVar[int] = ... + VK_JAPANESE_HIRAGANA: typing.ClassVar[int] = ... + VK_JAPANESE_ROMAN: typing.ClassVar[int] = ... + VK_KANA_LOCK: typing.ClassVar[int] = ... + VK_INPUT_METHOD_ON_OFF: typing.ClassVar[int] = ... + VK_CUT: typing.ClassVar[int] = ... + VK_COPY: typing.ClassVar[int] = ... + VK_PASTE: typing.ClassVar[int] = ... + VK_UNDO: typing.ClassVar[int] = ... + VK_AGAIN: typing.ClassVar[int] = ... + VK_FIND: typing.ClassVar[int] = ... + VK_PROPS: typing.ClassVar[int] = ... + VK_STOP: typing.ClassVar[int] = ... + VK_COMPOSE: typing.ClassVar[int] = ... + VK_ALT_GRAPH: typing.ClassVar[int] = ... + VK_BEGIN: typing.ClassVar[int] = ... + VK_UNDEFINED: typing.ClassVar[int] = ... + CHAR_UNDEFINED: typing.ClassVar[str] = ... + KEY_LOCATION_UNKNOWN: typing.ClassVar[int] = ... + KEY_LOCATION_STANDARD: typing.ClassVar[int] = ... + KEY_LOCATION_LEFT: typing.ClassVar[int] = ... + KEY_LOCATION_RIGHT: typing.ClassVar[int] = ... + KEY_LOCATION_NUMPAD: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, component: java.awt.Component, int: int, long: int, int2: int, int3: int + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + long: int, + int2: int, + int3: int, + char: str, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + long: int, + int2: int, + int3: int, + char: str, + int4: int, + ): ... + def getExtendedKeyCode(self) -> int: ... + @staticmethod + def getExtendedKeyCodeForChar(int: int) -> int: ... + def getKeyChar(self) -> str: ... + def getKeyCode(self) -> int: ... + def getKeyLocation(self) -> int: ... + @staticmethod + def getKeyModifiersText(int: int) -> java.lang.String: ... + @staticmethod + def getKeyText(int: int) -> java.lang.String: ... + def isActionKey(self) -> bool: ... + def paramString(self) -> java.lang.String: ... + def setKeyChar(self, char: str) -> None: ... + def setKeyCode(self, int: int) -> None: ... + def setModifiers(self, int: int) -> None: ... + +class MouseEvent(InputEvent): + MOUSE_FIRST: typing.ClassVar[int] = ... + MOUSE_LAST: typing.ClassVar[int] = ... + MOUSE_CLICKED: typing.ClassVar[int] = ... + MOUSE_PRESSED: typing.ClassVar[int] = ... + MOUSE_RELEASED: typing.ClassVar[int] = ... + MOUSE_MOVED: typing.ClassVar[int] = ... + MOUSE_ENTERED: typing.ClassVar[int] = ... + MOUSE_EXITED: typing.ClassVar[int] = ... + MOUSE_DRAGGED: typing.ClassVar[int] = ... + MOUSE_WHEEL: typing.ClassVar[int] = ... + NOBUTTON: typing.ClassVar[int] = ... + BUTTON1: typing.ClassVar[int] = ... + BUTTON2: typing.ClassVar[int] = ... + BUTTON3: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + long: int, + int2: int, + int3: int, + int4: int, + int5: int, + boolean: bool, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + long: int, + int2: int, + int3: int, + int4: int, + int5: int, + boolean: bool, + int6: int, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + long: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + boolean: bool, + int8: int, + ): ... + def getButton(self) -> int: ... + def getClickCount(self) -> int: ... + def getLocationOnScreen(self) -> java.awt.Point: ... + def getModifiersEx(self) -> int: ... + @staticmethod + def getMouseModifiersText(int: int) -> java.lang.String: ... + def getPoint(self) -> java.awt.Point: ... + def getX(self) -> int: ... + def getXOnScreen(self) -> int: ... + def getY(self) -> int: ... + def getYOnScreen(self) -> int: ... + def isPopupTrigger(self) -> bool: ... + def paramString(self) -> java.lang.String: ... + def translatePoint(self, int: int, int2: int) -> None: ... + +class MouseWheelEvent(MouseEvent): + WHEEL_UNIT_SCROLL: typing.ClassVar[int] = ... + WHEEL_BLOCK_SCROLL: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + long: int, + int2: int, + int3: int, + int4: int, + int5: int, + boolean: bool, + int6: int, + int7: int, + int8: int, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + long: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + boolean: bool, + int8: int, + int9: int, + int10: int, + ): ... + @typing.overload + def __init__( + self, + component: java.awt.Component, + int: int, + long: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + boolean: bool, + int8: int, + int9: int, + int10: int, + double: float, + ): ... + def getPreciseWheelRotation(self) -> float: ... + def getScrollAmount(self) -> int: ... + def getScrollType(self) -> int: ... + def getUnitsToScroll(self) -> int: ... + def getWheelRotation(self) -> int: ... + def paramString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.event")``. + + AWTEventListener: type[AWTEventListener] + AWTEventListenerProxy: type[AWTEventListenerProxy] + ActionEvent: type[ActionEvent] + ActionListener: type[ActionListener] + AdjustmentEvent: type[AdjustmentEvent] + AdjustmentListener: type[AdjustmentListener] + ComponentAdapter: type[ComponentAdapter] + ComponentEvent: type[ComponentEvent] + ComponentListener: type[ComponentListener] + ContainerAdapter: type[ContainerAdapter] + ContainerEvent: type[ContainerEvent] + ContainerListener: type[ContainerListener] + FocusAdapter: type[FocusAdapter] + FocusEvent: type[FocusEvent] + FocusListener: type[FocusListener] + HierarchyBoundsAdapter: type[HierarchyBoundsAdapter] + HierarchyBoundsListener: type[HierarchyBoundsListener] + HierarchyEvent: type[HierarchyEvent] + HierarchyListener: type[HierarchyListener] + InputEvent: type[InputEvent] + InputMethodEvent: type[InputMethodEvent] + InputMethodListener: type[InputMethodListener] + InvocationEvent: type[InvocationEvent] + ItemEvent: type[ItemEvent] + ItemListener: type[ItemListener] + KeyAdapter: type[KeyAdapter] + KeyEvent: type[KeyEvent] + KeyListener: type[KeyListener] + MouseAdapter: type[MouseAdapter] + MouseEvent: type[MouseEvent] + MouseListener: type[MouseListener] + MouseMotionAdapter: type[MouseMotionAdapter] + MouseMotionListener: type[MouseMotionListener] + MouseWheelEvent: type[MouseWheelEvent] + MouseWheelListener: type[MouseWheelListener] + PaintEvent: type[PaintEvent] + TextEvent: type[TextEvent] + TextListener: type[TextListener] + WindowAdapter: type[WindowAdapter] + WindowEvent: type[WindowEvent] + WindowFocusListener: type[WindowFocusListener] + WindowListener: type[WindowListener] + WindowStateListener: type[WindowStateListener] diff --git a/typings/java/awt/font/__init__.pyi b/typings/java/awt/font/__init__.pyi new file mode 100644 index 0000000..e7e5912 --- /dev/null +++ b/typings/java/awt/font/__init__.pyi @@ -0,0 +1,744 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.geom +import java.io +import java.lang +import java.text +import java.util +import jpype + +class FontRenderContext: + @typing.overload + def __init__( + self, + affineTransform: java.awt.geom.AffineTransform, + boolean: bool, + boolean2: bool, + ): ... + @typing.overload + def __init__( + self, + affineTransform: java.awt.geom.AffineTransform, + object: typing.Any, + object2: typing.Any, + ): ... + @typing.overload + def equals(self, fontRenderContext: FontRenderContext) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + def getAntiAliasingHint(self) -> typing.Any: ... + def getFractionalMetricsHint(self) -> typing.Any: ... + def getTransform(self) -> java.awt.geom.AffineTransform: ... + def getTransformType(self) -> int: ... + def hashCode(self) -> int: ... + def isAntiAliased(self) -> bool: ... + def isTransformed(self) -> bool: ... + def usesFractionalMetrics(self) -> bool: ... + +class GlyphJustificationInfo: + PRIORITY_KASHIDA: typing.ClassVar[int] = ... + PRIORITY_WHITESPACE: typing.ClassVar[int] = ... + PRIORITY_INTERCHAR: typing.ClassVar[int] = ... + PRIORITY_NONE: typing.ClassVar[int] = ... + weight: float = ... + growPriority: int = ... + growAbsorb: bool = ... + growLeftLimit: float = ... + growRightLimit: float = ... + shrinkPriority: int = ... + shrinkAbsorb: bool = ... + shrinkLeftLimit: float = ... + shrinkRightLimit: float = ... + def __init__( + self, + float: float, + boolean: bool, + int: int, + float2: float, + float3: float, + boolean2: bool, + int2: int, + float4: float, + float5: float, + ): ... + +class GlyphMetrics: + STANDARD: typing.ClassVar[int] = ... + LIGATURE: typing.ClassVar[int] = ... + COMBINING: typing.ClassVar[int] = ... + COMPONENT: typing.ClassVar[int] = ... + WHITESPACE: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, + boolean: bool, + float: float, + float2: float, + rectangle2D: java.awt.geom.Rectangle2D, + byte: int, + ): ... + @typing.overload + def __init__( + self, float: float, rectangle2D: java.awt.geom.Rectangle2D, byte: int + ): ... + def getAdvance(self) -> float: ... + def getAdvanceX(self) -> float: ... + def getAdvanceY(self) -> float: ... + def getBounds2D(self) -> java.awt.geom.Rectangle2D: ... + def getLSB(self) -> float: ... + def getRSB(self) -> float: ... + def getType(self) -> int: ... + def isCombining(self) -> bool: ... + def isComponent(self) -> bool: ... + def isLigature(self) -> bool: ... + def isStandard(self) -> bool: ... + def isWhitespace(self) -> bool: ... + +class GlyphVector(java.lang.Cloneable): + FLAG_HAS_TRANSFORMS: typing.ClassVar[int] = ... + FLAG_HAS_POSITION_ADJUSTMENTS: typing.ClassVar[int] = ... + FLAG_RUN_RTL: typing.ClassVar[int] = ... + FLAG_COMPLEX_GLYPHS: typing.ClassVar[int] = ... + FLAG_MASK: typing.ClassVar[int] = ... + @typing.overload + def equals(self, glyphVector: GlyphVector) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + def getFont(self) -> java.awt.Font: ... + def getFontRenderContext(self) -> FontRenderContext: ... + def getGlyphCharIndex(self, int: int) -> int: ... + def getGlyphCharIndices( + self, int: int, int2: int, intArray: list[int] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + def getGlyphCode(self, int: int) -> int: ... + def getGlyphCodes( + self, int: int, int2: int, intArray: list[int] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + def getGlyphJustificationInfo(self, int: int) -> GlyphJustificationInfo: ... + def getGlyphLogicalBounds(self, int: int) -> java.awt.Shape: ... + def getGlyphMetrics(self, int: int) -> GlyphMetrics: ... + @typing.overload + def getGlyphOutline(self, int: int) -> java.awt.Shape: ... + @typing.overload + def getGlyphOutline( + self, int: int, float: float, float2: float + ) -> java.awt.Shape: ... + def getGlyphPixelBounds( + self, + int: int, + fontRenderContext: FontRenderContext, + float: float, + float2: float, + ) -> java.awt.Rectangle: ... + def getGlyphPosition(self, int: int) -> java.awt.geom.Point2D: ... + def getGlyphPositions( + self, int: int, int2: int, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def getGlyphTransform(self, int: int) -> java.awt.geom.AffineTransform: ... + def getGlyphVisualBounds(self, int: int) -> java.awt.Shape: ... + def getLayoutFlags(self) -> int: ... + def getLogicalBounds(self) -> java.awt.geom.Rectangle2D: ... + def getNumGlyphs(self) -> int: ... + @typing.overload + def getOutline(self) -> java.awt.Shape: ... + @typing.overload + def getOutline(self, float: float, float2: float) -> java.awt.Shape: ... + def getPixelBounds( + self, fontRenderContext: FontRenderContext, float: float, float2: float + ) -> java.awt.Rectangle: ... + def getVisualBounds(self) -> java.awt.geom.Rectangle2D: ... + def performDefaultLayout(self) -> None: ... + def setGlyphPosition(self, int: int, point2D: java.awt.geom.Point2D) -> None: ... + def setGlyphTransform( + self, int: int, affineTransform: java.awt.geom.AffineTransform + ) -> None: ... + +class GraphicAttribute: + TOP_ALIGNMENT: typing.ClassVar[int] = ... + BOTTOM_ALIGNMENT: typing.ClassVar[int] = ... + ROMAN_BASELINE: typing.ClassVar[int] = ... + CENTER_BASELINE: typing.ClassVar[int] = ... + HANGING_BASELINE: typing.ClassVar[int] = ... + def draw( + self, graphics2D: java.awt.Graphics2D, float: float, float2: float + ) -> None: ... + def getAdvance(self) -> float: ... + def getAlignment(self) -> int: ... + def getAscent(self) -> float: ... + def getBounds(self) -> java.awt.geom.Rectangle2D: ... + def getDescent(self) -> float: ... + def getJustificationInfo(self) -> GlyphJustificationInfo: ... + def getOutline( + self, affineTransform: java.awt.geom.AffineTransform + ) -> java.awt.Shape: ... + +class LayoutPath: + def pathToPoint( + self, + point2D: java.awt.geom.Point2D, + boolean: bool, + point2D2: java.awt.geom.Point2D, + ) -> None: ... + def pointToPath( + self, point2D: java.awt.geom.Point2D, point2D2: java.awt.geom.Point2D + ) -> bool: ... + +class LineBreakMeasurer: + @typing.overload + def __init__( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + fontRenderContext: FontRenderContext, + ): ... + @typing.overload + def __init__( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + breakIterator: java.text.BreakIterator, + fontRenderContext: FontRenderContext, + ): ... + def deleteChar( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int: int, + ) -> None: ... + def getPosition(self) -> int: ... + def insertChar( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int: int, + ) -> None: ... + @typing.overload + def nextLayout(self, float: float) -> TextLayout: ... + @typing.overload + def nextLayout(self, float: float, int: int, boolean: bool) -> TextLayout: ... + @typing.overload + def nextOffset(self, float: float) -> int: ... + @typing.overload + def nextOffset(self, float: float, int: int, boolean: bool) -> int: ... + def setPosition(self, int: int) -> None: ... + +class LineMetrics: + def getAscent(self) -> float: ... + def getBaselineIndex(self) -> int: ... + def getBaselineOffsets(self) -> typing.MutableSequence[float]: ... + def getDescent(self) -> float: ... + def getHeight(self) -> float: ... + def getLeading(self) -> float: ... + def getNumChars(self) -> int: ... + def getStrikethroughOffset(self) -> float: ... + def getStrikethroughThickness(self) -> float: ... + def getUnderlineOffset(self) -> float: ... + def getUnderlineThickness(self) -> float: ... + +class MultipleMaster: + @typing.overload + def deriveMMFont(self, floatArray: list[float] | jpype.JArray) -> java.awt.Font: ... + @typing.overload + def deriveMMFont( + self, + floatArray: list[float] | jpype.JArray, + float2: float, + float3: float, + float4: float, + float5: float, + ) -> java.awt.Font: ... + def getDesignAxisDefaults(self) -> typing.MutableSequence[float]: ... + def getDesignAxisNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getDesignAxisRanges(self) -> typing.MutableSequence[float]: ... + def getNumDesignAxes(self) -> int: ... + +class NumericShaper(java.io.Serializable): + EUROPEAN: typing.ClassVar[int] = ... + ARABIC: typing.ClassVar[int] = ... + EASTERN_ARABIC: typing.ClassVar[int] = ... + DEVANAGARI: typing.ClassVar[int] = ... + BENGALI: typing.ClassVar[int] = ... + GURMUKHI: typing.ClassVar[int] = ... + GUJARATI: typing.ClassVar[int] = ... + ORIYA: typing.ClassVar[int] = ... + TAMIL: typing.ClassVar[int] = ... + TELUGU: typing.ClassVar[int] = ... + KANNADA: typing.ClassVar[int] = ... + MALAYALAM: typing.ClassVar[int] = ... + THAI: typing.ClassVar[int] = ... + LAO: typing.ClassVar[int] = ... + TIBETAN: typing.ClassVar[int] = ... + MYANMAR: typing.ClassVar[int] = ... + ETHIOPIC: typing.ClassVar[int] = ... + KHMER: typing.ClassVar[int] = ... + MONGOLIAN: typing.ClassVar[int] = ... + ALL_RANGES: typing.ClassVar[int] = ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + @staticmethod + def getContextualShaper(int: int) -> NumericShaper: ... + @typing.overload + @staticmethod + def getContextualShaper(int: int, int2: int) -> NumericShaper: ... + @typing.overload + @staticmethod + def getContextualShaper( + set: java.util.Set[NumericShaper.Range], + ) -> NumericShaper: ... + @typing.overload + @staticmethod + def getContextualShaper( + set: java.util.Set[NumericShaper.Range], range: NumericShaper.Range + ) -> NumericShaper: ... + def getRangeSet(self) -> java.util.Set[NumericShaper.Range]: ... + def getRanges(self) -> int: ... + @typing.overload + @staticmethod + def getShaper(int: int) -> NumericShaper: ... + @typing.overload + @staticmethod + def getShaper(range: NumericShaper.Range) -> NumericShaper: ... + def hashCode(self) -> int: ... + def isContextual(self) -> bool: ... + @typing.overload + def shape( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def shape( + self, charArray: list[str] | jpype.JArray, int: int, int2: int, int3: int + ) -> None: ... + @typing.overload + def shape( + self, + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + range: NumericShaper.Range, + ) -> None: ... + def toString(self) -> java.lang.String: ... + class Range(java.lang.Enum["NumericShaper.Range"]): + EUROPEAN: typing.ClassVar[NumericShaper.Range] = ... + ARABIC: typing.ClassVar[NumericShaper.Range] = ... + EASTERN_ARABIC: typing.ClassVar[NumericShaper.Range] = ... + DEVANAGARI: typing.ClassVar[NumericShaper.Range] = ... + BENGALI: typing.ClassVar[NumericShaper.Range] = ... + GURMUKHI: typing.ClassVar[NumericShaper.Range] = ... + GUJARATI: typing.ClassVar[NumericShaper.Range] = ... + ORIYA: typing.ClassVar[NumericShaper.Range] = ... + TAMIL: typing.ClassVar[NumericShaper.Range] = ... + TELUGU: typing.ClassVar[NumericShaper.Range] = ... + KANNADA: typing.ClassVar[NumericShaper.Range] = ... + MALAYALAM: typing.ClassVar[NumericShaper.Range] = ... + THAI: typing.ClassVar[NumericShaper.Range] = ... + LAO: typing.ClassVar[NumericShaper.Range] = ... + TIBETAN: typing.ClassVar[NumericShaper.Range] = ... + MYANMAR: typing.ClassVar[NumericShaper.Range] = ... + ETHIOPIC: typing.ClassVar[NumericShaper.Range] = ... + KHMER: typing.ClassVar[NumericShaper.Range] = ... + MONGOLIAN: typing.ClassVar[NumericShaper.Range] = ... + NKO: typing.ClassVar[NumericShaper.Range] = ... + MYANMAR_SHAN: typing.ClassVar[NumericShaper.Range] = ... + LIMBU: typing.ClassVar[NumericShaper.Range] = ... + NEW_TAI_LUE: typing.ClassVar[NumericShaper.Range] = ... + BALINESE: typing.ClassVar[NumericShaper.Range] = ... + SUNDANESE: typing.ClassVar[NumericShaper.Range] = ... + LEPCHA: typing.ClassVar[NumericShaper.Range] = ... + OL_CHIKI: typing.ClassVar[NumericShaper.Range] = ... + VAI: typing.ClassVar[NumericShaper.Range] = ... + SAURASHTRA: typing.ClassVar[NumericShaper.Range] = ... + KAYAH_LI: typing.ClassVar[NumericShaper.Range] = ... + CHAM: typing.ClassVar[NumericShaper.Range] = ... + TAI_THAM_HORA: typing.ClassVar[NumericShaper.Range] = ... + TAI_THAM_THAM: typing.ClassVar[NumericShaper.Range] = ... + JAVANESE: typing.ClassVar[NumericShaper.Range] = ... + MEETEI_MAYEK: typing.ClassVar[NumericShaper.Range] = ... + SINHALA: typing.ClassVar[NumericShaper.Range] = ... + MYANMAR_TAI_LAING: typing.ClassVar[NumericShaper.Range] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> NumericShaper.Range: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[NumericShaper.Range]: ... + +class OpenType: + TAG_CMAP: typing.ClassVar[int] = ... + TAG_HEAD: typing.ClassVar[int] = ... + TAG_NAME: typing.ClassVar[int] = ... + TAG_GLYF: typing.ClassVar[int] = ... + TAG_MAXP: typing.ClassVar[int] = ... + TAG_PREP: typing.ClassVar[int] = ... + TAG_HMTX: typing.ClassVar[int] = ... + TAG_KERN: typing.ClassVar[int] = ... + TAG_HDMX: typing.ClassVar[int] = ... + TAG_LOCA: typing.ClassVar[int] = ... + TAG_POST: typing.ClassVar[int] = ... + TAG_OS2: typing.ClassVar[int] = ... + TAG_CVT: typing.ClassVar[int] = ... + TAG_GASP: typing.ClassVar[int] = ... + TAG_VDMX: typing.ClassVar[int] = ... + TAG_VMTX: typing.ClassVar[int] = ... + TAG_VHEA: typing.ClassVar[int] = ... + TAG_HHEA: typing.ClassVar[int] = ... + TAG_TYP1: typing.ClassVar[int] = ... + TAG_BSLN: typing.ClassVar[int] = ... + TAG_GSUB: typing.ClassVar[int] = ... + TAG_DSIG: typing.ClassVar[int] = ... + TAG_FPGM: typing.ClassVar[int] = ... + TAG_FVAR: typing.ClassVar[int] = ... + TAG_GVAR: typing.ClassVar[int] = ... + TAG_CFF: typing.ClassVar[int] = ... + TAG_MMSD: typing.ClassVar[int] = ... + TAG_MMFX: typing.ClassVar[int] = ... + TAG_BASE: typing.ClassVar[int] = ... + TAG_GDEF: typing.ClassVar[int] = ... + TAG_GPOS: typing.ClassVar[int] = ... + TAG_JSTF: typing.ClassVar[int] = ... + TAG_EBDT: typing.ClassVar[int] = ... + TAG_EBLC: typing.ClassVar[int] = ... + TAG_EBSC: typing.ClassVar[int] = ... + TAG_LTSH: typing.ClassVar[int] = ... + TAG_PCLT: typing.ClassVar[int] = ... + TAG_ACNT: typing.ClassVar[int] = ... + TAG_AVAR: typing.ClassVar[int] = ... + TAG_BDAT: typing.ClassVar[int] = ... + TAG_BLOC: typing.ClassVar[int] = ... + TAG_CVAR: typing.ClassVar[int] = ... + TAG_FEAT: typing.ClassVar[int] = ... + TAG_FDSC: typing.ClassVar[int] = ... + TAG_FMTX: typing.ClassVar[int] = ... + TAG_JUST: typing.ClassVar[int] = ... + TAG_LCAR: typing.ClassVar[int] = ... + TAG_MORT: typing.ClassVar[int] = ... + TAG_OPBD: typing.ClassVar[int] = ... + TAG_PROP: typing.ClassVar[int] = ... + TAG_TRAK: typing.ClassVar[int] = ... + @typing.overload + def getFontTable(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getFontTable( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getFontTable( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getFontTable( + self, string: java.lang.String | str, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getFontTableSize(self, int: int) -> int: ... + @typing.overload + def getFontTableSize(self, string: java.lang.String | str) -> int: ... + def getVersion(self) -> int: ... + +class TextAttribute(java.text.AttributedCharacterIterator.Attribute): + FAMILY: typing.ClassVar[TextAttribute] = ... + WEIGHT: typing.ClassVar[TextAttribute] = ... + WEIGHT_EXTRA_LIGHT: typing.ClassVar[float] = ... + WEIGHT_LIGHT: typing.ClassVar[float] = ... + WEIGHT_DEMILIGHT: typing.ClassVar[float] = ... + WEIGHT_REGULAR: typing.ClassVar[float] = ... + WEIGHT_SEMIBOLD: typing.ClassVar[float] = ... + WEIGHT_MEDIUM: typing.ClassVar[float] = ... + WEIGHT_DEMIBOLD: typing.ClassVar[float] = ... + WEIGHT_BOLD: typing.ClassVar[float] = ... + WEIGHT_HEAVY: typing.ClassVar[float] = ... + WEIGHT_EXTRABOLD: typing.ClassVar[float] = ... + WEIGHT_ULTRABOLD: typing.ClassVar[float] = ... + WIDTH: typing.ClassVar[TextAttribute] = ... + WIDTH_CONDENSED: typing.ClassVar[float] = ... + WIDTH_SEMI_CONDENSED: typing.ClassVar[float] = ... + WIDTH_REGULAR: typing.ClassVar[float] = ... + WIDTH_SEMI_EXTENDED: typing.ClassVar[float] = ... + WIDTH_EXTENDED: typing.ClassVar[float] = ... + POSTURE: typing.ClassVar[TextAttribute] = ... + POSTURE_REGULAR: typing.ClassVar[float] = ... + POSTURE_OBLIQUE: typing.ClassVar[float] = ... + SIZE: typing.ClassVar[TextAttribute] = ... + TRANSFORM: typing.ClassVar[TextAttribute] = ... + SUPERSCRIPT: typing.ClassVar[TextAttribute] = ... + SUPERSCRIPT_SUPER: typing.ClassVar[int] = ... + SUPERSCRIPT_SUB: typing.ClassVar[int] = ... + FONT: typing.ClassVar[TextAttribute] = ... + CHAR_REPLACEMENT: typing.ClassVar[TextAttribute] = ... + FOREGROUND: typing.ClassVar[TextAttribute] = ... + BACKGROUND: typing.ClassVar[TextAttribute] = ... + UNDERLINE: typing.ClassVar[TextAttribute] = ... + UNDERLINE_ON: typing.ClassVar[int] = ... + STRIKETHROUGH: typing.ClassVar[TextAttribute] = ... + STRIKETHROUGH_ON: typing.ClassVar[bool] = ... + RUN_DIRECTION: typing.ClassVar[TextAttribute] = ... + RUN_DIRECTION_LTR: typing.ClassVar[bool] = ... + RUN_DIRECTION_RTL: typing.ClassVar[bool] = ... + BIDI_EMBEDDING: typing.ClassVar[TextAttribute] = ... + JUSTIFICATION: typing.ClassVar[TextAttribute] = ... + JUSTIFICATION_FULL: typing.ClassVar[float] = ... + JUSTIFICATION_NONE: typing.ClassVar[float] = ... + INPUT_METHOD_HIGHLIGHT: typing.ClassVar[TextAttribute] = ... + INPUT_METHOD_UNDERLINE: typing.ClassVar[TextAttribute] = ... + UNDERLINE_LOW_ONE_PIXEL: typing.ClassVar[int] = ... + UNDERLINE_LOW_TWO_PIXEL: typing.ClassVar[int] = ... + UNDERLINE_LOW_DOTTED: typing.ClassVar[int] = ... + UNDERLINE_LOW_GRAY: typing.ClassVar[int] = ... + UNDERLINE_LOW_DASHED: typing.ClassVar[int] = ... + SWAP_COLORS: typing.ClassVar[TextAttribute] = ... + SWAP_COLORS_ON: typing.ClassVar[bool] = ... + NUMERIC_SHAPING: typing.ClassVar[TextAttribute] = ... + KERNING: typing.ClassVar[TextAttribute] = ... + KERNING_ON: typing.ClassVar[int] = ... + LIGATURES: typing.ClassVar[TextAttribute] = ... + LIGATURES_ON: typing.ClassVar[int] = ... + TRACKING: typing.ClassVar[TextAttribute] = ... + TRACKING_TIGHT: typing.ClassVar[float] = ... + TRACKING_LOOSE: typing.ClassVar[float] = ... + +class TextHitInfo: + @staticmethod + def afterOffset(int: int) -> TextHitInfo: ... + @staticmethod + def beforeOffset(int: int) -> TextHitInfo: ... + @typing.overload + def equals(self, textHitInfo: TextHitInfo) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + def getCharIndex(self) -> int: ... + def getInsertionIndex(self) -> int: ... + def getOffsetHit(self, int: int) -> TextHitInfo: ... + def getOtherHit(self) -> TextHitInfo: ... + def hashCode(self) -> int: ... + def isLeadingEdge(self) -> bool: ... + @staticmethod + def leading(int: int) -> TextHitInfo: ... + def toString(self) -> java.lang.String: ... + @staticmethod + def trailing(int: int) -> TextHitInfo: ... + +class TextLayout(java.lang.Cloneable): + DEFAULT_CARET_POLICY: typing.ClassVar[TextLayout.CaretPolicy] = ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + font: java.awt.Font, + fontRenderContext: FontRenderContext, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + map: java.util.Map[java.text.AttributedCharacterIterator.Attribute, typing.Any] + | typing.Mapping[java.text.AttributedCharacterIterator.Attribute, typing.Any], + fontRenderContext: FontRenderContext, + ): ... + @typing.overload + def __init__( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + fontRenderContext: FontRenderContext, + ): ... + def draw( + self, graphics2D: java.awt.Graphics2D, float: float, float2: float + ) -> None: ... + @typing.overload + def equals(self, textLayout: TextLayout) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + def getAdvance(self) -> float: ... + def getAscent(self) -> float: ... + def getBaseline(self) -> int: ... + def getBaselineOffsets(self) -> typing.MutableSequence[float]: ... + def getBlackBoxBounds(self, int: int, int2: int) -> java.awt.Shape: ... + def getBounds(self) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getCaretInfo( + self, textHitInfo: TextHitInfo + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getCaretInfo( + self, textHitInfo: TextHitInfo, rectangle2D: java.awt.geom.Rectangle2D + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getCaretShape(self, textHitInfo: TextHitInfo) -> java.awt.Shape: ... + @typing.overload + def getCaretShape( + self, textHitInfo: TextHitInfo, rectangle2D: java.awt.geom.Rectangle2D + ) -> java.awt.Shape: ... + @typing.overload + def getCaretShapes(self, int: int) -> typing.MutableSequence[java.awt.Shape]: ... + @typing.overload + def getCaretShapes( + self, int: int, rectangle2D: java.awt.geom.Rectangle2D + ) -> typing.MutableSequence[java.awt.Shape]: ... + @typing.overload + def getCaretShapes( + self, + int: int, + rectangle2D: java.awt.geom.Rectangle2D, + caretPolicy: TextLayout.CaretPolicy, + ) -> typing.MutableSequence[java.awt.Shape]: ... + def getCharacterCount(self) -> int: ... + def getCharacterLevel(self, int: int) -> int: ... + def getDescent(self) -> float: ... + def getJustifiedLayout(self, float: float) -> TextLayout: ... + def getLayoutPath(self) -> LayoutPath: ... + def getLeading(self) -> float: ... + @typing.overload + def getLogicalHighlightShape(self, int: int, int2: int) -> java.awt.Shape: ... + @typing.overload + def getLogicalHighlightShape( + self, int: int, int2: int, rectangle2D: java.awt.geom.Rectangle2D + ) -> java.awt.Shape: ... + def getLogicalRangesForVisualSelection( + self, textHitInfo: TextHitInfo, textHitInfo2: TextHitInfo + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getNextLeftHit(self, int: int) -> TextHitInfo: ... + @typing.overload + def getNextLeftHit( + self, int: int, caretPolicy: TextLayout.CaretPolicy + ) -> TextHitInfo: ... + @typing.overload + def getNextLeftHit(self, textHitInfo: TextHitInfo) -> TextHitInfo: ... + @typing.overload + def getNextRightHit(self, int: int) -> TextHitInfo: ... + @typing.overload + def getNextRightHit( + self, int: int, caretPolicy: TextLayout.CaretPolicy + ) -> TextHitInfo: ... + @typing.overload + def getNextRightHit(self, textHitInfo: TextHitInfo) -> TextHitInfo: ... + def getOutline( + self, affineTransform: java.awt.geom.AffineTransform + ) -> java.awt.Shape: ... + def getPixelBounds( + self, fontRenderContext: FontRenderContext, float: float, float2: float + ) -> java.awt.Rectangle: ... + def getVisibleAdvance(self) -> float: ... + @typing.overload + def getVisualHighlightShape( + self, textHitInfo: TextHitInfo, textHitInfo2: TextHitInfo + ) -> java.awt.Shape: ... + @typing.overload + def getVisualHighlightShape( + self, + textHitInfo: TextHitInfo, + textHitInfo2: TextHitInfo, + rectangle2D: java.awt.geom.Rectangle2D, + ) -> java.awt.Shape: ... + def getVisualOtherHit(self, textHitInfo: TextHitInfo) -> TextHitInfo: ... + @typing.overload + def hitTestChar(self, float: float, float2: float) -> TextHitInfo: ... + @typing.overload + def hitTestChar( + self, float: float, float2: float, rectangle2D: java.awt.geom.Rectangle2D + ) -> TextHitInfo: ... + def hitToPoint( + self, textHitInfo: TextHitInfo, point2D: java.awt.geom.Point2D + ) -> None: ... + def isLeftToRight(self) -> bool: ... + def isVertical(self) -> bool: ... + def toString(self) -> java.lang.String: ... + class CaretPolicy: + def __init__(self): ... + def getStrongCaret( + self, + textHitInfo: TextHitInfo, + textHitInfo2: TextHitInfo, + textLayout: TextLayout, + ) -> TextHitInfo: ... + +class TextMeasurer(java.lang.Cloneable): + def __init__( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + fontRenderContext: FontRenderContext, + ): ... + def deleteChar( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int: int, + ) -> None: ... + def getAdvanceBetween(self, int: int, int2: int) -> float: ... + def getLayout(self, int: int, int2: int) -> TextLayout: ... + def getLineBreakIndex(self, int: int, float: float) -> int: ... + def insertChar( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int: int, + ) -> None: ... + +class TransformAttribute(java.io.Serializable): + IDENTITY: typing.ClassVar[TransformAttribute] = ... + def __init__(self, affineTransform: java.awt.geom.AffineTransform): ... + def equals(self, object: typing.Any) -> bool: ... + def getTransform(self) -> java.awt.geom.AffineTransform: ... + def hashCode(self) -> int: ... + def isIdentity(self) -> bool: ... + +class ImageGraphicAttribute(GraphicAttribute): + @typing.overload + def __init__(self, image: java.awt.Image, int: int): ... + @typing.overload + def __init__( + self, image: java.awt.Image, int: int, float: float, float2: float + ): ... + def draw( + self, graphics2D: java.awt.Graphics2D, float: float, float2: float + ) -> None: ... + @typing.overload + def equals(self, imageGraphicAttribute: ImageGraphicAttribute) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + def getAdvance(self) -> float: ... + def getAscent(self) -> float: ... + def getBounds(self) -> java.awt.geom.Rectangle2D: ... + def getDescent(self) -> float: ... + def hashCode(self) -> int: ... + +class ShapeGraphicAttribute(GraphicAttribute): + STROKE: typing.ClassVar[bool] = ... + FILL: typing.ClassVar[bool] = ... + def __init__(self, shape: java.awt.Shape, int: int, boolean: bool): ... + def draw( + self, graphics2D: java.awt.Graphics2D, float: float, float2: float + ) -> None: ... + @typing.overload + def equals(self, shapeGraphicAttribute: ShapeGraphicAttribute) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + def getAdvance(self) -> float: ... + def getAscent(self) -> float: ... + def getBounds(self) -> java.awt.geom.Rectangle2D: ... + def getDescent(self) -> float: ... + def getOutline( + self, affineTransform: java.awt.geom.AffineTransform + ) -> java.awt.Shape: ... + def hashCode(self) -> int: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.font")``. + + FontRenderContext: type[FontRenderContext] + GlyphJustificationInfo: type[GlyphJustificationInfo] + GlyphMetrics: type[GlyphMetrics] + GlyphVector: type[GlyphVector] + GraphicAttribute: type[GraphicAttribute] + ImageGraphicAttribute: type[ImageGraphicAttribute] + LayoutPath: type[LayoutPath] + LineBreakMeasurer: type[LineBreakMeasurer] + LineMetrics: type[LineMetrics] + MultipleMaster: type[MultipleMaster] + NumericShaper: type[NumericShaper] + OpenType: type[OpenType] + ShapeGraphicAttribute: type[ShapeGraphicAttribute] + TextAttribute: type[TextAttribute] + TextHitInfo: type[TextHitInfo] + TextLayout: type[TextLayout] + TextMeasurer: type[TextMeasurer] + TransformAttribute: type[TransformAttribute] diff --git a/typings/java/awt/geom/__init__.pyi b/typings/java/awt/geom/__init__.pyi new file mode 100644 index 0000000..c997b5d --- /dev/null +++ b/typings/java/awt/geom/__init__.pyi @@ -0,0 +1,1913 @@ +import typing +from typing import Protocol + +import java +import java.awt +import java.io +import java.lang +import jpype + +class AffineTransform(java.lang.Cloneable, java.io.Serializable): + TYPE_IDENTITY: typing.ClassVar[int] = ... + TYPE_TRANSLATION: typing.ClassVar[int] = ... + TYPE_UNIFORM_SCALE: typing.ClassVar[int] = ... + TYPE_GENERAL_SCALE: typing.ClassVar[int] = ... + TYPE_MASK_SCALE: typing.ClassVar[int] = ... + TYPE_FLIP: typing.ClassVar[int] = ... + TYPE_QUADRANT_ROTATION: typing.ClassVar[int] = ... + TYPE_GENERAL_ROTATION: typing.ClassVar[int] = ... + TYPE_MASK_ROTATION: typing.ClassVar[int] = ... + TYPE_GENERAL_TRANSFORM: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ): ... + @typing.overload + def __init__(self, doubleArray: list[float] | jpype.JArray): ... + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + float6: float, + ): ... + @typing.overload + def __init__(self, floatArray: list[float] | jpype.JArray): ... + @typing.overload + def __init__(self, affineTransform: AffineTransform): ... + def clone(self) -> typing.Any: ... + def concatenate(self, affineTransform: AffineTransform) -> None: ... + def createInverse(self) -> AffineTransform: ... + def createTransformedShape(self, shape: java.awt.Shape) -> java.awt.Shape: ... + @typing.overload + def deltaTransform(self, point2D: Point2D, point2D2: Point2D) -> Point2D: ... + @typing.overload + def deltaTransform( + self, + doubleArray: list[float] | jpype.JArray, + int: int, + doubleArray2: list[float] | jpype.JArray, + int2: int, + int3: int, + ) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getDeterminant(self) -> float: ... + def getMatrix(self, doubleArray: list[float] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def getQuadrantRotateInstance(int: int) -> AffineTransform: ... + @typing.overload + @staticmethod + def getQuadrantRotateInstance( + int: int, double: float, double2: float + ) -> AffineTransform: ... + @typing.overload + @staticmethod + def getRotateInstance(double: float) -> AffineTransform: ... + @typing.overload + @staticmethod + def getRotateInstance(double: float, double2: float) -> AffineTransform: ... + @typing.overload + @staticmethod + def getRotateInstance( + double: float, double2: float, double3: float + ) -> AffineTransform: ... + @typing.overload + @staticmethod + def getRotateInstance( + double: float, double2: float, double3: float, double4: float + ) -> AffineTransform: ... + @staticmethod + def getScaleInstance(double: float, double2: float) -> AffineTransform: ... + def getScaleX(self) -> float: ... + def getScaleY(self) -> float: ... + @staticmethod + def getShearInstance(double: float, double2: float) -> AffineTransform: ... + def getShearX(self) -> float: ... + def getShearY(self) -> float: ... + @staticmethod + def getTranslateInstance(double: float, double2: float) -> AffineTransform: ... + def getTranslateX(self) -> float: ... + def getTranslateY(self) -> float: ... + def getType(self) -> int: ... + def hashCode(self) -> int: ... + @typing.overload + def inverseTransform(self, point2D: Point2D, point2D2: Point2D) -> Point2D: ... + @typing.overload + def inverseTransform( + self, + doubleArray: list[float] | jpype.JArray, + int: int, + doubleArray2: list[float] | jpype.JArray, + int2: int, + int3: int, + ) -> None: ... + def invert(self) -> None: ... + def isIdentity(self) -> bool: ... + def preConcatenate(self, affineTransform: AffineTransform) -> None: ... + @typing.overload + def quadrantRotate(self, int: int) -> None: ... + @typing.overload + def quadrantRotate(self, int: int, double: float, double2: float) -> None: ... + @typing.overload + def rotate(self, double: float) -> None: ... + @typing.overload + def rotate(self, double: float, double2: float) -> None: ... + @typing.overload + def rotate(self, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def rotate( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + def scale(self, double: float, double2: float) -> None: ... + def setToIdentity(self) -> None: ... + @typing.overload + def setToQuadrantRotation(self, int: int) -> None: ... + @typing.overload + def setToQuadrantRotation( + self, int: int, double: float, double2: float + ) -> None: ... + @typing.overload + def setToRotation(self, double: float) -> None: ... + @typing.overload + def setToRotation(self, double: float, double2: float) -> None: ... + @typing.overload + def setToRotation(self, double: float, double2: float, double3: float) -> None: ... + @typing.overload + def setToRotation( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + def setToScale(self, double: float, double2: float) -> None: ... + def setToShear(self, double: float, double2: float) -> None: ... + def setToTranslation(self, double: float, double2: float) -> None: ... + @typing.overload + def setTransform( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + @typing.overload + def setTransform(self, affineTransform: AffineTransform) -> None: ... + def shear(self, double: float, double2: float) -> None: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def transform(self, point2D: Point2D, point2D2: Point2D) -> Point2D: ... + @typing.overload + def transform( + self, + doubleArray: list[float] | jpype.JArray, + int: int, + doubleArray2: list[float] | jpype.JArray, + int2: int, + int3: int, + ) -> None: ... + @typing.overload + def transform( + self, + doubleArray: list[float] | jpype.JArray, + int: int, + floatArray: list[float] | jpype.JArray, + int2: int, + int3: int, + ) -> None: ... + @typing.overload + def transform( + self, + floatArray: list[float] | jpype.JArray, + int: int, + doubleArray: list[float] | jpype.JArray, + int2: int, + int3: int, + ) -> None: ... + @typing.overload + def transform( + self, + floatArray: list[float] | jpype.JArray, + int: int, + floatArray2: list[float] | jpype.JArray, + int2: int, + int3: int, + ) -> None: ... + @typing.overload + def transform( + self, + point2DArray: list[Point2D] | jpype.JArray, + int: int, + point2DArray2: list[Point2D] | jpype.JArray, + int2: int, + int3: int, + ) -> None: ... + def translate(self, double: float, double2: float) -> None: ... + +class Area(java.awt.Shape, java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, shape: java.awt.Shape): ... + def add(self, area: Area) -> None: ... + def clone(self) -> typing.Any: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + def createTransformedArea(self, affineTransform: AffineTransform) -> Area: ... + @typing.overload + def equals(self, area: Area) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + def exclusiveOr(self, area: Area) -> None: ... + def getBounds(self) -> java.awt.Rectangle: ... + def getBounds2D(self) -> Rectangle2D: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def intersect(self, area: Area) -> None: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + def isEmpty(self) -> bool: ... + def isPolygonal(self) -> bool: ... + def isRectangular(self) -> bool: ... + def isSingular(self) -> bool: ... + def reset(self) -> None: ... + def subtract(self, area: Area) -> None: ... + def transform(self, affineTransform: AffineTransform) -> None: ... + +class Dimension2D(java.lang.Cloneable): + def clone(self) -> typing.Any: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + @typing.overload + def setSize(self, double: float, double2: float) -> None: ... + @typing.overload + def setSize(self, dimension2D: Dimension2D) -> None: ... + +class IllegalPathStateException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class NoninvertibleTransformException(java.lang.Exception): + def __init__(self, string: java.lang.String | str): ... + +class PathIterator: + WIND_EVEN_ODD: typing.ClassVar[int] = ... + WIND_NON_ZERO: typing.ClassVar[int] = ... + SEG_MOVETO: typing.ClassVar[int] = ... + SEG_LINETO: typing.ClassVar[int] = ... + SEG_QUADTO: typing.ClassVar[int] = ... + SEG_CUBICTO: typing.ClassVar[int] = ... + SEG_CLOSE: typing.ClassVar[int] = ... + @typing.overload + def currentSegment(self, doubleArray: list[float] | jpype.JArray) -> int: ... + @typing.overload + def currentSegment(self, floatArray: list[float] | jpype.JArray) -> int: ... + def getWindingRule(self) -> int: ... + def isDone(self) -> bool: ... + def next(self) -> None: ... + +class RectangularShape(java.awt.Shape, java.lang.Cloneable): + def clone(self) -> typing.Any: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + def getBounds(self) -> java.awt.Rectangle: ... + def getCenterX(self) -> float: ... + def getCenterY(self) -> float: ... + def getFrame(self) -> Rectangle2D: ... + def getHeight(self) -> float: ... + def getMaxX(self) -> float: ... + def getMaxY(self) -> float: ... + def getMinX(self) -> float: ... + def getMinY(self) -> float: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + def isEmpty(self) -> bool: ... + @typing.overload + def setFrame( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setFrame(self, point2D: Point2D, dimension2D: Dimension2D) -> None: ... + @typing.overload + def setFrame(self, rectangle2D: Rectangle2D) -> None: ... + @typing.overload + def setFrameFromCenter( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setFrameFromCenter(self, point2D: Point2D, point2D2: Point2D) -> None: ... + @typing.overload + def setFrameFromDiagonal( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setFrameFromDiagonal(self, point2D: Point2D, point2D2: Point2D) -> None: ... + +class FlatteningPathIterator(PathIterator): + @typing.overload + def __init__(self, pathIterator: PathIterator, double: float): ... + @typing.overload + def __init__(self, pathIterator: PathIterator, double: float, int: int): ... + @typing.overload + def currentSegment(self, doubleArray: list[float] | jpype.JArray) -> int: ... + @typing.overload + def currentSegment(self, floatArray: list[float] | jpype.JArray) -> int: ... + def getFlatness(self) -> float: ... + def getRecursionLimit(self) -> int: ... + def getWindingRule(self) -> int: ... + def isDone(self) -> bool: ... + def next(self) -> None: ... + +class Arc2D(RectangularShape): + OPEN: typing.ClassVar[int] = ... + CHORD: typing.ClassVar[int] = ... + PIE: typing.ClassVar[int] = ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + def containsAngle(self, double: float) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def getAngleExtent(self) -> float: ... + def getAngleStart(self) -> float: ... + def getArcType(self) -> int: ... + def getBounds2D(self) -> Rectangle2D: ... + def getEndPoint(self) -> Point2D: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def getStartPoint(self) -> Point2D: ... + def hashCode(self) -> int: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + def setAngleExtent(self, double: float) -> None: ... + @typing.overload + def setAngleStart(self, double: float) -> None: ... + @typing.overload + def setAngleStart(self, point2D: Point2D) -> None: ... + @typing.overload + def setAngles( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setAngles(self, point2D: Point2D, point2D2: Point2D) -> None: ... + @typing.overload + def setArc( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + int: int, + ) -> None: ... + @typing.overload + def setArc(self, arc2D: Arc2D) -> None: ... + @typing.overload + def setArc( + self, + point2D: Point2D, + dimension2D: Dimension2D, + double: float, + double2: float, + int: int, + ) -> None: ... + @typing.overload + def setArc( + self, rectangle2D: Rectangle2D, double: float, double2: float, int: int + ) -> None: ... + def setArcByCenter( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + int: int, + ) -> None: ... + def setArcByTangent( + self, point2D: Point2D, point2D2: Point2D, point2D3: Point2D, double: float + ) -> None: ... + def setArcType(self, int: int) -> None: ... + @typing.overload + def setFrame( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setFrame(self, point2D: Point2D, dimension2D: Dimension2D) -> None: ... + @typing.overload + def setFrame(self, rectangle2D: Rectangle2D) -> None: ... + class Double(java.awt.geom.Arc2D, java.io.Serializable): + x: float = ... + y: float = ... + width: float = ... + height: float = ... + start: float = ... + extent: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + int: int, + ): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, rectangle2D: Rectangle2D, double: float, double2: float, int: int + ): ... + def getAngleExtent(self) -> float: ... + def getAngleStart(self) -> float: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def isEmpty(self) -> bool: ... + def setAngleExtent(self, double: float) -> None: ... + @typing.overload + def setAngleStart(self, double: float) -> None: ... + @typing.overload + def setAngleStart(self, point2D: Point2D) -> None: ... + @typing.overload + def setArc( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + int: int, + ) -> None: ... + @typing.overload + def setArc(self, arc2D: Arc2D) -> None: ... + @typing.overload + def setArc( + self, + point2D: Point2D, + dimension2D: Dimension2D, + double: float, + double2: float, + int: int, + ) -> None: ... + @typing.overload + def setArc( + self, rectangle2D: Rectangle2D, double: float, double2: float, int: int + ) -> None: ... + + class Float(java.awt.geom.Arc2D, java.io.Serializable): + x: float = ... + y: float = ... + width: float = ... + height: float = ... + start: float = ... + extent: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + float6: float, + int: int, + ): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, rectangle2D: Rectangle2D, float: float, float2: float, int: int + ): ... + def getAngleExtent(self) -> float: ... + def getAngleStart(self) -> float: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def isEmpty(self) -> bool: ... + def setAngleExtent(self, double: float) -> None: ... + @typing.overload + def setAngleStart(self, double: float) -> None: ... + @typing.overload + def setAngleStart(self, point2D: Point2D) -> None: ... + @typing.overload + def setArc( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + int: int, + ) -> None: ... + @typing.overload + def setArc(self, arc2D: Arc2D) -> None: ... + @typing.overload + def setArc( + self, + point2D: Point2D, + dimension2D: Dimension2D, + double: float, + double2: float, + int: int, + ) -> None: ... + @typing.overload + def setArc( + self, rectangle2D: Rectangle2D, double: float, double2: float, int: int + ) -> None: ... + +class CubicCurve2D(java.awt.Shape, java.lang.Cloneable): + def clone(self) -> typing.Any: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + def getBounds(self) -> java.awt.Rectangle: ... + def getBounds2D(self) -> Rectangle2D: ... + def getCtrlP1(self) -> Point2D: ... + def getCtrlP2(self) -> Point2D: ... + def getCtrlX1(self) -> float: ... + def getCtrlX2(self) -> float: ... + def getCtrlY1(self) -> float: ... + def getCtrlY2(self) -> float: ... + @typing.overload + def getFlatness(self) -> float: ... + @typing.overload + @staticmethod + def getFlatness( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + double7: float, + double8: float, + ) -> float: ... + @typing.overload + @staticmethod + def getFlatness(doubleArray: list[float] | jpype.JArray, int: int) -> float: ... + @typing.overload + def getFlatnessSq(self) -> float: ... + @typing.overload + @staticmethod + def getFlatnessSq( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + double7: float, + double8: float, + ) -> float: ... + @typing.overload + @staticmethod + def getFlatnessSq(doubleArray: list[float] | jpype.JArray, int: int) -> float: ... + def getP1(self) -> Point2D: ... + def getP2(self) -> Point2D: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + @typing.overload + def setCurve( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + double7: float, + double8: float, + ) -> None: ... + @typing.overload + def setCurve(self, doubleArray: list[float] | jpype.JArray, int: int) -> None: ... + @typing.overload + def setCurve(self, cubicCurve2D: CubicCurve2D) -> None: ... + @typing.overload + def setCurve( + self, point2D: Point2D, point2D2: Point2D, point2D3: Point2D, point2D4: Point2D + ) -> None: ... + @typing.overload + def setCurve( + self, point2DArray: list[Point2D] | jpype.JArray, int: int + ) -> None: ... + @typing.overload + @staticmethod + def solveCubic(doubleArray: list[float] | jpype.JArray) -> int: ... + @typing.overload + @staticmethod + def solveCubic( + doubleArray: list[float] | jpype.JArray, + doubleArray2: list[float] | jpype.JArray, + ) -> int: ... + @typing.overload + @staticmethod + def subdivide( + doubleArray: list[float] | jpype.JArray, + int: int, + doubleArray2: list[float] | jpype.JArray, + int2: int, + doubleArray3: list[float] | jpype.JArray, + int3: int, + ) -> None: ... + @typing.overload + @staticmethod + def subdivide( + cubicCurve2D: CubicCurve2D, + cubicCurve2D2: CubicCurve2D, + cubicCurve2D3: CubicCurve2D, + ) -> None: ... + @typing.overload + def subdivide( + self, cubicCurve2D: CubicCurve2D, cubicCurve2D2: CubicCurve2D + ) -> None: ... + class Double(java.awt.geom.CubicCurve2D, java.io.Serializable): + x1: float = ... + y1: float = ... + ctrlx1: float = ... + ctrly1: float = ... + ctrlx2: float = ... + ctrly2: float = ... + x2: float = ... + y2: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + double7: float, + double8: float, + ): ... + def getCtrlP1(self) -> Point2D: ... + def getCtrlP2(self) -> Point2D: ... + def getCtrlX1(self) -> float: ... + def getCtrlX2(self) -> float: ... + def getCtrlY1(self) -> float: ... + def getCtrlY2(self) -> float: ... + def getP1(self) -> Point2D: ... + def getP2(self) -> Point2D: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + @typing.overload + def setCurve( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + double7: float, + double8: float, + ) -> None: ... + @typing.overload + def setCurve( + self, doubleArray: list[float] | jpype.JArray, int: int + ) -> None: ... + @typing.overload + def setCurve(self, cubicCurve2D: CubicCurve2D) -> None: ... + @typing.overload + def setCurve( + self, + point2D: Point2D, + point2D2: Point2D, + point2D3: Point2D, + point2D4: Point2D, + ) -> None: ... + @typing.overload + def setCurve( + self, point2DArray: list[Point2D] | jpype.JArray, int: int + ) -> None: ... + + class Float(java.awt.geom.CubicCurve2D, java.io.Serializable): + x1: float = ... + y1: float = ... + ctrlx1: float = ... + ctrly1: float = ... + ctrlx2: float = ... + ctrly2: float = ... + x2: float = ... + y2: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + float6: float, + float7: float, + float8: float, + ): ... + def getCtrlP1(self) -> Point2D: ... + def getCtrlP2(self) -> Point2D: ... + def getCtrlX1(self) -> float: ... + def getCtrlX2(self) -> float: ... + def getCtrlY1(self) -> float: ... + def getCtrlY2(self) -> float: ... + def getP1(self) -> Point2D: ... + def getP2(self) -> Point2D: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + @typing.overload + def setCurve( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + double7: float, + double8: float, + ) -> None: ... + @typing.overload + def setCurve( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + float6: float, + float7: float, + float8: float, + ) -> None: ... + @typing.overload + def setCurve( + self, doubleArray: list[float] | jpype.JArray, int: int + ) -> None: ... + @typing.overload + def setCurve(self, cubicCurve2D: CubicCurve2D) -> None: ... + @typing.overload + def setCurve( + self, + point2D: Point2D, + point2D2: Point2D, + point2D3: Point2D, + point2D4: Point2D, + ) -> None: ... + @typing.overload + def setCurve( + self, point2DArray: list[Point2D] | jpype.JArray, int: int + ) -> None: ... + +class Ellipse2D(RectangularShape): + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def hashCode(self) -> int: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + class Double(java.awt.geom.Ellipse2D, java.io.Serializable): + x: float = ... + y: float = ... + width: float = ... + height: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, double: float, double2: float, double3: float, double4: float + ): ... + def getBounds2D(self) -> Rectangle2D: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def isEmpty(self) -> bool: ... + @typing.overload + def setFrame( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setFrame(self, point2D: Point2D, dimension2D: Dimension2D) -> None: ... + @typing.overload + def setFrame(self, rectangle2D: Rectangle2D) -> None: ... + + class Float(java.awt.geom.Ellipse2D, java.io.Serializable): + x: float = ... + y: float = ... + width: float = ... + height: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, float: float, float2: float, float3: float, float4: float + ): ... + def getBounds2D(self) -> Rectangle2D: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def isEmpty(self) -> bool: ... + @typing.overload + def setFrame( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setFrame( + self, float: float, float2: float, float3: float, float4: float + ) -> None: ... + @typing.overload + def setFrame(self, point2D: Point2D, dimension2D: Dimension2D) -> None: ... + @typing.overload + def setFrame(self, rectangle2D: Rectangle2D) -> None: ... + +class GeneralPath(java.awt.geom.Path2D.Float): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, shape: java.awt.Shape): ... + +class Line2D(java.awt.Shape, java.lang.Cloneable): + def clone(self) -> typing.Any: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + def getBounds(self) -> java.awt.Rectangle: ... + def getP1(self) -> Point2D: ... + def getP2(self) -> Point2D: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + @typing.overload + def intersectsLine( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersectsLine(self, line2D: Line2D) -> bool: ... + @staticmethod + def linesIntersect( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + double7: float, + double8: float, + ) -> bool: ... + @typing.overload + def ptLineDist(self, double: float, double2: float) -> float: ... + @typing.overload + def ptLineDist(self, point2D: Point2D) -> float: ... + @typing.overload + @staticmethod + def ptLineDist( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> float: ... + @typing.overload + def ptLineDistSq(self, double: float, double2: float) -> float: ... + @typing.overload + def ptLineDistSq(self, point2D: Point2D) -> float: ... + @typing.overload + @staticmethod + def ptLineDistSq( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> float: ... + @typing.overload + def ptSegDist(self, double: float, double2: float) -> float: ... + @typing.overload + def ptSegDist(self, point2D: Point2D) -> float: ... + @typing.overload + @staticmethod + def ptSegDist( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> float: ... + @typing.overload + def ptSegDistSq(self, double: float, double2: float) -> float: ... + @typing.overload + def ptSegDistSq(self, point2D: Point2D) -> float: ... + @typing.overload + @staticmethod + def ptSegDistSq( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> float: ... + @typing.overload + def relativeCCW(self, double: float, double2: float) -> int: ... + @typing.overload + def relativeCCW(self, point2D: Point2D) -> int: ... + @typing.overload + @staticmethod + def relativeCCW( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> int: ... + @typing.overload + def setLine( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setLine(self, line2D: Line2D) -> None: ... + @typing.overload + def setLine(self, point2D: Point2D, point2D2: Point2D) -> None: ... + class Double(java.awt.geom.Line2D, java.io.Serializable): + x1: float = ... + y1: float = ... + x2: float = ... + y2: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, double: float, double2: float, double3: float, double4: float + ): ... + @typing.overload + def __init__(self, point2D: Point2D, point2D2: Point2D): ... + def getBounds2D(self) -> Rectangle2D: ... + def getP1(self) -> Point2D: ... + def getP2(self) -> Point2D: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + @typing.overload + def setLine( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setLine(self, line2D: Line2D) -> None: ... + @typing.overload + def setLine(self, point2D: Point2D, point2D2: Point2D) -> None: ... + + class Float(java.awt.geom.Line2D, java.io.Serializable): + x1: float = ... + y1: float = ... + x2: float = ... + y2: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, float: float, float2: float, float3: float, float4: float + ): ... + @typing.overload + def __init__(self, point2D: Point2D, point2D2: Point2D): ... + def getBounds2D(self) -> Rectangle2D: ... + def getP1(self) -> Point2D: ... + def getP2(self) -> Point2D: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + @typing.overload + def setLine( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setLine( + self, float: float, float2: float, float3: float, float4: float + ) -> None: ... + @typing.overload + def setLine(self, line2D: Line2D) -> None: ... + @typing.overload + def setLine(self, point2D: Point2D, point2D2: Point2D) -> None: ... + +class Path2D(java.awt.Shape, java.lang.Cloneable): + WIND_EVEN_ODD: typing.ClassVar[int] = ... + WIND_NON_ZERO: typing.ClassVar[int] = ... + @typing.overload + def append(self, pathIterator: PathIterator, boolean: bool) -> None: ... + @typing.overload + def append(self, shape: java.awt.Shape, boolean: bool) -> None: ... + def clone(self) -> typing.Any: ... + def closePath(self) -> None: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + @typing.overload + @staticmethod + def contains(pathIterator: PathIterator, double: float, double2: float) -> bool: ... + @typing.overload + @staticmethod + def contains( + pathIterator: PathIterator, + double: float, + double2: float, + double3: float, + double4: float, + ) -> bool: ... + @typing.overload + @staticmethod + def contains(pathIterator: PathIterator, point2D: Point2D) -> bool: ... + @typing.overload + @staticmethod + def contains(pathIterator: PathIterator, rectangle2D: Rectangle2D) -> bool: ... + def createTransformedShape( + self, affineTransform: AffineTransform + ) -> java.awt.Shape: ... + def curveTo( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + def getBounds(self) -> java.awt.Rectangle: ... + def getCurrentPoint(self) -> Point2D: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def getWindingRule(self) -> int: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + @typing.overload + @staticmethod + def intersects( + pathIterator: PathIterator, + double: float, + double2: float, + double3: float, + double4: float, + ) -> bool: ... + @typing.overload + @staticmethod + def intersects(pathIterator: PathIterator, rectangle2D: Rectangle2D) -> bool: ... + def lineTo(self, double: float, double2: float) -> None: ... + def moveTo(self, double: float, double2: float) -> None: ... + def quadTo( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + def reset(self) -> None: ... + def setWindingRule(self, int: int) -> None: ... + def transform(self, affineTransform: AffineTransform) -> None: ... + def trimToSize(self) -> None: ... + class Double(java.awt.geom.Path2D, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, shape: java.awt.Shape): ... + @typing.overload + def __init__(self, shape: java.awt.Shape, affineTransform: AffineTransform): ... + @typing.overload + def append(self, pathIterator: PathIterator, boolean: bool) -> None: ... + @typing.overload + def append(self, shape: java.awt.Shape, boolean: bool) -> None: ... + def clone(self) -> typing.Any: ... + def curveTo( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + def getBounds2D(self) -> Rectangle2D: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def lineTo(self, double: float, double2: float) -> None: ... + def moveTo(self, double: float, double2: float) -> None: ... + def quadTo( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + def transform(self, affineTransform: AffineTransform) -> None: ... + def trimToSize(self) -> None: ... + + class Float(java.awt.geom.Path2D, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, shape: java.awt.Shape): ... + @typing.overload + def __init__(self, shape: java.awt.Shape, affineTransform: AffineTransform): ... + @typing.overload + def append(self, pathIterator: PathIterator, boolean: bool) -> None: ... + @typing.overload + def append(self, shape: java.awt.Shape, boolean: bool) -> None: ... + def clone(self) -> typing.Any: ... + @typing.overload + def curveTo( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + @typing.overload + def curveTo( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + float6: float, + ) -> None: ... + def getBounds2D(self) -> Rectangle2D: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + @typing.overload + def lineTo(self, double: float, double2: float) -> None: ... + @typing.overload + def lineTo(self, float: float, float2: float) -> None: ... + @typing.overload + def moveTo(self, double: float, double2: float) -> None: ... + @typing.overload + def moveTo(self, float: float, float2: float) -> None: ... + @typing.overload + def quadTo( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def quadTo( + self, float: float, float2: float, float3: float, float4: float + ) -> None: ... + def transform(self, affineTransform: AffineTransform) -> None: ... + def trimToSize(self) -> None: ... + +class Point2D(java.lang.Cloneable): + def clone(self) -> typing.Any: ... + @typing.overload + def distance(self, double: float, double2: float) -> float: ... + @typing.overload + def distance(self, point2D: Point2D) -> float: ... + @typing.overload + @staticmethod + def distance( + double: float, double2: float, double3: float, double4: float + ) -> float: ... + @typing.overload + def distanceSq(self, double: float, double2: float) -> float: ... + @typing.overload + def distanceSq(self, point2D: Point2D) -> float: ... + @typing.overload + @staticmethod + def distanceSq( + double: float, double2: float, double3: float, double4: float + ) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def hashCode(self) -> int: ... + @typing.overload + def setLocation(self, double: float, double2: float) -> None: ... + @typing.overload + def setLocation(self, point2D: Point2D) -> None: ... + class Double(java.awt.geom.Point2D, java.io.Serializable): + x: float = ... + y: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, double: float, double2: float): ... + def getX(self) -> float: ... + def getY(self) -> float: ... + @typing.overload + def setLocation(self, double: float, double2: float) -> None: ... + @typing.overload + def setLocation(self, point2D: Point2D) -> None: ... + def toString(self) -> java.lang.String: ... + + class Float(java.awt.geom.Point2D, java.io.Serializable): + x: float = ... + y: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, float: float, float2: float): ... + def getX(self) -> float: ... + def getY(self) -> float: ... + @typing.overload + def setLocation(self, double: float, double2: float) -> None: ... + @typing.overload + def setLocation(self, float: float, float2: float) -> None: ... + @typing.overload + def setLocation(self, point2D: Point2D) -> None: ... + def toString(self) -> java.lang.String: ... + +class QuadCurve2D(java.awt.Shape, java.lang.Cloneable): + def clone(self) -> typing.Any: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + def getBounds(self) -> java.awt.Rectangle: ... + def getBounds2D(self) -> Rectangle2D: ... + def getCtrlPt(self) -> Point2D: ... + def getCtrlX(self) -> float: ... + def getCtrlY(self) -> float: ... + @typing.overload + def getFlatness(self) -> float: ... + @typing.overload + @staticmethod + def getFlatness( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> float: ... + @typing.overload + @staticmethod + def getFlatness(doubleArray: list[float] | jpype.JArray, int: int) -> float: ... + @typing.overload + def getFlatnessSq(self) -> float: ... + @typing.overload + @staticmethod + def getFlatnessSq( + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> float: ... + @typing.overload + @staticmethod + def getFlatnessSq(doubleArray: list[float] | jpype.JArray, int: int) -> float: ... + def getP1(self) -> Point2D: ... + def getP2(self) -> Point2D: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + @typing.overload + def setCurve( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + @typing.overload + def setCurve(self, doubleArray: list[float] | jpype.JArray, int: int) -> None: ... + @typing.overload + def setCurve( + self, point2D: Point2D, point2D2: Point2D, point2D3: Point2D + ) -> None: ... + @typing.overload + def setCurve( + self, point2DArray: list[Point2D] | jpype.JArray, int: int + ) -> None: ... + @typing.overload + def setCurve(self, quadCurve2D: QuadCurve2D) -> None: ... + @typing.overload + @staticmethod + def solveQuadratic(doubleArray: list[float] | jpype.JArray) -> int: ... + @typing.overload + @staticmethod + def solveQuadratic( + doubleArray: list[float] | jpype.JArray, + doubleArray2: list[float] | jpype.JArray, + ) -> int: ... + @typing.overload + @staticmethod + def subdivide( + doubleArray: list[float] | jpype.JArray, + int: int, + doubleArray2: list[float] | jpype.JArray, + int2: int, + doubleArray3: list[float] | jpype.JArray, + int3: int, + ) -> None: ... + @typing.overload + @staticmethod + def subdivide( + quadCurve2D: QuadCurve2D, quadCurve2D2: QuadCurve2D, quadCurve2D3: QuadCurve2D + ) -> None: ... + @typing.overload + def subdivide( + self, quadCurve2D: QuadCurve2D, quadCurve2D2: QuadCurve2D + ) -> None: ... + class Double(java.awt.geom.QuadCurve2D, java.io.Serializable): + x1: float = ... + y1: float = ... + ctrlx: float = ... + ctrly: float = ... + x2: float = ... + y2: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ): ... + def getCtrlPt(self) -> Point2D: ... + def getCtrlX(self) -> float: ... + def getCtrlY(self) -> float: ... + def getP1(self) -> Point2D: ... + def getP2(self) -> Point2D: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + @typing.overload + def setCurve( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + @typing.overload + def setCurve( + self, doubleArray: list[float] | jpype.JArray, int: int + ) -> None: ... + @typing.overload + def setCurve( + self, point2D: Point2D, point2D2: Point2D, point2D3: Point2D + ) -> None: ... + @typing.overload + def setCurve( + self, point2DArray: list[Point2D] | jpype.JArray, int: int + ) -> None: ... + @typing.overload + def setCurve(self, quadCurve2D: QuadCurve2D) -> None: ... + + class Float(java.awt.geom.QuadCurve2D, java.io.Serializable): + x1: float = ... + y1: float = ... + ctrlx: float = ... + ctrly: float = ... + x2: float = ... + y2: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + float6: float, + ): ... + def getCtrlPt(self) -> Point2D: ... + def getCtrlX(self) -> float: ... + def getCtrlY(self) -> float: ... + def getP1(self) -> Point2D: ... + def getP2(self) -> Point2D: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + @typing.overload + def setCurve( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + @typing.overload + def setCurve( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + float6: float, + ) -> None: ... + @typing.overload + def setCurve( + self, doubleArray: list[float] | jpype.JArray, int: int + ) -> None: ... + @typing.overload + def setCurve( + self, point2D: Point2D, point2D2: Point2D, point2D3: Point2D + ) -> None: ... + @typing.overload + def setCurve( + self, point2DArray: list[Point2D] | jpype.JArray, int: int + ) -> None: ... + @typing.overload + def setCurve(self, quadCurve2D: QuadCurve2D) -> None: ... + +class Rectangle2D(RectangularShape): + OUT_LEFT: typing.ClassVar[int] = ... + OUT_TOP: typing.ClassVar[int] = ... + OUT_RIGHT: typing.ClassVar[int] = ... + OUT_BOTTOM: typing.ClassVar[int] = ... + @typing.overload + def add(self, double: float, double2: float) -> None: ... + @typing.overload + def add(self, point2D: Point2D) -> None: ... + @typing.overload + def add(self, rectangle2D: Rectangle2D) -> None: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + def createIntersection(self, rectangle2D: Rectangle2D) -> Rectangle2D: ... + def createUnion(self, rectangle2D: Rectangle2D) -> Rectangle2D: ... + def equals(self, object: typing.Any) -> bool: ... + def getBounds2D(self) -> Rectangle2D: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + def hashCode(self) -> int: ... + @staticmethod + def intersect( + rectangle2D: Rectangle2D, rectangle2D2: Rectangle2D, rectangle2D3: Rectangle2D + ) -> None: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + @typing.overload + def intersectsLine( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def intersectsLine(self, line2D: Line2D) -> bool: ... + @typing.overload + def outcode(self, double: float, double2: float) -> int: ... + @typing.overload + def outcode(self, point2D: Point2D) -> int: ... + @typing.overload + def setFrame( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setFrame(self, point2D: Point2D, dimension2D: Dimension2D) -> None: ... + @typing.overload + def setFrame(self, rectangle2D: Rectangle2D) -> None: ... + @typing.overload + def setRect( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setRect(self, rectangle2D: Rectangle2D) -> None: ... + @staticmethod + def union( + rectangle2D: Rectangle2D, rectangle2D2: Rectangle2D, rectangle2D3: Rectangle2D + ) -> None: ... + class Double(java.awt.geom.Rectangle2D, java.io.Serializable): + x: float = ... + y: float = ... + width: float = ... + height: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, double: float, double2: float, double3: float, double4: float + ): ... + def createIntersection(self, rectangle2D: Rectangle2D) -> Rectangle2D: ... + def createUnion(self, rectangle2D: Rectangle2D) -> Rectangle2D: ... + def getBounds2D(self) -> Rectangle2D: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def isEmpty(self) -> bool: ... + @typing.overload + def outcode(self, double: float, double2: float) -> int: ... + @typing.overload + def outcode(self, point2D: Point2D) -> int: ... + @typing.overload + def setRect( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setRect(self, rectangle2D: Rectangle2D) -> None: ... + def toString(self) -> java.lang.String: ... + + class Float(java.awt.geom.Rectangle2D, java.io.Serializable): + x: float = ... + y: float = ... + width: float = ... + height: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, float: float, float2: float, float3: float, float4: float + ): ... + def createIntersection(self, rectangle2D: Rectangle2D) -> Rectangle2D: ... + def createUnion(self, rectangle2D: Rectangle2D) -> Rectangle2D: ... + def getBounds2D(self) -> Rectangle2D: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def isEmpty(self) -> bool: ... + @typing.overload + def outcode(self, double: float, double2: float) -> int: ... + @typing.overload + def outcode(self, point2D: Point2D) -> int: ... + @typing.overload + def setRect( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setRect( + self, float: float, float2: float, float3: float, float4: float + ) -> None: ... + @typing.overload + def setRect(self, rectangle2D: Rectangle2D) -> None: ... + def toString(self) -> java.lang.String: ... + +class RoundRectangle2D(RectangularShape): + @typing.overload + def contains(self, point2D: Point2D) -> bool: ... + @typing.overload + def contains(self, rectangle2D: Rectangle2D) -> bool: ... + @typing.overload + def contains(self, double: float, double2: float) -> bool: ... + @typing.overload + def contains( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def getArcHeight(self) -> float: ... + def getArcWidth(self) -> float: ... + @typing.overload + def getPathIterator( + self, affineTransform: AffineTransform, double: float + ) -> PathIterator: ... + @typing.overload + def getPathIterator(self, affineTransform: AffineTransform) -> PathIterator: ... + def hashCode(self) -> int: ... + @typing.overload + def intersects(self, rectangle2D: Rectangle2D) -> bool: ... + @typing.overload + def intersects( + self, double: float, double2: float, double3: float, double4: float + ) -> bool: ... + @typing.overload + def setFrame(self, point2D: Point2D, dimension2D: Dimension2D) -> None: ... + @typing.overload + def setFrame(self, rectangle2D: Rectangle2D) -> None: ... + @typing.overload + def setFrame( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + @typing.overload + def setRoundRect( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + @typing.overload + def setRoundRect(self, roundRectangle2D: RoundRectangle2D) -> None: ... + class Double(java.awt.geom.RoundRectangle2D, java.io.Serializable): + x: float = ... + y: float = ... + width: float = ... + height: float = ... + arcwidth: float = ... + archeight: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ): ... + def getArcHeight(self) -> float: ... + def getArcWidth(self) -> float: ... + def getBounds2D(self) -> Rectangle2D: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def isEmpty(self) -> bool: ... + @typing.overload + def setRoundRect( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + @typing.overload + def setRoundRect(self, roundRectangle2D: RoundRectangle2D) -> None: ... + + class Float(java.awt.geom.RoundRectangle2D, java.io.Serializable): + x: float = ... + y: float = ... + width: float = ... + height: float = ... + arcwidth: float = ... + archeight: float = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + float6: float, + ): ... + def getArcHeight(self) -> float: ... + def getArcWidth(self) -> float: ... + def getBounds2D(self) -> Rectangle2D: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def isEmpty(self) -> bool: ... + @typing.overload + def setRoundRect( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + double6: float, + ) -> None: ... + @typing.overload + def setRoundRect( + self, + float: float, + float2: float, + float3: float, + float4: float, + float5: float, + float6: float, + ) -> None: ... + @typing.overload + def setRoundRect(self, roundRectangle2D: RoundRectangle2D) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.geom")``. + + AffineTransform: type[AffineTransform] + Arc2D: type[Arc2D] + Area: type[Area] + CubicCurve2D: type[CubicCurve2D] + Dimension2D: type[Dimension2D] + Ellipse2D: type[Ellipse2D] + FlatteningPathIterator: type[FlatteningPathIterator] + GeneralPath: type[GeneralPath] + IllegalPathStateException: type[IllegalPathStateException] + Line2D: type[Line2D] + NoninvertibleTransformException: type[NoninvertibleTransformException] + Path2D: type[Path2D] + PathIterator: type[PathIterator] + Point2D: type[Point2D] + QuadCurve2D: type[QuadCurve2D] + Rectangle2D: type[Rectangle2D] + RectangularShape: type[RectangularShape] + RoundRectangle2D: type[RoundRectangle2D] diff --git a/typings/java/awt/im/__init__.pyi b/typings/java/awt/im/__init__.pyi new file mode 100644 index 0000000..20082f2 --- /dev/null +++ b/typings/java/awt/im/__init__.pyi @@ -0,0 +1,97 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.font +import java.awt.im.spi +import java.lang +import java.text +import java.util +import jpype + +class InputContext: + def dispatchEvent(self, aWTEvent: java.awt.AWTEvent) -> None: ... + def dispose(self) -> None: ... + def endComposition(self) -> None: ... + def getInputMethodControlObject(self) -> typing.Any: ... + @staticmethod + def getInstance() -> InputContext: ... + def getLocale(self) -> java.util.Locale: ... + def isCompositionEnabled(self) -> bool: ... + def reconvert(self) -> None: ... + def removeNotify(self, component: java.awt.Component) -> None: ... + def selectInputMethod(self, locale: java.util.Locale) -> bool: ... + def setCharacterSubsets( + self, subsetArray: list[java.lang.Character.Subset] | jpype.JArray + ) -> None: ... + def setCompositionEnabled(self, boolean: bool) -> None: ... + +class InputMethodHighlight: + RAW_TEXT: typing.ClassVar[int] = ... + CONVERTED_TEXT: typing.ClassVar[int] = ... + UNSELECTED_RAW_TEXT_HIGHLIGHT: typing.ClassVar[InputMethodHighlight] = ... + SELECTED_RAW_TEXT_HIGHLIGHT: typing.ClassVar[InputMethodHighlight] = ... + UNSELECTED_CONVERTED_TEXT_HIGHLIGHT: typing.ClassVar[InputMethodHighlight] = ... + SELECTED_CONVERTED_TEXT_HIGHLIGHT: typing.ClassVar[InputMethodHighlight] = ... + @typing.overload + def __init__(self, boolean: bool, int: int): ... + @typing.overload + def __init__(self, boolean: bool, int: int, int2: int): ... + @typing.overload + def __init__( + self, + boolean: bool, + int: int, + int2: int, + map: java.util.Map[java.awt.font.TextAttribute, typing.Any] + | typing.Mapping[java.awt.font.TextAttribute, typing.Any], + ): ... + def getState(self) -> int: ... + def getStyle(self) -> java.util.Map[java.awt.font.TextAttribute, typing.Any]: ... + def getVariation(self) -> int: ... + def isSelected(self) -> bool: ... + +class InputMethodRequests: + def cancelLatestCommittedText( + self, + attributeArray: list[java.text.AttributedCharacterIterator.Attribute] + | jpype.JArray, + ) -> java.text.AttributedCharacterIterator: ... + def getCommittedText( + self, + int: int, + int2: int, + attributeArray: list[java.text.AttributedCharacterIterator.Attribute] + | jpype.JArray, + ) -> java.text.AttributedCharacterIterator: ... + def getCommittedTextLength(self) -> int: ... + def getInsertPositionOffset(self) -> int: ... + def getLocationOffset(self, int: int, int2: int) -> java.awt.font.TextHitInfo: ... + def getSelectedText( + self, + attributeArray: list[java.text.AttributedCharacterIterator.Attribute] + | jpype.JArray, + ) -> java.text.AttributedCharacterIterator: ... + def getTextLocation( + self, textHitInfo: java.awt.font.TextHitInfo + ) -> java.awt.Rectangle: ... + +class InputSubset(java.lang.Character.Subset): + LATIN: typing.ClassVar[InputSubset] = ... + LATIN_DIGITS: typing.ClassVar[InputSubset] = ... + TRADITIONAL_HANZI: typing.ClassVar[InputSubset] = ... + SIMPLIFIED_HANZI: typing.ClassVar[InputSubset] = ... + KANJI: typing.ClassVar[InputSubset] = ... + HANJA: typing.ClassVar[InputSubset] = ... + HALFWIDTH_KATAKANA: typing.ClassVar[InputSubset] = ... + FULLWIDTH_LATIN: typing.ClassVar[InputSubset] = ... + FULLWIDTH_DIGITS: typing.ClassVar[InputSubset] = ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.im")``. + + InputContext: type[InputContext] + InputMethodHighlight: type[InputMethodHighlight] + InputMethodRequests: type[InputMethodRequests] + InputSubset: type[InputSubset] + spi: java.awt.im.spi.__module_protocol__ diff --git a/typings/java/awt/im/spi/__init__.pyi b/typings/java/awt/im/spi/__init__.pyi new file mode 100644 index 0000000..50ff2fa --- /dev/null +++ b/typings/java/awt/im/spi/__init__.pyi @@ -0,0 +1,66 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.font +import java.awt.im +import java.lang +import java.text +import java.util +import javax.swing +import jpype + +class InputMethod: + def activate(self) -> None: ... + def deactivate(self, boolean: bool) -> None: ... + def dispatchEvent(self, aWTEvent: java.awt.AWTEvent) -> None: ... + def dispose(self) -> None: ... + def endComposition(self) -> None: ... + def getControlObject(self) -> typing.Any: ... + def getLocale(self) -> java.util.Locale: ... + def hideWindows(self) -> None: ... + def isCompositionEnabled(self) -> bool: ... + def notifyClientWindowChange(self, rectangle: java.awt.Rectangle) -> None: ... + def reconvert(self) -> None: ... + def removeNotify(self) -> None: ... + def setCharacterSubsets( + self, subsetArray: list[java.lang.Character.Subset] | jpype.JArray + ) -> None: ... + def setCompositionEnabled(self, boolean: bool) -> None: ... + def setInputMethodContext(self, inputMethodContext: InputMethodContext) -> None: ... + def setLocale(self, locale: java.util.Locale) -> bool: ... + +class InputMethodContext(java.awt.im.InputMethodRequests): + def createInputMethodJFrame( + self, string: java.lang.String | str, boolean: bool + ) -> javax.swing.JFrame: ... + def createInputMethodWindow( + self, string: java.lang.String | str, boolean: bool + ) -> java.awt.Window: ... + def dispatchInputMethodEvent( + self, + int: int, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int2: int, + textHitInfo: java.awt.font.TextHitInfo, + textHitInfo2: java.awt.font.TextHitInfo, + ) -> None: ... + def enableClientWindowNotification( + self, inputMethod: InputMethod, boolean: bool + ) -> None: ... + +class InputMethodDescriptor: + def createInputMethod(self) -> InputMethod: ... + def getAvailableLocales(self) -> typing.MutableSequence[java.util.Locale]: ... + def getInputMethodDisplayName( + self, locale: java.util.Locale, locale2: java.util.Locale + ) -> java.lang.String: ... + def getInputMethodIcon(self, locale: java.util.Locale) -> java.awt.Image: ... + def hasDynamicLocaleList(self) -> bool: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.im.spi")``. + + InputMethod: type[InputMethod] + InputMethodContext: type[InputMethodContext] + InputMethodDescriptor: type[InputMethodDescriptor] diff --git a/typings/java/awt/image/__init__.pyi b/typings/java/awt/image/__init__.pyi new file mode 100644 index 0000000..f714f24 --- /dev/null +++ b/typings/java/awt/image/__init__.pyi @@ -0,0 +1,3191 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.color +import java.awt.geom +import java.awt.image.renderable +import java.lang +import java.math +import java.util +import jpype + +class BufferStrategy: + def contentsLost(self) -> bool: ... + def contentsRestored(self) -> bool: ... + def dispose(self) -> None: ... + def getCapabilities(self) -> java.awt.BufferCapabilities: ... + def getDrawGraphics(self) -> java.awt.Graphics: ... + def show(self) -> None: ... + +class BufferedImageOp: + def createCompatibleDestImage( + self, bufferedImage: BufferedImage, colorModel: ColorModel + ) -> BufferedImage: ... + def filter( + self, bufferedImage: BufferedImage, bufferedImage2: BufferedImage + ) -> BufferedImage: ... + def getBounds2D( + self, bufferedImage: BufferedImage + ) -> java.awt.geom.Rectangle2D: ... + def getPoint2D( + self, point2D: java.awt.geom.Point2D, point2D2: java.awt.geom.Point2D + ) -> java.awt.geom.Point2D: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + +class ColorModel(java.awt.Transparency): + def __init__(self, int: int): ... + def coerceData( + self, writableRaster: WritableRaster, boolean: bool + ) -> ColorModel: ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def createCompatibleWritableRaster(self, int: int, int2: int) -> WritableRaster: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def getAlpha(self, int: int) -> int: ... + @typing.overload + def getAlpha(self, object: typing.Any) -> int: ... + def getAlphaRaster(self, writableRaster: WritableRaster) -> WritableRaster: ... + @typing.overload + def getBlue(self, int: int) -> int: ... + @typing.overload + def getBlue(self, object: typing.Any) -> int: ... + def getColorSpace(self) -> java.awt.color.ColorSpace: ... + @typing.overload + def getComponentSize(self, int: int) -> int: ... + @typing.overload + def getComponentSize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getComponents( + self, int: int, intArray: list[int] | jpype.JArray, int3: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getComponents( + self, object: typing.Any, intArray: list[int] | jpype.JArray, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getDataElement( + self, floatArray: list[float] | jpype.JArray, int: int + ) -> int: ... + @typing.overload + def getDataElement(self, intArray: list[int] | jpype.JArray, int2: int) -> int: ... + @typing.overload + def getDataElements( + self, floatArray: list[float] | jpype.JArray, int: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements(self, int: int, object: typing.Any) -> typing.Any: ... + @typing.overload + def getDataElements( + self, intArray: list[int] | jpype.JArray, int2: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getGreen(self, int: int) -> int: ... + @typing.overload + def getGreen(self, object: typing.Any) -> int: ... + @typing.overload + def getNormalizedComponents( + self, + intArray: list[int] | jpype.JArray, + int2: int, + floatArray: list[float] | jpype.JArray, + int3: int, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getNormalizedComponents( + self, object: typing.Any, floatArray: list[float] | jpype.JArray, int: int + ) -> typing.MutableSequence[float]: ... + def getNumColorComponents(self) -> int: ... + def getNumComponents(self) -> int: ... + def getPixelSize(self) -> int: ... + @typing.overload + def getRGB(self, int: int) -> int: ... + @typing.overload + def getRGB(self, object: typing.Any) -> int: ... + @staticmethod + def getRGBdefault() -> ColorModel: ... + @typing.overload + def getRed(self, int: int) -> int: ... + @typing.overload + def getRed(self, object: typing.Any) -> int: ... + def getTransferType(self) -> int: ... + def getTransparency(self) -> int: ... + def getUnnormalizedComponents( + self, + floatArray: list[float] | jpype.JArray, + int: int, + intArray: list[int] | jpype.JArray, + int3: int, + ) -> typing.MutableSequence[int]: ... + def hasAlpha(self) -> bool: ... + def hashCode(self) -> int: ... + def isAlphaPremultiplied(self) -> bool: ... + def isCompatibleRaster(self, raster: Raster) -> bool: ... + def isCompatibleSampleModel(self, sampleModel: SampleModel) -> bool: ... + def toString(self) -> java.lang.String: ... + +class DataBuffer: + TYPE_BYTE: typing.ClassVar[int] = ... + TYPE_USHORT: typing.ClassVar[int] = ... + TYPE_SHORT: typing.ClassVar[int] = ... + TYPE_INT: typing.ClassVar[int] = ... + TYPE_FLOAT: typing.ClassVar[int] = ... + TYPE_DOUBLE: typing.ClassVar[int] = ... + TYPE_UNDEFINED: typing.ClassVar[int] = ... + def getDataType(self) -> int: ... + @staticmethod + def getDataTypeSize(int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElemDouble(self, int: int) -> float: ... + @typing.overload + def getElemDouble(self, int: int, int2: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int, int2: int) -> float: ... + def getNumBanks(self) -> int: ... + def getOffset(self) -> int: ... + def getOffsets(self) -> typing.MutableSequence[int]: ... + def getSize(self) -> int: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElemDouble(self, int: int, double: float) -> None: ... + @typing.overload + def setElemDouble(self, int: int, int2: int, double: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, float: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, int2: int, float: float) -> None: ... + +class ImageConsumer: + RANDOMPIXELORDER: typing.ClassVar[int] = ... + TOPDOWNLEFTRIGHT: typing.ClassVar[int] = ... + COMPLETESCANLINES: typing.ClassVar[int] = ... + SINGLEPASS: typing.ClassVar[int] = ... + SINGLEFRAME: typing.ClassVar[int] = ... + IMAGEERROR: typing.ClassVar[int] = ... + SINGLEFRAMEDONE: typing.ClassVar[int] = ... + STATICIMAGEDONE: typing.ClassVar[int] = ... + IMAGEABORTED: typing.ClassVar[int] = ... + def imageComplete(self, int: int) -> None: ... + def setColorModel(self, colorModel: ColorModel) -> None: ... + def setDimensions(self, int: int, int2: int) -> None: ... + def setHints(self, int: int) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int5: int, + int6: int, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + def setProperties( + self, hashtable: java.util.Hashtable[typing.Any, typing.Any] + ) -> None: ... + +class ImageObserver: + WIDTH: typing.ClassVar[int] = ... + HEIGHT: typing.ClassVar[int] = ... + PROPERTIES: typing.ClassVar[int] = ... + SOMEBITS: typing.ClassVar[int] = ... + FRAMEBITS: typing.ClassVar[int] = ... + ALLBITS: typing.ClassVar[int] = ... + ERROR: typing.ClassVar[int] = ... + ABORT: typing.ClassVar[int] = ... + def imageUpdate( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> bool: ... + +class ImageProducer: + def addConsumer(self, imageConsumer: ImageConsumer) -> None: ... + def isConsumer(self, imageConsumer: ImageConsumer) -> bool: ... + def removeConsumer(self, imageConsumer: ImageConsumer) -> None: ... + def requestTopDownLeftRightResend(self, imageConsumer: ImageConsumer) -> None: ... + def startProduction(self, imageConsumer: ImageConsumer) -> None: ... + +class ImagingOpException(java.lang.RuntimeException): + def __init__(self, string: java.lang.String | str): ... + +class Kernel(java.lang.Cloneable): + def __init__(self, int: int, int2: int, floatArray: list[float] | jpype.JArray): ... + def clone(self) -> typing.Any: ... + def getHeight(self) -> int: ... + def getKernelData( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def getWidth(self) -> int: ... + def getXOrigin(self) -> int: ... + def getYOrigin(self) -> int: ... + +class LookupTable: + def getNumComponents(self) -> int: ... + def getOffset(self) -> int: ... + def lookupPixel( + self, intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + +class MultiResolutionImage: + def getResolutionVariant(self, double: float, double2: float) -> java.awt.Image: ... + def getResolutionVariants(self) -> java.util.List[java.awt.Image]: ... + +class Raster: + @typing.overload + @staticmethod + def createBandedRaster( + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + point: java.awt.Point, + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createBandedRaster( + int: int, int2: int, int3: int, int4: int, point: java.awt.Point + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createBandedRaster( + dataBuffer: DataBuffer, + int: int, + int2: int, + int3: int, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + point: java.awt.Point, + ) -> WritableRaster: ... + def createChild( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + intArray: list[int] | jpype.JArray, + ) -> Raster: ... + @typing.overload + def createCompatibleWritableRaster(self) -> WritableRaster: ... + @typing.overload + def createCompatibleWritableRaster(self, int: int, int2: int) -> WritableRaster: ... + @typing.overload + def createCompatibleWritableRaster( + self, int: int, int2: int, int3: int, int4: int + ) -> WritableRaster: ... + @typing.overload + def createCompatibleWritableRaster( + self, rectangle: java.awt.Rectangle + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createInterleavedRaster( + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + point: java.awt.Point, + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createInterleavedRaster( + int: int, int2: int, int3: int, int4: int, point: java.awt.Point + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createInterleavedRaster( + dataBuffer: DataBuffer, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + point: java.awt.Point, + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createPackedRaster( + int: int, int2: int, int3: int, int4: int, int5: int, point: java.awt.Point + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createPackedRaster( + int: int, + int2: int, + int3: int, + intArray: list[int] | jpype.JArray, + point: java.awt.Point, + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createPackedRaster( + dataBuffer: DataBuffer, + int: int, + int2: int, + int3: int, + intArray: list[int] | jpype.JArray, + point: java.awt.Point, + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createPackedRaster( + dataBuffer: DataBuffer, int: int, int2: int, int3: int, point: java.awt.Point + ) -> WritableRaster: ... + @staticmethod + def createRaster( + sampleModel: SampleModel, dataBuffer: DataBuffer, point: java.awt.Point + ) -> Raster: ... + def createTranslatedChild(self, int: int, int2: int) -> Raster: ... + @typing.overload + @staticmethod + def createWritableRaster( + sampleModel: SampleModel, point: java.awt.Point + ) -> WritableRaster: ... + @typing.overload + @staticmethod + def createWritableRaster( + sampleModel: SampleModel, dataBuffer: DataBuffer, point: java.awt.Point + ) -> WritableRaster: ... + def getBounds(self) -> java.awt.Rectangle: ... + def getDataBuffer(self) -> DataBuffer: ... + @typing.overload + def getDataElements( + self, int: int, int2: int, int3: int, int4: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, int: int, int2: int, object: typing.Any + ) -> typing.Any: ... + def getHeight(self) -> int: ... + def getMinX(self) -> int: ... + def getMinY(self) -> int: ... + def getNumBands(self) -> int: ... + def getNumDataElements(self) -> int: ... + def getParent(self) -> Raster: ... + @typing.overload + def getPixel( + self, int: int, int2: int, doubleArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, int: int, int2: int, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, int: int, int2: int, intArray: list[int] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + ) -> typing.MutableSequence[int]: ... + def getSample(self, int: int, int2: int, int3: int) -> int: ... + def getSampleDouble(self, int: int, int2: int, int3: int) -> float: ... + def getSampleFloat(self, int: int, int2: int, int3: int) -> float: ... + def getSampleModel(self) -> SampleModel: ... + def getSampleModelTranslateX(self) -> int: ... + def getSampleModelTranslateY(self) -> int: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + ) -> typing.MutableSequence[int]: ... + def getTransferType(self) -> int: ... + def getWidth(self) -> int: ... + +class RasterFormatException(java.lang.RuntimeException): + def __init__(self, string: java.lang.String | str): ... + +class RasterOp: + def createCompatibleDestRaster(self, raster: Raster) -> WritableRaster: ... + def filter( + self, raster: Raster, writableRaster: WritableRaster + ) -> WritableRaster: ... + def getBounds2D(self, raster: Raster) -> java.awt.geom.Rectangle2D: ... + def getPoint2D( + self, point2D: java.awt.geom.Point2D, point2D2: java.awt.geom.Point2D + ) -> java.awt.geom.Point2D: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + +class RenderedImage: + def copyData(self, writableRaster: WritableRaster) -> WritableRaster: ... + def getColorModel(self) -> ColorModel: ... + @typing.overload + def getData(self) -> Raster: ... + @typing.overload + def getData(self, rectangle: java.awt.Rectangle) -> Raster: ... + def getHeight(self) -> int: ... + def getMinTileX(self) -> int: ... + def getMinTileY(self) -> int: ... + def getMinX(self) -> int: ... + def getMinY(self) -> int: ... + def getNumXTiles(self) -> int: ... + def getNumYTiles(self) -> int: ... + def getProperty(self, string: java.lang.String | str) -> typing.Any: ... + def getPropertyNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getSampleModel(self) -> SampleModel: ... + def getSources(self) -> java.util.Vector[RenderedImage]: ... + def getTile(self, int: int, int2: int) -> Raster: ... + def getTileGridXOffset(self) -> int: ... + def getTileGridYOffset(self) -> int: ... + def getTileHeight(self) -> int: ... + def getTileWidth(self) -> int: ... + def getWidth(self) -> int: ... + +class SampleModel: + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def createDataBuffer(self) -> DataBuffer: ... + def createSubsetSampleModel( + self, intArray: list[int] | jpype.JArray + ) -> SampleModel: ... + @typing.overload + def getDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> typing.Any: ... + def getDataType(self) -> int: ... + def getHeight(self) -> int: ... + def getNumBands(self) -> int: ... + def getNumDataElements(self) -> int: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def getSample( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> int: ... + def getSampleDouble( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> float: ... + def getSampleFloat( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> float: ... + @typing.overload + def getSampleSize(self, int: int) -> int: ... + @typing.overload + def getSampleSize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def getTransferType(self) -> int: ... + def getWidth(self) -> int: ... + @typing.overload + def setDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, int4: int, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, double: float, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, float: float, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + +class TileObserver: + def tileUpdate( + self, + writableRenderedImage: WritableRenderedImage, + int: int, + int2: int, + boolean: bool, + ) -> None: ... + +class VolatileImage(java.awt.Image, java.awt.Transparency): + IMAGE_OK: typing.ClassVar[int] = ... + IMAGE_RESTORED: typing.ClassVar[int] = ... + IMAGE_INCOMPATIBLE: typing.ClassVar[int] = ... + def contentsLost(self) -> bool: ... + def createGraphics(self) -> java.awt.Graphics2D: ... + @typing.overload + def getCapabilities(self) -> java.awt.ImageCapabilities: ... + @typing.overload + def getCapabilities( + self, graphicsConfiguration: java.awt.GraphicsConfiguration + ) -> java.awt.ImageCapabilities: ... + def getGraphics(self) -> java.awt.Graphics: ... + @typing.overload + def getHeight(self, imageObserver: ImageObserver | typing.Callable) -> int: ... + @typing.overload + def getHeight(self) -> int: ... + def getSnapshot(self) -> BufferedImage: ... + def getSource(self) -> ImageProducer: ... + def getTransparency(self) -> int: ... + @typing.overload + def getWidth(self, imageObserver: ImageObserver | typing.Callable) -> int: ... + @typing.overload + def getWidth(self) -> int: ... + def validate( + self, graphicsConfiguration: java.awt.GraphicsConfiguration + ) -> int: ... + +class AbstractMultiResolutionImage(java.awt.Image, MultiResolutionImage): + def getGraphics(self) -> java.awt.Graphics: ... + def getHeight(self, imageObserver: ImageObserver | typing.Callable) -> int: ... + def getProperty( + self, + string: java.lang.String | str, + imageObserver: ImageObserver | typing.Callable, + ) -> typing.Any: ... + def getSource(self) -> ImageProducer: ... + def getWidth(self, imageObserver: ImageObserver | typing.Callable) -> int: ... + +class AffineTransformOp(BufferedImageOp, RasterOp): + TYPE_NEAREST_NEIGHBOR: typing.ClassVar[int] = ... + TYPE_BILINEAR: typing.ClassVar[int] = ... + TYPE_BICUBIC: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, affineTransform: java.awt.geom.AffineTransform, int: int): ... + @typing.overload + def __init__( + self, + affineTransform: java.awt.geom.AffineTransform, + renderingHints: java.awt.RenderingHints, + ): ... + def createCompatibleDestImage( + self, bufferedImage: BufferedImage, colorModel: ColorModel + ) -> BufferedImage: ... + def createCompatibleDestRaster(self, raster: Raster) -> WritableRaster: ... + @typing.overload + def filter( + self, bufferedImage: BufferedImage, bufferedImage2: BufferedImage + ) -> BufferedImage: ... + @typing.overload + def filter( + self, raster: Raster, writableRaster: WritableRaster + ) -> WritableRaster: ... + @typing.overload + def getBounds2D( + self, bufferedImage: BufferedImage + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getBounds2D(self, raster: Raster) -> java.awt.geom.Rectangle2D: ... + def getInterpolationType(self) -> int: ... + def getPoint2D( + self, point2D: java.awt.geom.Point2D, point2D2: java.awt.geom.Point2D + ) -> java.awt.geom.Point2D: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + def getTransform(self) -> java.awt.geom.AffineTransform: ... + +class BandCombineOp(RasterOp): + def __init__( + self, + floatArray: list[typing.MutableSequence[float]] | jpype.JArray, + renderingHints: java.awt.RenderingHints, + ): ... + def createCompatibleDestRaster(self, raster: Raster) -> WritableRaster: ... + def filter( + self, raster: Raster, writableRaster: WritableRaster + ) -> WritableRaster: ... + def getBounds2D(self, raster: Raster) -> java.awt.geom.Rectangle2D: ... + def getMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def getPoint2D( + self, point2D: java.awt.geom.Point2D, point2D2: java.awt.geom.Point2D + ) -> java.awt.geom.Point2D: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + +class ByteLookupTable(LookupTable): + @typing.overload + def __init__(self, int: int, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__( + self, int: int, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ): ... + def getTable(self) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def lookupPixel( + self, + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def lookupPixel( + self, intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + +class ColorConvertOp(BufferedImageOp, RasterOp): + @typing.overload + def __init__(self, renderingHints: java.awt.RenderingHints): ... + @typing.overload + def __init__( + self, + colorSpace: java.awt.color.ColorSpace, + renderingHints: java.awt.RenderingHints, + ): ... + @typing.overload + def __init__( + self, + colorSpace: java.awt.color.ColorSpace, + colorSpace2: java.awt.color.ColorSpace, + renderingHints: java.awt.RenderingHints, + ): ... + @typing.overload + def __init__( + self, + iCC_ProfileArray: list[java.awt.color.ICC_Profile] | jpype.JArray, + renderingHints: java.awt.RenderingHints, + ): ... + def createCompatibleDestImage( + self, bufferedImage: BufferedImage, colorModel: ColorModel + ) -> BufferedImage: ... + def createCompatibleDestRaster(self, raster: Raster) -> WritableRaster: ... + @typing.overload + def filter( + self, bufferedImage: BufferedImage, bufferedImage2: BufferedImage + ) -> BufferedImage: ... + @typing.overload + def filter( + self, raster: Raster, writableRaster: WritableRaster + ) -> WritableRaster: ... + @typing.overload + def getBounds2D( + self, bufferedImage: BufferedImage + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getBounds2D(self, raster: Raster) -> java.awt.geom.Rectangle2D: ... + def getICC_Profiles(self) -> typing.MutableSequence[java.awt.color.ICC_Profile]: ... + def getPoint2D( + self, point2D: java.awt.geom.Point2D, point2D2: java.awt.geom.Point2D + ) -> java.awt.geom.Point2D: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + +class ComponentColorModel(ColorModel): + @typing.overload + def __init__( + self, + colorSpace: java.awt.color.ColorSpace, + boolean: bool, + boolean2: bool, + int: int, + int2: int, + ): ... + @typing.overload + def __init__( + self, + colorSpace: java.awt.color.ColorSpace, + intArray: list[int] | jpype.JArray, + boolean: bool, + boolean2: bool, + int2: int, + int3: int, + ): ... + def coerceData( + self, writableRaster: WritableRaster, boolean: bool + ) -> ColorModel: ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def createCompatibleWritableRaster(self, int: int, int2: int) -> WritableRaster: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def getAlpha(self, int: int) -> int: ... + @typing.overload + def getAlpha(self, object: typing.Any) -> int: ... + def getAlphaRaster(self, writableRaster: WritableRaster) -> WritableRaster: ... + @typing.overload + def getBlue(self, int: int) -> int: ... + @typing.overload + def getBlue(self, object: typing.Any) -> int: ... + @typing.overload + def getComponents( + self, int: int, intArray: list[int] | jpype.JArray, int3: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getComponents( + self, object: typing.Any, intArray: list[int] | jpype.JArray, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getDataElement( + self, floatArray: list[float] | jpype.JArray, int: int + ) -> int: ... + @typing.overload + def getDataElement(self, intArray: list[int] | jpype.JArray, int2: int) -> int: ... + @typing.overload + def getDataElements( + self, floatArray: list[float] | jpype.JArray, int: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements(self, int: int, object: typing.Any) -> typing.Any: ... + @typing.overload + def getDataElements( + self, intArray: list[int] | jpype.JArray, int2: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getGreen(self, int: int) -> int: ... + @typing.overload + def getGreen(self, object: typing.Any) -> int: ... + @typing.overload + def getNormalizedComponents( + self, + intArray: list[int] | jpype.JArray, + int2: int, + floatArray: list[float] | jpype.JArray, + int3: int, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getNormalizedComponents( + self, object: typing.Any, floatArray: list[float] | jpype.JArray, int: int + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getRGB(self, int: int) -> int: ... + @typing.overload + def getRGB(self, object: typing.Any) -> int: ... + @typing.overload + def getRed(self, int: int) -> int: ... + @typing.overload + def getRed(self, object: typing.Any) -> int: ... + def getUnnormalizedComponents( + self, + floatArray: list[float] | jpype.JArray, + int: int, + intArray: list[int] | jpype.JArray, + int3: int, + ) -> typing.MutableSequence[int]: ... + def hashCode(self) -> int: ... + def isCompatibleRaster(self, raster: Raster) -> bool: ... + def isCompatibleSampleModel(self, sampleModel: SampleModel) -> bool: ... + +class ComponentSampleModel(SampleModel): + @typing.overload + def __init__( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ): ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def createDataBuffer(self) -> DataBuffer: ... + def createSubsetSampleModel( + self, intArray: list[int] | jpype.JArray + ) -> SampleModel: ... + def equals(self, object: typing.Any) -> bool: ... + def getBandOffsets(self) -> typing.MutableSequence[int]: ... + def getBankIndices(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> typing.Any: ... + def getNumDataElements(self) -> int: ... + @typing.overload + def getOffset(self, int: int, int2: int) -> int: ... + @typing.overload + def getOffset(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def getPixelStride(self) -> int: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def getSample( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> int: ... + def getSampleDouble( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> float: ... + def getSampleFloat( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> float: ... + @typing.overload + def getSampleSize(self, int: int) -> int: ... + @typing.overload + def getSampleSize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def getScanlineStride(self) -> int: ... + def hashCode(self) -> int: ... + @typing.overload + def setDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, double: float, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, float: float, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, int4: int, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + +class ConvolveOp(BufferedImageOp, RasterOp): + EDGE_ZERO_FILL: typing.ClassVar[int] = ... + EDGE_NO_OP: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, kernel: Kernel): ... + @typing.overload + def __init__( + self, kernel: Kernel, int: int, renderingHints: java.awt.RenderingHints + ): ... + def createCompatibleDestImage( + self, bufferedImage: BufferedImage, colorModel: ColorModel + ) -> BufferedImage: ... + def createCompatibleDestRaster(self, raster: Raster) -> WritableRaster: ... + @typing.overload + def filter( + self, bufferedImage: BufferedImage, bufferedImage2: BufferedImage + ) -> BufferedImage: ... + @typing.overload + def filter( + self, raster: Raster, writableRaster: WritableRaster + ) -> WritableRaster: ... + @typing.overload + def getBounds2D( + self, bufferedImage: BufferedImage + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getBounds2D(self, raster: Raster) -> java.awt.geom.Rectangle2D: ... + def getEdgeCondition(self) -> int: ... + def getKernel(self) -> Kernel: ... + def getPoint2D( + self, point2D: java.awt.geom.Point2D, point2D2: java.awt.geom.Point2D + ) -> java.awt.geom.Point2D: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + +class DataBufferByte(DataBuffer): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes, int: int): ... + @typing.overload + def __init__( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ): ... + @typing.overload + def __init__( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray, int: int + ): ... + @typing.overload + def __init__( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + def getBankData(self) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + +class DataBufferDouble(DataBuffer): + @typing.overload + def __init__(self, doubleArray: list[float] | jpype.JArray, int: int): ... + @typing.overload + def __init__( + self, doubleArray: list[float] | jpype.JArray, int: int, int2: int + ): ... + @typing.overload + def __init__( + self, doubleArray: list[typing.MutableSequence[float]] | jpype.JArray, int: int + ): ... + @typing.overload + def __init__( + self, + doubleArray: list[typing.MutableSequence[float]] | jpype.JArray, + int: int, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + def getBankData(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + def getData(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[float]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def getElemDouble(self, int: int) -> float: ... + @typing.overload + def getElemDouble(self, int: int, int2: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int, int2: int) -> float: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def setElemDouble(self, int: int, double: float) -> None: ... + @typing.overload + def setElemDouble(self, int: int, int2: int, double: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, float: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, int2: int, float: float) -> None: ... + +class DataBufferFloat(DataBuffer): + @typing.overload + def __init__(self, floatArray: list[float] | jpype.JArray, int: int): ... + @typing.overload + def __init__(self, floatArray: list[float] | jpype.JArray, int: int, int2: int): ... + @typing.overload + def __init__( + self, floatArray: list[typing.MutableSequence[float]] | jpype.JArray, int: int + ): ... + @typing.overload + def __init__( + self, + floatArray: list[typing.MutableSequence[float]] | jpype.JArray, + int: int, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + def getBankData(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + def getData(self) -> typing.MutableSequence[float]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[float]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def getElemDouble(self, int: int) -> float: ... + @typing.overload + def getElemDouble(self, int: int, int2: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int, int2: int) -> float: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def setElemDouble(self, int: int, double: float) -> None: ... + @typing.overload + def setElemDouble(self, int: int, int2: int, double: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, float: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, int2: int, float: float) -> None: ... + +class DataBufferInt(DataBuffer): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, intArray: list[int] | jpype.JArray, int2: int): ... + @typing.overload + def __init__(self, intArray: list[int] | jpype.JArray, int2: int, int3: int): ... + @typing.overload + def __init__( + self, intArray: list[typing.MutableSequence[int]] | jpype.JArray, int2: int + ): ... + @typing.overload + def __init__( + self, + intArray: list[typing.MutableSequence[int]] | jpype.JArray, + int2: int, + intArray2: list[int] | jpype.JArray, + ): ... + def getBankData(self) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + +class DataBufferShort(DataBuffer): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, shortArray: list[int] | jpype.JArray, int: int): ... + @typing.overload + def __init__(self, shortArray: list[int] | jpype.JArray, int: int, int2: int): ... + @typing.overload + def __init__( + self, shortArray: list[typing.MutableSequence[int]] | jpype.JArray, int: int + ): ... + @typing.overload + def __init__( + self, + shortArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + intArray: list[int] | jpype.JArray, + ): ... + def getBankData(self) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + +class DataBufferUShort(DataBuffer): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, shortArray: list[int] | jpype.JArray, int: int): ... + @typing.overload + def __init__(self, shortArray: list[int] | jpype.JArray, int: int, int2: int): ... + @typing.overload + def __init__( + self, shortArray: list[typing.MutableSequence[int]] | jpype.JArray, int: int + ): ... + @typing.overload + def __init__( + self, + shortArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + intArray: list[int] | jpype.JArray, + ): ... + def getBankData(self) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + +class FilteredImageSource(ImageProducer): + def __init__(self, imageProducer: ImageProducer, imageFilter: ImageFilter): ... + def addConsumer(self, imageConsumer: ImageConsumer) -> None: ... + def isConsumer(self, imageConsumer: ImageConsumer) -> bool: ... + def removeConsumer(self, imageConsumer: ImageConsumer) -> None: ... + def requestTopDownLeftRightResend(self, imageConsumer: ImageConsumer) -> None: ... + def startProduction(self, imageConsumer: ImageConsumer) -> None: ... + +class ImageFilter(ImageConsumer, java.lang.Cloneable): + def __init__(self): ... + def clone(self) -> typing.Any: ... + def getFilterInstance(self, imageConsumer: ImageConsumer) -> ImageFilter: ... + def imageComplete(self, int: int) -> None: ... + def resendTopDownLeftRight(self, imageProducer: ImageProducer) -> None: ... + def setColorModel(self, colorModel: ColorModel) -> None: ... + def setDimensions(self, int: int, int2: int) -> None: ... + def setHints(self, int: int) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int5: int, + int6: int, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + def setProperties( + self, hashtable: java.util.Hashtable[typing.Any, typing.Any] + ) -> None: ... + +class IndexColorModel(ColorModel): + @typing.overload + def __init__( + self, + int: int, + int2: int, + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + byteArray3: list[int] | jpype.JArray | bytes, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + byteArray3: list[int] | jpype.JArray | bytes, + byteArray4: list[int] | jpype.JArray | bytes, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + byteArray3: list[int] | jpype.JArray | bytes, + int3: int, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + byteArray: list[int] | jpype.JArray | bytes, + int3: int, + boolean: bool, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + byteArray: list[int] | jpype.JArray | bytes, + int3: int, + boolean: bool, + int4: int, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + int4: int, + boolean: bool, + int5: int, + int6: int, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + int4: int, + int5: int, + bigInteger: java.math.BigInteger, + ): ... + def convertToIntDiscrete(self, raster: Raster, boolean: bool) -> BufferedImage: ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def createCompatibleWritableRaster(self, int: int, int2: int) -> WritableRaster: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def getAlpha(self, int: int) -> int: ... + @typing.overload + def getAlpha(self, object: typing.Any) -> int: ... + def getAlphas(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def getBlue(self, int: int) -> int: ... + @typing.overload + def getBlue(self, object: typing.Any) -> int: ... + def getBlues(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def getComponentSize(self, int: int) -> int: ... + @typing.overload + def getComponentSize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getComponents( + self, int: int, intArray: list[int] | jpype.JArray, int3: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getComponents( + self, object: typing.Any, intArray: list[int] | jpype.JArray, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getDataElement( + self, floatArray: list[float] | jpype.JArray, int: int + ) -> int: ... + @typing.overload + def getDataElement(self, intArray: list[int] | jpype.JArray, int2: int) -> int: ... + @typing.overload + def getDataElements( + self, floatArray: list[float] | jpype.JArray, int: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, intArray: list[int] | jpype.JArray, int2: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements(self, int: int, object: typing.Any) -> typing.Any: ... + @typing.overload + def getGreen(self, int: int) -> int: ... + @typing.overload + def getGreen(self, object: typing.Any) -> int: ... + def getGreens(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def getMapSize(self) -> int: ... + @typing.overload + def getRGB(self, int: int) -> int: ... + @typing.overload + def getRGB(self, object: typing.Any) -> int: ... + def getRGBs(self, intArray: list[int] | jpype.JArray) -> None: ... + @typing.overload + def getRed(self, int: int) -> int: ... + @typing.overload + def getRed(self, object: typing.Any) -> int: ... + def getReds(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def getTransparency(self) -> int: ... + def getTransparentPixel(self) -> int: ... + def getValidPixels(self) -> java.math.BigInteger: ... + def hashCode(self) -> int: ... + def isCompatibleRaster(self, raster: Raster) -> bool: ... + def isCompatibleSampleModel(self, sampleModel: SampleModel) -> bool: ... + @typing.overload + def isValid(self) -> bool: ... + @typing.overload + def isValid(self, int: int) -> bool: ... + def toString(self) -> java.lang.String: ... + +class LookupOp(BufferedImageOp, RasterOp): + def __init__( + self, lookupTable: LookupTable, renderingHints: java.awt.RenderingHints + ): ... + def createCompatibleDestImage( + self, bufferedImage: BufferedImage, colorModel: ColorModel + ) -> BufferedImage: ... + def createCompatibleDestRaster(self, raster: Raster) -> WritableRaster: ... + @typing.overload + def filter( + self, bufferedImage: BufferedImage, bufferedImage2: BufferedImage + ) -> BufferedImage: ... + @typing.overload + def filter( + self, raster: Raster, writableRaster: WritableRaster + ) -> WritableRaster: ... + @typing.overload + def getBounds2D( + self, bufferedImage: BufferedImage + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getBounds2D(self, raster: Raster) -> java.awt.geom.Rectangle2D: ... + def getPoint2D( + self, point2D: java.awt.geom.Point2D, point2D2: java.awt.geom.Point2D + ) -> java.awt.geom.Point2D: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + def getTable(self) -> LookupTable: ... + +class MemoryImageSource(ImageProducer): + @typing.overload + def __init__( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + int4: int, + int5: int, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + int4: int, + int5: int, + hashtable: java.util.Hashtable[typing.Any, typing.Any], + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int3: int, + int4: int, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int3: int, + int4: int, + hashtable: java.util.Hashtable[typing.Any, typing.Any], + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int4: int, + int5: int, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int4: int, + int5: int, + hashtable: java.util.Hashtable[typing.Any, typing.Any], + ): ... + def addConsumer(self, imageConsumer: ImageConsumer) -> None: ... + def isConsumer(self, imageConsumer: ImageConsumer) -> bool: ... + @typing.overload + def newPixels( + self, + byteArray: list[int] | jpype.JArray | bytes, + colorModel: ColorModel, + int: int, + int2: int, + ) -> None: ... + @typing.overload + def newPixels(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def newPixels( + self, int: int, int2: int, int3: int, int4: int, boolean: bool + ) -> None: ... + @typing.overload + def newPixels( + self, + intArray: list[int] | jpype.JArray, + colorModel: ColorModel, + int2: int, + int3: int, + ) -> None: ... + @typing.overload + def newPixels(self) -> None: ... + def removeConsumer(self, imageConsumer: ImageConsumer) -> None: ... + def requestTopDownLeftRightResend(self, imageConsumer: ImageConsumer) -> None: ... + def setAnimated(self, boolean: bool) -> None: ... + def setFullBufferUpdates(self, boolean: bool) -> None: ... + def startProduction(self, imageConsumer: ImageConsumer) -> None: ... + +class MultiPixelPackedSampleModel(SampleModel): + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + @typing.overload + def __init__( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ): ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def createDataBuffer(self) -> DataBuffer: ... + def createSubsetSampleModel( + self, intArray: list[int] | jpype.JArray + ) -> SampleModel: ... + def equals(self, object: typing.Any) -> bool: ... + def getBitOffset(self, int: int) -> int: ... + def getDataBitOffset(self) -> int: ... + @typing.overload + def getDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> typing.Any: ... + def getNumDataElements(self) -> int: ... + def getOffset(self, int: int, int2: int) -> int: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def getPixelBitStride(self) -> int: ... + def getSample( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> int: ... + @typing.overload + def getSampleSize(self, int: int) -> int: ... + @typing.overload + def getSampleSize(self) -> typing.MutableSequence[int]: ... + def getScanlineStride(self) -> int: ... + def getTransferType(self) -> int: ... + def hashCode(self) -> int: ... + @typing.overload + def setDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, int4: int, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, double: float, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, float: float, dataBuffer: DataBuffer + ) -> None: ... + +class PackedColorModel(ColorModel): + @typing.overload + def __init__( + self, + colorSpace: java.awt.color.ColorSpace, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + boolean: bool, + int6: int, + int7: int, + ): ... + @typing.overload + def __init__( + self, + colorSpace: java.awt.color.ColorSpace, + int: int, + intArray: list[int] | jpype.JArray, + int3: int, + boolean: bool, + int4: int, + int5: int, + ): ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def equals(self, object: typing.Any) -> bool: ... + def getAlphaRaster(self, writableRaster: WritableRaster) -> WritableRaster: ... + def getMask(self, int: int) -> int: ... + def getMasks(self) -> typing.MutableSequence[int]: ... + def hashCode(self) -> int: ... + def isCompatibleSampleModel(self, sampleModel: SampleModel) -> bool: ... + +class PixelGrabber(ImageConsumer): + @typing.overload + def __init__( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + boolean: bool, + ): ... + @typing.overload + def __init__( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ): ... + @typing.overload + def __init__( + self, + imageProducer: ImageProducer, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ): ... + def abortGrabbing(self) -> None: ... + def getColorModel(self) -> ColorModel: ... + def getHeight(self) -> int: ... + def getPixels(self) -> typing.Any: ... + def getStatus(self) -> int: ... + def getWidth(self) -> int: ... + @typing.overload + def grabPixels(self) -> bool: ... + @typing.overload + def grabPixels(self, long: int) -> bool: ... + def imageComplete(self, int: int) -> None: ... + def setColorModel(self, colorModel: ColorModel) -> None: ... + def setDimensions(self, int: int, int2: int) -> None: ... + def setHints(self, int: int) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int5: int, + int6: int, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + def setProperties( + self, hashtable: java.util.Hashtable[typing.Any, typing.Any] + ) -> None: ... + def startGrabbing(self) -> None: ... + def status(self) -> int: ... + +class RescaleOp(BufferedImageOp, RasterOp): + @typing.overload + def __init__( + self, float: float, float2: float, renderingHints: java.awt.RenderingHints + ): ... + @typing.overload + def __init__( + self, + floatArray: list[float] | jpype.JArray, + floatArray2: list[float] | jpype.JArray, + renderingHints: java.awt.RenderingHints, + ): ... + def createCompatibleDestImage( + self, bufferedImage: BufferedImage, colorModel: ColorModel + ) -> BufferedImage: ... + def createCompatibleDestRaster(self, raster: Raster) -> WritableRaster: ... + @typing.overload + def filter( + self, bufferedImage: BufferedImage, bufferedImage2: BufferedImage + ) -> BufferedImage: ... + @typing.overload + def filter( + self, raster: Raster, writableRaster: WritableRaster + ) -> WritableRaster: ... + @typing.overload + def getBounds2D( + self, bufferedImage: BufferedImage + ) -> java.awt.geom.Rectangle2D: ... + @typing.overload + def getBounds2D(self, raster: Raster) -> java.awt.geom.Rectangle2D: ... + def getNumFactors(self) -> int: ... + def getOffsets( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def getPoint2D( + self, point2D: java.awt.geom.Point2D, point2D2: java.awt.geom.Point2D + ) -> java.awt.geom.Point2D: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + def getScaleFactors( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + +class ShortLookupTable(LookupTable): + @typing.overload + def __init__(self, int: int, shortArray: list[int] | jpype.JArray): ... + @typing.overload + def __init__( + self, int: int, shortArray: list[typing.MutableSequence[int]] | jpype.JArray + ): ... + def getTable(self) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def lookupPixel( + self, intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def lookupPixel( + self, + shortArray: list[int] | jpype.JArray, + shortArray2: list[int] | jpype.JArray, + ) -> typing.MutableSequence[int]: ... + +class SinglePixelPackedSampleModel(SampleModel): + @typing.overload + def __init__( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, int: int, int2: int, int3: int, intArray: list[int] | jpype.JArray + ): ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def createDataBuffer(self) -> DataBuffer: ... + def createSubsetSampleModel( + self, intArray: list[int] | jpype.JArray + ) -> SampleModel: ... + def equals(self, object: typing.Any) -> bool: ... + def getBitMasks(self) -> typing.MutableSequence[int]: ... + def getBitOffsets(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> typing.Any: ... + def getNumDataElements(self) -> int: ... + def getOffset(self, int: int, int2: int) -> int: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def getSample( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> int: ... + @typing.overload + def getSampleSize(self, int: int) -> int: ... + @typing.overload + def getSampleSize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def getScanlineStride(self) -> int: ... + def hashCode(self) -> int: ... + @typing.overload + def setDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, double: float, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, float: float, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, int4: int, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + +class WritableRaster(Raster): + def createWritableChild( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + intArray: list[int] | jpype.JArray, + ) -> WritableRaster: ... + def createWritableTranslatedChild(self, int: int, int2: int) -> WritableRaster: ... + def getWritableParent(self) -> WritableRaster: ... + @typing.overload + def setDataElements( + self, int: int, int2: int, int3: int, int4: int, object: typing.Any + ) -> None: ... + @typing.overload + def setDataElements(self, int: int, int2: int, raster: Raster) -> None: ... + @typing.overload + def setDataElements(self, int: int, int2: int, object: typing.Any) -> None: ... + @typing.overload + def setPixel( + self, int: int, int2: int, doubleArray: list[float] | jpype.JArray + ) -> None: ... + @typing.overload + def setPixel( + self, int: int, int2: int, floatArray: list[float] | jpype.JArray + ) -> None: ... + @typing.overload + def setPixel( + self, int: int, int2: int, intArray: list[int] | jpype.JArray + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + ) -> None: ... + @typing.overload + def setRect(self, int: int, int2: int, raster: Raster) -> None: ... + @typing.overload + def setRect(self, raster: Raster) -> None: ... + @typing.overload + def setSample(self, int: int, int2: int, int3: int, double: float) -> None: ... + @typing.overload + def setSample(self, int: int, int2: int, int3: int, float: float) -> None: ... + @typing.overload + def setSample(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + ) -> None: ... + +class WritableRenderedImage(RenderedImage): + def addTileObserver(self, tileObserver: TileObserver | typing.Callable) -> None: ... + def getWritableTile(self, int: int, int2: int) -> WritableRaster: ... + def getWritableTileIndices(self) -> typing.MutableSequence[java.awt.Point]: ... + def hasTileWriters(self) -> bool: ... + def isTileWritable(self, int: int, int2: int) -> bool: ... + def releaseWritableTile(self, int: int, int2: int) -> None: ... + def removeTileObserver( + self, tileObserver: TileObserver | typing.Callable + ) -> None: ... + def setData(self, raster: Raster) -> None: ... + +class BandedSampleModel(ComponentSampleModel): + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ): ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def createDataBuffer(self) -> DataBuffer: ... + def createSubsetSampleModel( + self, intArray: list[int] | jpype.JArray + ) -> SampleModel: ... + @typing.overload + def getDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> typing.Any: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def getSample( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> int: ... + def getSampleDouble( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> float: ... + def getSampleFloat( + self, int: int, int2: int, int3: int, dataBuffer: DataBuffer + ) -> float: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[float]: ... + @typing.overload + def getSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> typing.MutableSequence[int]: ... + def hashCode(self) -> int: ... + @typing.overload + def setDataElements( + self, int: int, int2: int, object: typing.Any, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setDataElements( + self, + int: int, + int2: int, + int3: int, + int4: int, + object: typing.Any, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixel( + self, + int: int, + int2: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, double: float, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, float: float, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSample( + self, int: int, int2: int, int3: int, int4: int, dataBuffer: DataBuffer + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + doubleArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + @typing.overload + def setSamples( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + floatArray: list[float] | jpype.JArray, + dataBuffer: DataBuffer, + ) -> None: ... + +class BaseMultiResolutionImage(AbstractMultiResolutionImage): + @typing.overload + def __init__(self, int: int, *image: java.awt.Image): ... + @typing.overload + def __init__(self, *image: java.awt.Image): ... + def getResolutionVariant(self, double: float, double2: float) -> java.awt.Image: ... + def getResolutionVariants(self) -> java.util.List[java.awt.Image]: ... + +class BufferedImage(java.awt.Image, WritableRenderedImage, java.awt.Transparency): + TYPE_CUSTOM: typing.ClassVar[int] = ... + TYPE_INT_RGB: typing.ClassVar[int] = ... + TYPE_INT_ARGB: typing.ClassVar[int] = ... + TYPE_INT_ARGB_PRE: typing.ClassVar[int] = ... + TYPE_INT_BGR: typing.ClassVar[int] = ... + TYPE_3BYTE_BGR: typing.ClassVar[int] = ... + TYPE_4BYTE_ABGR: typing.ClassVar[int] = ... + TYPE_4BYTE_ABGR_PRE: typing.ClassVar[int] = ... + TYPE_USHORT_565_RGB: typing.ClassVar[int] = ... + TYPE_USHORT_555_RGB: typing.ClassVar[int] = ... + TYPE_BYTE_GRAY: typing.ClassVar[int] = ... + TYPE_USHORT_GRAY: typing.ClassVar[int] = ... + TYPE_BYTE_BINARY: typing.ClassVar[int] = ... + TYPE_BYTE_INDEXED: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int): ... + @typing.overload + def __init__( + self, int: int, int2: int, int3: int, indexColorModel: IndexColorModel + ): ... + @typing.overload + def __init__( + self, + colorModel: ColorModel, + writableRaster: WritableRaster, + boolean: bool, + hashtable: java.util.Hashtable[typing.Any, typing.Any], + ): ... + def addTileObserver(self, tileObserver: TileObserver | typing.Callable) -> None: ... + def coerceData(self, boolean: bool) -> None: ... + def copyData(self, writableRaster: WritableRaster) -> WritableRaster: ... + def createGraphics(self) -> java.awt.Graphics2D: ... + def getAlphaRaster(self) -> WritableRaster: ... + def getColorModel(self) -> ColorModel: ... + @typing.overload + def getData(self) -> Raster: ... + @typing.overload + def getData(self, rectangle: java.awt.Rectangle) -> Raster: ... + def getGraphics(self) -> java.awt.Graphics: ... + @typing.overload + def getHeight(self) -> int: ... + @typing.overload + def getHeight(self, imageObserver: ImageObserver | typing.Callable) -> int: ... + def getMinTileX(self) -> int: ... + def getMinTileY(self) -> int: ... + def getMinX(self) -> int: ... + def getMinY(self) -> int: ... + def getNumXTiles(self) -> int: ... + def getNumYTiles(self) -> int: ... + @typing.overload + def getProperty(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def getProperty( + self, + string: java.lang.String | str, + imageObserver: ImageObserver | typing.Callable, + ) -> typing.Any: ... + def getPropertyNames(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getRGB(self, int: int, int2: int) -> int: ... + @typing.overload + def getRGB( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> typing.MutableSequence[int]: ... + def getRaster(self) -> WritableRaster: ... + def getSampleModel(self) -> SampleModel: ... + def getSource(self) -> ImageProducer: ... + def getSources(self) -> java.util.Vector[RenderedImage]: ... + def getSubimage( + self, int: int, int2: int, int3: int, int4: int + ) -> BufferedImage: ... + def getTile(self, int: int, int2: int) -> Raster: ... + def getTileGridXOffset(self) -> int: ... + def getTileGridYOffset(self) -> int: ... + def getTileHeight(self) -> int: ... + def getTileWidth(self) -> int: ... + def getTransparency(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def getWidth(self) -> int: ... + @typing.overload + def getWidth(self, imageObserver: ImageObserver | typing.Callable) -> int: ... + def getWritableTile(self, int: int, int2: int) -> WritableRaster: ... + def getWritableTileIndices(self) -> typing.MutableSequence[java.awt.Point]: ... + def hasTileWriters(self) -> bool: ... + def isAlphaPremultiplied(self) -> bool: ... + def isTileWritable(self, int: int, int2: int) -> bool: ... + def releaseWritableTile(self, int: int, int2: int) -> None: ... + def removeTileObserver( + self, tileObserver: TileObserver | typing.Callable + ) -> None: ... + def setData(self, raster: Raster) -> None: ... + @typing.overload + def setRGB(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def setRGB( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + def toString(self) -> java.lang.String: ... + +class BufferedImageFilter(ImageFilter, java.lang.Cloneable): + def __init__(self, bufferedImageOp: BufferedImageOp): ... + def getBufferedImageOp(self) -> BufferedImageOp: ... + def imageComplete(self, int: int) -> None: ... + def setColorModel(self, colorModel: ColorModel) -> None: ... + def setDimensions(self, int: int, int2: int) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int5: int, + int6: int, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + +class CropImageFilter(ImageFilter): + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + def setDimensions(self, int: int, int2: int) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int5: int, + int6: int, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + def setProperties( + self, hashtable: java.util.Hashtable[typing.Any, typing.Any] + ) -> None: ... + +class DirectColorModel(PackedColorModel): + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int, int5: int): ... + @typing.overload + def __init__( + self, + colorSpace: java.awt.color.ColorSpace, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + boolean: bool, + int6: int, + ): ... + def coerceData( + self, writableRaster: WritableRaster, boolean: bool + ) -> ColorModel: ... + def createCompatibleWritableRaster(self, int: int, int2: int) -> WritableRaster: ... + @typing.overload + def getAlpha(self, int: int) -> int: ... + @typing.overload + def getAlpha(self, object: typing.Any) -> int: ... + def getAlphaMask(self) -> int: ... + @typing.overload + def getBlue(self, int: int) -> int: ... + @typing.overload + def getBlue(self, object: typing.Any) -> int: ... + def getBlueMask(self) -> int: ... + @typing.overload + def getComponents( + self, int: int, intArray: list[int] | jpype.JArray, int3: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getComponents( + self, object: typing.Any, intArray: list[int] | jpype.JArray, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getDataElement( + self, floatArray: list[float] | jpype.JArray, int: int + ) -> int: ... + @typing.overload + def getDataElement(self, intArray: list[int] | jpype.JArray, int2: int) -> int: ... + @typing.overload + def getDataElements( + self, floatArray: list[float] | jpype.JArray, int: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements(self, int: int, object: typing.Any) -> typing.Any: ... + @typing.overload + def getDataElements( + self, intArray: list[int] | jpype.JArray, int2: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getGreen(self, int: int) -> int: ... + @typing.overload + def getGreen(self, object: typing.Any) -> int: ... + def getGreenMask(self) -> int: ... + @typing.overload + def getRGB(self, int: int) -> int: ... + @typing.overload + def getRGB(self, object: typing.Any) -> int: ... + @typing.overload + def getRed(self, int: int) -> int: ... + @typing.overload + def getRed(self, object: typing.Any) -> int: ... + def getRedMask(self) -> int: ... + def isCompatibleRaster(self, raster: Raster) -> bool: ... + def toString(self) -> java.lang.String: ... + +class PixelInterleavedSampleModel(ComponentSampleModel): + def __init__( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + intArray: list[int] | jpype.JArray, + ): ... + def createCompatibleSampleModel(self, int: int, int2: int) -> SampleModel: ... + def createSubsetSampleModel( + self, intArray: list[int] | jpype.JArray + ) -> SampleModel: ... + def hashCode(self) -> int: ... + +class RGBImageFilter(ImageFilter): + def filterIndexColorModel( + self, indexColorModel: IndexColorModel + ) -> IndexColorModel: ... + def filterRGB(self, int: int, int2: int, int3: int) -> int: ... + def filterRGBPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + def setColorModel(self, colorModel: ColorModel) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int5: int, + int6: int, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + def substituteColorModel( + self, colorModel: ColorModel, colorModel2: ColorModel + ) -> None: ... + +class ReplicateScaleFilter(ImageFilter): + def __init__(self, int: int, int2: int): ... + def setDimensions(self, int: int, int2: int) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int5: int, + int6: int, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + def setProperties( + self, hashtable: java.util.Hashtable[typing.Any, typing.Any] + ) -> None: ... + +class AreaAveragingScaleFilter(ReplicateScaleFilter): + def __init__(self, int: int, int2: int): ... + def setHints(self, int: int) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + byteArray: list[int] | jpype.JArray | bytes, + int5: int, + int6: int, + ) -> None: ... + @typing.overload + def setPixels( + self, + int: int, + int2: int, + int3: int, + int4: int, + colorModel: ColorModel, + intArray: list[int] | jpype.JArray, + int6: int, + int7: int, + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.image")``. + + AbstractMultiResolutionImage: type[AbstractMultiResolutionImage] + AffineTransformOp: type[AffineTransformOp] + AreaAveragingScaleFilter: type[AreaAveragingScaleFilter] + BandCombineOp: type[BandCombineOp] + BandedSampleModel: type[BandedSampleModel] + BaseMultiResolutionImage: type[BaseMultiResolutionImage] + BufferStrategy: type[BufferStrategy] + BufferedImage: type[BufferedImage] + BufferedImageFilter: type[BufferedImageFilter] + BufferedImageOp: type[BufferedImageOp] + ByteLookupTable: type[ByteLookupTable] + ColorConvertOp: type[ColorConvertOp] + ColorModel: type[ColorModel] + ComponentColorModel: type[ComponentColorModel] + ComponentSampleModel: type[ComponentSampleModel] + ConvolveOp: type[ConvolveOp] + CropImageFilter: type[CropImageFilter] + DataBuffer: type[DataBuffer] + DataBufferByte: type[DataBufferByte] + DataBufferDouble: type[DataBufferDouble] + DataBufferFloat: type[DataBufferFloat] + DataBufferInt: type[DataBufferInt] + DataBufferShort: type[DataBufferShort] + DataBufferUShort: type[DataBufferUShort] + DirectColorModel: type[DirectColorModel] + FilteredImageSource: type[FilteredImageSource] + ImageConsumer: type[ImageConsumer] + ImageFilter: type[ImageFilter] + ImageObserver: type[ImageObserver] + ImageProducer: type[ImageProducer] + ImagingOpException: type[ImagingOpException] + IndexColorModel: type[IndexColorModel] + Kernel: type[Kernel] + LookupOp: type[LookupOp] + LookupTable: type[LookupTable] + MemoryImageSource: type[MemoryImageSource] + MultiPixelPackedSampleModel: type[MultiPixelPackedSampleModel] + MultiResolutionImage: type[MultiResolutionImage] + PackedColorModel: type[PackedColorModel] + PixelGrabber: type[PixelGrabber] + PixelInterleavedSampleModel: type[PixelInterleavedSampleModel] + RGBImageFilter: type[RGBImageFilter] + Raster: type[Raster] + RasterFormatException: type[RasterFormatException] + RasterOp: type[RasterOp] + RenderedImage: type[RenderedImage] + ReplicateScaleFilter: type[ReplicateScaleFilter] + RescaleOp: type[RescaleOp] + SampleModel: type[SampleModel] + ShortLookupTable: type[ShortLookupTable] + SinglePixelPackedSampleModel: type[SinglePixelPackedSampleModel] + TileObserver: type[TileObserver] + VolatileImage: type[VolatileImage] + WritableRaster: type[WritableRaster] + WritableRenderedImage: type[WritableRenderedImage] + renderable: java.awt.image.renderable.__module_protocol__ diff --git a/typings/java/awt/image/renderable/__init__.pyi b/typings/java/awt/image/renderable/__init__.pyi new file mode 100644 index 0000000..cd0cc27 --- /dev/null +++ b/typings/java/awt/image/renderable/__init__.pyi @@ -0,0 +1,214 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.geom +import java.awt.image +import java.io +import java.lang +import java.util + +class ParameterBlock(java.lang.Cloneable, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, vector: java.util.Vector[typing.Any]): ... + @typing.overload + def __init__( + self, + vector: java.util.Vector[typing.Any], + vector2: java.util.Vector[typing.Any], + ): ... + @typing.overload + def add(self, byte: int) -> ParameterBlock: ... + @typing.overload + def add(self, char: str) -> ParameterBlock: ... + @typing.overload + def add(self, double: float) -> ParameterBlock: ... + @typing.overload + def add(self, float: float) -> ParameterBlock: ... + @typing.overload + def add(self, int: int) -> ParameterBlock: ... + @typing.overload + def add(self, object: typing.Any) -> ParameterBlock: ... + @typing.overload + def add(self, long: int) -> ParameterBlock: ... + @typing.overload + def add(self, short: int) -> ParameterBlock: ... + def addSource(self, object: typing.Any) -> ParameterBlock: ... + def clone(self) -> typing.Any: ... + def getByteParameter(self, int: int) -> int: ... + def getCharParameter(self, int: int) -> str: ... + def getDoubleParameter(self, int: int) -> float: ... + def getFloatParameter(self, int: int) -> float: ... + def getIntParameter(self, int: int) -> int: ... + def getLongParameter(self, int: int) -> int: ... + def getNumParameters(self) -> int: ... + def getNumSources(self) -> int: ... + def getObjectParameter(self, int: int) -> typing.Any: ... + def getParamClasses(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getParameters(self) -> java.util.Vector[typing.Any]: ... + def getRenderableSource(self, int: int) -> RenderableImage: ... + def getRenderedSource(self, int: int) -> java.awt.image.RenderedImage: ... + def getShortParameter(self, int: int) -> int: ... + def getSource(self, int: int) -> typing.Any: ... + def getSources(self) -> java.util.Vector[typing.Any]: ... + def removeParameters(self) -> None: ... + def removeSources(self) -> None: ... + @typing.overload + def set(self, byte: int, int: int) -> ParameterBlock: ... + @typing.overload + def set(self, char: str, int: int) -> ParameterBlock: ... + @typing.overload + def set(self, double: float, int: int) -> ParameterBlock: ... + @typing.overload + def set(self, float: float, int: int) -> ParameterBlock: ... + @typing.overload + def set(self, int: int, int2: int) -> ParameterBlock: ... + @typing.overload + def set(self, object: typing.Any, int: int) -> ParameterBlock: ... + @typing.overload + def set(self, long: int, int: int) -> ParameterBlock: ... + @typing.overload + def set(self, short: int, int: int) -> ParameterBlock: ... + def setParameters(self, vector: java.util.Vector[typing.Any]) -> None: ... + def setSource(self, object: typing.Any, int: int) -> ParameterBlock: ... + def setSources(self, vector: java.util.Vector[typing.Any]) -> None: ... + def shallowClone(self) -> typing.Any: ... + +class RenderContext(java.lang.Cloneable): + @typing.overload + def __init__(self, affineTransform: java.awt.geom.AffineTransform): ... + @typing.overload + def __init__( + self, + affineTransform: java.awt.geom.AffineTransform, + renderingHints: java.awt.RenderingHints, + ): ... + @typing.overload + def __init__( + self, affineTransform: java.awt.geom.AffineTransform, shape: java.awt.Shape + ): ... + @typing.overload + def __init__( + self, + affineTransform: java.awt.geom.AffineTransform, + shape: java.awt.Shape, + renderingHints: java.awt.RenderingHints, + ): ... + def clone(self) -> typing.Any: ... + def concatenateTransform( + self, affineTransform: java.awt.geom.AffineTransform + ) -> None: ... + def concetenateTransform( + self, affineTransform: java.awt.geom.AffineTransform + ) -> None: ... + def getAreaOfInterest(self) -> java.awt.Shape: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + def getTransform(self) -> java.awt.geom.AffineTransform: ... + def preConcatenateTransform( + self, affineTransform: java.awt.geom.AffineTransform + ) -> None: ... + def preConcetenateTransform( + self, affineTransform: java.awt.geom.AffineTransform + ) -> None: ... + def setAreaOfInterest(self, shape: java.awt.Shape) -> None: ... + def setRenderingHints(self, renderingHints: java.awt.RenderingHints) -> None: ... + def setTransform(self, affineTransform: java.awt.geom.AffineTransform) -> None: ... + +class RenderableImage: + HINTS_OBSERVED: typing.ClassVar[java.lang.String] = ... + def createDefaultRendering(self) -> java.awt.image.RenderedImage: ... + def createRendering( + self, renderContext: RenderContext + ) -> java.awt.image.RenderedImage: ... + def createScaledRendering( + self, int: int, int2: int, renderingHints: java.awt.RenderingHints + ) -> java.awt.image.RenderedImage: ... + def getHeight(self) -> float: ... + def getMinX(self) -> float: ... + def getMinY(self) -> float: ... + def getProperty(self, string: java.lang.String | str) -> typing.Any: ... + def getPropertyNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getSources(self) -> java.util.Vector[RenderableImage]: ... + def getWidth(self) -> float: ... + def isDynamic(self) -> bool: ... + +class RenderableImageProducer(java.awt.image.ImageProducer, java.lang.Runnable): + def __init__( + self, renderableImage: RenderableImage, renderContext: RenderContext + ): ... + def addConsumer(self, imageConsumer: java.awt.image.ImageConsumer) -> None: ... + def isConsumer(self, imageConsumer: java.awt.image.ImageConsumer) -> bool: ... + def removeConsumer(self, imageConsumer: java.awt.image.ImageConsumer) -> None: ... + def requestTopDownLeftRightResend( + self, imageConsumer: java.awt.image.ImageConsumer + ) -> None: ... + def run(self) -> None: ... + def setRenderContext(self, renderContext: RenderContext) -> None: ... + def startProduction(self, imageConsumer: java.awt.image.ImageConsumer) -> None: ... + +class RenderedImageFactory: + def create( + self, parameterBlock: ParameterBlock, renderingHints: java.awt.RenderingHints + ) -> java.awt.image.RenderedImage: ... + +class ContextualRenderedImageFactory(RenderedImageFactory): + @typing.overload + def create( + self, renderContext: RenderContext, parameterBlock: ParameterBlock + ) -> java.awt.image.RenderedImage: ... + @typing.overload + def create( + self, parameterBlock: ParameterBlock, renderingHints: java.awt.RenderingHints + ) -> java.awt.image.RenderedImage: ... + def getBounds2D( + self, parameterBlock: ParameterBlock + ) -> java.awt.geom.Rectangle2D: ... + def getProperty( + self, parameterBlock: ParameterBlock, string: java.lang.String | str + ) -> typing.Any: ... + def getPropertyNames(self) -> typing.MutableSequence[java.lang.String]: ... + def isDynamic(self) -> bool: ... + def mapRenderContext( + self, + int: int, + renderContext: RenderContext, + parameterBlock: ParameterBlock, + renderableImage: RenderableImage, + ) -> RenderContext: ... + +class RenderableImageOp(RenderableImage): + def __init__( + self, + contextualRenderedImageFactory: ContextualRenderedImageFactory, + parameterBlock: ParameterBlock, + ): ... + def createDefaultRendering(self) -> java.awt.image.RenderedImage: ... + def createRendering( + self, renderContext: RenderContext + ) -> java.awt.image.RenderedImage: ... + def createScaledRendering( + self, int: int, int2: int, renderingHints: java.awt.RenderingHints + ) -> java.awt.image.RenderedImage: ... + def getHeight(self) -> float: ... + def getMinX(self) -> float: ... + def getMinY(self) -> float: ... + def getParameterBlock(self) -> ParameterBlock: ... + def getProperty(self, string: java.lang.String | str) -> typing.Any: ... + def getPropertyNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getSources(self) -> java.util.Vector[RenderableImage]: ... + def getWidth(self) -> float: ... + def isDynamic(self) -> bool: ... + def setParameterBlock(self, parameterBlock: ParameterBlock) -> ParameterBlock: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.image.renderable")``. + + ContextualRenderedImageFactory: type[ContextualRenderedImageFactory] + ParameterBlock: type[ParameterBlock] + RenderContext: type[RenderContext] + RenderableImage: type[RenderableImage] + RenderableImageOp: type[RenderableImageOp] + RenderableImageProducer: type[RenderableImageProducer] + RenderedImageFactory: type[RenderedImageFactory] diff --git a/typings/java/awt/peer/__init__.pyi b/typings/java/awt/peer/__init__.pyi new file mode 100644 index 0000000..f3d6420 --- /dev/null +++ b/typings/java/awt/peer/__init__.pyi @@ -0,0 +1,382 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.desktop +import java.awt.event +import java.awt.im +import java.awt.image +import java.io +import java.lang +import java.net +import java.util +import javax.swing +import jpype.protocol +import sun.java2d.pipe + +class ComponentPeer: + SET_LOCATION: typing.ClassVar[int] = ... + SET_SIZE: typing.ClassVar[int] = ... + SET_BOUNDS: typing.ClassVar[int] = ... + SET_CLIENT_SIZE: typing.ClassVar[int] = ... + RESET_OPERATION: typing.ClassVar[int] = ... + NO_EMBEDDED_CHECK: typing.ClassVar[int] = ... + DEFAULT_OPERATION: typing.ClassVar[int] = ... + def applyShape(self, region: sun.java2d.pipe.Region) -> None: ... + def canDetermineObscurity(self) -> bool: ... + def coalescePaintEvent(self, paintEvent: java.awt.event.PaintEvent) -> None: ... + def createBuffers( + self, int: int, bufferCapabilities: java.awt.BufferCapabilities + ) -> None: ... + def createImage(self, int: int, int2: int) -> java.awt.Image: ... + def createVolatileImage( + self, int: int, int2: int + ) -> java.awt.image.VolatileImage: ... + def destroyBuffers(self) -> None: ... + def dispose(self) -> None: ... + def flip( + self, + int: int, + int2: int, + int3: int, + int4: int, + flipContents: java.awt.BufferCapabilities.FlipContents, + ) -> None: ... + def getBackBuffer(self) -> java.awt.Image: ... + def getColorModel(self) -> java.awt.image.ColorModel: ... + def getFontMetrics(self, font: java.awt.Font) -> java.awt.FontMetrics: ... + def getGraphics(self) -> java.awt.Graphics: ... + def getGraphicsConfiguration(self) -> java.awt.GraphicsConfiguration: ... + def getLocationOnScreen(self) -> java.awt.Point: ... + def getMinimumSize(self) -> java.awt.Dimension: ... + def getPreferredSize(self) -> java.awt.Dimension: ... + def handleEvent(self, aWTEvent: java.awt.AWTEvent) -> None: ... + def handlesWheelScrolling(self) -> bool: ... + def isFocusable(self) -> bool: ... + def isObscured(self) -> bool: ... + def isReparentSupported(self) -> bool: ... + def layout(self) -> None: ... + def paint(self, graphics: java.awt.Graphics) -> None: ... + def print_(self, graphics: java.awt.Graphics) -> None: ... + def reparent(self, containerPeer: ContainerPeer) -> None: ... + def requestFocus( + self, + component: java.awt.Component, + boolean: bool, + boolean2: bool, + long: int, + cause: java.awt.event.FocusEvent.Cause, + ) -> bool: ... + def setBackground(self, color: java.awt.Color) -> None: ... + def setBounds( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + def setEnabled(self, boolean: bool) -> None: ... + def setFont(self, font: java.awt.Font) -> None: ... + def setForeground(self, color: java.awt.Color) -> None: ... + def setVisible(self, boolean: bool) -> None: ... + def setZOrder(self, componentPeer: ComponentPeer) -> None: ... + def updateCursorImmediately(self) -> None: ... + def updateGraphicsData( + self, graphicsConfiguration: java.awt.GraphicsConfiguration + ) -> bool: ... + +class DesktopPeer: + def addAppEventListener( + self, systemEventListener: java.awt.desktop.SystemEventListener + ) -> None: ... + def browse(self, uRI: java.net.URI) -> None: ... + def browseFileDirectory( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> bool: ... + def disableSuddenTermination(self) -> None: ... + def edit(self, file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + def enableSuddenTermination(self) -> None: ... + def isSupported(self, action: java.awt.Desktop.Action) -> bool: ... + def mail(self, uRI: java.net.URI) -> None: ... + def moveToTrash(self, file: java.io.File | jpype.protocol.SupportsPath) -> bool: ... + def open(self, file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + def openHelpViewer(self) -> None: ... + def print_(self, file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + def removeAppEventListener( + self, systemEventListener: java.awt.desktop.SystemEventListener + ) -> None: ... + def requestForeground(self, boolean: bool) -> None: ... + def setAboutHandler( + self, aboutHandler: java.awt.desktop.AboutHandler | typing.Callable + ) -> None: ... + def setDefaultMenuBar(self, jMenuBar: javax.swing.JMenuBar) -> None: ... + def setOpenFileHandler( + self, openFilesHandler: java.awt.desktop.OpenFilesHandler | typing.Callable + ) -> None: ... + def setOpenURIHandler( + self, openURIHandler: java.awt.desktop.OpenURIHandler | typing.Callable + ) -> None: ... + def setPreferencesHandler( + self, preferencesHandler: java.awt.desktop.PreferencesHandler | typing.Callable + ) -> None: ... + def setPrintFileHandler( + self, printFilesHandler: java.awt.desktop.PrintFilesHandler | typing.Callable + ) -> None: ... + def setQuitHandler( + self, quitHandler: java.awt.desktop.QuitHandler | typing.Callable + ) -> None: ... + def setQuitStrategy(self, quitStrategy: java.awt.desktop.QuitStrategy) -> None: ... + +class FontPeer: ... + +class KeyboardFocusManagerPeer: + def clearGlobalFocusOwner(self, window: java.awt.Window) -> None: ... + def getCurrentFocusOwner(self) -> java.awt.Component: ... + def getCurrentFocusedWindow(self) -> java.awt.Window: ... + def setCurrentFocusOwner(self, component: java.awt.Component) -> None: ... + def setCurrentFocusedWindow(self, window: java.awt.Window) -> None: ... + +class MenuComponentPeer: + def dispose(self) -> None: ... + def setFont(self, font: java.awt.Font) -> None: ... + +class MouseInfoPeer: + def fillPointWithCoords(self, point: java.awt.Point) -> int: ... + def isWindowUnderMouse(self, window: java.awt.Window) -> bool: ... + +class RobotPeer: + def getRGBPixel(self, int: int, int2: int) -> int: ... + def getRGBPixels( + self, rectangle: java.awt.Rectangle + ) -> typing.MutableSequence[int]: ... + def keyPress(self, int: int) -> None: ... + def keyRelease(self, int: int) -> None: ... + def mouseMove(self, int: int, int2: int) -> None: ... + def mousePress(self, int: int) -> None: ... + def mouseRelease(self, int: int) -> None: ... + def mouseWheel(self, int: int) -> None: ... + def useAbsoluteCoordinates(self) -> bool: ... + +class SystemTrayPeer: + def getTrayIconSize(self) -> java.awt.Dimension: ... + +class TaskbarPeer: + def getIconImage(self) -> java.awt.Image: ... + def getMenu(self) -> java.awt.PopupMenu: ... + def isSupported(self, feature: java.awt.Taskbar.Feature) -> bool: ... + def requestUserAttention(self, boolean: bool, boolean2: bool) -> None: ... + def requestWindowUserAttention(self, window: java.awt.Window) -> None: ... + def setIconBadge(self, string: java.lang.String | str) -> None: ... + def setIconImage(self, image: java.awt.Image) -> None: ... + def setMenu(self, popupMenu: java.awt.PopupMenu) -> None: ... + def setProgressValue(self, int: int) -> None: ... + def setWindowIconBadge( + self, window: java.awt.Window, image: java.awt.Image + ) -> None: ... + def setWindowProgressState( + self, window: java.awt.Window, state: java.awt.Taskbar.State + ) -> None: ... + def setWindowProgressValue(self, window: java.awt.Window, int: int) -> None: ... + +class TrayIconPeer: + def displayMessage( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> None: ... + def dispose(self) -> None: ... + def setToolTip(self, string: java.lang.String | str) -> None: ... + def showPopupMenu(self, int: int, int2: int) -> None: ... + def updateImage(self) -> None: ... + +class ButtonPeer(ComponentPeer): + def setLabel(self, string: java.lang.String | str) -> None: ... + +class CanvasPeer(ComponentPeer): + def getAppropriateGraphicsConfiguration( + self, graphicsConfiguration: java.awt.GraphicsConfiguration + ) -> java.awt.GraphicsConfiguration: ... + +class CheckboxPeer(ComponentPeer): + def setCheckboxGroup(self, checkboxGroup: java.awt.CheckboxGroup) -> None: ... + def setLabel(self, string: java.lang.String | str) -> None: ... + def setState(self, boolean: bool) -> None: ... + +class ChoicePeer(ComponentPeer): + def add(self, string: java.lang.String | str, int: int) -> None: ... + def remove(self, int: int) -> None: ... + def removeAll(self) -> None: ... + def select(self, int: int) -> None: ... + +class ContainerPeer(ComponentPeer): + def beginLayout(self) -> None: ... + def beginValidate(self) -> None: ... + def endLayout(self) -> None: ... + def endValidate(self) -> None: ... + def getInsets(self) -> java.awt.Insets: ... + +class LabelPeer(ComponentPeer): + def setAlignment(self, int: int) -> None: ... + def setText(self, string: java.lang.String | str) -> None: ... + +class LightweightPeer(ComponentPeer): ... + +class ListPeer(ComponentPeer): + def add(self, string: java.lang.String | str, int: int) -> None: ... + def delItems(self, int: int, int2: int) -> None: ... + def deselect(self, int: int) -> None: ... + @typing.overload + def getMinimumSize(self) -> java.awt.Dimension: ... + @typing.overload + def getMinimumSize(self, int: int) -> java.awt.Dimension: ... + @typing.overload + def getPreferredSize(self) -> java.awt.Dimension: ... + @typing.overload + def getPreferredSize(self, int: int) -> java.awt.Dimension: ... + def getSelectedIndexes(self) -> typing.MutableSequence[int]: ... + def makeVisible(self, int: int) -> None: ... + def removeAll(self) -> None: ... + def select(self, int: int) -> None: ... + def setMultipleMode(self, boolean: bool) -> None: ... + +class MenuBarPeer(MenuComponentPeer): + def addHelpMenu(self, menu: java.awt.Menu) -> None: ... + def addMenu(self, menu: java.awt.Menu) -> None: ... + def delMenu(self, int: int) -> None: ... + +class MenuItemPeer(MenuComponentPeer): + def setEnabled(self, boolean: bool) -> None: ... + def setLabel(self, string: java.lang.String | str) -> None: ... + +class ScrollbarPeer(ComponentPeer): + def setLineIncrement(self, int: int) -> None: ... + def setPageIncrement(self, int: int) -> None: ... + def setValues(self, int: int, int2: int, int3: int, int4: int) -> None: ... + +class TextComponentPeer(ComponentPeer): + def getCaretPosition(self) -> int: ... + def getInputMethodRequests(self) -> java.awt.im.InputMethodRequests: ... + def getSelectionEnd(self) -> int: ... + def getSelectionStart(self) -> int: ... + def getText(self) -> java.lang.String: ... + def select(self, int: int, int2: int) -> None: ... + def setCaretPosition(self, int: int) -> None: ... + def setEditable(self, boolean: bool) -> None: ... + def setText(self, string: java.lang.String | str) -> None: ... + +class CheckboxMenuItemPeer(MenuItemPeer): + def setState(self, boolean: bool) -> None: ... + +class MenuPeer(MenuItemPeer): + def addItem(self, menuItem: java.awt.MenuItem) -> None: ... + def delItem(self, int: int) -> None: ... + +class PanelPeer(ContainerPeer): ... + +class ScrollPanePeer(ContainerPeer): + def childResized(self, int: int, int2: int) -> None: ... + def getHScrollbarHeight(self) -> int: ... + def getVScrollbarWidth(self) -> int: ... + def setScrollPosition(self, int: int, int2: int) -> None: ... + def setUnitIncrement(self, adjustable: java.awt.Adjustable, int: int) -> None: ... + def setValue(self, adjustable: java.awt.Adjustable, int: int) -> None: ... + +class TextAreaPeer(TextComponentPeer): + @typing.overload + def getMinimumSize(self) -> java.awt.Dimension: ... + @typing.overload + def getMinimumSize(self, int: int, int2: int) -> java.awt.Dimension: ... + @typing.overload + def getPreferredSize(self) -> java.awt.Dimension: ... + @typing.overload + def getPreferredSize(self, int: int, int2: int) -> java.awt.Dimension: ... + def insert(self, string: java.lang.String | str, int: int) -> None: ... + def replaceRange( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + +class TextFieldPeer(TextComponentPeer): + @typing.overload + def getMinimumSize(self) -> java.awt.Dimension: ... + @typing.overload + def getMinimumSize(self, int: int) -> java.awt.Dimension: ... + @typing.overload + def getPreferredSize(self) -> java.awt.Dimension: ... + @typing.overload + def getPreferredSize(self, int: int) -> java.awt.Dimension: ... + def setEchoChar(self, char: str) -> None: ... + +class WindowPeer(ContainerPeer): + def getAppropriateGraphicsConfiguration( + self, graphicsConfiguration: java.awt.GraphicsConfiguration + ) -> java.awt.GraphicsConfiguration: ... + def setModalBlocked(self, dialog: java.awt.Dialog, boolean: bool) -> None: ... + def setOpacity(self, float: float) -> None: ... + def setOpaque(self, boolean: bool) -> None: ... + def toBack(self) -> None: ... + def toFront(self) -> None: ... + def updateAlwaysOnTopState(self) -> None: ... + def updateFocusableWindowState(self) -> None: ... + def updateIconImages(self) -> None: ... + def updateMinimumSize(self) -> None: ... + def updateWindow(self) -> None: ... + +class DialogPeer(WindowPeer): + def blockWindows(self, list: java.util.List[java.awt.Window]) -> None: ... + def setResizable(self, boolean: bool) -> None: ... + def setTitle(self, string: java.lang.String | str) -> None: ... + +class FramePeer(WindowPeer): + def emulateActivation(self, boolean: bool) -> None: ... + def getBoundsPrivate(self) -> java.awt.Rectangle: ... + def getState(self) -> int: ... + def setBoundsPrivate(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def setMaximizedBounds(self, rectangle: java.awt.Rectangle) -> None: ... + def setMenuBar(self, menuBar: java.awt.MenuBar) -> None: ... + def setResizable(self, boolean: bool) -> None: ... + def setState(self, int: int) -> None: ... + def setTitle(self, string: java.lang.String | str) -> None: ... + +class PopupMenuPeer(MenuPeer): + def show(self, event: java.awt.Event) -> None: ... + +class FileDialogPeer(DialogPeer): + def setDirectory(self, string: java.lang.String | str) -> None: ... + def setFile(self, string: java.lang.String | str) -> None: ... + def setFilenameFilter( + self, filenameFilter: java.io.FilenameFilter | typing.Callable + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.peer")``. + + ButtonPeer: type[ButtonPeer] + CanvasPeer: type[CanvasPeer] + CheckboxMenuItemPeer: type[CheckboxMenuItemPeer] + CheckboxPeer: type[CheckboxPeer] + ChoicePeer: type[ChoicePeer] + ComponentPeer: type[ComponentPeer] + ContainerPeer: type[ContainerPeer] + DesktopPeer: type[DesktopPeer] + DialogPeer: type[DialogPeer] + FileDialogPeer: type[FileDialogPeer] + FontPeer: type[FontPeer] + FramePeer: type[FramePeer] + KeyboardFocusManagerPeer: type[KeyboardFocusManagerPeer] + LabelPeer: type[LabelPeer] + LightweightPeer: type[LightweightPeer] + ListPeer: type[ListPeer] + MenuBarPeer: type[MenuBarPeer] + MenuComponentPeer: type[MenuComponentPeer] + MenuItemPeer: type[MenuItemPeer] + MenuPeer: type[MenuPeer] + MouseInfoPeer: type[MouseInfoPeer] + PanelPeer: type[PanelPeer] + PopupMenuPeer: type[PopupMenuPeer] + RobotPeer: type[RobotPeer] + ScrollPanePeer: type[ScrollPanePeer] + ScrollbarPeer: type[ScrollbarPeer] + SystemTrayPeer: type[SystemTrayPeer] + TaskbarPeer: type[TaskbarPeer] + TextAreaPeer: type[TextAreaPeer] + TextComponentPeer: type[TextComponentPeer] + TextFieldPeer: type[TextFieldPeer] + TrayIconPeer: type[TrayIconPeer] + WindowPeer: type[WindowPeer] diff --git a/typings/java/awt/print_/__init__.pyi b/typings/java/awt/print_/__init__.pyi new file mode 100644 index 0000000..ec18fe0 --- /dev/null +++ b/typings/java/awt/print_/__init__.pyi @@ -0,0 +1,158 @@ +import typing +from typing import Protocol + +import java +import java.awt +import java.io +import java.lang +import javax.print_ +import javax.print_.attribute + +class Book(java.awt.print_.Pageable): + def __init__(self): ... + @typing.overload + def append( + self, printable: Printable | typing.Callable, pageFormat: PageFormat + ) -> None: ... + @typing.overload + def append( + self, printable: Printable | typing.Callable, pageFormat: PageFormat, int: int + ) -> None: ... + def getNumberOfPages(self) -> int: ... + def getPageFormat(self, int: int) -> PageFormat: ... + def getPrintable(self, int: int) -> Printable: ... + def setPage( + self, int: int, printable: Printable | typing.Callable, pageFormat: PageFormat + ) -> None: ... + +class PageFormat(java.lang.Cloneable): + LANDSCAPE: typing.ClassVar[int] = ... + PORTRAIT: typing.ClassVar[int] = ... + REVERSE_LANDSCAPE: typing.ClassVar[int] = ... + def __init__(self): ... + def clone(self) -> typing.Any: ... + def getHeight(self) -> float: ... + def getImageableHeight(self) -> float: ... + def getImageableWidth(self) -> float: ... + def getImageableX(self) -> float: ... + def getImageableY(self) -> float: ... + def getMatrix(self) -> typing.MutableSequence[float]: ... + def getOrientation(self) -> int: ... + def getPaper(self) -> Paper: ... + def getWidth(self) -> float: ... + def setOrientation(self, int: int) -> None: ... + def setPaper(self, paper: Paper) -> None: ... + +class Pageable: + UNKNOWN_NUMBER_OF_PAGES: typing.ClassVar[int] = ... + def getNumberOfPages(self) -> int: ... + def getPageFormat(self, int: int) -> PageFormat: ... + def getPrintable(self, int: int) -> Printable: ... + +class Paper(java.lang.Cloneable): + def __init__(self): ... + def clone(self) -> typing.Any: ... + def getHeight(self) -> float: ... + def getImageableHeight(self) -> float: ... + def getImageableWidth(self) -> float: ... + def getImageableX(self) -> float: ... + def getImageableY(self) -> float: ... + def getWidth(self) -> float: ... + def setImageableArea( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... + def setSize(self, double: float, double2: float) -> None: ... + +class Printable: + PAGE_EXISTS: typing.ClassVar[int] = ... + NO_SUCH_PAGE: typing.ClassVar[int] = ... + def print_( + self, graphics: java.awt.Graphics, pageFormat: PageFormat, int: int + ) -> int: ... + +class PrinterAbortException(java.awt.print_.PrinterException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class PrinterException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class PrinterGraphics: + def getPrinterJob(self) -> PrinterJob: ... + +class PrinterIOException(PrinterException): + def __init__(self, iOException: java.io.IOException): ... + def getCause(self) -> java.lang.Throwable: ... + def getIOException(self) -> java.io.IOException: ... + +class PrinterJob: + def __init__(self): ... + def cancel(self) -> None: ... + @typing.overload + def defaultPage(self, pageFormat: PageFormat) -> PageFormat: ... + @typing.overload + def defaultPage(self) -> PageFormat: ... + def getCopies(self) -> int: ... + def getJobName(self) -> java.lang.String: ... + def getPageFormat( + self, printRequestAttributeSet: javax.print_.attribute.PrintRequestAttributeSet + ) -> PageFormat: ... + def getPrintService(self) -> javax.print_.PrintService: ... + @staticmethod + def getPrinterJob() -> PrinterJob: ... + def getUserName(self) -> java.lang.String: ... + def isCancelled(self) -> bool: ... + @staticmethod + def lookupPrintServices() -> typing.MutableSequence[javax.print_.PrintService]: ... + @staticmethod + def lookupStreamPrintServices( + string: java.lang.String | str, + ) -> typing.MutableSequence[javax.print_.StreamPrintServiceFactory]: ... + @typing.overload + def pageDialog(self, pageFormat: PageFormat) -> PageFormat: ... + @typing.overload + def pageDialog( + self, printRequestAttributeSet: javax.print_.attribute.PrintRequestAttributeSet + ) -> PageFormat: ... + @typing.overload + def printDialog(self) -> bool: ... + @typing.overload + def printDialog( + self, printRequestAttributeSet: javax.print_.attribute.PrintRequestAttributeSet + ) -> bool: ... + @typing.overload + def print_(self) -> None: ... + @typing.overload + def print_( + self, printRequestAttributeSet: javax.print_.attribute.PrintRequestAttributeSet + ) -> None: ... + def setCopies(self, int: int) -> None: ... + def setJobName(self, string: java.lang.String | str) -> None: ... + def setPageable(self, pageable: Pageable) -> None: ... + def setPrintService(self, printService: javax.print_.PrintService) -> None: ... + @typing.overload + def setPrintable(self, printable: Printable | typing.Callable) -> None: ... + @typing.overload + def setPrintable( + self, printable: Printable | typing.Callable, pageFormat: PageFormat + ) -> None: ... + def validatePage(self, pageFormat: PageFormat) -> PageFormat: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.awt.print_")``. + + Book: type[Book] + PageFormat: type[PageFormat] + Pageable: type[Pageable] + Paper: type[Paper] + Printable: type[Printable] + PrinterAbortException: type[PrinterAbortException] + PrinterException: type[PrinterException] + PrinterGraphics: type[PrinterGraphics] + PrinterIOException: type[PrinterIOException] + PrinterJob: type[PrinterJob] diff --git a/typings/java/beans/__init__.pyi b/typings/java/beans/__init__.pyi new file mode 100644 index 0000000..f282c2d --- /dev/null +++ b/typings/java/beans/__init__.pyi @@ -0,0 +1,787 @@ +import typing +from typing import Protocol + +import java.applet +import java.awt +import java.beans.beancontext +import java.io +import java.lang +import java.lang.annotation +import java.lang.reflect +import java.util +import jpype +import org.xml.sax +import org.xml.sax.helpers + +class AppletInitializer: + def activate(self, applet: java.applet.Applet) -> None: ... + def initialize( + self, + applet: java.applet.Applet, + beanContext: java.beans.beancontext.BeanContext, + ) -> None: ... + +class BeanInfo: + ICON_COLOR_16x16: typing.ClassVar[int] = ... + ICON_COLOR_32x32: typing.ClassVar[int] = ... + ICON_MONO_16x16: typing.ClassVar[int] = ... + ICON_MONO_32x32: typing.ClassVar[int] = ... + def getAdditionalBeanInfo(self) -> typing.MutableSequence[BeanInfo]: ... + def getBeanDescriptor(self) -> BeanDescriptor: ... + def getDefaultEventIndex(self) -> int: ... + def getDefaultPropertyIndex(self) -> int: ... + def getEventSetDescriptors(self) -> typing.MutableSequence[EventSetDescriptor]: ... + def getIcon(self, int: int) -> java.awt.Image: ... + def getMethodDescriptors(self) -> typing.MutableSequence[MethodDescriptor]: ... + def getPropertyDescriptors(self) -> typing.MutableSequence[PropertyDescriptor]: ... + +class BeanProperty(java.lang.annotation.Annotation): + def bound(self) -> bool: ... + def description(self) -> java.lang.String: ... + def enumerationValues(self) -> typing.MutableSequence[java.lang.String]: ... + def equals(self, object: typing.Any) -> bool: ... + def expert(self) -> bool: ... + def hashCode(self) -> int: ... + def hidden(self) -> bool: ... + def preferred(self) -> bool: ... + def required(self) -> bool: ... + def toString(self) -> java.lang.String: ... + def visualUpdate(self) -> bool: ... + +class Beans: + def __init__(self): ... + @staticmethod + def getInstanceOf(object: typing.Any, class_: type[typing.Any]) -> typing.Any: ... + @typing.overload + @staticmethod + def instantiate( + classLoader: java.lang.ClassLoader, string: java.lang.String | str + ) -> typing.Any: ... + @typing.overload + @staticmethod + def instantiate( + classLoader: java.lang.ClassLoader, + string: java.lang.String | str, + beanContext: java.beans.beancontext.BeanContext, + ) -> typing.Any: ... + @typing.overload + @staticmethod + def instantiate( + classLoader: java.lang.ClassLoader, + string: java.lang.String | str, + beanContext: java.beans.beancontext.BeanContext, + appletInitializer: AppletInitializer, + ) -> typing.Any: ... + @staticmethod + def isDesignTime() -> bool: ... + @staticmethod + def isGuiAvailable() -> bool: ... + @staticmethod + def isInstanceOf(object: typing.Any, class_: type[typing.Any]) -> bool: ... + @staticmethod + def setDesignTime(boolean: bool) -> None: ... + @staticmethod + def setGuiAvailable(boolean: bool) -> None: ... + +class ConstructorProperties(java.lang.annotation.Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def value(self) -> typing.MutableSequence[java.lang.String]: ... + +class Customizer: + def addPropertyChangeListener( + self, propertyChangeListener: PropertyChangeListener | typing.Callable + ) -> None: ... + def removePropertyChangeListener( + self, propertyChangeListener: PropertyChangeListener | typing.Callable + ) -> None: ... + def setObject(self, object: typing.Any) -> None: ... + +class DesignMode: + PROPERTYNAME: typing.ClassVar[java.lang.String] = ... + def isDesignTime(self) -> bool: ... + def setDesignTime(self, boolean: bool) -> None: ... + +class Encoder: + def __init__(self): ... + def get(self, object: typing.Any) -> typing.Any: ... + def getExceptionListener(self) -> ExceptionListener: ... + def getPersistenceDelegate( + self, class_: type[typing.Any] + ) -> PersistenceDelegate: ... + def remove(self, object: typing.Any) -> typing.Any: ... + def setExceptionListener( + self, exceptionListener: ExceptionListener | typing.Callable + ) -> None: ... + def setPersistenceDelegate( + self, class_: type[typing.Any], persistenceDelegate: PersistenceDelegate + ) -> None: ... + def writeExpression(self, expression: Expression) -> None: ... + def writeStatement(self, statement: Statement) -> None: ... + +class EventHandler(java.lang.reflect.InvocationHandler): + def __init__( + self, + object: typing.Any, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + _create_0__T = typing.TypeVar("_create_0__T") # + _create_1__T = typing.TypeVar("_create_1__T") # + _create_2__T = typing.TypeVar("_create_2__T") # + @typing.overload + @staticmethod + def create( + class_: type[_create_0__T], object: typing.Any, string: java.lang.String | str + ) -> _create_0__T: ... + @typing.overload + @staticmethod + def create( + class_: type[_create_1__T], + object: typing.Any, + string: java.lang.String | str, + string2: java.lang.String | str, + ) -> _create_1__T: ... + @typing.overload + @staticmethod + def create( + class_: type[_create_2__T], + object: typing.Any, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> _create_2__T: ... + def getAction(self) -> java.lang.String: ... + def getEventPropertyName(self) -> java.lang.String: ... + def getListenerMethodName(self) -> java.lang.String: ... + def getTarget(self) -> typing.Any: ... + def invoke( + self, + object: typing.Any, + method: java.lang.reflect.Method, + objectArray: list[typing.Any] | jpype.JArray, + ) -> typing.Any: ... + +class ExceptionListener: + def exceptionThrown(self, exception: java.lang.Exception) -> None: ... + +class FeatureDescriptor: + def __init__(self): ... + def attributeNames(self) -> java.util.Enumeration[java.lang.String]: ... + def getDisplayName(self) -> java.lang.String: ... + def getName(self) -> java.lang.String: ... + def getShortDescription(self) -> java.lang.String: ... + def getValue(self, string: java.lang.String | str) -> typing.Any: ... + def isExpert(self) -> bool: ... + def isHidden(self) -> bool: ... + def isPreferred(self) -> bool: ... + def setDisplayName(self, string: java.lang.String | str) -> None: ... + def setExpert(self, boolean: bool) -> None: ... + def setHidden(self, boolean: bool) -> None: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setPreferred(self, boolean: bool) -> None: ... + def setShortDescription(self, string: java.lang.String | str) -> None: ... + def setValue(self, string: java.lang.String | str, object: typing.Any) -> None: ... + def toString(self) -> java.lang.String: ... + +class IntrospectionException(java.lang.Exception): + def __init__(self, string: java.lang.String | str): ... + +class Introspector: + USE_ALL_BEANINFO: typing.ClassVar[int] = ... + IGNORE_IMMEDIATE_BEANINFO: typing.ClassVar[int] = ... + IGNORE_ALL_BEANINFO: typing.ClassVar[int] = ... + @staticmethod + def decapitalize(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def flushCaches() -> None: ... + @staticmethod + def flushFromCaches(class_: type[typing.Any]) -> None: ... + @typing.overload + @staticmethod + def getBeanInfo(class_: type[typing.Any]) -> BeanInfo: ... + @typing.overload + @staticmethod + def getBeanInfo(class_: type[typing.Any], int: int) -> BeanInfo: ... + @typing.overload + @staticmethod + def getBeanInfo(class_: type[typing.Any], class2: type[typing.Any]) -> BeanInfo: ... + @typing.overload + @staticmethod + def getBeanInfo( + class_: type[typing.Any], class2: type[typing.Any], int: int + ) -> BeanInfo: ... + @staticmethod + def getBeanInfoSearchPath() -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def setBeanInfoSearchPath( + stringArray: list[java.lang.String] | jpype.JArray, + ) -> None: ... + +class JavaBean(java.lang.annotation.Annotation): + def defaultEventSet(self) -> java.lang.String: ... + def defaultProperty(self) -> java.lang.String: ... + def description(self) -> java.lang.String: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class PersistenceDelegate: + def writeObject(self, object: typing.Any, encoder: Encoder) -> None: ... + +class PropertyChangeEvent(java.util.EventObject): + def __init__( + self, + object: typing.Any, + string: java.lang.String | str, + object2: typing.Any, + object3: typing.Any, + ): ... + def getNewValue(self) -> typing.Any: ... + def getOldValue(self) -> typing.Any: ... + def getPropagationId(self) -> typing.Any: ... + def getPropertyName(self) -> java.lang.String: ... + def setPropagationId(self, object: typing.Any) -> None: ... + def toString(self) -> java.lang.String: ... + +class PropertyChangeListener(java.util.EventListener): + def propertyChange(self, propertyChangeEvent: PropertyChangeEvent) -> None: ... + +class PropertyChangeSupport(java.io.Serializable): + def __init__(self, object: typing.Any): ... + @typing.overload + def addPropertyChangeListener( + self, propertyChangeListener: PropertyChangeListener | typing.Callable + ) -> None: ... + @typing.overload + def addPropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: PropertyChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def fireIndexedPropertyChange( + self, string: java.lang.String | str, int: int, boolean: bool, boolean2: bool + ) -> None: ... + @typing.overload + def fireIndexedPropertyChange( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + @typing.overload + def fireIndexedPropertyChange( + self, + string: java.lang.String | str, + int: int, + object: typing.Any, + object2: typing.Any, + ) -> None: ... + @typing.overload + def firePropertyChange(self, propertyChangeEvent: PropertyChangeEvent) -> None: ... + @typing.overload + def firePropertyChange( + self, string: java.lang.String | str, boolean: bool, boolean2: bool + ) -> None: ... + @typing.overload + def firePropertyChange( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + @typing.overload + def firePropertyChange( + self, string: java.lang.String | str, object: typing.Any, object2: typing.Any + ) -> None: ... + @typing.overload + def getPropertyChangeListeners( + self, + ) -> typing.MutableSequence[PropertyChangeListener]: ... + @typing.overload + def getPropertyChangeListeners( + self, string: java.lang.String | str + ) -> typing.MutableSequence[PropertyChangeListener]: ... + def hasListeners(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def removePropertyChangeListener( + self, propertyChangeListener: PropertyChangeListener | typing.Callable + ) -> None: ... + @typing.overload + def removePropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: PropertyChangeListener | typing.Callable, + ) -> None: ... + +class PropertyEditor: + def addPropertyChangeListener( + self, propertyChangeListener: PropertyChangeListener | typing.Callable + ) -> None: ... + def getAsText(self) -> java.lang.String: ... + def getCustomEditor(self) -> java.awt.Component: ... + def getJavaInitializationString(self) -> java.lang.String: ... + def getTags(self) -> typing.MutableSequence[java.lang.String]: ... + def getValue(self) -> typing.Any: ... + def isPaintable(self) -> bool: ... + def paintValue( + self, graphics: java.awt.Graphics, rectangle: java.awt.Rectangle + ) -> None: ... + def removePropertyChangeListener( + self, propertyChangeListener: PropertyChangeListener | typing.Callable + ) -> None: ... + def setAsText(self, string: java.lang.String | str) -> None: ... + def setValue(self, object: typing.Any) -> None: ... + def supportsCustomEditor(self) -> bool: ... + +class PropertyEditorManager: + def __init__(self): ... + @staticmethod + def findEditor(class_: type[typing.Any]) -> PropertyEditor: ... + @staticmethod + def getEditorSearchPath() -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def registerEditor(class_: type[typing.Any], class2: type[typing.Any]) -> None: ... + @staticmethod + def setEditorSearchPath( + stringArray: list[java.lang.String] | jpype.JArray, + ) -> None: ... + +class PropertyVetoException(java.lang.Exception): + def __init__( + self, string: java.lang.String | str, propertyChangeEvent: PropertyChangeEvent + ): ... + def getPropertyChangeEvent(self) -> PropertyChangeEvent: ... + +class Statement: + def __init__( + self, + object: typing.Any, + string: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ): ... + def execute(self) -> None: ... + def getArguments(self) -> typing.MutableSequence[typing.Any]: ... + def getMethodName(self) -> java.lang.String: ... + def getTarget(self) -> typing.Any: ... + def toString(self) -> java.lang.String: ... + +class Transient(java.lang.annotation.Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def value(self) -> bool: ... + +class VetoableChangeListener(java.util.EventListener): + def vetoableChange(self, propertyChangeEvent: PropertyChangeEvent) -> None: ... + +class VetoableChangeSupport(java.io.Serializable): + def __init__(self, object: typing.Any): ... + @typing.overload + def addVetoableChangeListener( + self, vetoableChangeListener: VetoableChangeListener | typing.Callable + ) -> None: ... + @typing.overload + def addVetoableChangeListener( + self, + string: java.lang.String | str, + vetoableChangeListener: VetoableChangeListener | typing.Callable, + ) -> None: ... + @typing.overload + def fireVetoableChange(self, propertyChangeEvent: PropertyChangeEvent) -> None: ... + @typing.overload + def fireVetoableChange( + self, string: java.lang.String | str, boolean: bool, boolean2: bool + ) -> None: ... + @typing.overload + def fireVetoableChange( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + @typing.overload + def fireVetoableChange( + self, string: java.lang.String | str, object: typing.Any, object2: typing.Any + ) -> None: ... + @typing.overload + def getVetoableChangeListeners( + self, + ) -> typing.MutableSequence[VetoableChangeListener]: ... + @typing.overload + def getVetoableChangeListeners( + self, string: java.lang.String | str + ) -> typing.MutableSequence[VetoableChangeListener]: ... + def hasListeners(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def removeVetoableChangeListener( + self, vetoableChangeListener: VetoableChangeListener | typing.Callable + ) -> None: ... + @typing.overload + def removeVetoableChangeListener( + self, + string: java.lang.String | str, + vetoableChangeListener: VetoableChangeListener | typing.Callable, + ) -> None: ... + +class Visibility: + def avoidingGui(self) -> bool: ... + def dontUseGui(self) -> None: ... + def needsGui(self) -> bool: ... + def okToUseGui(self) -> None: ... + +class XMLDecoder(java.lang.AutoCloseable): + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + @typing.overload + def __init__(self, inputStream: java.io.InputStream, object: typing.Any): ... + @typing.overload + def __init__( + self, + inputStream: java.io.InputStream, + object: typing.Any, + exceptionListener: ExceptionListener | typing.Callable, + ): ... + @typing.overload + def __init__( + self, + inputStream: java.io.InputStream, + object: typing.Any, + exceptionListener: ExceptionListener | typing.Callable, + classLoader: java.lang.ClassLoader, + ): ... + @typing.overload + def __init__(self, inputSource: org.xml.sax.InputSource): ... + def close(self) -> None: ... + @staticmethod + def createHandler( + object: typing.Any, + exceptionListener: ExceptionListener | typing.Callable, + classLoader: java.lang.ClassLoader, + ) -> org.xml.sax.helpers.DefaultHandler: ... + def getExceptionListener(self) -> ExceptionListener: ... + def getOwner(self) -> typing.Any: ... + def readObject(self) -> typing.Any: ... + def setExceptionListener( + self, exceptionListener: ExceptionListener | typing.Callable + ) -> None: ... + def setOwner(self, object: typing.Any) -> None: ... + +class BeanDescriptor(FeatureDescriptor): + @typing.overload + def __init__(self, class_: type[typing.Any]): ... + @typing.overload + def __init__(self, class_: type[typing.Any], class2: type[typing.Any]): ... + def getBeanClass(self) -> type[typing.Any]: ... + def getCustomizerClass(self) -> type[typing.Any]: ... + +class DefaultPersistenceDelegate(PersistenceDelegate): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, stringArray: list[java.lang.String] | jpype.JArray): ... + +class EventSetDescriptor(FeatureDescriptor): + @typing.overload + def __init__( + self, + class_: type[typing.Any], + string: java.lang.String | str, + class2: type[typing.Any], + string2: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + class_: type[typing.Any], + string: java.lang.String | str, + class2: type[typing.Any], + stringArray: list[java.lang.String] | jpype.JArray, + string3: java.lang.String | str, + string4: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + class_: type[typing.Any], + string: java.lang.String | str, + class2: type[typing.Any], + stringArray: list[java.lang.String] | jpype.JArray, + string3: java.lang.String | str, + string4: java.lang.String | str, + string5: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + class_: type[typing.Any], + methodDescriptorArray: list[MethodDescriptor] | jpype.JArray, + method2: java.lang.reflect.Method, + method3: java.lang.reflect.Method, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + class_: type[typing.Any], + methodArray: list[java.lang.reflect.Method] | jpype.JArray, + method2: java.lang.reflect.Method, + method3: java.lang.reflect.Method, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + class_: type[typing.Any], + methodArray: list[java.lang.reflect.Method] | jpype.JArray, + method2: java.lang.reflect.Method, + method3: java.lang.reflect.Method, + method4: java.lang.reflect.Method, + ): ... + def getAddListenerMethod(self) -> java.lang.reflect.Method: ... + def getGetListenerMethod(self) -> java.lang.reflect.Method: ... + def getListenerMethodDescriptors( + self, + ) -> typing.MutableSequence[MethodDescriptor]: ... + def getListenerMethods( + self, + ) -> typing.MutableSequence[java.lang.reflect.Method]: ... + def getListenerType(self) -> type[typing.Any]: ... + def getRemoveListenerMethod(self) -> java.lang.reflect.Method: ... + def isInDefaultEventSet(self) -> bool: ... + def isUnicast(self) -> bool: ... + def setInDefaultEventSet(self, boolean: bool) -> None: ... + def setUnicast(self, boolean: bool) -> None: ... + +class Expression(Statement): + @typing.overload + def __init__( + self, + object: typing.Any, + object2: typing.Any, + string: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + object: typing.Any, + string: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ): ... + def execute(self) -> None: ... + def getValue(self) -> typing.Any: ... + def setValue(self, object: typing.Any) -> None: ... + def toString(self) -> java.lang.String: ... + +class IndexedPropertyChangeEvent(PropertyChangeEvent): + def __init__( + self, + object: typing.Any, + string: java.lang.String | str, + object2: typing.Any, + object3: typing.Any, + int: int, + ): ... + def getIndex(self) -> int: ... + +class MethodDescriptor(FeatureDescriptor): + @typing.overload + def __init__(self, method: java.lang.reflect.Method): ... + @typing.overload + def __init__( + self, + method: java.lang.reflect.Method, + parameterDescriptorArray: list[ParameterDescriptor] | jpype.JArray, + ): ... + def getMethod(self) -> java.lang.reflect.Method: ... + def getParameterDescriptors( + self, + ) -> typing.MutableSequence[ParameterDescriptor]: ... + +class ParameterDescriptor(FeatureDescriptor): + def __init__(self): ... + +class PropertyChangeListenerProxy( + java.util.EventListenerProxy[PropertyChangeListener], PropertyChangeListener +): + def __init__( + self, + string: java.lang.String | str, + propertyChangeListener: PropertyChangeListener | typing.Callable, + ): ... + def getPropertyName(self) -> java.lang.String: ... + def propertyChange(self, propertyChangeEvent: PropertyChangeEvent) -> None: ... + +class PropertyDescriptor(FeatureDescriptor): + @typing.overload + def __init__(self, string: java.lang.String | str, class_: type[typing.Any]): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + class_: type[typing.Any], + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + method: java.lang.reflect.Method, + method2: java.lang.reflect.Method, + ): ... + def createPropertyEditor(self, object: typing.Any) -> PropertyEditor: ... + def equals(self, object: typing.Any) -> bool: ... + def getPropertyEditorClass(self) -> type[typing.Any]: ... + def getPropertyType(self) -> type[typing.Any]: ... + def getReadMethod(self) -> java.lang.reflect.Method: ... + def getWriteMethod(self) -> java.lang.reflect.Method: ... + def hashCode(self) -> int: ... + def isBound(self) -> bool: ... + def isConstrained(self) -> bool: ... + def setBound(self, boolean: bool) -> None: ... + def setConstrained(self, boolean: bool) -> None: ... + def setPropertyEditorClass(self, class_: type[typing.Any]) -> None: ... + def setReadMethod(self, method: java.lang.reflect.Method) -> None: ... + def setWriteMethod(self, method: java.lang.reflect.Method) -> None: ... + +class PropertyEditorSupport(PropertyEditor): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, object: typing.Any): ... + def addPropertyChangeListener( + self, propertyChangeListener: PropertyChangeListener | typing.Callable + ) -> None: ... + def firePropertyChange(self) -> None: ... + def getAsText(self) -> java.lang.String: ... + def getCustomEditor(self) -> java.awt.Component: ... + def getJavaInitializationString(self) -> java.lang.String: ... + def getSource(self) -> typing.Any: ... + def getTags(self) -> typing.MutableSequence[java.lang.String]: ... + def getValue(self) -> typing.Any: ... + def isPaintable(self) -> bool: ... + def paintValue( + self, graphics: java.awt.Graphics, rectangle: java.awt.Rectangle + ) -> None: ... + def removePropertyChangeListener( + self, propertyChangeListener: PropertyChangeListener | typing.Callable + ) -> None: ... + def setAsText(self, string: java.lang.String | str) -> None: ... + def setSource(self, object: typing.Any) -> None: ... + def setValue(self, object: typing.Any) -> None: ... + def supportsCustomEditor(self) -> bool: ... + +class SimpleBeanInfo(BeanInfo): + def __init__(self): ... + def getAdditionalBeanInfo(self) -> typing.MutableSequence[BeanInfo]: ... + def getBeanDescriptor(self) -> BeanDescriptor: ... + def getDefaultEventIndex(self) -> int: ... + def getDefaultPropertyIndex(self) -> int: ... + def getEventSetDescriptors(self) -> typing.MutableSequence[EventSetDescriptor]: ... + def getIcon(self, int: int) -> java.awt.Image: ... + def getMethodDescriptors(self) -> typing.MutableSequence[MethodDescriptor]: ... + def getPropertyDescriptors(self) -> typing.MutableSequence[PropertyDescriptor]: ... + def loadImage(self, string: java.lang.String | str) -> java.awt.Image: ... + +class VetoableChangeListenerProxy( + java.util.EventListenerProxy[VetoableChangeListener], VetoableChangeListener +): + def __init__( + self, + string: java.lang.String | str, + vetoableChangeListener: VetoableChangeListener | typing.Callable, + ): ... + def getPropertyName(self) -> java.lang.String: ... + def vetoableChange(self, propertyChangeEvent: PropertyChangeEvent) -> None: ... + +class XMLEncoder(Encoder, java.lang.AutoCloseable): + @typing.overload + def __init__(self, outputStream: java.io.OutputStream): ... + @typing.overload + def __init__( + self, + outputStream: java.io.OutputStream, + string: java.lang.String | str, + boolean: bool, + int: int, + ): ... + def close(self) -> None: ... + def flush(self) -> None: ... + def getOwner(self) -> typing.Any: ... + def setOwner(self, object: typing.Any) -> None: ... + def writeExpression(self, expression: Expression) -> None: ... + def writeObject(self, object: typing.Any) -> None: ... + def writeStatement(self, statement: Statement) -> None: ... + +class IndexedPropertyDescriptor(PropertyDescriptor): + @typing.overload + def __init__(self, string: java.lang.String | str, class_: type[typing.Any]): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + class_: type[typing.Any], + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + string5: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + method: java.lang.reflect.Method, + method2: java.lang.reflect.Method, + method3: java.lang.reflect.Method, + method4: java.lang.reflect.Method, + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getIndexedPropertyType(self) -> type[typing.Any]: ... + def getIndexedReadMethod(self) -> java.lang.reflect.Method: ... + def getIndexedWriteMethod(self) -> java.lang.reflect.Method: ... + def hashCode(self) -> int: ... + def setIndexedReadMethod(self, method: java.lang.reflect.Method) -> None: ... + def setIndexedWriteMethod(self, method: java.lang.reflect.Method) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.beans")``. + + AppletInitializer: type[AppletInitializer] + BeanDescriptor: type[BeanDescriptor] + BeanInfo: type[BeanInfo] + BeanProperty: type[BeanProperty] + Beans: type[Beans] + ConstructorProperties: type[ConstructorProperties] + Customizer: type[Customizer] + DefaultPersistenceDelegate: type[DefaultPersistenceDelegate] + DesignMode: type[DesignMode] + Encoder: type[Encoder] + EventHandler: type[EventHandler] + EventSetDescriptor: type[EventSetDescriptor] + ExceptionListener: type[ExceptionListener] + Expression: type[Expression] + FeatureDescriptor: type[FeatureDescriptor] + IndexedPropertyChangeEvent: type[IndexedPropertyChangeEvent] + IndexedPropertyDescriptor: type[IndexedPropertyDescriptor] + IntrospectionException: type[IntrospectionException] + Introspector: type[Introspector] + JavaBean: type[JavaBean] + MethodDescriptor: type[MethodDescriptor] + ParameterDescriptor: type[ParameterDescriptor] + PersistenceDelegate: type[PersistenceDelegate] + PropertyChangeEvent: type[PropertyChangeEvent] + PropertyChangeListener: type[PropertyChangeListener] + PropertyChangeListenerProxy: type[PropertyChangeListenerProxy] + PropertyChangeSupport: type[PropertyChangeSupport] + PropertyDescriptor: type[PropertyDescriptor] + PropertyEditor: type[PropertyEditor] + PropertyEditorManager: type[PropertyEditorManager] + PropertyEditorSupport: type[PropertyEditorSupport] + PropertyVetoException: type[PropertyVetoException] + SimpleBeanInfo: type[SimpleBeanInfo] + Statement: type[Statement] + Transient: type[Transient] + VetoableChangeListener: type[VetoableChangeListener] + VetoableChangeListenerProxy: type[VetoableChangeListenerProxy] + VetoableChangeSupport: type[VetoableChangeSupport] + Visibility: type[Visibility] + XMLDecoder: type[XMLDecoder] + XMLEncoder: type[XMLEncoder] + beancontext: java.beans.beancontext.__module_protocol__ diff --git a/typings/java/beans/beancontext/__init__.pyi b/typings/java/beans/beancontext/__init__.pyi new file mode 100644 index 0000000..972807f --- /dev/null +++ b/typings/java/beans/beancontext/__init__.pyi @@ -0,0 +1,414 @@ +import typing +from typing import Protocol + +import java.awt +import java.beans +import java.io +import java.lang +import java.net +import java.util +import java.util.function +import jpype + +class BeanContextChild: + def addPropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def addVetoableChangeListener( + self, + string: java.lang.String | str, + vetoableChangeListener: java.beans.VetoableChangeListener | typing.Callable, + ) -> None: ... + def getBeanContext(self) -> BeanContext: ... + def removePropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def removeVetoableChangeListener( + self, + string: java.lang.String | str, + vetoableChangeListener: java.beans.VetoableChangeListener | typing.Callable, + ) -> None: ... + def setBeanContext(self, beanContext: BeanContext) -> None: ... + +class BeanContextChildComponentProxy: + def getComponent(self) -> java.awt.Component: ... + +class BeanContextContainerProxy: + def getContainer(self) -> java.awt.Container: ... + +class BeanContextEvent(java.util.EventObject): + def getBeanContext(self) -> BeanContext: ... + def getPropagatedFrom(self) -> BeanContext: ... + def isPropagated(self) -> bool: ... + def setPropagatedFrom(self, beanContext: BeanContext) -> None: ... + +class BeanContextMembershipListener(java.util.EventListener): + def childrenAdded( + self, beanContextMembershipEvent: BeanContextMembershipEvent + ) -> None: ... + def childrenRemoved( + self, beanContextMembershipEvent: BeanContextMembershipEvent + ) -> None: ... + +class BeanContextProxy: + def getBeanContextProxy(self) -> BeanContextChild: ... + +class BeanContextServiceProvider: + def getCurrentServiceSelectors( + self, beanContextServices: BeanContextServices, class_: type[typing.Any] + ) -> java.util.Iterator[typing.Any]: ... + def getService( + self, + beanContextServices: BeanContextServices, + object: typing.Any, + class_: type[typing.Any], + object2: typing.Any, + ) -> typing.Any: ... + def releaseService( + self, + beanContextServices: BeanContextServices, + object: typing.Any, + object2: typing.Any, + ) -> None: ... + +class BeanContextServiceProviderBeanInfo(java.beans.BeanInfo): + def getServicesBeanInfo(self) -> typing.MutableSequence[java.beans.BeanInfo]: ... + +class BeanContextServiceRevokedListener(java.util.EventListener): + def serviceRevoked( + self, beanContextServiceRevokedEvent: BeanContextServiceRevokedEvent + ) -> None: ... + +class BeanContext( + BeanContextChild, java.util.Collection, java.beans.DesignMode, java.beans.Visibility +): + globalHierarchyLock: typing.ClassVar[typing.Any] = ... + def addBeanContextMembershipListener( + self, beanContextMembershipListener: BeanContextMembershipListener + ) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getResource( + self, string: java.lang.String | str, beanContextChild: BeanContextChild + ) -> java.net.URL: ... + def getResourceAsStream( + self, string: java.lang.String | str, beanContextChild: BeanContextChild + ) -> java.io.InputStream: ... + def hashCode(self) -> int: ... + def instantiateChild(self, string: java.lang.String | str) -> typing.Any: ... + def removeBeanContextMembershipListener( + self, beanContextMembershipListener: BeanContextMembershipListener + ) -> None: ... + +class BeanContextMembershipEvent(BeanContextEvent): + @typing.overload + def __init__( + self, beanContext: BeanContext, objectArray: list[typing.Any] | jpype.JArray + ): ... + @typing.overload + def __init__( + self, + beanContext: BeanContext, + collection: java.util.Collection | typing.Sequence | set, + ): ... + def contains(self, object: typing.Any) -> bool: ... + def iterator(self) -> java.util.Iterator: ... + def size(self) -> int: ... + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + +class BeanContextServiceAvailableEvent(BeanContextEvent): + def __init__( + self, beanContextServices: BeanContextServices, class_: type[typing.Any] + ): ... + def getCurrentServiceSelectors(self) -> java.util.Iterator[typing.Any]: ... + def getServiceClass(self) -> type[typing.Any]: ... + def getSourceAsBeanContextServices(self) -> BeanContextServices: ... + +class BeanContextServiceRevokedEvent(BeanContextEvent): + def __init__( + self, + beanContextServices: BeanContextServices, + class_: type[typing.Any], + boolean: bool, + ): ... + def getServiceClass(self) -> type[typing.Any]: ... + def getSourceAsBeanContextServices(self) -> BeanContextServices: ... + def isCurrentServiceInvalidNow(self) -> bool: ... + def isServiceClass(self, class_: type[typing.Any]) -> bool: ... + +class BeanContextServicesListener(BeanContextServiceRevokedListener): + def serviceAvailable( + self, beanContextServiceAvailableEvent: BeanContextServiceAvailableEvent + ) -> None: ... + +class BeanContextChildSupport( + BeanContextChild, BeanContextServicesListener, java.io.Serializable +): + beanContextChildPeer: BeanContextChild = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, beanContextChild: BeanContextChild): ... + def addPropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def addVetoableChangeListener( + self, + string: java.lang.String | str, + vetoableChangeListener: java.beans.VetoableChangeListener | typing.Callable, + ) -> None: ... + def firePropertyChange( + self, string: java.lang.String | str, object: typing.Any, object2: typing.Any + ) -> None: ... + def fireVetoableChange( + self, string: java.lang.String | str, object: typing.Any, object2: typing.Any + ) -> None: ... + def getBeanContext(self) -> BeanContext: ... + def getBeanContextChildPeer(self) -> BeanContextChild: ... + def isDelegated(self) -> bool: ... + def removePropertyChangeListener( + self, + string: java.lang.String | str, + propertyChangeListener: java.beans.PropertyChangeListener | typing.Callable, + ) -> None: ... + def removeVetoableChangeListener( + self, + string: java.lang.String | str, + vetoableChangeListener: java.beans.VetoableChangeListener | typing.Callable, + ) -> None: ... + def serviceAvailable( + self, beanContextServiceAvailableEvent: BeanContextServiceAvailableEvent + ) -> None: ... + def serviceRevoked( + self, beanContextServiceRevokedEvent: BeanContextServiceRevokedEvent + ) -> None: ... + def setBeanContext(self, beanContext: BeanContext) -> None: ... + def validatePendingSetBeanContext(self, beanContext: BeanContext) -> bool: ... + +class BeanContextServices(BeanContext, BeanContextServicesListener): + def addBeanContextServicesListener( + self, beanContextServicesListener: BeanContextServicesListener + ) -> None: ... + def addService( + self, + class_: type[typing.Any], + beanContextServiceProvider: BeanContextServiceProvider, + ) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def getCurrentServiceClasses(self) -> java.util.Iterator[typing.Any]: ... + def getCurrentServiceSelectors( + self, class_: type[typing.Any] + ) -> java.util.Iterator[typing.Any]: ... + def getService( + self, + beanContextChild: BeanContextChild, + object: typing.Any, + class_: type[typing.Any], + object2: typing.Any, + beanContextServiceRevokedListener: BeanContextServiceRevokedListener + | typing.Callable, + ) -> typing.Any: ... + def hasService(self, class_: type[typing.Any]) -> bool: ... + def hashCode(self) -> int: ... + def releaseService( + self, + beanContextChild: BeanContextChild, + object: typing.Any, + object2: typing.Any, + ) -> None: ... + def removeBeanContextServicesListener( + self, beanContextServicesListener: BeanContextServicesListener + ) -> None: ... + def revokeService( + self, + class_: type[typing.Any], + beanContextServiceProvider: BeanContextServiceProvider, + boolean: bool, + ) -> None: ... + +class BeanContextSupport( + BeanContextChildSupport, + BeanContext, + java.io.Serializable, + java.beans.PropertyChangeListener, + java.beans.VetoableChangeListener, +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, beanContext: BeanContext): ... + @typing.overload + def __init__(self, beanContext: BeanContext, locale: java.util.Locale): ... + @typing.overload + def __init__( + self, beanContext: BeanContext, locale: java.util.Locale, boolean: bool + ): ... + @typing.overload + def __init__( + self, + beanContext: BeanContext, + locale: java.util.Locale, + boolean: bool, + boolean2: bool, + ): ... + def add(self, object: typing.Any) -> bool: ... + def addAll( + self, collection: java.util.Collection | typing.Sequence | set + ) -> bool: ... + def addBeanContextMembershipListener( + self, beanContextMembershipListener: BeanContextMembershipListener + ) -> None: ... + def avoidingGui(self) -> bool: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, collection: java.util.Collection | typing.Sequence | set + ) -> bool: ... + def containsKey(self, object: typing.Any) -> bool: ... + def dontUseGui(self) -> None: ... + def getBeanContextPeer(self) -> BeanContext: ... + def getLocale(self) -> java.util.Locale: ... + def getResource( + self, string: java.lang.String | str, beanContextChild: BeanContextChild + ) -> java.net.URL: ... + def getResourceAsStream( + self, string: java.lang.String | str, beanContextChild: BeanContextChild + ) -> java.io.InputStream: ... + def instantiateChild(self, string: java.lang.String | str) -> typing.Any: ... + def isDesignTime(self) -> bool: ... + def isEmpty(self) -> bool: ... + def isSerializing(self) -> bool: ... + def iterator(self) -> java.util.Iterator[typing.Any]: ... + def needsGui(self) -> bool: ... + def okToUseGui(self) -> None: ... + def propertyChange( + self, propertyChangeEvent: java.beans.PropertyChangeEvent + ) -> None: ... + def readChildren(self, objectInputStream: java.io.ObjectInputStream) -> None: ... + def remove(self, object: typing.Any) -> bool: ... + def removeAll( + self, collection: java.util.Collection | typing.Sequence | set + ) -> bool: ... + def removeBeanContextMembershipListener( + self, beanContextMembershipListener: BeanContextMembershipListener + ) -> None: ... + def retainAll( + self, collection: java.util.Collection | typing.Sequence | set + ) -> bool: ... + def setDesignTime(self, boolean: bool) -> None: ... + def setLocale(self, locale: java.util.Locale) -> None: ... + def size(self) -> int: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, objectArray: list[typing.Any] | jpype.JArray + ) -> typing.MutableSequence[typing.Any]: ... + def vetoableChange( + self, propertyChangeEvent: java.beans.PropertyChangeEvent + ) -> None: ... + def writeChildren(self, objectOutputStream: java.io.ObjectOutputStream) -> None: ... + +class BeanContextServicesSupport(BeanContextSupport, BeanContextServices): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, beanContextServices: BeanContextServices): ... + @typing.overload + def __init__( + self, beanContextServices: BeanContextServices, locale: java.util.Locale + ): ... + @typing.overload + def __init__( + self, + beanContextServices: BeanContextServices, + locale: java.util.Locale, + boolean: bool, + ): ... + @typing.overload + def __init__( + self, + beanContextServices: BeanContextServices, + locale: java.util.Locale, + boolean: bool, + boolean2: bool, + ): ... + def addBeanContextServicesListener( + self, beanContextServicesListener: BeanContextServicesListener + ) -> None: ... + def addService( + self, + class_: type[typing.Any], + beanContextServiceProvider: BeanContextServiceProvider, + ) -> bool: ... + def getBeanContextServicesPeer(self) -> BeanContextServices: ... + def getCurrentServiceClasses(self) -> java.util.Iterator[typing.Any]: ... + def getCurrentServiceSelectors( + self, class_: type[typing.Any] + ) -> java.util.Iterator[typing.Any]: ... + def getService( + self, + beanContextChild: BeanContextChild, + object: typing.Any, + class_: type[typing.Any], + object2: typing.Any, + beanContextServiceRevokedListener: BeanContextServiceRevokedListener + | typing.Callable, + ) -> typing.Any: ... + def hasService(self, class_: type[typing.Any]) -> bool: ... + def initialize(self) -> None: ... + def releaseService( + self, + beanContextChild: BeanContextChild, + object: typing.Any, + object2: typing.Any, + ) -> None: ... + def removeBeanContextServicesListener( + self, beanContextServicesListener: BeanContextServicesListener + ) -> None: ... + def revokeService( + self, + class_: type[typing.Any], + beanContextServiceProvider: BeanContextServiceProvider, + boolean: bool, + ) -> None: ... + def serviceAvailable( + self, beanContextServiceAvailableEvent: BeanContextServiceAvailableEvent + ) -> None: ... + def serviceRevoked( + self, beanContextServiceRevokedEvent: BeanContextServiceRevokedEvent + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.beans.beancontext")``. + + BeanContext: type[BeanContext] + BeanContextChild: type[BeanContextChild] + BeanContextChildComponentProxy: type[BeanContextChildComponentProxy] + BeanContextChildSupport: type[BeanContextChildSupport] + BeanContextContainerProxy: type[BeanContextContainerProxy] + BeanContextEvent: type[BeanContextEvent] + BeanContextMembershipEvent: type[BeanContextMembershipEvent] + BeanContextMembershipListener: type[BeanContextMembershipListener] + BeanContextProxy: type[BeanContextProxy] + BeanContextServiceAvailableEvent: type[BeanContextServiceAvailableEvent] + BeanContextServiceProvider: type[BeanContextServiceProvider] + BeanContextServiceProviderBeanInfo: type[BeanContextServiceProviderBeanInfo] + BeanContextServiceRevokedEvent: type[BeanContextServiceRevokedEvent] + BeanContextServiceRevokedListener: type[BeanContextServiceRevokedListener] + BeanContextServices: type[BeanContextServices] + BeanContextServicesListener: type[BeanContextServicesListener] + BeanContextServicesSupport: type[BeanContextServicesSupport] + BeanContextSupport: type[BeanContextSupport] diff --git a/typings/java/io/__init__.pyi b/typings/java/io/__init__.pyi new file mode 100644 index 0000000..b3b1a59 --- /dev/null +++ b/typings/java/io/__init__.pyi @@ -0,0 +1,1903 @@ +import typing +from typing import Protocol + +import java.lang +import java.lang.annotation +import java.net +import java.nio +import java.nio.channels +import java.nio.charset +import java.nio.file +import java.security +import java.util +import java.util.function +import java.util.stream +import jpype +import jpype.protocol + +class Closeable(java.lang.AutoCloseable): + def close(self) -> None: ... + +class DataInput: + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readShort(self) -> int: ... + def readUTF(self) -> java.lang.String: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def skipBytes(self, int: int) -> int: ... + +class DataOutput: + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, int: int) -> None: ... + def writeBytes(self, string: java.lang.String | str) -> None: ... + def writeChar(self, int: int) -> None: ... + def writeChars(self, string: java.lang.String | str) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeShort(self, int: int) -> None: ... + def writeUTF(self, string: java.lang.String | str) -> None: ... + +class FileDescriptor: + in_: typing.ClassVar[FileDescriptor] = ... + out: typing.ClassVar[FileDescriptor] = ... + err: typing.ClassVar[FileDescriptor] = ... + def __init__(self): ... + def sync(self) -> None: ... + def valid(self) -> bool: ... + +class FileFilter: + def accept(self, file: File | jpype.protocol.SupportsPath) -> bool: ... + +class FilenameFilter: + def accept( + self, file: File | jpype.protocol.SupportsPath, string: java.lang.String | str + ) -> bool: ... + +class Flushable: + def flush(self) -> None: ... + +class IOError(java.lang.Error): + def __init__(self, throwable: java.lang.Throwable): ... + +class IOException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class ObjectInputFilter: + @staticmethod + def allowFilter( + predicate: java.util.function.Predicate[type[typing.Any]] + | typing.Callable[[type[typing.Any]], bool], + status: ObjectInputFilter.Status, + ) -> ObjectInputFilter: ... + def checkInput( + self, filterInfo: ObjectInputFilter.FilterInfo + ) -> ObjectInputFilter.Status: ... + @staticmethod + def merge( + objectInputFilter: ObjectInputFilter | typing.Callable, + objectInputFilter2: ObjectInputFilter | typing.Callable, + ) -> ObjectInputFilter: ... + @staticmethod + def rejectFilter( + predicate: java.util.function.Predicate[type[typing.Any]] + | typing.Callable[[type[typing.Any]], bool], + status: ObjectInputFilter.Status, + ) -> ObjectInputFilter: ... + @staticmethod + def rejectUndecidedClass( + objectInputFilter: ObjectInputFilter | typing.Callable, + ) -> ObjectInputFilter: ... + class Config: + @staticmethod + def createFilter(string: java.lang.String | str) -> ObjectInputFilter: ... + @staticmethod + def getSerialFilter() -> ObjectInputFilter: ... + @staticmethod + def getSerialFilterFactory() -> java.util.function.BinaryOperator[ + ObjectInputFilter + ]: ... + @staticmethod + def setSerialFilter( + objectInputFilter: ObjectInputFilter | typing.Callable, + ) -> None: ... + @staticmethod + def setSerialFilterFactory( + binaryOperator: java.util.function.BinaryOperator[ + ObjectInputFilter | typing.Callable + ] + | typing.Callable, + ) -> None: ... + + class FilterInfo: + def arrayLength(self) -> int: ... + def depth(self) -> int: ... + def references(self) -> int: ... + def serialClass(self) -> type[typing.Any]: ... + def streamBytes(self) -> int: ... + + class Status(java.lang.Enum["ObjectInputFilter.Status"]): + UNDECIDED: typing.ClassVar[ObjectInputFilter.Status] = ... + ALLOWED: typing.ClassVar[ObjectInputFilter.Status] = ... + REJECTED: typing.ClassVar[ObjectInputFilter.Status] = ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ObjectInputFilter.Status: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: java.lang.String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[ObjectInputFilter.Status]: ... + +class ObjectInputValidation: + def validateObject(self) -> None: ... + +class ObjectStreamConstants: + STREAM_MAGIC: typing.ClassVar[int] = ... + STREAM_VERSION: typing.ClassVar[int] = ... + TC_BASE: typing.ClassVar[int] = ... + TC_NULL: typing.ClassVar[int] = ... + TC_REFERENCE: typing.ClassVar[int] = ... + TC_CLASSDESC: typing.ClassVar[int] = ... + TC_OBJECT: typing.ClassVar[int] = ... + TC_STRING: typing.ClassVar[int] = ... + TC_ARRAY: typing.ClassVar[int] = ... + TC_CLASS: typing.ClassVar[int] = ... + TC_BLOCKDATA: typing.ClassVar[int] = ... + TC_ENDBLOCKDATA: typing.ClassVar[int] = ... + TC_RESET: typing.ClassVar[int] = ... + TC_BLOCKDATALONG: typing.ClassVar[int] = ... + TC_EXCEPTION: typing.ClassVar[int] = ... + TC_LONGSTRING: typing.ClassVar[int] = ... + TC_PROXYCLASSDESC: typing.ClassVar[int] = ... + TC_ENUM: typing.ClassVar[int] = ... + TC_MAX: typing.ClassVar[int] = ... + baseWireHandle: typing.ClassVar[int] = ... + SC_WRITE_METHOD: typing.ClassVar[int] = ... + SC_BLOCK_DATA: typing.ClassVar[int] = ... + SC_SERIALIZABLE: typing.ClassVar[int] = ... + SC_EXTERNALIZABLE: typing.ClassVar[int] = ... + SC_ENUM: typing.ClassVar[int] = ... + SUBSTITUTION_PERMISSION: typing.ClassVar[SerializablePermission] = ... + SUBCLASS_IMPLEMENTATION_PERMISSION: typing.ClassVar[SerializablePermission] = ... + SERIAL_FILTER_PERMISSION: typing.ClassVar[SerializablePermission] = ... + PROTOCOL_VERSION_1: typing.ClassVar[int] = ... + PROTOCOL_VERSION_2: typing.ClassVar[int] = ... + +class ObjectStreamField(java.lang.Comparable[typing.Any]): + @typing.overload + def __init__(self, string: java.lang.String | str, class_: type[typing.Any]): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, class_: type[typing.Any], boolean: bool + ): ... + def compareTo(self, object: typing.Any) -> int: ... + def getName(self) -> java.lang.String: ... + def getOffset(self) -> int: ... + def getType(self) -> type[typing.Any]: ... + def getTypeCode(self) -> str: ... + def getTypeString(self) -> java.lang.String: ... + def isPrimitive(self) -> bool: ... + def isUnshared(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class Serial(java.lang.annotation.Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class Serializable: ... + +class SerializablePermission(java.security.BasicPermission): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class StreamTokenizer: + ttype: int = ... + TT_EOF: typing.ClassVar[int] = ... + TT_EOL: typing.ClassVar[int] = ... + TT_NUMBER: typing.ClassVar[int] = ... + TT_WORD: typing.ClassVar[int] = ... + sval: java.lang.String = ... + nval: float = ... + @typing.overload + def __init__(self, inputStream: InputStream): ... + @typing.overload + def __init__(self, reader: Reader): ... + def commentChar(self, int: int) -> None: ... + def eolIsSignificant(self, boolean: bool) -> None: ... + def lineno(self) -> int: ... + def lowerCaseMode(self, boolean: bool) -> None: ... + def nextToken(self) -> int: ... + def ordinaryChar(self, int: int) -> None: ... + def ordinaryChars(self, int: int, int2: int) -> None: ... + def parseNumbers(self) -> None: ... + def pushBack(self) -> None: ... + def quoteChar(self, int: int) -> None: ... + def resetSyntax(self) -> None: ... + def slashSlashComments(self, boolean: bool) -> None: ... + def slashStarComments(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + def whitespaceChars(self, int: int, int2: int) -> None: ... + def wordChars(self, int: int, int2: int) -> None: ... + +class UncheckedIOException(java.lang.RuntimeException): + @typing.overload + def __init__(self, iOException: IOException): ... + @typing.overload + def __init__(self, string: java.lang.String | str, iOException: IOException): ... + def getCause(self) -> IOException: ... + +class CharConversionException(IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Console(Flushable): + def charset(self) -> java.nio.charset.Charset: ... + def flush(self) -> None: ... + @typing.overload + def format( + self, string: java.lang.String | str, *object: typing.Any + ) -> Console: ... + @typing.overload + def format( + self, + locale: java.util.Locale, + string: java.lang.String | str, + *object: typing.Any, + ) -> Console: ... + def isTerminal(self) -> bool: ... + @typing.overload + def printf( + self, string: java.lang.String | str, *object: typing.Any + ) -> Console: ... + @typing.overload + def printf( + self, + locale: java.util.Locale, + string: java.lang.String | str, + *object: typing.Any, + ) -> Console: ... + @typing.overload + def readLine(self) -> java.lang.String: ... + @typing.overload + def readLine( + self, string: java.lang.String | str, *object: typing.Any + ) -> java.lang.String: ... + @typing.overload + def readLine( + self, + locale: java.util.Locale, + string: java.lang.String | str, + *object: typing.Any, + ) -> java.lang.String: ... + @typing.overload + def readPassword(self) -> typing.MutableSequence[str]: ... + @typing.overload + def readPassword( + self, string: java.lang.String | str, *object: typing.Any + ) -> typing.MutableSequence[str]: ... + @typing.overload + def readPassword( + self, + locale: java.util.Locale, + string: java.lang.String | str, + *object: typing.Any, + ) -> typing.MutableSequence[str]: ... + def reader(self) -> Reader: ... + def writer(self) -> PrintWriter: ... + +class EOFException(IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Externalizable(Serializable): + def readExternal(self, objectInput: ObjectInput) -> None: ... + def writeExternal(self, objectOutput: ObjectOutput) -> None: ... + +class File(Serializable, java.lang.Comparable["File"]): + separatorChar: typing.ClassVar[str] = ... + separator: typing.ClassVar[java.lang.String] = ... + pathSeparatorChar: typing.ClassVar[str] = ... + pathSeparator: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__( + self, file: File | jpype.protocol.SupportsPath, string: java.lang.String | str + ): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__(self, uRI: java.net.URI): ... + def canExecute(self) -> bool: ... + def canRead(self) -> bool: ... + def canWrite(self) -> bool: ... + def compareTo(self, file: File | jpype.protocol.SupportsPath) -> int: ... + def createNewFile(self) -> bool: ... + @typing.overload + @staticmethod + def createTempFile( + string: java.lang.String | str, string2: java.lang.String | str + ) -> File: ... + @typing.overload + @staticmethod + def createTempFile( + string: java.lang.String | str, + string2: java.lang.String | str, + file: File | jpype.protocol.SupportsPath, + ) -> File: ... + def delete(self) -> bool: ... + def deleteOnExit(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def exists(self) -> bool: ... + def getAbsoluteFile(self) -> File: ... + def getAbsolutePath(self) -> java.lang.String: ... + def getCanonicalFile(self) -> File: ... + def getCanonicalPath(self) -> java.lang.String: ... + def getFreeSpace(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getParent(self) -> java.lang.String: ... + def getParentFile(self) -> File: ... + def getPath(self) -> java.lang.String: ... + def getTotalSpace(self) -> int: ... + def getUsableSpace(self) -> int: ... + def hashCode(self) -> int: ... + def isAbsolute(self) -> bool: ... + def isDirectory(self) -> bool: ... + def isFile(self) -> bool: ... + def isHidden(self) -> bool: ... + def lastModified(self) -> int: ... + def length(self) -> int: ... + @typing.overload + def list(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def list( + self, filenameFilter: FilenameFilter | typing.Callable + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def listFiles(self) -> typing.MutableSequence[File]: ... + @typing.overload + def listFiles( + self, fileFilter: FileFilter | typing.Callable + ) -> typing.MutableSequence[File]: ... + @typing.overload + def listFiles( + self, filenameFilter: FilenameFilter | typing.Callable + ) -> typing.MutableSequence[File]: ... + @staticmethod + def listRoots() -> typing.MutableSequence[File]: ... + def mkdir(self) -> bool: ... + def mkdirs(self) -> bool: ... + def renameTo(self, file: File | jpype.protocol.SupportsPath) -> bool: ... + @typing.overload + def setExecutable(self, boolean: bool) -> bool: ... + @typing.overload + def setExecutable(self, boolean: bool, boolean2: bool) -> bool: ... + def setLastModified(self, long: int) -> bool: ... + def setReadOnly(self) -> bool: ... + @typing.overload + def setReadable(self, boolean: bool) -> bool: ... + @typing.overload + def setReadable(self, boolean: bool, boolean2: bool) -> bool: ... + @typing.overload + def setWritable(self, boolean: bool) -> bool: ... + @typing.overload + def setWritable(self, boolean: bool, boolean2: bool) -> bool: ... + def toPath(self) -> java.nio.file.Path: ... + def toString(self) -> java.lang.String: ... + def toURI(self) -> java.net.URI: ... + def toURL(self) -> java.net.URL: ... + +class FileNotFoundException(IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class FilePermission(java.security.Permission, Serializable): + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getActions(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def implies(self, permission: java.security.Permission) -> bool: ... + def newPermissionCollection(self) -> java.security.PermissionCollection: ... + +class InputStream(Closeable): + def __init__(self): ... + def available(self) -> int: ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @staticmethod + def nullInputStream() -> InputStream: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def readAllBytes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def readNBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def readNBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + def skipNBytes(self, long: int) -> None: ... + def transferTo(self, outputStream: OutputStream) -> int: ... + +class InterruptedIOException(IOException): + bytesTransferred: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class ObjectInput(DataInput, java.lang.AutoCloseable): + def available(self) -> int: ... + def close(self) -> None: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def readObject(self) -> typing.Any: ... + def skip(self, long: int) -> int: ... + +class ObjectOutput(DataOutput, java.lang.AutoCloseable): + def close(self) -> None: ... + def flush(self) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + def writeObject(self, object: typing.Any) -> None: ... + +class ObjectStreamClass(Serializable): + NO_FIELDS: typing.ClassVar[typing.MutableSequence[ObjectStreamField]] = ... + def forClass(self) -> type[typing.Any]: ... + def getField(self, string: java.lang.String | str) -> ObjectStreamField: ... + def getFields(self) -> typing.MutableSequence[ObjectStreamField]: ... + def getName(self) -> java.lang.String: ... + def getSerialVersionUID(self) -> int: ... + @staticmethod + def lookup(class_: type[typing.Any]) -> ObjectStreamClass: ... + @staticmethod + def lookupAny(class_: type[typing.Any]) -> ObjectStreamClass: ... + def toString(self) -> java.lang.String: ... + +class ObjectStreamException(IOException): ... + +class OutputStream(Closeable, Flushable): + def __init__(self): ... + def close(self) -> None: ... + def flush(self) -> None: ... + @staticmethod + def nullOutputStream() -> OutputStream: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + +class RandomAccessFile(DataOutput, DataInput, Closeable): + @typing.overload + def __init__( + self, file: File | jpype.protocol.SupportsPath, string: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def close(self) -> None: ... + def getChannel(self) -> java.nio.channels.FileChannel: ... + def getFD(self) -> FileDescriptor: ... + def getFilePointer(self) -> int: ... + def length(self) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readShort(self) -> int: ... + def readUTF(self) -> java.lang.String: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def seek(self, long: int) -> None: ... + def setLength(self, long: int) -> None: ... + def skipBytes(self, int: int) -> int: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, int: int) -> None: ... + def writeBytes(self, string: java.lang.String | str) -> None: ... + def writeChar(self, int: int) -> None: ... + def writeChars(self, string: java.lang.String | str) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeShort(self, int: int) -> None: ... + def writeUTF(self, string: java.lang.String | str) -> None: ... + +class Reader(java.lang.Readable, Closeable): + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @staticmethod + def nullReader() -> Reader: ... + @staticmethod + def of(charSequence: java.lang.CharSequence | str) -> Reader: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray, int: int, int2: int) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray) -> int: ... + @typing.overload + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + def readAllAsString(self) -> java.lang.String: ... + def readAllLines(self) -> java.util.List[java.lang.String]: ... + def ready(self) -> bool: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + def transferTo(self, writer: Writer) -> int: ... + +class SyncFailedException(IOException): + def __init__(self, string: java.lang.String | str): ... + +class UTFDataFormatException(IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class UnsupportedEncodingException(IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Writer(java.lang.Appendable, Closeable, Flushable): + @typing.overload + def append(self, char: str) -> Writer: ... + @typing.overload + def append(self, charSequence: java.lang.CharSequence | str) -> Writer: ... + @typing.overload + def append( + self, charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> Writer: ... + def close(self) -> None: ... + def flush(self) -> None: ... + @staticmethod + def nullWriter() -> Writer: ... + @typing.overload + def write( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + +class BufferedReader(Reader): + @typing.overload + def __init__(self, reader: Reader): ... + @typing.overload + def __init__(self, reader: Reader, int: int): ... + def close(self) -> None: ... + def lines(self) -> java.util.stream.Stream[java.lang.String]: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray, int: int, int2: int) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray) -> int: ... + @typing.overload + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + def readLine(self) -> java.lang.String: ... + def ready(self) -> bool: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class BufferedWriter(Writer): + @typing.overload + def __init__(self, writer: Writer): ... + @typing.overload + def __init__(self, writer: Writer, int: int): ... + def close(self) -> None: ... + def flush(self) -> None: ... + def newLine(self) -> None: ... + @typing.overload + def write( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + @typing.overload + def write(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + +class ByteArrayInputStream(InputStream): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ): ... + def available(self) -> int: ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def readAllBytes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def readNBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def readNBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + def transferTo(self, outputStream: OutputStream) -> int: ... + +class ByteArrayOutputStream(OutputStream): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + def close(self) -> None: ... + def reset(self) -> None: ... + def size(self) -> int: ... + def toByteArray(self) -> typing.MutableSequence[int]: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + def toString(self, int: int) -> java.lang.String: ... + @typing.overload + def toString(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def toString(self, charset: java.nio.charset.Charset) -> java.lang.String: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def writeBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def writeTo(self, outputStream: OutputStream) -> None: ... + +class CharArrayReader(Reader): + @typing.overload + def __init__(self, charArray: list[str] | jpype.JArray): ... + @typing.overload + def __init__(self, charArray: list[str] | jpype.JArray, int: int, int2: int): ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray, int: int, int2: int) -> int: ... + @typing.overload + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray) -> int: ... + def ready(self) -> bool: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class CharArrayWriter(Writer): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def append(self, char: str) -> CharArrayWriter: ... + @typing.overload + def append(self, charSequence: java.lang.CharSequence | str) -> CharArrayWriter: ... + @typing.overload + def append( + self, charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> CharArrayWriter: ... + def close(self) -> None: ... + def flush(self) -> None: ... + def reset(self) -> None: ... + def size(self) -> int: ... + def toCharArray(self) -> typing.MutableSequence[str]: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def write( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + @typing.overload + def write(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + def writeTo(self, writer: Writer) -> None: ... + +class FileInputStream(InputStream): + @typing.overload + def __init__(self, file: File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__(self, fileDescriptor: FileDescriptor): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def available(self) -> int: ... + def close(self) -> None: ... + def getChannel(self) -> java.nio.channels.FileChannel: ... + def getFD(self) -> FileDescriptor: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def readAllBytes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def readNBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def readNBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def skip(self, long: int) -> int: ... + def transferTo(self, outputStream: OutputStream) -> int: ... + +class FileOutputStream(OutputStream): + @typing.overload + def __init__(self, file: File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__(self, file: File | jpype.protocol.SupportsPath, boolean: bool): ... + @typing.overload + def __init__(self, fileDescriptor: FileDescriptor): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + def close(self) -> None: ... + def getChannel(self) -> java.nio.channels.FileChannel: ... + def getFD(self) -> FileDescriptor: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class FilterInputStream(InputStream): + def available(self) -> int: ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class FilterOutputStream(OutputStream): + def __init__(self, outputStream: OutputStream): ... + def close(self) -> None: ... + def flush(self) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class FilterReader(Reader): + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray, int: int, int2: int) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray) -> int: ... + @typing.overload + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + def ready(self) -> bool: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class FilterWriter(Writer): + def close(self) -> None: ... + def flush(self) -> None: ... + @typing.overload + def write( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + @typing.overload + def write(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + +class InputStreamReader(Reader): + @typing.overload + def __init__(self, inputStream: InputStream): ... + @typing.overload + def __init__(self, inputStream: InputStream, string: java.lang.String | str): ... + @typing.overload + def __init__(self, inputStream: InputStream, charset: java.nio.charset.Charset): ... + @typing.overload + def __init__( + self, inputStream: InputStream, charsetDecoder: java.nio.charset.CharsetDecoder + ): ... + def close(self) -> None: ... + def getEncoding(self) -> java.lang.String: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray, int: int, int2: int) -> int: ... + @typing.overload + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray) -> int: ... + def ready(self) -> bool: ... + +class InvalidClassException(ObjectStreamException): + classname: java.lang.String = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + def getMessage(self) -> java.lang.String: ... + +class InvalidObjectException(ObjectStreamException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + +class NotActiveException(ObjectStreamException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class NotSerializableException(ObjectStreamException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class ObjectInputStream(InputStream, ObjectInput, ObjectStreamConstants): + def __init__(self, inputStream: InputStream): ... + def available(self) -> int: ... + def close(self) -> None: ... + def defaultReadObject(self) -> None: ... + def getObjectInputFilter(self) -> ObjectInputFilter: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFields(self) -> ObjectInputStream.GetField: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readObject(self) -> typing.Any: ... + def readShort(self) -> int: ... + def readUTF(self) -> java.lang.String: ... + def readUnshared(self) -> typing.Any: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def registerValidation( + self, objectInputValidation: ObjectInputValidation | typing.Callable, int: int + ) -> None: ... + def setObjectInputFilter( + self, objectInputFilter: ObjectInputFilter | typing.Callable + ) -> None: ... + def skipBytes(self, int: int) -> int: ... + class GetField: + def __init__(self): ... + def defaulted(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def get(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def get(self, string: java.lang.String | str, byte: int) -> int: ... + @typing.overload + def get(self, string: java.lang.String | str, char: str) -> str: ... + @typing.overload + def get(self, string: java.lang.String | str, double: float) -> float: ... + @typing.overload + def get(self, string: java.lang.String | str, float: float) -> float: ... + @typing.overload + def get(self, string: java.lang.String | str, int: int) -> int: ... + @typing.overload + def get( + self, string: java.lang.String | str, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def get(self, string: java.lang.String | str, long: int) -> int: ... + @typing.overload + def get(self, string: java.lang.String | str, short: int) -> int: ... + def getObjectStreamClass(self) -> ObjectStreamClass: ... + +class ObjectOutputStream(OutputStream, ObjectOutput, ObjectStreamConstants): + def __init__(self, outputStream: OutputStream): ... + def close(self) -> None: ... + def defaultWriteObject(self) -> None: ... + def flush(self) -> None: ... + def putFields(self) -> ObjectOutputStream.PutField: ... + def reset(self) -> None: ... + def useProtocolVersion(self, int: int) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, int: int) -> None: ... + def writeBytes(self, string: java.lang.String | str) -> None: ... + def writeChar(self, int: int) -> None: ... + def writeChars(self, string: java.lang.String | str) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFields(self) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeObject(self, object: typing.Any) -> None: ... + def writeShort(self, int: int) -> None: ... + def writeUTF(self, string: java.lang.String | str) -> None: ... + def writeUnshared(self, object: typing.Any) -> None: ... + class PutField: + def __init__(self): ... + @typing.overload + def put(self, string: java.lang.String | str, boolean: bool) -> None: ... + @typing.overload + def put(self, string: java.lang.String | str, byte: int) -> None: ... + @typing.overload + def put(self, string: java.lang.String | str, char: str) -> None: ... + @typing.overload + def put(self, string: java.lang.String | str, double: float) -> None: ... + @typing.overload + def put(self, string: java.lang.String | str, float: float) -> None: ... + @typing.overload + def put(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def put(self, string: java.lang.String | str, object: typing.Any) -> None: ... + @typing.overload + def put(self, string: java.lang.String | str, long: int) -> None: ... + @typing.overload + def put(self, string: java.lang.String | str, short: int) -> None: ... + def write(self, objectOutput: ObjectOutput) -> None: ... + +class OptionalDataException(ObjectStreamException): + length: int = ... + eof: bool = ... + +class OutputStreamWriter(Writer): + @typing.overload + def __init__(self, outputStream: OutputStream): ... + @typing.overload + def __init__(self, outputStream: OutputStream, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, outputStream: OutputStream, charset: java.nio.charset.Charset + ): ... + @typing.overload + def __init__( + self, + outputStream: OutputStream, + charsetEncoder: java.nio.charset.CharsetEncoder, + ): ... + @typing.overload + def append(self, charSequence: java.lang.CharSequence | str) -> Writer: ... + @typing.overload + def append( + self, charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> Writer: ... + @typing.overload + def append(self, char: str) -> Writer: ... + def close(self) -> None: ... + def flush(self) -> None: ... + def getEncoding(self) -> java.lang.String: ... + @typing.overload + def write( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + @typing.overload + def write(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + +class PipedInputStream(InputStream): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, pipedOutputStream: PipedOutputStream): ... + @typing.overload + def __init__(self, pipedOutputStream: PipedOutputStream, int: int): ... + def available(self) -> int: ... + def close(self) -> None: ... + def connect(self, pipedOutputStream: PipedOutputStream) -> None: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + +class PipedOutputStream(OutputStream): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, pipedInputStream: PipedInputStream): ... + def close(self) -> None: ... + def connect(self, pipedInputStream: PipedInputStream) -> None: ... + def flush(self) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class PipedReader(Reader): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, pipedWriter: PipedWriter): ... + @typing.overload + def __init__(self, pipedWriter: PipedWriter, int: int): ... + def close(self) -> None: ... + def connect(self, pipedWriter: PipedWriter) -> None: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray) -> int: ... + @typing.overload + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray, int: int, int2: int) -> int: ... + def ready(self) -> bool: ... + +class PipedWriter(Writer): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, pipedReader: PipedReader): ... + def close(self) -> None: ... + def connect(self, pipedReader: PipedReader) -> None: ... + def flush(self) -> None: ... + @typing.overload + def write( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + +class PrintWriter(Writer): + @typing.overload + def __init__(self, file: File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__( + self, file: File | jpype.protocol.SupportsPath, string: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + file: File | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__(self, outputStream: OutputStream): ... + @typing.overload + def __init__(self, outputStream: OutputStream, boolean: bool): ... + @typing.overload + def __init__( + self, + outputStream: OutputStream, + boolean: bool, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__(self, writer: Writer): ... + @typing.overload + def __init__(self, writer: Writer, boolean: bool): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, charset: java.nio.charset.Charset + ): ... + @typing.overload + def append(self, char: str) -> PrintWriter: ... + @typing.overload + def append(self, charSequence: java.lang.CharSequence | str) -> PrintWriter: ... + @typing.overload + def append( + self, charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> PrintWriter: ... + def checkError(self) -> bool: ... + def close(self) -> None: ... + def flush(self) -> None: ... + @typing.overload + def format( + self, string: java.lang.String | str, *object: typing.Any + ) -> PrintWriter: ... + @typing.overload + def format( + self, + locale: java.util.Locale, + string: java.lang.String | str, + *object: typing.Any, + ) -> PrintWriter: ... + @typing.overload + def print_(self, boolean: bool) -> None: ... + @typing.overload + def print_(self, char: str) -> None: ... + @typing.overload + def print_(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def print_(self, double: float) -> None: ... + @typing.overload + def print_(self, float: float) -> None: ... + @typing.overload + def print_(self, int: int) -> None: ... + @typing.overload + def print_(self, object: typing.Any) -> None: ... + @typing.overload + def print_(self, string: java.lang.String | str) -> None: ... + @typing.overload + def print_(self, long: int) -> None: ... + @typing.overload + def printf( + self, string: java.lang.String | str, *object: typing.Any + ) -> PrintWriter: ... + @typing.overload + def printf( + self, + locale: java.util.Locale, + string: java.lang.String | str, + *object: typing.Any, + ) -> PrintWriter: ... + @typing.overload + def println(self) -> None: ... + @typing.overload + def println(self, boolean: bool) -> None: ... + @typing.overload + def println(self, char: str) -> None: ... + @typing.overload + def println(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def println(self, double: float) -> None: ... + @typing.overload + def println(self, float: float) -> None: ... + @typing.overload + def println(self, int: int) -> None: ... + @typing.overload + def println(self, object: typing.Any) -> None: ... + @typing.overload + def println(self, string: java.lang.String | str) -> None: ... + @typing.overload + def println(self, long: int) -> None: ... + @typing.overload + def write(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def write( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + +class SequenceInputStream(InputStream): + @typing.overload + def __init__(self, inputStream: InputStream, inputStream2: InputStream): ... + @typing.overload + def __init__(self, enumeration: java.util.Enumeration[InputStream]): ... + def available(self) -> int: ... + def close(self) -> None: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def transferTo(self, outputStream: OutputStream) -> int: ... + +class StreamCorruptedException(ObjectStreamException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class StringBufferInputStream(InputStream): + def __init__(self, string: java.lang.String | str): ... + def available(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class StringReader(Reader): + def __init__(self, string: java.lang.String | str): ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray) -> int: ... + @typing.overload + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray, int: int, int2: int) -> int: ... + def ready(self) -> bool: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class StringWriter(Writer): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def append(self, char: str) -> StringWriter: ... + @typing.overload + def append(self, charSequence: java.lang.CharSequence | str) -> StringWriter: ... + @typing.overload + def append( + self, charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> StringWriter: ... + def close(self) -> None: ... + def flush(self) -> None: ... + def getBuffer(self) -> java.lang.StringBuffer: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def write( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + @typing.overload + def write(self, charArray: list[str] | jpype.JArray) -> None: ... + +class WriteAbortedException(ObjectStreamException): + detail: java.lang.Exception = ... + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + def getCause(self) -> java.lang.Throwable: ... + def getMessage(self) -> java.lang.String: ... + +class BufferedInputStream(FilterInputStream): + @typing.overload + def __init__(self, inputStream: InputStream): ... + @typing.overload + def __init__(self, inputStream: InputStream, int: int): ... + def available(self) -> int: ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + def transferTo(self, outputStream: OutputStream) -> int: ... + +class BufferedOutputStream(FilterOutputStream): + @typing.overload + def __init__(self, outputStream: OutputStream): ... + @typing.overload + def __init__(self, outputStream: OutputStream, int: int): ... + def flush(self) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + +class DataInputStream(FilterInputStream, DataInput): + def __init__(self, inputStream: InputStream): ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self) -> int: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readShort(self) -> int: ... + @typing.overload + def readUTF(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def readUTF(dataInput: DataInput) -> java.lang.String: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def skipBytes(self, int: int) -> int: ... + +class DataOutputStream(FilterOutputStream, DataOutput): + def __init__(self, outputStream: OutputStream): ... + def flush(self) -> None: ... + def size(self) -> int: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, int: int) -> None: ... + def writeBytes(self, string: java.lang.String | str) -> None: ... + def writeChar(self, int: int) -> None: ... + def writeChars(self, string: java.lang.String | str) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeShort(self, int: int) -> None: ... + def writeUTF(self, string: java.lang.String | str) -> None: ... + +class FileReader(InputStreamReader): + @typing.overload + def __init__(self, file: File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__( + self, + file: File | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__(self, fileDescriptor: FileDescriptor): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, charset: java.nio.charset.Charset + ): ... + +class FileWriter(OutputStreamWriter): + @typing.overload + def __init__(self, file: File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__(self, file: File | jpype.protocol.SupportsPath, boolean: bool): ... + @typing.overload + def __init__( + self, + file: File | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__( + self, + file: File | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + boolean: bool, + ): ... + @typing.overload + def __init__(self, fileDescriptor: FileDescriptor): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, charset: java.nio.charset.Charset + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + charset: java.nio.charset.Charset, + boolean: bool, + ): ... + +class LineNumberInputStream(FilterInputStream): + def __init__(self, inputStream: InputStream): ... + def available(self) -> int: ... + def getLineNumber(self) -> int: ... + def mark(self, int: int) -> None: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def setLineNumber(self, int: int) -> None: ... + def skip(self, long: int) -> int: ... + +class LineNumberReader(BufferedReader): + @typing.overload + def __init__(self, reader: Reader): ... + @typing.overload + def __init__(self, reader: Reader, int: int): ... + def getLineNumber(self) -> int: ... + def mark(self, int: int) -> None: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray, int: int, int2: int) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray) -> int: ... + @typing.overload + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + def readLine(self) -> java.lang.String: ... + def reset(self) -> None: ... + def setLineNumber(self, int: int) -> None: ... + def skip(self, long: int) -> int: ... + +class PrintStream(FilterOutputStream, java.lang.Appendable, Closeable): + @typing.overload + def __init__(self, file: File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__( + self, file: File | jpype.protocol.SupportsPath, string: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + file: File | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__(self, outputStream: OutputStream): ... + @typing.overload + def __init__(self, outputStream: OutputStream, boolean: bool): ... + @typing.overload + def __init__( + self, outputStream: OutputStream, boolean: bool, string: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + outputStream: OutputStream, + boolean: bool, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, charset: java.nio.charset.Charset + ): ... + @typing.overload + def append(self, char: str) -> PrintStream: ... + @typing.overload + def append(self, charSequence: java.lang.CharSequence | str) -> PrintStream: ... + @typing.overload + def append( + self, charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> PrintStream: ... + def charset(self) -> java.nio.charset.Charset: ... + def checkError(self) -> bool: ... + def close(self) -> None: ... + def flush(self) -> None: ... + @typing.overload + def format( + self, string: java.lang.String | str, *object: typing.Any + ) -> PrintStream: ... + @typing.overload + def format( + self, + locale: java.util.Locale, + string: java.lang.String | str, + *object: typing.Any, + ) -> PrintStream: ... + @typing.overload + def print_(self, boolean: bool) -> None: ... + @typing.overload + def print_(self, char: str) -> None: ... + @typing.overload + def print_(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def print_(self, double: float) -> None: ... + @typing.overload + def print_(self, float: float) -> None: ... + @typing.overload + def print_(self, int: int) -> None: ... + @typing.overload + def print_(self, object: typing.Any) -> None: ... + @typing.overload + def print_(self, string: java.lang.String | str) -> None: ... + @typing.overload + def print_(self, long: int) -> None: ... + @typing.overload + def printf( + self, string: java.lang.String | str, *object: typing.Any + ) -> PrintStream: ... + @typing.overload + def printf( + self, + locale: java.util.Locale, + string: java.lang.String | str, + *object: typing.Any, + ) -> PrintStream: ... + @typing.overload + def println(self) -> None: ... + @typing.overload + def println(self, boolean: bool) -> None: ... + @typing.overload + def println(self, char: str) -> None: ... + @typing.overload + def println(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def println(self, double: float) -> None: ... + @typing.overload + def println(self, float: float) -> None: ... + @typing.overload + def println(self, int: int) -> None: ... + @typing.overload + def println(self, object: typing.Any) -> None: ... + @typing.overload + def println(self, string: java.lang.String | str) -> None: ... + @typing.overload + def println(self, long: int) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + def writeBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + +class PushbackInputStream(FilterInputStream): + @typing.overload + def __init__(self, inputStream: InputStream): ... + @typing.overload + def __init__(self, inputStream: InputStream, int: int): ... + def available(self) -> int: ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + def transferTo(self, outputStream: OutputStream) -> int: ... + @typing.overload + def unread(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def unread( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def unread(self, int: int) -> None: ... + +class PushbackReader(FilterReader): + @typing.overload + def __init__(self, reader: Reader): ... + @typing.overload + def __init__(self, reader: Reader, int: int): ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray, int: int, int2: int) -> int: ... + @typing.overload + def read(self, charArray: list[str] | jpype.JArray) -> int: ... + @typing.overload + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + def ready(self) -> bool: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + @typing.overload + def unread(self, charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + def unread( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + def unread(self, int: int) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.io")``. + + BufferedInputStream: type[BufferedInputStream] + BufferedOutputStream: type[BufferedOutputStream] + BufferedReader: type[BufferedReader] + BufferedWriter: type[BufferedWriter] + ByteArrayInputStream: type[ByteArrayInputStream] + ByteArrayOutputStream: type[ByteArrayOutputStream] + CharArrayReader: type[CharArrayReader] + CharArrayWriter: type[CharArrayWriter] + CharConversionException: type[CharConversionException] + Closeable: type[Closeable] + Console: type[Console] + DataInput: type[DataInput] + DataInputStream: type[DataInputStream] + DataOutput: type[DataOutput] + DataOutputStream: type[DataOutputStream] + EOFException: type[EOFException] + Externalizable: type[Externalizable] + File: type[File] + FileDescriptor: type[FileDescriptor] + FileFilter: type[FileFilter] + FileInputStream: type[FileInputStream] + FileNotFoundException: type[FileNotFoundException] + FileOutputStream: type[FileOutputStream] + FilePermission: type[FilePermission] + FileReader: type[FileReader] + FileWriter: type[FileWriter] + FilenameFilter: type[FilenameFilter] + FilterInputStream: type[FilterInputStream] + FilterOutputStream: type[FilterOutputStream] + FilterReader: type[FilterReader] + FilterWriter: type[FilterWriter] + Flushable: type[Flushable] + IOError: type[IOError] + IOException: type[IOException] + InputStream: type[InputStream] + InputStreamReader: type[InputStreamReader] + InterruptedIOException: type[InterruptedIOException] + InvalidClassException: type[InvalidClassException] + InvalidObjectException: type[InvalidObjectException] + LineNumberInputStream: type[LineNumberInputStream] + LineNumberReader: type[LineNumberReader] + NotActiveException: type[NotActiveException] + NotSerializableException: type[NotSerializableException] + ObjectInput: type[ObjectInput] + ObjectInputFilter: type[ObjectInputFilter] + ObjectInputStream: type[ObjectInputStream] + ObjectInputValidation: type[ObjectInputValidation] + ObjectOutput: type[ObjectOutput] + ObjectOutputStream: type[ObjectOutputStream] + ObjectStreamClass: type[ObjectStreamClass] + ObjectStreamConstants: type[ObjectStreamConstants] + ObjectStreamException: type[ObjectStreamException] + ObjectStreamField: type[ObjectStreamField] + OptionalDataException: type[OptionalDataException] + OutputStream: type[OutputStream] + OutputStreamWriter: type[OutputStreamWriter] + PipedInputStream: type[PipedInputStream] + PipedOutputStream: type[PipedOutputStream] + PipedReader: type[PipedReader] + PipedWriter: type[PipedWriter] + PrintStream: type[PrintStream] + PrintWriter: type[PrintWriter] + PushbackInputStream: type[PushbackInputStream] + PushbackReader: type[PushbackReader] + RandomAccessFile: type[RandomAccessFile] + Reader: type[Reader] + SequenceInputStream: type[SequenceInputStream] + Serial: type[Serial] + Serializable: type[Serializable] + SerializablePermission: type[SerializablePermission] + StreamCorruptedException: type[StreamCorruptedException] + StreamTokenizer: type[StreamTokenizer] + StringBufferInputStream: type[StringBufferInputStream] + StringReader: type[StringReader] + StringWriter: type[StringWriter] + SyncFailedException: type[SyncFailedException] + UTFDataFormatException: type[UTFDataFormatException] + UncheckedIOException: type[UncheckedIOException] + UnsupportedEncodingException: type[UnsupportedEncodingException] + WriteAbortedException: type[WriteAbortedException] + Writer: type[Writer] diff --git a/typings/java/lang/__init__.pyi b/typings/java/lang/__init__.pyi new file mode 100644 index 0000000..4508614 --- /dev/null +++ b/typings/java/lang/__init__.pyi @@ -0,0 +1,4545 @@ +import builtins +import typing +from typing import Protocol + +import java +import java.io +import java.lang.annotation +import java.lang.classfile +import java.lang.constant +import java.lang.foreign +import java.lang.instrument +import java.lang.invoke +import java.lang.management +import java.lang.module +import java.lang.ref +import java.lang.reflect +import java.lang.runtime +import java.net +import java.nio +import java.nio.channels +import java.nio.charset +import java.security +import java.time +import java.util +import java.util.concurrent +import java.util.function +import java.util.stream +import jpype +import jpype.protocol +from jpype._core import _JRuntime +from jpype._jcollection import _JIterable +from jpype._jexception import JException +from jpype._jio import _JCloseable +from jpype._jstring import _JStringProto +from jpype._jthread import _JThread + +class Appendable: + @typing.overload + def append(self, char: str) -> Appendable: ... + @typing.overload + def append(self, charSequence: CharSequence | str) -> Appendable: ... + @typing.overload + def append( + self, charSequence: CharSequence | str, int: int, int2: int + ) -> Appendable: ... + +class AutoCloseable(_JCloseable): + def close(self) -> None: ... + +class CharSequence: + def charAt(self, int: int) -> str: ... + def chars(self) -> java.util.stream.IntStream: ... + def codePoints(self) -> java.util.stream.IntStream: ... + @staticmethod + def compare( + charSequence: CharSequence | str, charSequence2: CharSequence | str + ) -> int: ... + def getChars( + self, int: int, int2: int, charArray: list[str] | jpype.JArray, int3: int + ) -> None: ... + def isEmpty(self) -> bool: ... + def length(self) -> int: ... + def subSequence(self, int: int, int2: int) -> CharSequence: ... + def toString(self) -> String: ... + +_Class__T = typing.TypeVar("_Class__T") # + +class Class( + java.io.Serializable, + java.lang.reflect.GenericDeclaration, + java.lang.reflect.Type, + java.lang.reflect.AnnotatedElement, + java.lang.invoke.TypeDescriptor.OfField[type[typing.Any]], + java.lang.constant.Constable, + typing.Generic[_Class__T], +): + def accessFlags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def arrayType(self) -> type[typing.Any]: ... + _asSubclass__U = typing.TypeVar("_asSubclass__U") # + def asSubclass(self, class_: type[_asSubclass__U]) -> type[_asSubclass__U]: ... + def cast(self, object: typing.Any) -> _Class__T: ... + def componentType(self) -> type[typing.Any]: ... + def describeConstable(self) -> java.util.Optional[java.lang.constant.ClassDesc]: ... + def descriptorString(self) -> String: ... + def desiredAssertionStatus(self) -> bool: ... + @typing.overload + @staticmethod + def forName(module: Module, string: String | str) -> type[typing.Any]: ... + @typing.overload + @staticmethod + def forName(string: String | str) -> type[typing.Any]: ... + @typing.overload + @staticmethod + def forName( + string: String | str, boolean: bool, classLoader: ClassLoader + ) -> type[typing.Any]: ... + @staticmethod + def forPrimitiveName(string: String | str) -> type[typing.Any]: ... + def getAnnotatedInterfaces( + self, + ) -> typing.MutableSequence[java.lang.reflect.AnnotatedType]: ... + def getAnnotatedSuperclass(self) -> java.lang.reflect.AnnotatedType: ... + _getAnnotation__A = typing.TypeVar( + "_getAnnotation__A", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__A]) -> _getAnnotation__A: ... + def getAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getAnnotationsByType__A = typing.TypeVar( + "_getAnnotationsByType__A", bound=java.lang.annotation.Annotation + ) # + def getAnnotationsByType( + self, class_: type[_getAnnotationsByType__A] + ) -> typing.MutableSequence[_getAnnotationsByType__A]: ... + def getCanonicalName(self) -> String: ... + def getClassLoader(self) -> ClassLoader: ... + def getClasses(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getComponentType(self) -> type[typing.Any]: ... + def getConstructor( + self, *class_: type[typing.Any] + ) -> java.lang.reflect.Constructor[_Class__T]: ... + def getConstructors( + self, + ) -> typing.MutableSequence[java.lang.reflect.Constructor[typing.Any]]: ... + _getDeclaredAnnotation__A = typing.TypeVar( + "_getDeclaredAnnotation__A", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotation( + self, class_: type[_getDeclaredAnnotation__A] + ) -> _getDeclaredAnnotation__A: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getDeclaredAnnotationsByType__A = typing.TypeVar( + "_getDeclaredAnnotationsByType__A", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotationsByType( + self, class_: type[_getDeclaredAnnotationsByType__A] + ) -> typing.MutableSequence[_getDeclaredAnnotationsByType__A]: ... + def getDeclaredClasses(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getDeclaredConstructor( + self, *class_: type[typing.Any] + ) -> java.lang.reflect.Constructor[_Class__T]: ... + def getDeclaredConstructors( + self, + ) -> typing.MutableSequence[java.lang.reflect.Constructor[typing.Any]]: ... + def getDeclaredField(self, string: String | str) -> java.lang.reflect.Field: ... + def getDeclaredFields(self) -> typing.MutableSequence[java.lang.reflect.Field]: ... + def getDeclaredMethod( + self, string: String | str, *class_: type[typing.Any] + ) -> java.lang.reflect.Method: ... + def getDeclaredMethods( + self, + ) -> typing.MutableSequence[java.lang.reflect.Method]: ... + def getDeclaringClass(self) -> type[typing.Any]: ... + def getEnclosingClass(self) -> type[typing.Any]: ... + def getEnclosingConstructor(self) -> java.lang.reflect.Constructor[typing.Any]: ... + def getEnclosingMethod(self) -> java.lang.reflect.Method: ... + def getEnumConstants(self) -> typing.MutableSequence[_Class__T]: ... + def getField(self, string: String | str) -> java.lang.reflect.Field: ... + def getFields(self) -> typing.MutableSequence[java.lang.reflect.Field]: ... + def getGenericInterfaces( + self, + ) -> typing.MutableSequence[java.lang.reflect.Type]: ... + def getGenericSuperclass(self) -> java.lang.reflect.Type: ... + def getInterfaces(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getMethod( + self, string: String | str, *class_: type[typing.Any] + ) -> java.lang.reflect.Method: ... + def getMethods(self) -> typing.MutableSequence[java.lang.reflect.Method]: ... + def getModifiers(self) -> int: ... + def getModule(self) -> Module: ... + def getName(self) -> String: ... + def getNestHost(self) -> type[typing.Any]: ... + def getNestMembers(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getPackage(self) -> Package: ... + def getPackageName(self) -> String: ... + def getPermittedSubclasses(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getProtectionDomain(self) -> java.security.ProtectionDomain: ... + def getRecordComponents( + self, + ) -> typing.MutableSequence[java.lang.reflect.RecordComponent]: ... + def getResource(self, string: String | str) -> java.net.URL: ... + def getResourceAsStream(self, string: String | str) -> java.io.InputStream: ... + def getSigners(self) -> typing.MutableSequence[typing.Any]: ... + def getSimpleName(self) -> String: ... + def getSuperclass(self) -> type[_Class__T]: ... + def getTypeName(self) -> String: ... + def getTypeParameters( + self, + ) -> typing.MutableSequence[java.lang.reflect.TypeVariable[type[_Class__T]]]: ... + def isAnnotation(self) -> bool: ... + def isAnnotationPresent( + self, class_: type[java.lang.annotation.Annotation] + ) -> bool: ... + def isAnonymousClass(self) -> bool: ... + def isArray(self) -> bool: ... + def isAssignableFrom(self, class_: type[typing.Any]) -> bool: ... + def isEnum(self) -> bool: ... + def isHidden(self) -> bool: ... + def isInstance(self, object: typing.Any) -> bool: ... + def isInterface(self) -> bool: ... + def isLocalClass(self) -> bool: ... + def isMemberClass(self) -> bool: ... + def isNestmateOf(self, class_: type[typing.Any]) -> bool: ... + def isPrimitive(self) -> bool: ... + def isRecord(self) -> bool: ... + def isSealed(self) -> bool: ... + def isSynthetic(self) -> bool: ... + def newInstance(self) -> _Class__T: ... + def toGenericString(self) -> String: ... + def toString(self) -> String: ... + +class ClassLoader: + def clearAssertionStatus(self) -> None: ... + def getDefinedPackage(self, string: String | str) -> Package: ... + def getDefinedPackages(self) -> typing.MutableSequence[Package]: ... + def getName(self) -> String: ... + def getParent(self) -> ClassLoader: ... + @staticmethod + def getPlatformClassLoader() -> ClassLoader: ... + def getResource(self, string: String | str) -> java.net.URL: ... + def getResourceAsStream(self, string: String | str) -> java.io.InputStream: ... + def getResources( + self, string: String | str + ) -> java.util.Enumeration[java.net.URL]: ... + @staticmethod + def getSystemClassLoader() -> ClassLoader: ... + @staticmethod + def getSystemResource(string: String | str) -> java.net.URL: ... + @staticmethod + def getSystemResourceAsStream(string: String | str) -> java.io.InputStream: ... + @staticmethod + def getSystemResources( + string: String | str, + ) -> java.util.Enumeration[java.net.URL]: ... + def getUnnamedModule(self) -> Module: ... + def isRegisteredAsParallelCapable(self) -> bool: ... + def loadClass(self, string: String | str) -> type[typing.Any]: ... + def resources( + self, string: String | str + ) -> java.util.stream.Stream[java.net.URL]: ... + def setClassAssertionStatus(self, string: String | str, boolean: bool) -> None: ... + def setDefaultAssertionStatus(self, boolean: bool) -> None: ... + def setPackageAssertionStatus( + self, string: String | str, boolean: bool + ) -> None: ... + +_ClassValue__T = typing.TypeVar("_ClassValue__T") # + +class ClassValue(typing.Generic[_ClassValue__T]): + def get(self, class_: type[typing.Any]) -> _ClassValue__T: ... + def remove(self, class_: type[typing.Any]) -> None: ... + +class Cloneable: ... + +_Comparable__T = typing.TypeVar("_Comparable__T") # + +class Comparable(typing.Generic[_Comparable__T]): + def compareTo(self, t: _Comparable__T) -> int: ... + +class Deprecated(java.lang.annotation.Annotation): + def equals(self, object: typing.Any) -> bool: ... + def forRemoval(self) -> bool: ... + def hashCode(self) -> int: ... + def since(self) -> String: ... + def toString(self) -> String: ... + +class FunctionalInterface(java.lang.annotation.Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> String: ... + +class IO: + @staticmethod + def print_(object: typing.Any) -> None: ... + @typing.overload + @staticmethod + def println() -> None: ... + @typing.overload + @staticmethod + def println(object: typing.Any) -> None: ... + @typing.overload + @staticmethod + def readln() -> String: ... + @typing.overload + @staticmethod + def readln(string: String | str) -> String: ... + +_Iterable__T = typing.TypeVar("_Iterable__T") # + +class Iterable(typing.Generic[_Iterable__T], _JIterable[_Iterable__T]): + def forEach( + self, + consumer: java.util.function.Consumer[_Iterable__T] + | typing.Callable[[_Iterable__T], None], + ) -> None: ... + def iterator(self) -> java.util.Iterator[_Iterable__T]: ... + def spliterator(self) -> java.util.Spliterator[_Iterable__T]: ... + +class Math: + E: typing.ClassVar[float] = ... + PI: typing.ClassVar[float] = ... + TAU: typing.ClassVar[float] = ... + @staticmethod + def IEEEremainder(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def abs(double: float) -> float: ... + @typing.overload + @staticmethod + def abs(float: float) -> float: ... + @typing.overload + @staticmethod + def abs(int: int) -> int: ... + @typing.overload + @staticmethod + def abs(long: int) -> int: ... + @typing.overload + @staticmethod + def absExact(int: int) -> int: ... + @typing.overload + @staticmethod + def absExact(long: int) -> int: ... + @staticmethod + def acos(double: float) -> float: ... + @typing.overload + @staticmethod + def addExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def addExact(long: int, long2: int) -> int: ... + @staticmethod + def asin(double: float) -> float: ... + @staticmethod + def atan(double: float) -> float: ... + @staticmethod + def atan2(double: float, double2: float) -> float: ... + @staticmethod + def cbrt(double: float) -> float: ... + @staticmethod + def ceil(double: float) -> float: ... + @typing.overload + @staticmethod + def ceilDiv(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def ceilDiv(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def ceilDiv(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def ceilDivExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def ceilDivExact(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def ceilMod(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def ceilMod(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def ceilMod(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def clamp(double: float, double2: float, double3: float) -> float: ... + @typing.overload + @staticmethod + def clamp(float: float, float2: float, float3: float) -> float: ... + @typing.overload + @staticmethod + def clamp(long: int, int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def clamp(long: int, long2: int, long3: int) -> int: ... + @typing.overload + @staticmethod + def copySign(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def copySign(float: float, float2: float) -> float: ... + @staticmethod + def cos(double: float) -> float: ... + @staticmethod + def cosh(double: float) -> float: ... + @typing.overload + @staticmethod + def decrementExact(int: int) -> int: ... + @typing.overload + @staticmethod + def decrementExact(long: int) -> int: ... + @typing.overload + @staticmethod + def divideExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def divideExact(long: int, long2: int) -> int: ... + @staticmethod + def exp(double: float) -> float: ... + @staticmethod + def expm1(double: float) -> float: ... + @staticmethod + def floor(double: float) -> float: ... + @typing.overload + @staticmethod + def floorDiv(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def floorDiv(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def floorDiv(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def floorDivExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def floorDivExact(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def floorMod(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def floorMod(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def floorMod(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def fma(double: float, double2: float, double3: float) -> float: ... + @typing.overload + @staticmethod + def fma(float: float, float2: float, float3: float) -> float: ... + @typing.overload + @staticmethod + def getExponent(double: float) -> int: ... + @typing.overload + @staticmethod + def getExponent(float: float) -> int: ... + @staticmethod + def hypot(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def incrementExact(int: int) -> int: ... + @typing.overload + @staticmethod + def incrementExact(long: int) -> int: ... + @staticmethod + def log(double: float) -> float: ... + @staticmethod + def log10(double: float) -> float: ... + @staticmethod + def log1p(double: float) -> float: ... + @typing.overload + @staticmethod + def max(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def max(float: float, float2: float) -> float: ... + @typing.overload + @staticmethod + def max(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def max(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def min(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def min(float: float, float2: float) -> float: ... + @typing.overload + @staticmethod + def min(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def min(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def multiplyExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def multiplyExact(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def multiplyExact(long: int, long2: int) -> int: ... + @staticmethod + def multiplyFull(int: int, int2: int) -> int: ... + @staticmethod + def multiplyHigh(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def negateExact(int: int) -> int: ... + @typing.overload + @staticmethod + def negateExact(long: int) -> int: ... + @typing.overload + @staticmethod + def nextAfter(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def nextAfter(float: float, double: float) -> float: ... + @typing.overload + @staticmethod + def nextDown(double: float) -> float: ... + @typing.overload + @staticmethod + def nextDown(float: float) -> float: ... + @typing.overload + @staticmethod + def nextUp(double: float) -> float: ... + @typing.overload + @staticmethod + def nextUp(float: float) -> float: ... + @staticmethod + def pow(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def powExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def powExact(long: int, int: int) -> int: ... + @staticmethod + def random() -> float: ... + @staticmethod + def rint(double: float) -> float: ... + @typing.overload + @staticmethod + def round(float: float) -> int: ... + @typing.overload + @staticmethod + def round(double: float) -> int: ... + @typing.overload + @staticmethod + def scalb(double: float, int: int) -> float: ... + @typing.overload + @staticmethod + def scalb(float: float, int: int) -> float: ... + @typing.overload + @staticmethod + def signum(double: float) -> float: ... + @typing.overload + @staticmethod + def signum(float: float) -> float: ... + @staticmethod + def sin(double: float) -> float: ... + @staticmethod + def sinh(double: float) -> float: ... + @staticmethod + def sqrt(double: float) -> float: ... + @typing.overload + @staticmethod + def subtractExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def subtractExact(long: int, long2: int) -> int: ... + @staticmethod + def tan(double: float) -> float: ... + @staticmethod + def tanh(double: float) -> float: ... + @staticmethod + def toDegrees(double: float) -> float: ... + @staticmethod + def toIntExact(long: int) -> int: ... + @staticmethod + def toRadians(double: float) -> float: ... + @typing.overload + @staticmethod + def ulp(double: float) -> float: ... + @typing.overload + @staticmethod + def ulp(float: float) -> float: ... + @typing.overload + @staticmethod + def unsignedMultiplyExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def unsignedMultiplyExact(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def unsignedMultiplyExact(long: int, long2: int) -> int: ... + @staticmethod + def unsignedMultiplyHigh(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def unsignedPowExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def unsignedPowExact(long: int, int: int) -> int: ... + +class Module(java.lang.reflect.AnnotatedElement): + def addExports(self, string: String | str, module: Module) -> Module: ... + def addOpens(self, string: String | str, module: Module) -> Module: ... + def addReads(self, module: Module) -> Module: ... + def addUses(self, class_: type[typing.Any]) -> Module: ... + def canRead(self, module: Module) -> bool: ... + def canUse(self, class_: type[typing.Any]) -> bool: ... + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__T]) -> _getAnnotation__T: ... + def getAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getClassLoader(self) -> ClassLoader: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getDescriptor(self) -> java.lang.module.ModuleDescriptor: ... + def getLayer(self) -> ModuleLayer: ... + def getName(self) -> String: ... + def getPackages(self) -> java.util.Set[String]: ... + def getResourceAsStream(self, string: String | str) -> java.io.InputStream: ... + @typing.overload + def isExported(self, string: String | str) -> bool: ... + @typing.overload + def isExported(self, string: String | str, module: Module) -> bool: ... + def isNamed(self) -> bool: ... + def isNativeAccessEnabled(self) -> bool: ... + @typing.overload + def isOpen(self, string: String | str) -> bool: ... + @typing.overload + def isOpen(self, string: String | str, module: Module) -> bool: ... + def toString(self) -> String: ... + +class ModuleLayer: + @staticmethod + def boot() -> ModuleLayer: ... + def configuration(self) -> java.lang.module.Configuration: ... + @typing.overload + def defineModules( + self, + configuration: java.lang.module.Configuration, + function: java.util.function.Function[String | str, ClassLoader] + | typing.Callable[[String | str], ClassLoader], + ) -> ModuleLayer: ... + @typing.overload + @staticmethod + def defineModules( + configuration: java.lang.module.Configuration, + list: java.util.List[ModuleLayer], + function: java.util.function.Function[String | str, ClassLoader] + | typing.Callable[[String | str], ClassLoader], + ) -> ModuleLayer.Controller: ... + @typing.overload + def defineModulesWithManyLoaders( + self, configuration: java.lang.module.Configuration, classLoader: ClassLoader + ) -> ModuleLayer: ... + @typing.overload + @staticmethod + def defineModulesWithManyLoaders( + configuration: java.lang.module.Configuration, + list: java.util.List[ModuleLayer], + classLoader: ClassLoader, + ) -> ModuleLayer.Controller: ... + @typing.overload + def defineModulesWithOneLoader( + self, configuration: java.lang.module.Configuration, classLoader: ClassLoader + ) -> ModuleLayer: ... + @typing.overload + @staticmethod + def defineModulesWithOneLoader( + configuration: java.lang.module.Configuration, + list: java.util.List[ModuleLayer], + classLoader: ClassLoader, + ) -> ModuleLayer.Controller: ... + @staticmethod + def empty() -> ModuleLayer: ... + def findLoader(self, string: String | str) -> ClassLoader: ... + def findModule(self, string: String | str) -> java.util.Optional[Module]: ... + def modules(self) -> java.util.Set[Module]: ... + def parents(self) -> java.util.List[ModuleLayer]: ... + def toString(self) -> String: ... + class Controller: + def addExports( + self, module: Module, string: String | str, module2: Module + ) -> ModuleLayer.Controller: ... + def addOpens( + self, module: Module, string: String | str, module2: Module + ) -> ModuleLayer.Controller: ... + def addReads( + self, module: Module, module2: Module + ) -> ModuleLayer.Controller: ... + def enableNativeAccess(self, module: Module) -> ModuleLayer.Controller: ... + def layer(self) -> ModuleLayer: ... + +class Number(java.io.Serializable): + def __init__(self): ... + def byteValue(self) -> int: ... + def doubleValue(self) -> float: ... + def floatValue(self) -> float: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + def shortValue(self) -> int: ... + +class Object: + def __init__(self): ... + def equals(self, object: typing.Any) -> bool: ... + def getClass(self) -> type[typing.Any]: ... + def hashCode(self) -> int: ... + def notify(self) -> None: ... + def notifyAll(self) -> None: ... + def toString(self) -> String: ... + @typing.overload + def wait(self) -> None: ... + @typing.overload + def wait(self, long: int) -> None: ... + @typing.overload + def wait(self, long: int, int: int) -> None: ... + +class Override(java.lang.annotation.Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> String: ... + +class Process: + def __init__(self): ... + def children(self) -> java.util.stream.Stream[ProcessHandle]: ... + def descendants(self) -> java.util.stream.Stream[ProcessHandle]: ... + def destroy(self) -> None: ... + def destroyForcibly(self) -> Process: ... + @typing.overload + def errorReader(self) -> java.io.BufferedReader: ... + @typing.overload + def errorReader( + self, charset: java.nio.charset.Charset + ) -> java.io.BufferedReader: ... + def exitValue(self) -> int: ... + def getErrorStream(self) -> java.io.InputStream: ... + def getInputStream(self) -> java.io.InputStream: ... + def getOutputStream(self) -> java.io.OutputStream: ... + def info(self) -> ProcessHandle.Info: ... + @typing.overload + def inputReader(self) -> java.io.BufferedReader: ... + @typing.overload + def inputReader( + self, charset: java.nio.charset.Charset + ) -> java.io.BufferedReader: ... + def isAlive(self) -> bool: ... + def onExit(self) -> java.util.concurrent.CompletableFuture[Process]: ... + @typing.overload + def outputWriter(self) -> java.io.BufferedWriter: ... + @typing.overload + def outputWriter( + self, charset: java.nio.charset.Charset + ) -> java.io.BufferedWriter: ... + def pid(self) -> int: ... + def supportsNormalTermination(self) -> bool: ... + def toHandle(self) -> ProcessHandle: ... + @typing.overload + def waitFor(self) -> int: ... + @typing.overload + def waitFor(self, duration: java.time.Duration) -> bool: ... + @typing.overload + def waitFor(self, long: int, timeUnit: java.util.concurrent.TimeUnit) -> bool: ... + +class Readable: + def read(self, charBuffer: java.nio.CharBuffer) -> int: ... + +class Record: + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> String: ... + +class Runnable: + def run(self) -> None: ... + +class RuntimePermission(java.security.BasicPermission): + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, string2: String | str): ... + +class SafeVarargs(java.lang.annotation.Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> String: ... + +_ScopedValue__CallableOp__T = typing.TypeVar("_ScopedValue__CallableOp__T") # +_ScopedValue__CallableOp__X = typing.TypeVar( + "_ScopedValue__CallableOp__X", bound="Throwable" +) # +_ScopedValue__T = typing.TypeVar("_ScopedValue__T") # + +class ScopedValue(typing.Generic[_ScopedValue__T]): + def get(self) -> _ScopedValue__T: ... + def hashCode(self) -> int: ... + def isBound(self) -> bool: ... + _newInstance__T = typing.TypeVar("_newInstance__T") # + @staticmethod + def newInstance() -> ScopedValue[_newInstance__T]: ... + def orElse(self, t: _ScopedValue__T) -> _ScopedValue__T: ... + _orElseThrow__X = typing.TypeVar("_orElseThrow__X", bound="Throwable") # + def orElseThrow( + self, + supplier: java.util.function.Supplier[_orElseThrow__X] + | typing.Callable[[], _orElseThrow__X], + ) -> _ScopedValue__T: ... + _where__T = typing.TypeVar("_where__T") # + @staticmethod + def where( + scopedValue: ScopedValue[_where__T], t: _where__T + ) -> ScopedValue.Carrier: ... + class CallableOp( + typing.Generic[_ScopedValue__CallableOp__T, _ScopedValue__CallableOp__X] + ): + def call(self) -> _ScopedValue__CallableOp__T: ... + + class Carrier: + _call__R = typing.TypeVar("_call__R") # + _call__X = typing.TypeVar("_call__X", bound="Throwable") # + def call( + self, + callableOp: ScopedValue.CallableOp[_call__R, _call__X] + | typing.Callable[[], _call__R], + ) -> _call__R: ... + _get__T = typing.TypeVar("_get__T") # + def get(self, scopedValue: ScopedValue[_get__T]) -> _get__T: ... + def run(self, runnable: Runnable | typing.Callable) -> None: ... + _where__T = typing.TypeVar("_where__T") # + def where( + self, scopedValue: ScopedValue[_where__T], t: _where__T + ) -> ScopedValue.Carrier: ... + +class SecurityManager: + def __init__(self): ... + def checkAccept(self, string: String | str, int: int) -> None: ... + @typing.overload + def checkAccess(self, thread: Thread) -> None: ... + @typing.overload + def checkAccess(self, threadGroup: ThreadGroup) -> None: ... + @typing.overload + def checkConnect(self, string: String | str, int: int) -> None: ... + @typing.overload + def checkConnect( + self, string: String | str, int: int, object: typing.Any + ) -> None: ... + def checkCreateClassLoader(self) -> None: ... + def checkDelete(self, string: String | str) -> None: ... + def checkExec(self, string: String | str) -> None: ... + def checkExit(self, int: int) -> None: ... + def checkLink(self, string: String | str) -> None: ... + def checkListen(self, int: int) -> None: ... + @typing.overload + def checkMulticast(self, inetAddress: java.net.InetAddress) -> None: ... + @typing.overload + def checkMulticast(self, inetAddress: java.net.InetAddress, byte: int) -> None: ... + def checkPackageAccess(self, string: String | str) -> None: ... + def checkPackageDefinition(self, string: String | str) -> None: ... + @typing.overload + def checkPermission(self, permission: java.security.Permission) -> None: ... + @typing.overload + def checkPermission( + self, permission: java.security.Permission, object: typing.Any + ) -> None: ... + def checkPrintJobAccess(self) -> None: ... + def checkPropertiesAccess(self) -> None: ... + def checkPropertyAccess(self, string: String | str) -> None: ... + @typing.overload + def checkRead(self, fileDescriptor: java.io.FileDescriptor) -> None: ... + @typing.overload + def checkRead(self, string: String | str) -> None: ... + @typing.overload + def checkRead(self, string: String | str, object: typing.Any) -> None: ... + def checkSecurityAccess(self, string: String | str) -> None: ... + def checkSetFactory(self) -> None: ... + @typing.overload + def checkWrite(self, fileDescriptor: java.io.FileDescriptor) -> None: ... + @typing.overload + def checkWrite(self, string: String | str) -> None: ... + def getSecurityContext(self) -> typing.Any: ... + def getThreadGroup(self) -> ThreadGroup: ... + +_StableValue__T = typing.TypeVar("_StableValue__T") # + +class StableValue(typing.Generic[_StableValue__T]): + def equals(self, object: typing.Any) -> bool: ... + _function__T = typing.TypeVar("_function__T") # + _function__R = typing.TypeVar("_function__R") # + @staticmethod + def function( + set: java.util.Set[_function__T], + function: java.util.function.Function[_function__T, _function__R] + | typing.Callable[[_function__T], _function__R], + ) -> java.util.function.Function[_function__T, _function__R]: ... + def hashCode(self) -> int: ... + _intFunction__R = typing.TypeVar("_intFunction__R") # + @staticmethod + def intFunction( + int: int, + intFunction: java.util.function.IntFunction[_intFunction__R] + | typing.Callable[[int], _intFunction__R], + ) -> java.util.function.IntFunction[_intFunction__R]: ... + def isSet(self) -> bool: ... + _list__E = typing.TypeVar("_list__E") # + @staticmethod + def list( + int: int, + intFunction: java.util.function.IntFunction[_list__E] + | typing.Callable[[int], _list__E], + ) -> java.util.List[_list__E]: ... + _map__K = typing.TypeVar("_map__K") # + _map__V = typing.TypeVar("_map__V") # + @staticmethod + def map( + set: java.util.Set[_map__K], + function: java.util.function.Function[_map__K, _map__V] + | typing.Callable[[_map__K], _map__V], + ) -> java.util.Map[_map__K, _map__V]: ... + _of_0__T = typing.TypeVar("_of_0__T") # + _of_1__T = typing.TypeVar("_of_1__T") # + @typing.overload + @staticmethod + def of() -> StableValue[_of_0__T]: ... + @typing.overload + @staticmethod + def of(t: _of_1__T) -> StableValue[_of_1__T]: ... + def orElse(self, t: _StableValue__T) -> _StableValue__T: ... + def orElseSet( + self, + supplier: java.util.function.Supplier[_StableValue__T] + | typing.Callable[[], _StableValue__T], + ) -> _StableValue__T: ... + def orElseThrow(self) -> _StableValue__T: ... + def setOrThrow(self, t: _StableValue__T) -> None: ... + _supplier__T = typing.TypeVar("_supplier__T") # + @staticmethod + def supplier( + supplier: java.util.function.Supplier[_supplier__T] + | typing.Callable[[], _supplier__T], + ) -> java.util.function.Supplier[_supplier__T]: ... + def trySet(self, t: _StableValue__T) -> bool: ... + +class StackTraceElement(java.io.Serializable): + @typing.overload + def __init__( + self, + string: String | str, + string2: String | str, + string3: String | str, + int: int, + ): ... + @typing.overload + def __init__( + self, + string: String | str, + string2: String | str, + string3: String | str, + string4: String | str, + string5: String | str, + string6: String | str, + int: int, + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getClassLoaderName(self) -> String: ... + def getClassName(self) -> String: ... + def getFileName(self) -> String: ... + def getLineNumber(self) -> int: ... + def getMethodName(self) -> String: ... + def getModuleName(self) -> String: ... + def getModuleVersion(self) -> String: ... + def hashCode(self) -> int: ... + def isNativeMethod(self) -> bool: ... + def toString(self) -> String: ... + +class StrictMath: + E: typing.ClassVar[float] = ... + PI: typing.ClassVar[float] = ... + TAU: typing.ClassVar[float] = ... + @staticmethod + def IEEEremainder(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def abs(double: float) -> float: ... + @typing.overload + @staticmethod + def abs(float: float) -> float: ... + @typing.overload + @staticmethod + def abs(int: int) -> int: ... + @typing.overload + @staticmethod + def abs(long: int) -> int: ... + @typing.overload + @staticmethod + def absExact(int: int) -> int: ... + @typing.overload + @staticmethod + def absExact(long: int) -> int: ... + @staticmethod + def acos(double: float) -> float: ... + @typing.overload + @staticmethod + def addExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def addExact(long: int, long2: int) -> int: ... + @staticmethod + def asin(double: float) -> float: ... + @staticmethod + def atan(double: float) -> float: ... + @staticmethod + def atan2(double: float, double2: float) -> float: ... + @staticmethod + def cbrt(double: float) -> float: ... + @staticmethod + def ceil(double: float) -> float: ... + @typing.overload + @staticmethod + def ceilDiv(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def ceilDiv(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def ceilDiv(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def ceilDivExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def ceilDivExact(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def ceilMod(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def ceilMod(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def ceilMod(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def clamp(double: float, double2: float, double3: float) -> float: ... + @typing.overload + @staticmethod + def clamp(float: float, float2: float, float3: float) -> float: ... + @typing.overload + @staticmethod + def clamp(long: int, int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def clamp(long: int, long2: int, long3: int) -> int: ... + @typing.overload + @staticmethod + def copySign(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def copySign(float: float, float2: float) -> float: ... + @staticmethod + def cos(double: float) -> float: ... + @staticmethod + def cosh(double: float) -> float: ... + @typing.overload + @staticmethod + def decrementExact(int: int) -> int: ... + @typing.overload + @staticmethod + def decrementExact(long: int) -> int: ... + @typing.overload + @staticmethod + def divideExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def divideExact(long: int, long2: int) -> int: ... + @staticmethod + def exp(double: float) -> float: ... + @staticmethod + def expm1(double: float) -> float: ... + @staticmethod + def floor(double: float) -> float: ... + @typing.overload + @staticmethod + def floorDiv(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def floorDiv(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def floorDiv(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def floorDivExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def floorDivExact(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def floorMod(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def floorMod(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def floorMod(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def fma(double: float, double2: float, double3: float) -> float: ... + @typing.overload + @staticmethod + def fma(float: float, float2: float, float3: float) -> float: ... + @typing.overload + @staticmethod + def getExponent(double: float) -> int: ... + @typing.overload + @staticmethod + def getExponent(float: float) -> int: ... + @staticmethod + def hypot(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def incrementExact(int: int) -> int: ... + @typing.overload + @staticmethod + def incrementExact(long: int) -> int: ... + @staticmethod + def log(double: float) -> float: ... + @staticmethod + def log10(double: float) -> float: ... + @staticmethod + def log1p(double: float) -> float: ... + @typing.overload + @staticmethod + def max(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def max(float: float, float2: float) -> float: ... + @typing.overload + @staticmethod + def max(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def max(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def min(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def min(float: float, float2: float) -> float: ... + @typing.overload + @staticmethod + def min(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def min(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def multiplyExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def multiplyExact(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def multiplyExact(long: int, long2: int) -> int: ... + @staticmethod + def multiplyFull(int: int, int2: int) -> int: ... + @staticmethod + def multiplyHigh(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def negateExact(int: int) -> int: ... + @typing.overload + @staticmethod + def negateExact(long: int) -> int: ... + @typing.overload + @staticmethod + def nextAfter(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def nextAfter(float: float, double: float) -> float: ... + @typing.overload + @staticmethod + def nextDown(double: float) -> float: ... + @typing.overload + @staticmethod + def nextDown(float: float) -> float: ... + @typing.overload + @staticmethod + def nextUp(double: float) -> float: ... + @typing.overload + @staticmethod + def nextUp(float: float) -> float: ... + @staticmethod + def pow(double: float, double2: float) -> float: ... + @typing.overload + @staticmethod + def powExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def powExact(long: int, int: int) -> int: ... + @staticmethod + def random() -> float: ... + @staticmethod + def rint(double: float) -> float: ... + @typing.overload + @staticmethod + def round(float: float) -> int: ... + @typing.overload + @staticmethod + def round(double: float) -> int: ... + @typing.overload + @staticmethod + def scalb(double: float, int: int) -> float: ... + @typing.overload + @staticmethod + def scalb(float: float, int: int) -> float: ... + @typing.overload + @staticmethod + def signum(double: float) -> float: ... + @typing.overload + @staticmethod + def signum(float: float) -> float: ... + @staticmethod + def sin(double: float) -> float: ... + @staticmethod + def sinh(double: float) -> float: ... + @staticmethod + def sqrt(double: float) -> float: ... + @typing.overload + @staticmethod + def subtractExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def subtractExact(long: int, long2: int) -> int: ... + @staticmethod + def tan(double: float) -> float: ... + @staticmethod + def tanh(double: float) -> float: ... + @staticmethod + def toDegrees(double: float) -> float: ... + @staticmethod + def toIntExact(long: int) -> int: ... + @staticmethod + def toRadians(double: float) -> float: ... + @typing.overload + @staticmethod + def ulp(double: float) -> float: ... + @typing.overload + @staticmethod + def ulp(float: float) -> float: ... + @typing.overload + @staticmethod + def unsignedMultiplyExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def unsignedMultiplyExact(long: int, int: int) -> int: ... + @typing.overload + @staticmethod + def unsignedMultiplyExact(long: int, long2: int) -> int: ... + @staticmethod + def unsignedMultiplyHigh(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def unsignedPowExact(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def unsignedPowExact(long: int, int: int) -> int: ... + +class SuppressWarnings(java.lang.annotation.Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> String: ... + def value(self) -> typing.MutableSequence[String]: ... + +_ThreadLocal__T = typing.TypeVar("_ThreadLocal__T") # + +class ThreadLocal(typing.Generic[_ThreadLocal__T]): + def __init__(self): ... + def get(self) -> _ThreadLocal__T: ... + def remove(self) -> None: ... + def set(self, t: _ThreadLocal__T) -> None: ... + _withInitial__S = typing.TypeVar("_withInitial__S") # + @staticmethod + def withInitial( + supplier: java.util.function.Supplier[_withInitial__S] + | typing.Callable[[], _withInitial__S], + ) -> ThreadLocal[_withInitial__S]: ... + +class Throwable(java.io.Serializable, JException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + def addSuppressed(self, throwable: Throwable) -> None: ... + def fillInStackTrace(self) -> Throwable: ... + def getCause(self) -> Throwable: ... + def getLocalizedMessage(self) -> String: ... + def getMessage(self) -> String: ... + def getStackTrace(self) -> typing.MutableSequence[StackTraceElement]: ... + def getSuppressed(self) -> typing.MutableSequence[Throwable]: ... + def initCause(self, throwable: Throwable) -> Throwable: ... + @typing.overload + def printStackTrace(self) -> None: ... + @typing.overload + def printStackTrace(self, printStream: java.io.PrintStream) -> None: ... + @typing.overload + def printStackTrace(self, printWriter: java.io.PrintWriter) -> None: ... + def setStackTrace( + self, stackTraceElementArray: list[StackTraceElement] | jpype.JArray + ) -> None: ... + def toString(self) -> String: ... + +class Void: + TYPE: typing.ClassVar[type] = ... + +class Boolean(java.io.Serializable, Comparable[bool], java.lang.constant.Constable): + TRUE: typing.ClassVar[bool] = ... + FALSE: typing.ClassVar[bool] = ... + TYPE: typing.ClassVar[type] = ... + @typing.overload + def __init__(self, boolean: bool): ... + @typing.overload + def __init__(self, string: String | str): ... + def booleanValue(self) -> bool: ... + @staticmethod + def compare(boolean: bool, boolean2: bool) -> int: ... + def compareTo(self, boolean: bool) -> int: ... + def describeConstable( + self, + ) -> java.util.Optional[java.lang.constant.DynamicConstantDesc[bool]]: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def getBoolean(string: String | str) -> bool: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(boolean: bool) -> int: ... + @staticmethod + def logicalAnd(boolean: bool, boolean2: bool) -> bool: ... + @staticmethod + def logicalOr(boolean: bool, boolean2: bool) -> bool: ... + @staticmethod + def logicalXor(boolean: bool, boolean2: bool) -> bool: ... + @staticmethod + def parseBoolean(string: String | str) -> bool: ... + @typing.overload + def toString(self) -> String: ... + @typing.overload + @staticmethod + def toString(boolean: bool) -> String: ... + @typing.overload + @staticmethod + def valueOf(boolean: bool) -> bool: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> bool: ... + +class Byte(Number, Comparable[int], java.lang.constant.Constable): + MIN_VALUE: typing.ClassVar[int] = ... + MAX_VALUE: typing.ClassVar[int] = ... + TYPE: typing.ClassVar[type] = ... + SIZE: typing.ClassVar[int] = ... + BYTES: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, byte: int): ... + @typing.overload + def __init__(self, string: String | str): ... + def byteValue(self) -> int: ... + @staticmethod + def compare(byte: int, byte2: int) -> int: ... + def compareTo(self, byte: int) -> int: ... + @staticmethod + def compareUnsigned(byte: int, byte2: int) -> int: ... + @staticmethod + def decode(string: String | str) -> int: ... + def describeConstable( + self, + ) -> java.util.Optional[java.lang.constant.DynamicConstantDesc[int]]: ... + def doubleValue(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def floatValue(self) -> float: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(byte: int) -> int: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + @typing.overload + @staticmethod + def parseByte(string: String | str) -> int: ... + @typing.overload + @staticmethod + def parseByte(string: String | str, int: int) -> int: ... + def shortValue(self) -> int: ... + @typing.overload + def toString(self) -> String: ... + @typing.overload + @staticmethod + def toString(byte: int) -> String: ... + @staticmethod + def toUnsignedInt(byte: int) -> int: ... + @staticmethod + def toUnsignedLong(byte: int) -> int: ... + @typing.overload + @staticmethod + def valueOf(byte: int) -> int: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> int: ... + @typing.overload + @staticmethod + def valueOf(string: String | str, int: int) -> int: ... + +class Double( + Number, + Comparable[float], + java.lang.constant.Constable, + java.lang.constant.ConstantDesc, +): + POSITIVE_INFINITY: typing.ClassVar[float] = ... + NEGATIVE_INFINITY: typing.ClassVar[float] = ... + NaN: typing.ClassVar[float] = ... + MAX_VALUE: typing.ClassVar[float] = ... + MIN_NORMAL: typing.ClassVar[float] = ... + MIN_VALUE: typing.ClassVar[float] = ... + SIZE: typing.ClassVar[int] = ... + PRECISION: typing.ClassVar[int] = ... + MAX_EXPONENT: typing.ClassVar[int] = ... + MIN_EXPONENT: typing.ClassVar[int] = ... + BYTES: typing.ClassVar[int] = ... + TYPE: typing.ClassVar[type] = ... + @typing.overload + def __init__(self, double: float): ... + @typing.overload + def __init__(self, string: String | str): ... + def byteValue(self) -> int: ... + @staticmethod + def compare(double: float, double2: float) -> int: ... + def compareTo(self, double: float) -> int: ... + def describeConstable(self) -> java.util.Optional[float]: ... + @staticmethod + def doubleToLongBits(double: float) -> int: ... + @staticmethod + def doubleToRawLongBits(double: float) -> int: ... + def doubleValue(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def floatValue(self) -> float: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(double: float) -> int: ... + def intValue(self) -> int: ... + @staticmethod + def isFinite(double: float) -> bool: ... + @typing.overload + def isInfinite(self) -> bool: ... + @typing.overload + @staticmethod + def isInfinite(double: float) -> bool: ... + @typing.overload + def isNaN(self) -> bool: ... + @typing.overload + @staticmethod + def isNaN(double: float) -> bool: ... + @staticmethod + def longBitsToDouble(long: int) -> float: ... + def longValue(self) -> int: ... + @staticmethod + def max(double: float, double2: float) -> float: ... + @staticmethod + def min(double: float, double2: float) -> float: ... + @staticmethod + def parseDouble(string: String | str) -> float: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> float: ... + def shortValue(self) -> int: ... + @staticmethod + def sum(double: float, double2: float) -> float: ... + @staticmethod + def toHexString(double: float) -> String: ... + @typing.overload + def toString(self) -> String: ... + @typing.overload + @staticmethod + def toString(double: float) -> String: ... + @typing.overload + @staticmethod + def valueOf(double: float) -> float: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> float: ... + +_Enum__EnumDesc__E = typing.TypeVar("_Enum__EnumDesc__E", bound="Enum") # +_Enum__E = typing.TypeVar("_Enum__E", bound="Enum") # + +class Enum( + java.lang.constant.Constable, + Comparable[_Enum__E], + java.io.Serializable, + typing.Generic[_Enum__E], +): + def compareTo(self, e: _Enum__E) -> int: ... + def describeConstable(self) -> java.util.Optional[Enum.EnumDesc[_Enum__E]]: ... + def equals(self, object: typing.Any) -> bool: ... + def getDeclaringClass(self) -> type[_Enum__E]: ... + def hashCode(self) -> int: ... + def name(self) -> String: ... + def ordinal(self) -> int: ... + def toString(self) -> String: ... + _valueOf__T = typing.TypeVar("_valueOf__T", bound="Enum") # + @staticmethod + def valueOf(class_: type[_valueOf__T], string: String | str) -> _valueOf__T: ... + class EnumDesc( + java.lang.constant.DynamicConstantDesc[_Enum__EnumDesc__E], + typing.Generic[_Enum__EnumDesc__E], + ): + _of_0__E = typing.TypeVar("_of_0__E", bound="Enum") # + _of_1__T = typing.TypeVar("_of_1__T") # + _of_2__T = typing.TypeVar("_of_2__T") # + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, string: String | str + ) -> Enum.EnumDesc[_of_0__E]: ... + @typing.overload + @staticmethod + def of( + directMethodHandleDesc: java.lang.constant.DirectMethodHandleDesc, + ) -> java.lang.constant.DynamicConstantDesc[_of_1__T]: ... + @typing.overload + @staticmethod + def of( + directMethodHandleDesc: java.lang.constant.DirectMethodHandleDesc, + *constantDesc: java.lang.constant.ConstantDesc, + ) -> java.lang.constant.DynamicConstantDesc[_of_2__T]: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> _Enum__EnumDesc__E: ... + def toString(self) -> String: ... + +class Error(Throwable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class Exception(Throwable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class Float( + Number, + Comparable[float], + java.lang.constant.Constable, + java.lang.constant.ConstantDesc, +): + POSITIVE_INFINITY: typing.ClassVar[float] = ... + NEGATIVE_INFINITY: typing.ClassVar[float] = ... + NaN: typing.ClassVar[float] = ... + MAX_VALUE: typing.ClassVar[float] = ... + MIN_NORMAL: typing.ClassVar[float] = ... + MIN_VALUE: typing.ClassVar[float] = ... + SIZE: typing.ClassVar[int] = ... + PRECISION: typing.ClassVar[int] = ... + MAX_EXPONENT: typing.ClassVar[int] = ... + MIN_EXPONENT: typing.ClassVar[int] = ... + BYTES: typing.ClassVar[int] = ... + TYPE: typing.ClassVar[type] = ... + @typing.overload + def __init__(self, double: float): ... + @typing.overload + def __init__(self, float: float): ... + @typing.overload + def __init__(self, string: String | str): ... + def byteValue(self) -> int: ... + @staticmethod + def compare(float: float, float2: float) -> int: ... + def compareTo(self, float: float) -> int: ... + def describeConstable(self) -> java.util.Optional[float]: ... + def doubleValue(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def float16ToFloat(short: int) -> float: ... + @staticmethod + def floatToFloat16(float: float) -> int: ... + @staticmethod + def floatToIntBits(float: float) -> int: ... + @staticmethod + def floatToRawIntBits(float: float) -> int: ... + def floatValue(self) -> float: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(float: float) -> int: ... + @staticmethod + def intBitsToFloat(int: int) -> float: ... + def intValue(self) -> int: ... + @staticmethod + def isFinite(float: float) -> bool: ... + @typing.overload + def isInfinite(self) -> bool: ... + @typing.overload + @staticmethod + def isInfinite(float: float) -> bool: ... + @typing.overload + def isNaN(self) -> bool: ... + @typing.overload + @staticmethod + def isNaN(float: float) -> bool: ... + def longValue(self) -> int: ... + @staticmethod + def max(float: float, float2: float) -> float: ... + @staticmethod + def min(float: float, float2: float) -> float: ... + @staticmethod + def parseFloat(string: String | str) -> float: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> float: ... + def shortValue(self) -> int: ... + @staticmethod + def sum(float: float, float2: float) -> float: ... + @staticmethod + def toHexString(float: float) -> String: ... + @typing.overload + def toString(self) -> String: ... + @typing.overload + @staticmethod + def toString(float: float) -> String: ... + @typing.overload + @staticmethod + def valueOf(float: float) -> float: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> float: ... + +_InheritableThreadLocal__T = typing.TypeVar("_InheritableThreadLocal__T") # + +class InheritableThreadLocal( + ThreadLocal[_InheritableThreadLocal__T], typing.Generic[_InheritableThreadLocal__T] +): + def __init__(self): ... + +class Integer( + Number, + Comparable[int], + java.lang.constant.Constable, + java.lang.constant.ConstantDesc, +): + MIN_VALUE: typing.ClassVar[int] = ... + MAX_VALUE: typing.ClassVar[int] = ... + TYPE: typing.ClassVar[type] = ... + SIZE: typing.ClassVar[int] = ... + BYTES: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, string: String | str): ... + @staticmethod + def bitCount(int: int) -> int: ... + def byteValue(self) -> int: ... + @staticmethod + def compare(int: int, int2: int) -> int: ... + def compareTo(self, integer: int) -> int: ... + @staticmethod + def compareUnsigned(int: int, int2: int) -> int: ... + @staticmethod + def compress(int: int, int2: int) -> int: ... + @staticmethod + def decode(string: String | str) -> int: ... + def describeConstable(self) -> java.util.Optional[int]: ... + @staticmethod + def divideUnsigned(int: int, int2: int) -> int: ... + def doubleValue(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def expand(int: int, int2: int) -> int: ... + def floatValue(self) -> float: ... + @typing.overload + @staticmethod + def getInteger(string: String | str) -> int: ... + @typing.overload + @staticmethod + def getInteger(string: String | str, int: int) -> int: ... + @typing.overload + @staticmethod + def getInteger(string: String | str, integer: int) -> int: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(int: int) -> int: ... + @staticmethod + def highestOneBit(int: int) -> int: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + @staticmethod + def lowestOneBit(int: int) -> int: ... + @staticmethod + def max(int: int, int2: int) -> int: ... + @staticmethod + def min(int: int, int2: int) -> int: ... + @staticmethod + def numberOfLeadingZeros(int: int) -> int: ... + @staticmethod + def numberOfTrailingZeros(int: int) -> int: ... + @typing.overload + @staticmethod + def parseInt( + charSequence: CharSequence | str, int: int, int2: int, int3: int + ) -> int: ... + @typing.overload + @staticmethod + def parseInt(string: String | str) -> int: ... + @typing.overload + @staticmethod + def parseInt(string: String | str, int: int) -> int: ... + @typing.overload + @staticmethod + def parseUnsignedInt( + charSequence: CharSequence | str, int: int, int2: int, int3: int + ) -> int: ... + @typing.overload + @staticmethod + def parseUnsignedInt(string: String | str) -> int: ... + @typing.overload + @staticmethod + def parseUnsignedInt(string: String | str, int: int) -> int: ... + @staticmethod + def remainderUnsigned(int: int, int2: int) -> int: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> int: ... + @staticmethod + def reverse(int: int) -> int: ... + @staticmethod + def reverseBytes(int: int) -> int: ... + @staticmethod + def rotateLeft(int: int, int2: int) -> int: ... + @staticmethod + def rotateRight(int: int, int2: int) -> int: ... + def shortValue(self) -> int: ... + @staticmethod + def signum(int: int) -> int: ... + @staticmethod + def sum(int: int, int2: int) -> int: ... + @staticmethod + def toBinaryString(int: int) -> String: ... + @staticmethod + def toHexString(int: int) -> String: ... + @staticmethod + def toOctalString(int: int) -> String: ... + @typing.overload + def toString(self) -> String: ... + @typing.overload + @staticmethod + def toString(int: int) -> String: ... + @typing.overload + @staticmethod + def toString(int: int, int2: int) -> String: ... + @staticmethod + def toUnsignedLong(int: int) -> int: ... + @typing.overload + @staticmethod + def toUnsignedString(int: int) -> String: ... + @typing.overload + @staticmethod + def toUnsignedString(int: int, int2: int) -> String: ... + @typing.overload + @staticmethod + def valueOf(int: int) -> int: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> int: ... + @typing.overload + @staticmethod + def valueOf(string: String | str, int: int) -> int: ... + +class Long( + Number, + Comparable[int], + java.lang.constant.Constable, + java.lang.constant.ConstantDesc, +): + MIN_VALUE: typing.ClassVar[int] = ... + MAX_VALUE: typing.ClassVar[int] = ... + TYPE: typing.ClassVar[type] = ... + SIZE: typing.ClassVar[int] = ... + BYTES: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, long: int): ... + @staticmethod + def bitCount(long: int) -> int: ... + def byteValue(self) -> int: ... + @staticmethod + def compare(long: int, long2: int) -> int: ... + def compareTo(self, long: int) -> int: ... + @staticmethod + def compareUnsigned(long: int, long2: int) -> int: ... + @staticmethod + def compress(long: int, long2: int) -> int: ... + @staticmethod + def decode(string: String | str) -> int: ... + def describeConstable(self) -> java.util.Optional[int]: ... + @staticmethod + def divideUnsigned(long: int, long2: int) -> int: ... + def doubleValue(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def expand(long: int, long2: int) -> int: ... + def floatValue(self) -> float: ... + @typing.overload + @staticmethod + def getLong(string: String | str) -> int: ... + @typing.overload + @staticmethod + def getLong(string: String | str, long: int) -> int: ... + @typing.overload + @staticmethod + def getLong(string: String | str, long: int) -> int: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(long: int) -> int: ... + @staticmethod + def highestOneBit(long: int) -> int: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + @staticmethod + def lowestOneBit(long: int) -> int: ... + @staticmethod + def max(long: int, long2: int) -> int: ... + @staticmethod + def min(long: int, long2: int) -> int: ... + @staticmethod + def numberOfLeadingZeros(long: int) -> int: ... + @staticmethod + def numberOfTrailingZeros(long: int) -> int: ... + @typing.overload + @staticmethod + def parseLong( + charSequence: CharSequence | str, int: int, int2: int, int3: int + ) -> int: ... + @typing.overload + @staticmethod + def parseLong(string: String | str) -> int: ... + @typing.overload + @staticmethod + def parseLong(string: String | str, int: int) -> int: ... + @typing.overload + @staticmethod + def parseUnsignedLong( + charSequence: CharSequence | str, int: int, int2: int, int3: int + ) -> int: ... + @typing.overload + @staticmethod + def parseUnsignedLong(string: String | str) -> int: ... + @typing.overload + @staticmethod + def parseUnsignedLong(string: String | str, int: int) -> int: ... + @staticmethod + def remainderUnsigned(long: int, long2: int) -> int: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> int: ... + @staticmethod + def reverse(long: int) -> int: ... + @staticmethod + def reverseBytes(long: int) -> int: ... + @staticmethod + def rotateLeft(long: int, int: int) -> int: ... + @staticmethod + def rotateRight(long: int, int: int) -> int: ... + def shortValue(self) -> int: ... + @staticmethod + def signum(long: int) -> int: ... + @staticmethod + def sum(long: int, long2: int) -> int: ... + @staticmethod + def toBinaryString(long: int) -> String: ... + @staticmethod + def toHexString(long: int) -> String: ... + @staticmethod + def toOctalString(long: int) -> String: ... + @typing.overload + def toString(self) -> String: ... + @typing.overload + @staticmethod + def toString(long: int) -> String: ... + @typing.overload + @staticmethod + def toString(long: int, int: int) -> String: ... + @typing.overload + @staticmethod + def toUnsignedString(long: int) -> String: ... + @typing.overload + @staticmethod + def toUnsignedString(long: int, int: int) -> String: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> int: ... + @typing.overload + @staticmethod + def valueOf(string: String | str, int: int) -> int: ... + @typing.overload + @staticmethod + def valueOf(long: int) -> int: ... + +class ProcessHandle(Comparable["ProcessHandle"]): + @staticmethod + def allProcesses() -> java.util.stream.Stream[ProcessHandle]: ... + def children(self) -> java.util.stream.Stream[ProcessHandle]: ... + def compareTo(self, processHandle: ProcessHandle) -> int: ... + @staticmethod + def current() -> ProcessHandle: ... + def descendants(self) -> java.util.stream.Stream[ProcessHandle]: ... + def destroy(self) -> bool: ... + def destroyForcibly(self) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def info(self) -> ProcessHandle.Info: ... + def isAlive(self) -> bool: ... + @staticmethod + def of(long: int) -> java.util.Optional[ProcessHandle]: ... + def onExit(self) -> java.util.concurrent.CompletableFuture[ProcessHandle]: ... + def parent(self) -> java.util.Optional[ProcessHandle]: ... + def pid(self) -> int: ... + def supportsNormalTermination(self) -> bool: ... + class Info: + def arguments(self) -> java.util.Optional[typing.MutableSequence[String]]: ... + def command(self) -> java.util.Optional[String]: ... + def commandLine(self) -> java.util.Optional[String]: ... + def startInstant(self) -> java.util.Optional[java.time.Instant]: ... + def totalCpuDuration(self) -> java.util.Optional[java.time.Duration]: ... + def user(self) -> java.util.Optional[String]: ... + +class Runtime(_JRuntime): + def availableProcessors(self) -> int: ... + @typing.overload + def exec_(self, string: String | str) -> Process: ... + @typing.overload + def exec_( + self, string: String | str, stringArray: list[String] | jpype.JArray + ) -> Process: ... + @typing.overload + def exec_( + self, + string: String | str, + stringArray: list[String] | jpype.JArray, + file: java.io.File | jpype.protocol.SupportsPath, + ) -> Process: ... + @typing.overload + def exec_(self, stringArray: list[String] | jpype.JArray) -> Process: ... + @typing.overload + def exec_( + self, + stringArray: list[String] | jpype.JArray, + stringArray2: list[String] | jpype.JArray, + ) -> Process: ... + @typing.overload + def exec_( + self, + stringArray: list[String] | jpype.JArray, + stringArray2: list[String] | jpype.JArray, + file: java.io.File | jpype.protocol.SupportsPath, + ) -> Process: ... + def exit(self, int: int) -> None: ... + def freeMemory(self) -> int: ... + def gc(self) -> None: ... + @staticmethod + def getRuntime() -> Runtime: ... + def halt(self, int: int) -> None: ... + def load(self, string: String | str) -> None: ... + def loadLibrary(self, string: String | str) -> None: ... + def maxMemory(self) -> int: ... + def runFinalization(self) -> None: ... + def totalMemory(self) -> int: ... + @staticmethod + def version() -> Runtime.Version: ... + class Version(Comparable["Runtime.Version"]): + def build(self) -> java.util.Optional[int]: ... + def compareTo(self, version: Runtime.Version) -> int: ... + def compareToIgnoreOptional(self, version: Runtime.Version) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def equalsIgnoreOptional(self, object: typing.Any) -> bool: ... + def feature(self) -> int: ... + def hashCode(self) -> int: ... + def interim(self) -> int: ... + def major(self) -> int: ... + def minor(self) -> int: ... + def optional(self) -> java.util.Optional[String]: ... + @staticmethod + def parse(string: String | str) -> Runtime.Version: ... + def patch(self) -> int: ... + def pre(self) -> java.util.Optional[String]: ... + def security(self) -> int: ... + def toString(self) -> String: ... + def update(self) -> int: ... + def version(self) -> java.util.List[int]: ... + +class Short(Number, Comparable[int], java.lang.constant.Constable): + MIN_VALUE: typing.ClassVar[int] = ... + MAX_VALUE: typing.ClassVar[int] = ... + TYPE: typing.ClassVar[type] = ... + SIZE: typing.ClassVar[int] = ... + BYTES: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, short: int): ... + def byteValue(self) -> int: ... + @staticmethod + def compare(short: int, short2: int) -> int: ... + def compareTo(self, short: int) -> int: ... + @staticmethod + def compareUnsigned(short: int, short2: int) -> int: ... + @staticmethod + def decode(string: String | str) -> int: ... + def describeConstable( + self, + ) -> java.util.Optional[java.lang.constant.DynamicConstantDesc[int]]: ... + def doubleValue(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def floatValue(self) -> float: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(short: int) -> int: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + @typing.overload + @staticmethod + def parseShort(string: String | str) -> int: ... + @typing.overload + @staticmethod + def parseShort(string: String | str, int: int) -> int: ... + @staticmethod + def reverseBytes(short: int) -> int: ... + def shortValue(self) -> int: ... + @typing.overload + def toString(self) -> String: ... + @typing.overload + @staticmethod + def toString(short: int) -> String: ... + @staticmethod + def toUnsignedInt(short: int) -> int: ... + @staticmethod + def toUnsignedLong(short: int) -> int: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> int: ... + @typing.overload + @staticmethod + def valueOf(string: String | str, int: int) -> int: ... + @typing.overload + @staticmethod + def valueOf(short: int) -> int: ... + +class String( + java.io.Serializable, + Comparable["String"], + CharSequence, + java.lang.constant.Constable, + java.lang.constant.ConstantDesc, + _JStringProto, +): + CASE_INSENSITIVE_ORDER: typing.ClassVar[java.util.Comparator] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes, int: int): ... + @typing.overload + def __init__( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + ): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + string: String | str, + ): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__( + self, byteArray: list[int] | jpype.JArray | bytes, string: String | str + ): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__(self, charArray: list[str] | jpype.JArray): ... + @typing.overload + def __init__(self, charArray: list[str] | jpype.JArray, int: int, int2: int): ... + @typing.overload + def __init__(self, intArray: list[int] | jpype.JArray, int2: int, int3: int): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, stringBuffer: StringBuffer): ... + @typing.overload + def __init__(self, stringBuilder: StringBuilder): ... + def charAt(self, int: int) -> str: ... + def chars(self) -> java.util.stream.IntStream: ... + def codePointAt(self, int: int) -> int: ... + def codePointBefore(self, int: int) -> int: ... + def codePointCount(self, int: int, int2: int) -> int: ... + def codePoints(self) -> java.util.stream.IntStream: ... + def compareTo(self, string: String | str) -> int: ... + def compareToIgnoreCase(self, string: String | str) -> int: ... + def concat(self, string: String | str) -> String: ... + def contains(self, charSequence: CharSequence | str) -> bool: ... + @typing.overload + def contentEquals(self, charSequence: CharSequence | str) -> bool: ... + @typing.overload + def contentEquals(self, stringBuffer: StringBuffer) -> bool: ... + @typing.overload + @staticmethod + def copyValueOf(charArray: list[str] | jpype.JArray) -> String: ... + @typing.overload + @staticmethod + def copyValueOf( + charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> String: ... + def describeConstable(self) -> java.util.Optional[String]: ... + def endsWith(self, string: String | str) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def equalsIgnoreCase(self, string: String | str) -> bool: ... + @typing.overload + @staticmethod + def format(string: String | str, *object: typing.Any) -> String: ... + @typing.overload + @staticmethod + def format( + locale: java.util.Locale, string: String | str, *object: typing.Any + ) -> String: ... + def formatted(self, *object: typing.Any) -> String: ... + @typing.overload + def getBytes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getBytes(self, string: String | str) -> typing.MutableSequence[int]: ... + @typing.overload + def getBytes( + self, charset: java.nio.charset.Charset + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getBytes( + self, + int: int, + int2: int, + byteArray: list[int] | jpype.JArray | bytes, + int3: int, + ) -> None: ... + def getChars( + self, int: int, int2: int, charArray: list[str] | jpype.JArray, int3: int + ) -> None: ... + def hashCode(self) -> int: ... + def indent(self, int: int) -> String: ... + @typing.overload + def indexOf(self, int: int) -> int: ... + @typing.overload + def indexOf(self, int: int, int2: int) -> int: ... + @typing.overload + def indexOf(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def indexOf(self, string: String | str) -> int: ... + @typing.overload + def indexOf(self, string: String | str, int: int) -> int: ... + @typing.overload + def indexOf(self, string: String | str, int: int, int2: int) -> int: ... + def intern(self) -> String: ... + def isBlank(self) -> bool: ... + def isEmpty(self) -> bool: ... + @typing.overload + @staticmethod + def join( + charSequence: CharSequence | str, *charSequence2: CharSequence | str + ) -> String: ... + @typing.overload + @staticmethod + def join( + charSequence: CharSequence | str, + iterable: Iterable[CharSequence] + | typing.Sequence[CharSequence] + | set[CharSequence] + | typing.Callable[[], java.util.Iterator[typing.Any]], + ) -> String: ... + @typing.overload + def lastIndexOf(self, int: int) -> int: ... + @typing.overload + def lastIndexOf(self, int: int, int2: int) -> int: ... + @typing.overload + def lastIndexOf(self, string: String | str) -> int: ... + @typing.overload + def lastIndexOf(self, string: String | str, int: int) -> int: ... + def length(self) -> int: ... + def lines(self) -> java.util.stream.Stream[String]: ... + def matches(self, string: String | str) -> bool: ... + def offsetByCodePoints(self, int: int, int2: int) -> int: ... + @typing.overload + def regionMatches( + self, boolean: bool, int: int, string: String | str, int2: int, int3: int + ) -> bool: ... + @typing.overload + def regionMatches( + self, int: int, string: String | str, int2: int, int3: int + ) -> bool: ... + def repeat(self, int: int) -> String: ... + @typing.overload + def replace(self, char: str, char2: str) -> String: ... + @typing.overload + def replace( + self, charSequence: CharSequence | str, charSequence2: CharSequence | str + ) -> String: ... + def replaceAll(self, string: String | str, string2: String | str) -> String: ... + def replaceFirst(self, string: String | str, string2: String | str) -> String: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> String: ... + @typing.overload + def split(self, string: String | str) -> typing.MutableSequence[String]: ... + @typing.overload + def split( + self, string: String | str, int: int + ) -> typing.MutableSequence[String]: ... + def splitWithDelimiters( + self, string: String | str, int: int + ) -> typing.MutableSequence[String]: ... + @typing.overload + def startsWith(self, string: String | str) -> bool: ... + @typing.overload + def startsWith(self, string: String | str, int: int) -> bool: ... + def strip(self) -> String: ... + def stripIndent(self) -> String: ... + def stripLeading(self) -> String: ... + def stripTrailing(self) -> String: ... + def subSequence(self, int: int, int2: int) -> CharSequence: ... + @typing.overload + def substring(self, int: int) -> String: ... + @typing.overload + def substring(self, int: int, int2: int) -> String: ... + def toCharArray(self) -> typing.MutableSequence[str]: ... + @typing.overload + def toLowerCase(self) -> String: ... + @typing.overload + def toLowerCase(self, locale: java.util.Locale) -> String: ... + def toString(self) -> String: ... + @typing.overload + def toUpperCase(self) -> String: ... + @typing.overload + def toUpperCase(self, locale: java.util.Locale) -> String: ... + _transform__R = typing.TypeVar("_transform__R") # + def transform( + self, + function: java.util.function.Function[String, _transform__R] + | typing.Callable[[String], _transform__R], + ) -> _transform__R: ... + def translateEscapes(self) -> String: ... + def trim(self) -> String: ... + @typing.overload + @staticmethod + def valueOf(boolean: bool) -> String: ... + @typing.overload + @staticmethod + def valueOf(char: str) -> String: ... + @typing.overload + @staticmethod + def valueOf(charArray: list[str] | jpype.JArray) -> String: ... + @typing.overload + @staticmethod + def valueOf(charArray: list[str] | jpype.JArray, int: int, int2: int) -> String: ... + @typing.overload + @staticmethod + def valueOf(double: float) -> String: ... + @typing.overload + @staticmethod + def valueOf(float: float) -> String: ... + @typing.overload + @staticmethod + def valueOf(int: int) -> String: ... + @typing.overload + @staticmethod + def valueOf(object: typing.Any) -> String: ... + @typing.overload + @staticmethod + def valueOf(long: int) -> String: ... + +class AssertionError(Error): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + @typing.overload + def __init__(self, char: str): ... + @typing.overload + def __init__(self, double: float): ... + @typing.overload + def __init__(self, float: float): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, object: typing.Any): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, long: int): ... + +class CloneNotSupportedException(Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class InterruptedException(Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class LinkageError(Error): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + +class ProcessBuilder: + @typing.overload + def __init__(self, *string: String | str): ... + @typing.overload + def __init__(self, list: java.util.List[String | str]): ... + @typing.overload + def command(self, *string: String | str) -> ProcessBuilder: ... + @typing.overload + def command(self, list: java.util.List[String | str]) -> ProcessBuilder: ... + @typing.overload + def command(self) -> java.util.List[String]: ... + @typing.overload + def directory(self) -> java.io.File: ... + @typing.overload + def directory( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> ProcessBuilder: ... + def environment(self) -> java.util.Map[String, String]: ... + def inheritIO(self) -> ProcessBuilder: ... + @typing.overload + def redirectError( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> ProcessBuilder: ... + @typing.overload + def redirectError(self, redirect: ProcessBuilder.Redirect) -> ProcessBuilder: ... + @typing.overload + def redirectError(self) -> ProcessBuilder.Redirect: ... + @typing.overload + def redirectErrorStream(self) -> bool: ... + @typing.overload + def redirectErrorStream(self, boolean: bool) -> ProcessBuilder: ... + @typing.overload + def redirectInput( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> ProcessBuilder: ... + @typing.overload + def redirectInput(self, redirect: ProcessBuilder.Redirect) -> ProcessBuilder: ... + @typing.overload + def redirectInput(self) -> ProcessBuilder.Redirect: ... + @typing.overload + def redirectOutput( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> ProcessBuilder: ... + @typing.overload + def redirectOutput(self, redirect: ProcessBuilder.Redirect) -> ProcessBuilder: ... + @typing.overload + def redirectOutput(self) -> ProcessBuilder.Redirect: ... + def start(self) -> Process: ... + @staticmethod + def startPipeline( + list: java.util.List[ProcessBuilder], + ) -> java.util.List[Process]: ... + class Redirect: + PIPE: typing.ClassVar[ProcessBuilder.Redirect] = ... + INHERIT: typing.ClassVar[ProcessBuilder.Redirect] = ... + DISCARD: typing.ClassVar[ProcessBuilder.Redirect] = ... + @staticmethod + def appendTo( + file: java.io.File | jpype.protocol.SupportsPath, + ) -> ProcessBuilder.Redirect: ... + def equals(self, object: typing.Any) -> bool: ... + def file(self) -> java.io.File: ... + @staticmethod + def from_( + file: java.io.File | jpype.protocol.SupportsPath, + ) -> ProcessBuilder.Redirect: ... + def hashCode(self) -> int: ... + @staticmethod + def to( + file: java.io.File | jpype.protocol.SupportsPath, + ) -> ProcessBuilder.Redirect: ... + def type(self) -> ProcessBuilder.Redirect.Type: ... + class Type(Enum["ProcessBuilder.Redirect.Type"]): + PIPE: typing.ClassVar[ProcessBuilder.Redirect.Type] = ... + INHERIT: typing.ClassVar[ProcessBuilder.Redirect.Type] = ... + READ: typing.ClassVar[ProcessBuilder.Redirect.Type] = ... + WRITE: typing.ClassVar[ProcessBuilder.Redirect.Type] = ... + APPEND: typing.ClassVar[ProcessBuilder.Redirect.Type] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> ProcessBuilder.Redirect.Type: ... + @staticmethod + def values() -> typing.MutableSequence[ProcessBuilder.Redirect.Type]: ... + +class ReflectiveOperationException(Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class RuntimeException(Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class StackWalker: + def forEach( + self, + consumer: java.util.function.Consumer[StackWalker.StackFrame] + | typing.Callable[[StackWalker.StackFrame], None], + ) -> None: ... + def getCallerClass(self) -> type[typing.Any]: ... + @typing.overload + @staticmethod + def getInstance() -> StackWalker: ... + @typing.overload + @staticmethod + def getInstance(option: StackWalker.Option) -> StackWalker: ... + @typing.overload + @staticmethod + def getInstance(set: java.util.Set[StackWalker.Option]) -> StackWalker: ... + @typing.overload + @staticmethod + def getInstance( + set: java.util.Set[StackWalker.Option], int: int + ) -> StackWalker: ... + _walk__T = typing.TypeVar("_walk__T") # + def walk( + self, + function: java.util.function.Function[ + java.util.stream.Stream[StackWalker.StackFrame], _walk__T + ] + | typing.Callable[[java.util.stream.Stream[StackWalker.StackFrame]], _walk__T], + ) -> _walk__T: ... + class Option(Enum["StackWalker.Option"]): + RETAIN_CLASS_REFERENCE: typing.ClassVar[StackWalker.Option] = ... + DROP_METHOD_INFO: typing.ClassVar[StackWalker.Option] = ... + SHOW_REFLECT_FRAMES: typing.ClassVar[StackWalker.Option] = ... + SHOW_HIDDEN_FRAMES: typing.ClassVar[StackWalker.Option] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> StackWalker.Option: ... + @staticmethod + def values() -> typing.MutableSequence[StackWalker.Option]: ... + + class StackFrame: + def getByteCodeIndex(self) -> int: ... + def getClassName(self) -> String: ... + def getDeclaringClass(self) -> type[typing.Any]: ... + def getDescriptor(self) -> String: ... + def getFileName(self) -> String: ... + def getLineNumber(self) -> int: ... + def getMethodName(self) -> String: ... + def getMethodType(self) -> java.lang.invoke.MethodType: ... + def isNativeMethod(self) -> bool: ... + def toStackTraceElement(self) -> StackTraceElement: ... + +class System: + in_: typing.ClassVar[java.io.InputStream] = ... + out: typing.ClassVar[java.io.PrintStream] = ... + err: typing.ClassVar[java.io.PrintStream] = ... + @staticmethod + def arraycopy( + object: typing.Any, int: int, object2: typing.Any, int2: int, int3: int + ) -> None: ... + @staticmethod + def clearProperty(string: String | str) -> String: ... + @staticmethod + def console() -> java.io.Console: ... + @staticmethod + def currentTimeMillis() -> int: ... + @staticmethod + def exit(int: int) -> None: ... + @staticmethod + def gc() -> None: ... + @typing.overload + @staticmethod + def getLogger(string: String | str) -> System.Logger: ... + @typing.overload + @staticmethod + def getLogger( + string: String | str, resourceBundle: java.util.ResourceBundle + ) -> System.Logger: ... + @staticmethod + def getProperties() -> java.util.Properties: ... + @typing.overload + @staticmethod + def getProperty(string: String | str) -> String: ... + @typing.overload + @staticmethod + def getProperty(string: String | str, string2: String | str) -> String: ... + @staticmethod + def getSecurityManager() -> SecurityManager: ... + @typing.overload + @staticmethod + def getenv(string: String | str) -> String: ... + @typing.overload + @staticmethod + def getenv() -> java.util.Map[String, String]: ... + @staticmethod + def identityHashCode(object: typing.Any) -> int: ... + @staticmethod + def inheritedChannel() -> java.nio.channels.Channel: ... + @staticmethod + def lineSeparator() -> String: ... + @staticmethod + def load(string: String | str) -> None: ... + @staticmethod + def loadLibrary(string: String | str) -> None: ... + @staticmethod + def mapLibraryName(string: String | str) -> String: ... + @staticmethod + def nanoTime() -> int: ... + @staticmethod + def runFinalization() -> None: ... + @staticmethod + def setErr(printStream: java.io.PrintStream) -> None: ... + @staticmethod + def setIn(inputStream: java.io.InputStream) -> None: ... + @staticmethod + def setOut(printStream: java.io.PrintStream) -> None: ... + @staticmethod + def setProperties(properties: java.util.Properties) -> None: ... + @staticmethod + def setProperty(string: String | str, string2: String | str) -> String: ... + @staticmethod + def setSecurityManager(securityManager: SecurityManager) -> None: ... + class Logger: + def getName(self) -> String: ... + def isLoggable(self, level: System.Logger.Level) -> bool: ... + @typing.overload + def log( + self, + level: System.Logger.Level, + resourceBundle: java.util.ResourceBundle, + string: String | str, + *object: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + level: System.Logger.Level, + resourceBundle: java.util.ResourceBundle, + string: String | str, + throwable: Throwable, + ) -> None: ... + @typing.overload + def log(self, level: System.Logger.Level, object: typing.Any) -> None: ... + @typing.overload + def log(self, level: System.Logger.Level, string: String | str) -> None: ... + @typing.overload + def log( + self, level: System.Logger.Level, string: String | str, *object: typing.Any + ) -> None: ... + @typing.overload + def log( + self, level: System.Logger.Level, string: String | str, throwable: Throwable + ) -> None: ... + @typing.overload + def log( + self, + level: System.Logger.Level, + supplier: java.util.function.Supplier[String | str] + | typing.Callable[[], String | str], + ) -> None: ... + @typing.overload + def log( + self, + level: System.Logger.Level, + supplier: java.util.function.Supplier[String | str] + | typing.Callable[[], String | str], + throwable: Throwable, + ) -> None: ... + class Level(Enum["System.Logger.Level"]): + ALL: typing.ClassVar[System.Logger.Level] = ... + TRACE: typing.ClassVar[System.Logger.Level] = ... + DEBUG: typing.ClassVar[System.Logger.Level] = ... + INFO: typing.ClassVar[System.Logger.Level] = ... + WARNING: typing.ClassVar[System.Logger.Level] = ... + ERROR: typing.ClassVar[System.Logger.Level] = ... + OFF: typing.ClassVar[System.Logger.Level] = ... + def getName(self) -> String: ... + def getSeverity(self) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> System.Logger.Level: ... + @staticmethod + def values() -> typing.MutableSequence[System.Logger.Level]: ... + + class LoggerFinder: + def getLocalizedLogger( + self, + string: String | str, + resourceBundle: java.util.ResourceBundle, + module: Module, + ) -> System.Logger: ... + def getLogger(self, string: String | str, module: Module) -> System.Logger: ... + @staticmethod + def getLoggerFinder() -> System.LoggerFinder: ... + +class ThreadDeath(Error): + def __init__(self): ... + +class VirtualMachineError(Error): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class ArithmeticException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class ArrayStoreException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class BootstrapMethodError(LinkageError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class ClassCastException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class ClassCircularityError(LinkageError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class ClassFormatError(LinkageError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class ClassNotFoundException(ReflectiveOperationException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + def getException(self) -> Throwable: ... + +class EnumConstantNotPresentException(RuntimeException): + def __init__(self, class_: type[Enum], string: String | str): ... + def constantName(self) -> String: ... + def enumType(self) -> type[Enum]: ... + +class ExceptionInInitializerError(LinkageError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + def getException(self) -> Throwable: ... + +class IllegalAccessException(ReflectiveOperationException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class IllegalArgumentException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class IllegalCallerException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class IllegalMonitorStateException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class IllegalStateException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class IncompatibleClassChangeError(LinkageError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class IndexOutOfBoundsException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, long: int): ... + +class InstantiationException(ReflectiveOperationException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class InternalError(VirtualMachineError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class LayerInstantiationException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class MatchException(RuntimeException): + def __init__(self, string: String | str, throwable: Throwable): ... + +class NegativeArraySizeException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class NoClassDefFoundError(LinkageError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class NoSuchFieldException(ReflectiveOperationException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class NoSuchMethodException(ReflectiveOperationException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class NullPointerException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + def fillInStackTrace(self) -> Throwable: ... + def getMessage(self) -> String: ... + +class OutOfMemoryError(VirtualMachineError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class SecurityException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class StackOverflowError(VirtualMachineError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class TypeNotPresentException(RuntimeException): + def __init__(self, string: String | str, throwable: Throwable): ... + def typeName(self) -> String: ... + +class UnknownError(VirtualMachineError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class UnsatisfiedLinkError(LinkageError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class UnsupportedOperationException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class VerifyError(LinkageError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class WrongThreadException(RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, string: String | str, throwable: Throwable): ... + @typing.overload + def __init__(self, throwable: Throwable): ... + +class AbstractMethodError(IncompatibleClassChangeError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class ArrayIndexOutOfBoundsException(IndexOutOfBoundsException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, string: String | str): ... + +class IllegalAccessError(IncompatibleClassChangeError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class IllegalThreadStateException(IllegalArgumentException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class InstantiationError(IncompatibleClassChangeError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class NoSuchFieldError(IncompatibleClassChangeError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class NoSuchMethodError(IncompatibleClassChangeError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class NumberFormatException(IllegalArgumentException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class StringIndexOutOfBoundsException(IndexOutOfBoundsException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, string: String | str): ... + +class UnsupportedClassVersionError(ClassFormatError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: String | str): ... + +class Character(java.io.Serializable, Comparable[str], java.lang.constant.Constable): + MIN_RADIX: typing.ClassVar[int] = ... + MAX_RADIX: typing.ClassVar[int] = ... + MIN_VALUE: typing.ClassVar[str] = ... + MAX_VALUE: typing.ClassVar[str] = ... + TYPE: typing.ClassVar[type] = ... + UNASSIGNED: typing.ClassVar[int] = ... + UPPERCASE_LETTER: typing.ClassVar[int] = ... + LOWERCASE_LETTER: typing.ClassVar[int] = ... + TITLECASE_LETTER: typing.ClassVar[int] = ... + MODIFIER_LETTER: typing.ClassVar[int] = ... + OTHER_LETTER: typing.ClassVar[int] = ... + NON_SPACING_MARK: typing.ClassVar[int] = ... + ENCLOSING_MARK: typing.ClassVar[int] = ... + COMBINING_SPACING_MARK: typing.ClassVar[int] = ... + DECIMAL_DIGIT_NUMBER: typing.ClassVar[int] = ... + LETTER_NUMBER: typing.ClassVar[int] = ... + OTHER_NUMBER: typing.ClassVar[int] = ... + SPACE_SEPARATOR: typing.ClassVar[int] = ... + LINE_SEPARATOR: typing.ClassVar[int] = ... + PARAGRAPH_SEPARATOR: typing.ClassVar[int] = ... + CONTROL: typing.ClassVar[int] = ... + FORMAT: typing.ClassVar[int] = ... + PRIVATE_USE: typing.ClassVar[int] = ... + SURROGATE: typing.ClassVar[int] = ... + DASH_PUNCTUATION: typing.ClassVar[int] = ... + START_PUNCTUATION: typing.ClassVar[int] = ... + END_PUNCTUATION: typing.ClassVar[int] = ... + CONNECTOR_PUNCTUATION: typing.ClassVar[int] = ... + OTHER_PUNCTUATION: typing.ClassVar[int] = ... + MATH_SYMBOL: typing.ClassVar[int] = ... + CURRENCY_SYMBOL: typing.ClassVar[int] = ... + MODIFIER_SYMBOL: typing.ClassVar[int] = ... + OTHER_SYMBOL: typing.ClassVar[int] = ... + INITIAL_QUOTE_PUNCTUATION: typing.ClassVar[int] = ... + FINAL_QUOTE_PUNCTUATION: typing.ClassVar[int] = ... + DIRECTIONALITY_UNDEFINED: typing.ClassVar[int] = ... + DIRECTIONALITY_LEFT_TO_RIGHT: typing.ClassVar[int] = ... + DIRECTIONALITY_RIGHT_TO_LEFT: typing.ClassVar[int] = ... + DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC: typing.ClassVar[int] = ... + DIRECTIONALITY_EUROPEAN_NUMBER: typing.ClassVar[int] = ... + DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR: typing.ClassVar[int] = ... + DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR: typing.ClassVar[int] = ... + DIRECTIONALITY_ARABIC_NUMBER: typing.ClassVar[int] = ... + DIRECTIONALITY_COMMON_NUMBER_SEPARATOR: typing.ClassVar[int] = ... + DIRECTIONALITY_NONSPACING_MARK: typing.ClassVar[int] = ... + DIRECTIONALITY_BOUNDARY_NEUTRAL: typing.ClassVar[int] = ... + DIRECTIONALITY_PARAGRAPH_SEPARATOR: typing.ClassVar[int] = ... + DIRECTIONALITY_SEGMENT_SEPARATOR: typing.ClassVar[int] = ... + DIRECTIONALITY_WHITESPACE: typing.ClassVar[int] = ... + DIRECTIONALITY_OTHER_NEUTRALS: typing.ClassVar[int] = ... + DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING: typing.ClassVar[int] = ... + DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE: typing.ClassVar[int] = ... + DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING: typing.ClassVar[int] = ... + DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE: typing.ClassVar[int] = ... + DIRECTIONALITY_POP_DIRECTIONAL_FORMAT: typing.ClassVar[int] = ... + DIRECTIONALITY_LEFT_TO_RIGHT_ISOLATE: typing.ClassVar[int] = ... + DIRECTIONALITY_RIGHT_TO_LEFT_ISOLATE: typing.ClassVar[int] = ... + DIRECTIONALITY_FIRST_STRONG_ISOLATE: typing.ClassVar[int] = ... + DIRECTIONALITY_POP_DIRECTIONAL_ISOLATE: typing.ClassVar[int] = ... + MIN_HIGH_SURROGATE: typing.ClassVar[str] = ... + MAX_HIGH_SURROGATE: typing.ClassVar[str] = ... + MIN_LOW_SURROGATE: typing.ClassVar[str] = ... + MAX_LOW_SURROGATE: typing.ClassVar[str] = ... + MIN_SURROGATE: typing.ClassVar[str] = ... + MAX_SURROGATE: typing.ClassVar[str] = ... + MIN_SUPPLEMENTARY_CODE_POINT: typing.ClassVar[int] = ... + MIN_CODE_POINT: typing.ClassVar[int] = ... + MAX_CODE_POINT: typing.ClassVar[int] = ... + SIZE: typing.ClassVar[int] = ... + BYTES: typing.ClassVar[int] = ... + def __init__(self, char: str): ... + @staticmethod + def charCount(int: int) -> int: ... + def charValue(self) -> str: ... + @typing.overload + @staticmethod + def codePointAt(charArray: list[str] | jpype.JArray, int: int) -> int: ... + @typing.overload + @staticmethod + def codePointAt( + charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> int: ... + @typing.overload + @staticmethod + def codePointAt(charSequence: CharSequence | str, int: int) -> int: ... + @typing.overload + @staticmethod + def codePointBefore(charArray: list[str] | jpype.JArray, int: int) -> int: ... + @typing.overload + @staticmethod + def codePointBefore( + charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> int: ... + @typing.overload + @staticmethod + def codePointBefore(charSequence: CharSequence | str, int: int) -> int: ... + @typing.overload + @staticmethod + def codePointCount( + charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> int: ... + @typing.overload + @staticmethod + def codePointCount( + charSequence: CharSequence | str, int: int, int2: int + ) -> int: ... + @staticmethod + def codePointOf(string: String | str) -> int: ... + @staticmethod + def compare(char: str, char2: str) -> int: ... + def compareTo(self, character: str) -> int: ... + def describeConstable( + self, + ) -> java.util.Optional[java.lang.constant.DynamicConstantDesc[str]]: ... + @typing.overload + @staticmethod + def digit(char: str, int: int) -> int: ... + @typing.overload + @staticmethod + def digit(int: int, int2: int) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def forDigit(int: int, int2: int) -> str: ... + @typing.overload + @staticmethod + def getDirectionality(char: str) -> int: ... + @typing.overload + @staticmethod + def getDirectionality(int: int) -> int: ... + @staticmethod + def getName(int: int) -> String: ... + @typing.overload + @staticmethod + def getNumericValue(char: str) -> int: ... + @typing.overload + @staticmethod + def getNumericValue(int: int) -> int: ... + @typing.overload + @staticmethod + def getType(char: str) -> int: ... + @typing.overload + @staticmethod + def getType(int: int) -> int: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(char: str) -> int: ... + @staticmethod + def highSurrogate(int: int) -> str: ... + @staticmethod + def isAlphabetic(int: int) -> bool: ... + @staticmethod + def isBmpCodePoint(int: int) -> bool: ... + @typing.overload + @staticmethod + def isDefined(char: str) -> bool: ... + @typing.overload + @staticmethod + def isDefined(int: int) -> bool: ... + @typing.overload + @staticmethod + def isDigit(char: str) -> bool: ... + @typing.overload + @staticmethod + def isDigit(int: int) -> bool: ... + @staticmethod + def isEmoji(int: int) -> bool: ... + @staticmethod + def isEmojiComponent(int: int) -> bool: ... + @staticmethod + def isEmojiModifier(int: int) -> bool: ... + @staticmethod + def isEmojiModifierBase(int: int) -> bool: ... + @staticmethod + def isEmojiPresentation(int: int) -> bool: ... + @staticmethod + def isExtendedPictographic(int: int) -> bool: ... + @staticmethod + def isHighSurrogate(char: str) -> bool: ... + @typing.overload + @staticmethod + def isISOControl(char: str) -> bool: ... + @typing.overload + @staticmethod + def isISOControl(int: int) -> bool: ... + @typing.overload + @staticmethod + def isIdentifierIgnorable(char: str) -> bool: ... + @typing.overload + @staticmethod + def isIdentifierIgnorable(int: int) -> bool: ... + @staticmethod + def isIdeographic(int: int) -> bool: ... + @typing.overload + @staticmethod + def isJavaIdentifierPart(char: str) -> bool: ... + @typing.overload + @staticmethod + def isJavaIdentifierPart(int: int) -> bool: ... + @typing.overload + @staticmethod + def isJavaIdentifierStart(char: str) -> bool: ... + @typing.overload + @staticmethod + def isJavaIdentifierStart(int: int) -> bool: ... + @staticmethod + def isJavaLetter(char: str) -> bool: ... + @staticmethod + def isJavaLetterOrDigit(char: str) -> bool: ... + @typing.overload + @staticmethod + def isLetter(char: str) -> bool: ... + @typing.overload + @staticmethod + def isLetter(int: int) -> bool: ... + @typing.overload + @staticmethod + def isLetterOrDigit(char: str) -> bool: ... + @typing.overload + @staticmethod + def isLetterOrDigit(int: int) -> bool: ... + @staticmethod + def isLowSurrogate(char: str) -> bool: ... + @typing.overload + @staticmethod + def isLowerCase(char: str) -> bool: ... + @typing.overload + @staticmethod + def isLowerCase(int: int) -> bool: ... + @typing.overload + @staticmethod + def isMirrored(char: str) -> bool: ... + @typing.overload + @staticmethod + def isMirrored(int: int) -> bool: ... + @staticmethod + def isSpace(char: str) -> bool: ... + @typing.overload + @staticmethod + def isSpaceChar(char: str) -> bool: ... + @typing.overload + @staticmethod + def isSpaceChar(int: int) -> bool: ... + @staticmethod + def isSupplementaryCodePoint(int: int) -> bool: ... + @staticmethod + def isSurrogate(char: str) -> bool: ... + @staticmethod + def isSurrogatePair(char: str, char2: str) -> bool: ... + @typing.overload + @staticmethod + def isTitleCase(char: str) -> bool: ... + @typing.overload + @staticmethod + def isTitleCase(int: int) -> bool: ... + @typing.overload + @staticmethod + def isUnicodeIdentifierPart(char: str) -> bool: ... + @typing.overload + @staticmethod + def isUnicodeIdentifierPart(int: int) -> bool: ... + @typing.overload + @staticmethod + def isUnicodeIdentifierStart(char: str) -> bool: ... + @typing.overload + @staticmethod + def isUnicodeIdentifierStart(int: int) -> bool: ... + @typing.overload + @staticmethod + def isUpperCase(char: str) -> bool: ... + @typing.overload + @staticmethod + def isUpperCase(int: int) -> bool: ... + @staticmethod + def isValidCodePoint(int: int) -> bool: ... + @typing.overload + @staticmethod + def isWhitespace(char: str) -> bool: ... + @typing.overload + @staticmethod + def isWhitespace(int: int) -> bool: ... + @staticmethod + def lowSurrogate(int: int) -> str: ... + @typing.overload + @staticmethod + def offsetByCodePoints( + charArray: list[str] | jpype.JArray, int: int, int2: int, int3: int, int4: int + ) -> int: ... + @typing.overload + @staticmethod + def offsetByCodePoints( + charSequence: CharSequence | str, int: int, int2: int + ) -> int: ... + @staticmethod + def reverseBytes(char: str) -> str: ... + @typing.overload + @staticmethod + def toChars(int: int) -> typing.MutableSequence[str]: ... + @typing.overload + @staticmethod + def toChars(int: int, charArray: list[str] | jpype.JArray, int2: int) -> int: ... + @staticmethod + def toCodePoint(char: str, char2: str) -> int: ... + @typing.overload + @staticmethod + def toLowerCase(char: str) -> str: ... + @typing.overload + @staticmethod + def toLowerCase(int: int) -> int: ... + @typing.overload + def toString(self) -> String: ... + @typing.overload + @staticmethod + def toString(char: str) -> String: ... + @typing.overload + @staticmethod + def toString(int: int) -> String: ... + @typing.overload + @staticmethod + def toTitleCase(char: str) -> str: ... + @typing.overload + @staticmethod + def toTitleCase(int: int) -> int: ... + @typing.overload + @staticmethod + def toUpperCase(char: str) -> str: ... + @typing.overload + @staticmethod + def toUpperCase(int: int) -> int: ... + @staticmethod + def valueOf(char: str) -> str: ... + class Subset: + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> String: ... + + class UnicodeBlock(java.lang.Character.Subset): + BASIC_LATIN: typing.ClassVar[Character.UnicodeBlock] = ... + LATIN_1_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + LATIN_EXTENDED_A: typing.ClassVar[Character.UnicodeBlock] = ... + LATIN_EXTENDED_B: typing.ClassVar[Character.UnicodeBlock] = ... + IPA_EXTENSIONS: typing.ClassVar[Character.UnicodeBlock] = ... + SPACING_MODIFIER_LETTERS: typing.ClassVar[Character.UnicodeBlock] = ... + COMBINING_DIACRITICAL_MARKS: typing.ClassVar[Character.UnicodeBlock] = ... + GREEK: typing.ClassVar[Character.UnicodeBlock] = ... + CYRILLIC: typing.ClassVar[Character.UnicodeBlock] = ... + ARMENIAN: typing.ClassVar[Character.UnicodeBlock] = ... + HEBREW: typing.ClassVar[Character.UnicodeBlock] = ... + ARABIC: typing.ClassVar[Character.UnicodeBlock] = ... + DEVANAGARI: typing.ClassVar[Character.UnicodeBlock] = ... + BENGALI: typing.ClassVar[Character.UnicodeBlock] = ... + GURMUKHI: typing.ClassVar[Character.UnicodeBlock] = ... + GUJARATI: typing.ClassVar[Character.UnicodeBlock] = ... + ORIYA: typing.ClassVar[Character.UnicodeBlock] = ... + TAMIL: typing.ClassVar[Character.UnicodeBlock] = ... + TELUGU: typing.ClassVar[Character.UnicodeBlock] = ... + KANNADA: typing.ClassVar[Character.UnicodeBlock] = ... + MALAYALAM: typing.ClassVar[Character.UnicodeBlock] = ... + THAI: typing.ClassVar[Character.UnicodeBlock] = ... + LAO: typing.ClassVar[Character.UnicodeBlock] = ... + TIBETAN: typing.ClassVar[Character.UnicodeBlock] = ... + GEORGIAN: typing.ClassVar[Character.UnicodeBlock] = ... + HANGUL_JAMO: typing.ClassVar[Character.UnicodeBlock] = ... + LATIN_EXTENDED_ADDITIONAL: typing.ClassVar[Character.UnicodeBlock] = ... + GREEK_EXTENDED: typing.ClassVar[Character.UnicodeBlock] = ... + GENERAL_PUNCTUATION: typing.ClassVar[Character.UnicodeBlock] = ... + SUPERSCRIPTS_AND_SUBSCRIPTS: typing.ClassVar[Character.UnicodeBlock] = ... + CURRENCY_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + COMBINING_MARKS_FOR_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + LETTERLIKE_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + NUMBER_FORMS: typing.ClassVar[Character.UnicodeBlock] = ... + ARROWS: typing.ClassVar[Character.UnicodeBlock] = ... + MATHEMATICAL_OPERATORS: typing.ClassVar[Character.UnicodeBlock] = ... + MISCELLANEOUS_TECHNICAL: typing.ClassVar[Character.UnicodeBlock] = ... + CONTROL_PICTURES: typing.ClassVar[Character.UnicodeBlock] = ... + OPTICAL_CHARACTER_RECOGNITION: typing.ClassVar[Character.UnicodeBlock] = ... + ENCLOSED_ALPHANUMERICS: typing.ClassVar[Character.UnicodeBlock] = ... + BOX_DRAWING: typing.ClassVar[Character.UnicodeBlock] = ... + BLOCK_ELEMENTS: typing.ClassVar[Character.UnicodeBlock] = ... + GEOMETRIC_SHAPES: typing.ClassVar[Character.UnicodeBlock] = ... + MISCELLANEOUS_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + DINGBATS: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_SYMBOLS_AND_PUNCTUATION: typing.ClassVar[Character.UnicodeBlock] = ... + HIRAGANA: typing.ClassVar[Character.UnicodeBlock] = ... + KATAKANA: typing.ClassVar[Character.UnicodeBlock] = ... + BOPOMOFO: typing.ClassVar[Character.UnicodeBlock] = ... + HANGUL_COMPATIBILITY_JAMO: typing.ClassVar[Character.UnicodeBlock] = ... + KANBUN: typing.ClassVar[Character.UnicodeBlock] = ... + ENCLOSED_CJK_LETTERS_AND_MONTHS: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_COMPATIBILITY: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_UNIFIED_IDEOGRAPHS: typing.ClassVar[Character.UnicodeBlock] = ... + HANGUL_SYLLABLES: typing.ClassVar[Character.UnicodeBlock] = ... + PRIVATE_USE_AREA: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_COMPATIBILITY_IDEOGRAPHS: typing.ClassVar[Character.UnicodeBlock] = ... + ALPHABETIC_PRESENTATION_FORMS: typing.ClassVar[Character.UnicodeBlock] = ... + ARABIC_PRESENTATION_FORMS_A: typing.ClassVar[Character.UnicodeBlock] = ... + COMBINING_HALF_MARKS: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_COMPATIBILITY_FORMS: typing.ClassVar[Character.UnicodeBlock] = ... + SMALL_FORM_VARIANTS: typing.ClassVar[Character.UnicodeBlock] = ... + ARABIC_PRESENTATION_FORMS_B: typing.ClassVar[Character.UnicodeBlock] = ... + HALFWIDTH_AND_FULLWIDTH_FORMS: typing.ClassVar[Character.UnicodeBlock] = ... + SPECIALS: typing.ClassVar[Character.UnicodeBlock] = ... + SURROGATES_AREA: typing.ClassVar[Character.UnicodeBlock] = ... + SYRIAC: typing.ClassVar[Character.UnicodeBlock] = ... + THAANA: typing.ClassVar[Character.UnicodeBlock] = ... + SINHALA: typing.ClassVar[Character.UnicodeBlock] = ... + MYANMAR: typing.ClassVar[Character.UnicodeBlock] = ... + ETHIOPIC: typing.ClassVar[Character.UnicodeBlock] = ... + CHEROKEE: typing.ClassVar[Character.UnicodeBlock] = ... + UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + OGHAM: typing.ClassVar[Character.UnicodeBlock] = ... + RUNIC: typing.ClassVar[Character.UnicodeBlock] = ... + KHMER: typing.ClassVar[Character.UnicodeBlock] = ... + MONGOLIAN: typing.ClassVar[Character.UnicodeBlock] = ... + BRAILLE_PATTERNS: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_RADICALS_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + KANGXI_RADICALS: typing.ClassVar[Character.UnicodeBlock] = ... + IDEOGRAPHIC_DESCRIPTION_CHARACTERS: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + BOPOMOFO_EXTENDED: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + YI_SYLLABLES: typing.ClassVar[Character.UnicodeBlock] = ... + YI_RADICALS: typing.ClassVar[Character.UnicodeBlock] = ... + CYRILLIC_SUPPLEMENTARY: typing.ClassVar[Character.UnicodeBlock] = ... + TAGALOG: typing.ClassVar[Character.UnicodeBlock] = ... + HANUNOO: typing.ClassVar[Character.UnicodeBlock] = ... + BUHID: typing.ClassVar[Character.UnicodeBlock] = ... + TAGBANWA: typing.ClassVar[Character.UnicodeBlock] = ... + LIMBU: typing.ClassVar[Character.UnicodeBlock] = ... + TAI_LE: typing.ClassVar[Character.UnicodeBlock] = ... + KHMER_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + PHONETIC_EXTENSIONS: typing.ClassVar[Character.UnicodeBlock] = ... + MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + SUPPLEMENTAL_ARROWS_A: typing.ClassVar[Character.UnicodeBlock] = ... + SUPPLEMENTAL_ARROWS_B: typing.ClassVar[Character.UnicodeBlock] = ... + MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + SUPPLEMENTAL_MATHEMATICAL_OPERATORS: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + MISCELLANEOUS_SYMBOLS_AND_ARROWS: typing.ClassVar[Character.UnicodeBlock] = ... + KATAKANA_PHONETIC_EXTENSIONS: typing.ClassVar[Character.UnicodeBlock] = ... + YIJING_HEXAGRAM_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + VARIATION_SELECTORS: typing.ClassVar[Character.UnicodeBlock] = ... + LINEAR_B_SYLLABARY: typing.ClassVar[Character.UnicodeBlock] = ... + LINEAR_B_IDEOGRAMS: typing.ClassVar[Character.UnicodeBlock] = ... + AEGEAN_NUMBERS: typing.ClassVar[Character.UnicodeBlock] = ... + OLD_ITALIC: typing.ClassVar[Character.UnicodeBlock] = ... + GOTHIC: typing.ClassVar[Character.UnicodeBlock] = ... + UGARITIC: typing.ClassVar[Character.UnicodeBlock] = ... + DESERET: typing.ClassVar[Character.UnicodeBlock] = ... + SHAVIAN: typing.ClassVar[Character.UnicodeBlock] = ... + OSMANYA: typing.ClassVar[Character.UnicodeBlock] = ... + CYPRIOT_SYLLABARY: typing.ClassVar[Character.UnicodeBlock] = ... + BYZANTINE_MUSICAL_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + MUSICAL_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + TAI_XUAN_JING_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + MATHEMATICAL_ALPHANUMERIC_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + TAGS: typing.ClassVar[Character.UnicodeBlock] = ... + VARIATION_SELECTORS_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + SUPPLEMENTARY_PRIVATE_USE_AREA_A: typing.ClassVar[Character.UnicodeBlock] = ... + SUPPLEMENTARY_PRIVATE_USE_AREA_B: typing.ClassVar[Character.UnicodeBlock] = ... + HIGH_SURROGATES: typing.ClassVar[Character.UnicodeBlock] = ... + HIGH_PRIVATE_USE_SURROGATES: typing.ClassVar[Character.UnicodeBlock] = ... + LOW_SURROGATES: typing.ClassVar[Character.UnicodeBlock] = ... + ARABIC_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + NKO: typing.ClassVar[Character.UnicodeBlock] = ... + SAMARITAN: typing.ClassVar[Character.UnicodeBlock] = ... + MANDAIC: typing.ClassVar[Character.UnicodeBlock] = ... + ETHIOPIC_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + NEW_TAI_LUE: typing.ClassVar[Character.UnicodeBlock] = ... + BUGINESE: typing.ClassVar[Character.UnicodeBlock] = ... + TAI_THAM: typing.ClassVar[Character.UnicodeBlock] = ... + BALINESE: typing.ClassVar[Character.UnicodeBlock] = ... + SUNDANESE: typing.ClassVar[Character.UnicodeBlock] = ... + BATAK: typing.ClassVar[Character.UnicodeBlock] = ... + LEPCHA: typing.ClassVar[Character.UnicodeBlock] = ... + OL_CHIKI: typing.ClassVar[Character.UnicodeBlock] = ... + VEDIC_EXTENSIONS: typing.ClassVar[Character.UnicodeBlock] = ... + PHONETIC_EXTENSIONS_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + GLAGOLITIC: typing.ClassVar[Character.UnicodeBlock] = ... + LATIN_EXTENDED_C: typing.ClassVar[Character.UnicodeBlock] = ... + COPTIC: typing.ClassVar[Character.UnicodeBlock] = ... + GEORGIAN_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + TIFINAGH: typing.ClassVar[Character.UnicodeBlock] = ... + ETHIOPIC_EXTENDED: typing.ClassVar[Character.UnicodeBlock] = ... + CYRILLIC_EXTENDED_A: typing.ClassVar[Character.UnicodeBlock] = ... + SUPPLEMENTAL_PUNCTUATION: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_STROKES: typing.ClassVar[Character.UnicodeBlock] = ... + LISU: typing.ClassVar[Character.UnicodeBlock] = ... + VAI: typing.ClassVar[Character.UnicodeBlock] = ... + CYRILLIC_EXTENDED_B: typing.ClassVar[Character.UnicodeBlock] = ... + BAMUM: typing.ClassVar[Character.UnicodeBlock] = ... + MODIFIER_TONE_LETTERS: typing.ClassVar[Character.UnicodeBlock] = ... + LATIN_EXTENDED_D: typing.ClassVar[Character.UnicodeBlock] = ... + SYLOTI_NAGRI: typing.ClassVar[Character.UnicodeBlock] = ... + COMMON_INDIC_NUMBER_FORMS: typing.ClassVar[Character.UnicodeBlock] = ... + PHAGS_PA: typing.ClassVar[Character.UnicodeBlock] = ... + SAURASHTRA: typing.ClassVar[Character.UnicodeBlock] = ... + DEVANAGARI_EXTENDED: typing.ClassVar[Character.UnicodeBlock] = ... + KAYAH_LI: typing.ClassVar[Character.UnicodeBlock] = ... + REJANG: typing.ClassVar[Character.UnicodeBlock] = ... + HANGUL_JAMO_EXTENDED_A: typing.ClassVar[Character.UnicodeBlock] = ... + JAVANESE: typing.ClassVar[Character.UnicodeBlock] = ... + CHAM: typing.ClassVar[Character.UnicodeBlock] = ... + MYANMAR_EXTENDED_A: typing.ClassVar[Character.UnicodeBlock] = ... + TAI_VIET: typing.ClassVar[Character.UnicodeBlock] = ... + ETHIOPIC_EXTENDED_A: typing.ClassVar[Character.UnicodeBlock] = ... + MEETEI_MAYEK: typing.ClassVar[Character.UnicodeBlock] = ... + HANGUL_JAMO_EXTENDED_B: typing.ClassVar[Character.UnicodeBlock] = ... + VERTICAL_FORMS: typing.ClassVar[Character.UnicodeBlock] = ... + ANCIENT_GREEK_NUMBERS: typing.ClassVar[Character.UnicodeBlock] = ... + ANCIENT_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + PHAISTOS_DISC: typing.ClassVar[Character.UnicodeBlock] = ... + LYCIAN: typing.ClassVar[Character.UnicodeBlock] = ... + CARIAN: typing.ClassVar[Character.UnicodeBlock] = ... + OLD_PERSIAN: typing.ClassVar[Character.UnicodeBlock] = ... + IMPERIAL_ARAMAIC: typing.ClassVar[Character.UnicodeBlock] = ... + PHOENICIAN: typing.ClassVar[Character.UnicodeBlock] = ... + LYDIAN: typing.ClassVar[Character.UnicodeBlock] = ... + KHAROSHTHI: typing.ClassVar[Character.UnicodeBlock] = ... + OLD_SOUTH_ARABIAN: typing.ClassVar[Character.UnicodeBlock] = ... + AVESTAN: typing.ClassVar[Character.UnicodeBlock] = ... + INSCRIPTIONAL_PARTHIAN: typing.ClassVar[Character.UnicodeBlock] = ... + INSCRIPTIONAL_PAHLAVI: typing.ClassVar[Character.UnicodeBlock] = ... + OLD_TURKIC: typing.ClassVar[Character.UnicodeBlock] = ... + RUMI_NUMERAL_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + BRAHMI: typing.ClassVar[Character.UnicodeBlock] = ... + KAITHI: typing.ClassVar[Character.UnicodeBlock] = ... + CUNEIFORM: typing.ClassVar[Character.UnicodeBlock] = ... + CUNEIFORM_NUMBERS_AND_PUNCTUATION: typing.ClassVar[Character.UnicodeBlock] = ... + EGYPTIAN_HIEROGLYPHS: typing.ClassVar[Character.UnicodeBlock] = ... + BAMUM_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + KANA_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + ANCIENT_GREEK_MUSICAL_NOTATION: typing.ClassVar[Character.UnicodeBlock] = ... + COUNTING_ROD_NUMERALS: typing.ClassVar[Character.UnicodeBlock] = ... + MAHJONG_TILES: typing.ClassVar[Character.UnicodeBlock] = ... + DOMINO_TILES: typing.ClassVar[Character.UnicodeBlock] = ... + PLAYING_CARDS: typing.ClassVar[Character.UnicodeBlock] = ... + ENCLOSED_ALPHANUMERIC_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + EMOTICONS: typing.ClassVar[Character.UnicodeBlock] = ... + TRANSPORT_AND_MAP_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + ALCHEMICAL_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + ARABIC_EXTENDED_A: typing.ClassVar[Character.UnicodeBlock] = ... + SUNDANESE_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + MEETEI_MAYEK_EXTENSIONS: typing.ClassVar[Character.UnicodeBlock] = ... + MEROITIC_HIEROGLYPHS: typing.ClassVar[Character.UnicodeBlock] = ... + MEROITIC_CURSIVE: typing.ClassVar[Character.UnicodeBlock] = ... + SORA_SOMPENG: typing.ClassVar[Character.UnicodeBlock] = ... + CHAKMA: typing.ClassVar[Character.UnicodeBlock] = ... + SHARADA: typing.ClassVar[Character.UnicodeBlock] = ... + TAKRI: typing.ClassVar[Character.UnicodeBlock] = ... + MIAO: typing.ClassVar[Character.UnicodeBlock] = ... + ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + COMBINING_DIACRITICAL_MARKS_EXTENDED: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + MYANMAR_EXTENDED_B: typing.ClassVar[Character.UnicodeBlock] = ... + LATIN_EXTENDED_E: typing.ClassVar[Character.UnicodeBlock] = ... + COPTIC_EPACT_NUMBERS: typing.ClassVar[Character.UnicodeBlock] = ... + OLD_PERMIC: typing.ClassVar[Character.UnicodeBlock] = ... + ELBASAN: typing.ClassVar[Character.UnicodeBlock] = ... + CAUCASIAN_ALBANIAN: typing.ClassVar[Character.UnicodeBlock] = ... + LINEAR_A: typing.ClassVar[Character.UnicodeBlock] = ... + PALMYRENE: typing.ClassVar[Character.UnicodeBlock] = ... + NABATAEAN: typing.ClassVar[Character.UnicodeBlock] = ... + OLD_NORTH_ARABIAN: typing.ClassVar[Character.UnicodeBlock] = ... + MANICHAEAN: typing.ClassVar[Character.UnicodeBlock] = ... + PSALTER_PAHLAVI: typing.ClassVar[Character.UnicodeBlock] = ... + MAHAJANI: typing.ClassVar[Character.UnicodeBlock] = ... + SINHALA_ARCHAIC_NUMBERS: typing.ClassVar[Character.UnicodeBlock] = ... + KHOJKI: typing.ClassVar[Character.UnicodeBlock] = ... + KHUDAWADI: typing.ClassVar[Character.UnicodeBlock] = ... + GRANTHA: typing.ClassVar[Character.UnicodeBlock] = ... + TIRHUTA: typing.ClassVar[Character.UnicodeBlock] = ... + SIDDHAM: typing.ClassVar[Character.UnicodeBlock] = ... + MODI: typing.ClassVar[Character.UnicodeBlock] = ... + WARANG_CITI: typing.ClassVar[Character.UnicodeBlock] = ... + PAU_CIN_HAU: typing.ClassVar[Character.UnicodeBlock] = ... + MRO: typing.ClassVar[Character.UnicodeBlock] = ... + BASSA_VAH: typing.ClassVar[Character.UnicodeBlock] = ... + PAHAWH_HMONG: typing.ClassVar[Character.UnicodeBlock] = ... + DUPLOYAN: typing.ClassVar[Character.UnicodeBlock] = ... + SHORTHAND_FORMAT_CONTROLS: typing.ClassVar[Character.UnicodeBlock] = ... + MENDE_KIKAKUI: typing.ClassVar[Character.UnicodeBlock] = ... + ORNAMENTAL_DINGBATS: typing.ClassVar[Character.UnicodeBlock] = ... + GEOMETRIC_SHAPES_EXTENDED: typing.ClassVar[Character.UnicodeBlock] = ... + SUPPLEMENTAL_ARROWS_C: typing.ClassVar[Character.UnicodeBlock] = ... + CHEROKEE_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + HATRAN: typing.ClassVar[Character.UnicodeBlock] = ... + OLD_HUNGARIAN: typing.ClassVar[Character.UnicodeBlock] = ... + MULTANI: typing.ClassVar[Character.UnicodeBlock] = ... + AHOM: typing.ClassVar[Character.UnicodeBlock] = ... + EARLY_DYNASTIC_CUNEIFORM: typing.ClassVar[Character.UnicodeBlock] = ... + ANATOLIAN_HIEROGLYPHS: typing.ClassVar[Character.UnicodeBlock] = ... + SUTTON_SIGNWRITING: typing.ClassVar[Character.UnicodeBlock] = ... + SUPPLEMENTAL_SYMBOLS_AND_PICTOGRAPHS: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + SYRIAC_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + CYRILLIC_EXTENDED_C: typing.ClassVar[Character.UnicodeBlock] = ... + OSAGE: typing.ClassVar[Character.UnicodeBlock] = ... + NEWA: typing.ClassVar[Character.UnicodeBlock] = ... + MONGOLIAN_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + MARCHEN: typing.ClassVar[Character.UnicodeBlock] = ... + IDEOGRAPHIC_SYMBOLS_AND_PUNCTUATION: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + TANGUT: typing.ClassVar[Character.UnicodeBlock] = ... + TANGUT_COMPONENTS: typing.ClassVar[Character.UnicodeBlock] = ... + KANA_EXTENDED_A: typing.ClassVar[Character.UnicodeBlock] = ... + GLAGOLITIC_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + ADLAM: typing.ClassVar[Character.UnicodeBlock] = ... + MASARAM_GONDI: typing.ClassVar[Character.UnicodeBlock] = ... + ZANABAZAR_SQUARE: typing.ClassVar[Character.UnicodeBlock] = ... + NUSHU: typing.ClassVar[Character.UnicodeBlock] = ... + SOYOMBO: typing.ClassVar[Character.UnicodeBlock] = ... + BHAIKSUKI: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_UNIFIED_IDEOGRAPHS_EXTENSION_F: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + GEORGIAN_EXTENDED: typing.ClassVar[Character.UnicodeBlock] = ... + HANIFI_ROHINGYA: typing.ClassVar[Character.UnicodeBlock] = ... + OLD_SOGDIAN: typing.ClassVar[Character.UnicodeBlock] = ... + SOGDIAN: typing.ClassVar[Character.UnicodeBlock] = ... + DOGRA: typing.ClassVar[Character.UnicodeBlock] = ... + GUNJALA_GONDI: typing.ClassVar[Character.UnicodeBlock] = ... + MAKASAR: typing.ClassVar[Character.UnicodeBlock] = ... + MEDEFAIDRIN: typing.ClassVar[Character.UnicodeBlock] = ... + MAYAN_NUMERALS: typing.ClassVar[Character.UnicodeBlock] = ... + INDIC_SIYAQ_NUMBERS: typing.ClassVar[Character.UnicodeBlock] = ... + CHESS_SYMBOLS: typing.ClassVar[Character.UnicodeBlock] = ... + ELYMAIC: typing.ClassVar[Character.UnicodeBlock] = ... + NANDINAGARI: typing.ClassVar[Character.UnicodeBlock] = ... + TAMIL_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + EGYPTIAN_HIEROGLYPH_FORMAT_CONTROLS: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + SMALL_KANA_EXTENSION: typing.ClassVar[Character.UnicodeBlock] = ... + NYIAKENG_PUACHUE_HMONG: typing.ClassVar[Character.UnicodeBlock] = ... + WANCHO: typing.ClassVar[Character.UnicodeBlock] = ... + OTTOMAN_SIYAQ_NUMBERS: typing.ClassVar[Character.UnicodeBlock] = ... + SYMBOLS_AND_PICTOGRAPHS_EXTENDED_A: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + YEZIDI: typing.ClassVar[Character.UnicodeBlock] = ... + CHORASMIAN: typing.ClassVar[Character.UnicodeBlock] = ... + DIVES_AKURU: typing.ClassVar[Character.UnicodeBlock] = ... + LISU_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + KHITAN_SMALL_SCRIPT: typing.ClassVar[Character.UnicodeBlock] = ... + TANGUT_SUPPLEMENT: typing.ClassVar[Character.UnicodeBlock] = ... + SYMBOLS_FOR_LEGACY_COMPUTING: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_UNIFIED_IDEOGRAPHS_EXTENSION_G: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + ARABIC_EXTENDED_B: typing.ClassVar[Character.UnicodeBlock] = ... + VITHKUQI: typing.ClassVar[Character.UnicodeBlock] = ... + LATIN_EXTENDED_F: typing.ClassVar[Character.UnicodeBlock] = ... + OLD_UYGHUR: typing.ClassVar[Character.UnicodeBlock] = ... + UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED_A: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + CYPRO_MINOAN: typing.ClassVar[Character.UnicodeBlock] = ... + TANGSA: typing.ClassVar[Character.UnicodeBlock] = ... + KANA_EXTENDED_B: typing.ClassVar[Character.UnicodeBlock] = ... + ZNAMENNY_MUSICAL_NOTATION: typing.ClassVar[Character.UnicodeBlock] = ... + LATIN_EXTENDED_G: typing.ClassVar[Character.UnicodeBlock] = ... + TOTO: typing.ClassVar[Character.UnicodeBlock] = ... + ETHIOPIC_EXTENDED_B: typing.ClassVar[Character.UnicodeBlock] = ... + ARABIC_EXTENDED_C: typing.ClassVar[Character.UnicodeBlock] = ... + DEVANAGARI_EXTENDED_A: typing.ClassVar[Character.UnicodeBlock] = ... + KAWI: typing.ClassVar[Character.UnicodeBlock] = ... + KAKTOVIK_NUMERALS: typing.ClassVar[Character.UnicodeBlock] = ... + CYRILLIC_EXTENDED_D: typing.ClassVar[Character.UnicodeBlock] = ... + NAG_MUNDARI: typing.ClassVar[Character.UnicodeBlock] = ... + CJK_UNIFIED_IDEOGRAPHS_EXTENSION_H: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + CJK_UNIFIED_IDEOGRAPHS_EXTENSION_I: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + TODHRI: typing.ClassVar[Character.UnicodeBlock] = ... + GARAY: typing.ClassVar[Character.UnicodeBlock] = ... + TULU_TIGALARI: typing.ClassVar[Character.UnicodeBlock] = ... + MYANMAR_EXTENDED_C: typing.ClassVar[Character.UnicodeBlock] = ... + SUNUWAR: typing.ClassVar[Character.UnicodeBlock] = ... + EGYPTIAN_HIEROGLYPHS_EXTENDED_A: typing.ClassVar[Character.UnicodeBlock] = ... + GURUNG_KHEMA: typing.ClassVar[Character.UnicodeBlock] = ... + KIRAT_RAI: typing.ClassVar[Character.UnicodeBlock] = ... + SYMBOLS_FOR_LEGACY_COMPUTING_SUPPLEMENT: typing.ClassVar[ + Character.UnicodeBlock + ] = ... + OL_ONAL: typing.ClassVar[Character.UnicodeBlock] = ... + @staticmethod + def forName(string: String | str) -> Character.UnicodeBlock: ... + @typing.overload + @staticmethod + def of(char: str) -> Character.UnicodeBlock: ... + @typing.overload + @staticmethod + def of(int: int) -> Character.UnicodeBlock: ... + + class UnicodeScript(Enum["Character.UnicodeScript"]): + COMMON: typing.ClassVar[Character.UnicodeScript] = ... + LATIN: typing.ClassVar[Character.UnicodeScript] = ... + GREEK: typing.ClassVar[Character.UnicodeScript] = ... + CYRILLIC: typing.ClassVar[Character.UnicodeScript] = ... + ARMENIAN: typing.ClassVar[Character.UnicodeScript] = ... + HEBREW: typing.ClassVar[Character.UnicodeScript] = ... + ARABIC: typing.ClassVar[Character.UnicodeScript] = ... + SYRIAC: typing.ClassVar[Character.UnicodeScript] = ... + THAANA: typing.ClassVar[Character.UnicodeScript] = ... + DEVANAGARI: typing.ClassVar[Character.UnicodeScript] = ... + BENGALI: typing.ClassVar[Character.UnicodeScript] = ... + GURMUKHI: typing.ClassVar[Character.UnicodeScript] = ... + GUJARATI: typing.ClassVar[Character.UnicodeScript] = ... + ORIYA: typing.ClassVar[Character.UnicodeScript] = ... + TAMIL: typing.ClassVar[Character.UnicodeScript] = ... + TELUGU: typing.ClassVar[Character.UnicodeScript] = ... + KANNADA: typing.ClassVar[Character.UnicodeScript] = ... + MALAYALAM: typing.ClassVar[Character.UnicodeScript] = ... + SINHALA: typing.ClassVar[Character.UnicodeScript] = ... + THAI: typing.ClassVar[Character.UnicodeScript] = ... + LAO: typing.ClassVar[Character.UnicodeScript] = ... + TIBETAN: typing.ClassVar[Character.UnicodeScript] = ... + MYANMAR: typing.ClassVar[Character.UnicodeScript] = ... + GEORGIAN: typing.ClassVar[Character.UnicodeScript] = ... + HANGUL: typing.ClassVar[Character.UnicodeScript] = ... + ETHIOPIC: typing.ClassVar[Character.UnicodeScript] = ... + CHEROKEE: typing.ClassVar[Character.UnicodeScript] = ... + CANADIAN_ABORIGINAL: typing.ClassVar[Character.UnicodeScript] = ... + OGHAM: typing.ClassVar[Character.UnicodeScript] = ... + RUNIC: typing.ClassVar[Character.UnicodeScript] = ... + KHMER: typing.ClassVar[Character.UnicodeScript] = ... + MONGOLIAN: typing.ClassVar[Character.UnicodeScript] = ... + HIRAGANA: typing.ClassVar[Character.UnicodeScript] = ... + KATAKANA: typing.ClassVar[Character.UnicodeScript] = ... + BOPOMOFO: typing.ClassVar[Character.UnicodeScript] = ... + HAN: typing.ClassVar[Character.UnicodeScript] = ... + YI: typing.ClassVar[Character.UnicodeScript] = ... + OLD_ITALIC: typing.ClassVar[Character.UnicodeScript] = ... + GOTHIC: typing.ClassVar[Character.UnicodeScript] = ... + DESERET: typing.ClassVar[Character.UnicodeScript] = ... + INHERITED: typing.ClassVar[Character.UnicodeScript] = ... + TAGALOG: typing.ClassVar[Character.UnicodeScript] = ... + HANUNOO: typing.ClassVar[Character.UnicodeScript] = ... + BUHID: typing.ClassVar[Character.UnicodeScript] = ... + TAGBANWA: typing.ClassVar[Character.UnicodeScript] = ... + LIMBU: typing.ClassVar[Character.UnicodeScript] = ... + TAI_LE: typing.ClassVar[Character.UnicodeScript] = ... + LINEAR_B: typing.ClassVar[Character.UnicodeScript] = ... + UGARITIC: typing.ClassVar[Character.UnicodeScript] = ... + SHAVIAN: typing.ClassVar[Character.UnicodeScript] = ... + OSMANYA: typing.ClassVar[Character.UnicodeScript] = ... + CYPRIOT: typing.ClassVar[Character.UnicodeScript] = ... + BRAILLE: typing.ClassVar[Character.UnicodeScript] = ... + BUGINESE: typing.ClassVar[Character.UnicodeScript] = ... + COPTIC: typing.ClassVar[Character.UnicodeScript] = ... + NEW_TAI_LUE: typing.ClassVar[Character.UnicodeScript] = ... + GLAGOLITIC: typing.ClassVar[Character.UnicodeScript] = ... + TIFINAGH: typing.ClassVar[Character.UnicodeScript] = ... + SYLOTI_NAGRI: typing.ClassVar[Character.UnicodeScript] = ... + OLD_PERSIAN: typing.ClassVar[Character.UnicodeScript] = ... + KHAROSHTHI: typing.ClassVar[Character.UnicodeScript] = ... + BALINESE: typing.ClassVar[Character.UnicodeScript] = ... + CUNEIFORM: typing.ClassVar[Character.UnicodeScript] = ... + PHOENICIAN: typing.ClassVar[Character.UnicodeScript] = ... + PHAGS_PA: typing.ClassVar[Character.UnicodeScript] = ... + NKO: typing.ClassVar[Character.UnicodeScript] = ... + SUNDANESE: typing.ClassVar[Character.UnicodeScript] = ... + BATAK: typing.ClassVar[Character.UnicodeScript] = ... + LEPCHA: typing.ClassVar[Character.UnicodeScript] = ... + OL_CHIKI: typing.ClassVar[Character.UnicodeScript] = ... + VAI: typing.ClassVar[Character.UnicodeScript] = ... + SAURASHTRA: typing.ClassVar[Character.UnicodeScript] = ... + KAYAH_LI: typing.ClassVar[Character.UnicodeScript] = ... + REJANG: typing.ClassVar[Character.UnicodeScript] = ... + LYCIAN: typing.ClassVar[Character.UnicodeScript] = ... + CARIAN: typing.ClassVar[Character.UnicodeScript] = ... + LYDIAN: typing.ClassVar[Character.UnicodeScript] = ... + CHAM: typing.ClassVar[Character.UnicodeScript] = ... + TAI_THAM: typing.ClassVar[Character.UnicodeScript] = ... + TAI_VIET: typing.ClassVar[Character.UnicodeScript] = ... + AVESTAN: typing.ClassVar[Character.UnicodeScript] = ... + EGYPTIAN_HIEROGLYPHS: typing.ClassVar[Character.UnicodeScript] = ... + SAMARITAN: typing.ClassVar[Character.UnicodeScript] = ... + MANDAIC: typing.ClassVar[Character.UnicodeScript] = ... + LISU: typing.ClassVar[Character.UnicodeScript] = ... + BAMUM: typing.ClassVar[Character.UnicodeScript] = ... + JAVANESE: typing.ClassVar[Character.UnicodeScript] = ... + MEETEI_MAYEK: typing.ClassVar[Character.UnicodeScript] = ... + IMPERIAL_ARAMAIC: typing.ClassVar[Character.UnicodeScript] = ... + OLD_SOUTH_ARABIAN: typing.ClassVar[Character.UnicodeScript] = ... + INSCRIPTIONAL_PARTHIAN: typing.ClassVar[Character.UnicodeScript] = ... + INSCRIPTIONAL_PAHLAVI: typing.ClassVar[Character.UnicodeScript] = ... + OLD_TURKIC: typing.ClassVar[Character.UnicodeScript] = ... + BRAHMI: typing.ClassVar[Character.UnicodeScript] = ... + KAITHI: typing.ClassVar[Character.UnicodeScript] = ... + MEROITIC_HIEROGLYPHS: typing.ClassVar[Character.UnicodeScript] = ... + MEROITIC_CURSIVE: typing.ClassVar[Character.UnicodeScript] = ... + SORA_SOMPENG: typing.ClassVar[Character.UnicodeScript] = ... + CHAKMA: typing.ClassVar[Character.UnicodeScript] = ... + SHARADA: typing.ClassVar[Character.UnicodeScript] = ... + TAKRI: typing.ClassVar[Character.UnicodeScript] = ... + MIAO: typing.ClassVar[Character.UnicodeScript] = ... + CAUCASIAN_ALBANIAN: typing.ClassVar[Character.UnicodeScript] = ... + BASSA_VAH: typing.ClassVar[Character.UnicodeScript] = ... + DUPLOYAN: typing.ClassVar[Character.UnicodeScript] = ... + ELBASAN: typing.ClassVar[Character.UnicodeScript] = ... + GRANTHA: typing.ClassVar[Character.UnicodeScript] = ... + PAHAWH_HMONG: typing.ClassVar[Character.UnicodeScript] = ... + KHOJKI: typing.ClassVar[Character.UnicodeScript] = ... + LINEAR_A: typing.ClassVar[Character.UnicodeScript] = ... + MAHAJANI: typing.ClassVar[Character.UnicodeScript] = ... + MANICHAEAN: typing.ClassVar[Character.UnicodeScript] = ... + MENDE_KIKAKUI: typing.ClassVar[Character.UnicodeScript] = ... + MODI: typing.ClassVar[Character.UnicodeScript] = ... + MRO: typing.ClassVar[Character.UnicodeScript] = ... + OLD_NORTH_ARABIAN: typing.ClassVar[Character.UnicodeScript] = ... + NABATAEAN: typing.ClassVar[Character.UnicodeScript] = ... + PALMYRENE: typing.ClassVar[Character.UnicodeScript] = ... + PAU_CIN_HAU: typing.ClassVar[Character.UnicodeScript] = ... + OLD_PERMIC: typing.ClassVar[Character.UnicodeScript] = ... + PSALTER_PAHLAVI: typing.ClassVar[Character.UnicodeScript] = ... + SIDDHAM: typing.ClassVar[Character.UnicodeScript] = ... + KHUDAWADI: typing.ClassVar[Character.UnicodeScript] = ... + TIRHUTA: typing.ClassVar[Character.UnicodeScript] = ... + WARANG_CITI: typing.ClassVar[Character.UnicodeScript] = ... + AHOM: typing.ClassVar[Character.UnicodeScript] = ... + ANATOLIAN_HIEROGLYPHS: typing.ClassVar[Character.UnicodeScript] = ... + HATRAN: typing.ClassVar[Character.UnicodeScript] = ... + MULTANI: typing.ClassVar[Character.UnicodeScript] = ... + OLD_HUNGARIAN: typing.ClassVar[Character.UnicodeScript] = ... + SIGNWRITING: typing.ClassVar[Character.UnicodeScript] = ... + ADLAM: typing.ClassVar[Character.UnicodeScript] = ... + BHAIKSUKI: typing.ClassVar[Character.UnicodeScript] = ... + MARCHEN: typing.ClassVar[Character.UnicodeScript] = ... + NEWA: typing.ClassVar[Character.UnicodeScript] = ... + OSAGE: typing.ClassVar[Character.UnicodeScript] = ... + TANGUT: typing.ClassVar[Character.UnicodeScript] = ... + MASARAM_GONDI: typing.ClassVar[Character.UnicodeScript] = ... + NUSHU: typing.ClassVar[Character.UnicodeScript] = ... + SOYOMBO: typing.ClassVar[Character.UnicodeScript] = ... + ZANABAZAR_SQUARE: typing.ClassVar[Character.UnicodeScript] = ... + HANIFI_ROHINGYA: typing.ClassVar[Character.UnicodeScript] = ... + OLD_SOGDIAN: typing.ClassVar[Character.UnicodeScript] = ... + SOGDIAN: typing.ClassVar[Character.UnicodeScript] = ... + DOGRA: typing.ClassVar[Character.UnicodeScript] = ... + GUNJALA_GONDI: typing.ClassVar[Character.UnicodeScript] = ... + MAKASAR: typing.ClassVar[Character.UnicodeScript] = ... + MEDEFAIDRIN: typing.ClassVar[Character.UnicodeScript] = ... + ELYMAIC: typing.ClassVar[Character.UnicodeScript] = ... + NANDINAGARI: typing.ClassVar[Character.UnicodeScript] = ... + NYIAKENG_PUACHUE_HMONG: typing.ClassVar[Character.UnicodeScript] = ... + WANCHO: typing.ClassVar[Character.UnicodeScript] = ... + YEZIDI: typing.ClassVar[Character.UnicodeScript] = ... + CHORASMIAN: typing.ClassVar[Character.UnicodeScript] = ... + DIVES_AKURU: typing.ClassVar[Character.UnicodeScript] = ... + KHITAN_SMALL_SCRIPT: typing.ClassVar[Character.UnicodeScript] = ... + VITHKUQI: typing.ClassVar[Character.UnicodeScript] = ... + OLD_UYGHUR: typing.ClassVar[Character.UnicodeScript] = ... + CYPRO_MINOAN: typing.ClassVar[Character.UnicodeScript] = ... + TANGSA: typing.ClassVar[Character.UnicodeScript] = ... + TOTO: typing.ClassVar[Character.UnicodeScript] = ... + KAWI: typing.ClassVar[Character.UnicodeScript] = ... + NAG_MUNDARI: typing.ClassVar[Character.UnicodeScript] = ... + TODHRI: typing.ClassVar[Character.UnicodeScript] = ... + GARAY: typing.ClassVar[Character.UnicodeScript] = ... + TULU_TIGALARI: typing.ClassVar[Character.UnicodeScript] = ... + SUNUWAR: typing.ClassVar[Character.UnicodeScript] = ... + GURUNG_KHEMA: typing.ClassVar[Character.UnicodeScript] = ... + KIRAT_RAI: typing.ClassVar[Character.UnicodeScript] = ... + OL_ONAL: typing.ClassVar[Character.UnicodeScript] = ... + UNKNOWN: typing.ClassVar[Character.UnicodeScript] = ... + @staticmethod + def forName(string: String | str) -> Character.UnicodeScript: ... + @staticmethod + def of(int: int) -> Character.UnicodeScript: ... + _valueOf_1__T = typing.TypeVar("_valueOf_1__T", bound=Enum) # + @typing.overload + @staticmethod + def valueOf(string: String | str) -> Character.UnicodeScript: ... + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_1__T], string: String | str + ) -> _valueOf_1__T: ... + @staticmethod + def values() -> typing.MutableSequence[Character.UnicodeScript]: ... + +class Package(java.lang.NamedPackage, java.lang.reflect.AnnotatedElement): + _getAnnotation__A = typing.TypeVar( + "_getAnnotation__A", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__A]) -> _getAnnotation__A: ... + def getAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getAnnotationsByType__A = typing.TypeVar( + "_getAnnotationsByType__A", bound=java.lang.annotation.Annotation + ) # + def getAnnotationsByType( + self, class_: type[_getAnnotationsByType__A] + ) -> typing.MutableSequence[_getAnnotationsByType__A]: ... + _getDeclaredAnnotation__A = typing.TypeVar( + "_getDeclaredAnnotation__A", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotation( + self, class_: type[_getDeclaredAnnotation__A] + ) -> _getDeclaredAnnotation__A: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getDeclaredAnnotationsByType__A = typing.TypeVar( + "_getDeclaredAnnotationsByType__A", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotationsByType( + self, class_: type[_getDeclaredAnnotationsByType__A] + ) -> typing.MutableSequence[_getDeclaredAnnotationsByType__A]: ... + def getImplementationTitle(self) -> String: ... + def getImplementationVendor(self) -> String: ... + def getImplementationVersion(self) -> String: ... + def getName(self) -> String: ... + @staticmethod + def getPackage(string: String | str) -> Package: ... + @staticmethod + def getPackages() -> typing.MutableSequence[Package]: ... + def getSpecificationTitle(self) -> String: ... + def getSpecificationVendor(self) -> String: ... + def getSpecificationVersion(self) -> String: ... + def hashCode(self) -> int: ... + def isAnnotationPresent( + self, class_: type[java.lang.annotation.Annotation] + ) -> bool: ... + def isCompatibleWith(self, string: String | str) -> bool: ... + @typing.overload + def isSealed(self) -> bool: ... + @typing.overload + def isSealed(self, uRL: java.net.URL) -> bool: ... + def toString(self) -> String: ... + +class StringBuffer( + java.lang.AbstractStringBuilder, + Appendable, + java.io.Serializable, + Comparable["StringBuffer"], + CharSequence, +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, charSequence: CharSequence | str): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def append(self, boolean: bool) -> StringBuffer: ... + @typing.overload + def append(self, char: str) -> StringBuffer: ... + @typing.overload + def append(self, charArray: list[str] | jpype.JArray) -> StringBuffer: ... + @typing.overload + def append( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> StringBuffer: ... + @typing.overload + def append(self, double: float) -> StringBuffer: ... + @typing.overload + def append(self, float: float) -> StringBuffer: ... + @typing.overload + def append(self, int: int) -> StringBuffer: ... + @typing.overload + def append(self, charSequence: CharSequence | str) -> StringBuffer: ... + @typing.overload + def append( + self, charSequence: CharSequence | str, int: int, int2: int + ) -> StringBuffer: ... + @typing.overload + def append(self, object: typing.Any) -> StringBuffer: ... + @typing.overload + def append(self, string: String | str) -> StringBuffer: ... + @typing.overload + def append(self, stringBuffer: StringBuffer) -> StringBuffer: ... + @typing.overload + def append(self, long: int) -> StringBuffer: ... + def appendCodePoint(self, int: int) -> StringBuffer: ... + def capacity(self) -> int: ... + def charAt(self, int: int) -> str: ... + def codePointAt(self, int: int) -> int: ... + def codePointBefore(self, int: int) -> int: ... + def codePointCount(self, int: int, int2: int) -> int: ... + def compareTo(self, stringBuffer: StringBuffer) -> int: ... + def delete(self, int: int, int2: int) -> StringBuffer: ... + def deleteCharAt(self, int: int) -> StringBuffer: ... + def ensureCapacity(self, int: int) -> None: ... + def getChars( + self, int: int, int2: int, charArray: list[str] | jpype.JArray, int3: int + ) -> None: ... + @typing.overload + def indexOf(self, string: String | str) -> int: ... + @typing.overload + def indexOf(self, string: String | str, int: int) -> int: ... + @typing.overload + def insert(self, int: int, boolean: bool) -> StringBuffer: ... + @typing.overload + def insert(self, int: int, double: float) -> StringBuffer: ... + @typing.overload + def insert(self, int: int, float: float) -> StringBuffer: ... + @typing.overload + def insert(self, int: int, int2: int) -> StringBuffer: ... + @typing.overload + def insert(self, int: int, charSequence: CharSequence | str) -> StringBuffer: ... + @typing.overload + def insert(self, int: int, long: int) -> StringBuffer: ... + @typing.overload + def insert(self, int: int, char: str) -> StringBuffer: ... + @typing.overload + def insert(self, int: int, charArray: list[str] | jpype.JArray) -> StringBuffer: ... + @typing.overload + def insert( + self, int: int, charArray: list[str] | jpype.JArray, int2: int, int3: int + ) -> StringBuffer: ... + @typing.overload + def insert( + self, int: int, charSequence: CharSequence | str, int2: int, int3: int + ) -> StringBuffer: ... + @typing.overload + def insert(self, int: int, object: typing.Any) -> StringBuffer: ... + @typing.overload + def insert(self, int: int, string: String | str) -> StringBuffer: ... + @typing.overload + def lastIndexOf(self, string: String | str) -> int: ... + @typing.overload + def lastIndexOf(self, string: String | str, int: int) -> int: ... + def length(self) -> int: ... + def offsetByCodePoints(self, int: int, int2: int) -> int: ... + @typing.overload + def repeat(self, int: int, int2: int) -> StringBuffer: ... + @typing.overload + def repeat(self, charSequence: CharSequence | str, int: int) -> StringBuffer: ... + def replace(self, int: int, int2: int, string: String | str) -> StringBuffer: ... + def reverse(self) -> StringBuffer: ... + def setCharAt(self, int: int, char: str) -> None: ... + def setLength(self, int: int) -> None: ... + def subSequence(self, int: int, int2: int) -> CharSequence: ... + @typing.overload + def substring(self, int: int) -> String: ... + @typing.overload + def substring(self, int: int, int2: int) -> String: ... + def toString(self) -> String: ... + def trimToSize(self) -> None: ... + +class StringBuilder( + java.lang.AbstractStringBuilder, + Appendable, + java.io.Serializable, + Comparable["StringBuilder"], + CharSequence, +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, charSequence: CharSequence | str): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def append(self, boolean: bool) -> StringBuilder: ... + @typing.overload + def append(self, char: str) -> StringBuilder: ... + @typing.overload + def append(self, charArray: list[str] | jpype.JArray) -> StringBuilder: ... + @typing.overload + def append( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> StringBuilder: ... + @typing.overload + def append(self, double: float) -> StringBuilder: ... + @typing.overload + def append(self, float: float) -> StringBuilder: ... + @typing.overload + def append(self, int: int) -> StringBuilder: ... + @typing.overload + def append(self, charSequence: CharSequence | str) -> StringBuilder: ... + @typing.overload + def append( + self, charSequence: CharSequence | str, int: int, int2: int + ) -> StringBuilder: ... + @typing.overload + def append(self, object: typing.Any) -> StringBuilder: ... + @typing.overload + def append(self, string: String | str) -> StringBuilder: ... + @typing.overload + def append(self, stringBuffer: StringBuffer) -> StringBuilder: ... + @typing.overload + def append(self, long: int) -> StringBuilder: ... + def appendCodePoint(self, int: int) -> StringBuilder: ... + def compareTo(self, stringBuilder: StringBuilder) -> int: ... + def delete(self, int: int, int2: int) -> StringBuilder: ... + def deleteCharAt(self, int: int) -> StringBuilder: ... + @typing.overload + def indexOf(self, string: String | str) -> int: ... + @typing.overload + def indexOf(self, string: String | str, int: int) -> int: ... + @typing.overload + def insert(self, int: int, boolean: bool) -> StringBuilder: ... + @typing.overload + def insert(self, int: int, char: str) -> StringBuilder: ... + @typing.overload + def insert( + self, int: int, charArray: list[str] | jpype.JArray + ) -> StringBuilder: ... + @typing.overload + def insert( + self, int: int, charArray: list[str] | jpype.JArray, int2: int, int3: int + ) -> StringBuilder: ... + @typing.overload + def insert(self, int: int, double: float) -> StringBuilder: ... + @typing.overload + def insert(self, int: int, float: float) -> StringBuilder: ... + @typing.overload + def insert(self, int: int, int2: int) -> StringBuilder: ... + @typing.overload + def insert(self, int: int, charSequence: CharSequence | str) -> StringBuilder: ... + @typing.overload + def insert( + self, int: int, charSequence: CharSequence | str, int2: int, int3: int + ) -> StringBuilder: ... + @typing.overload + def insert(self, int: int, object: typing.Any) -> StringBuilder: ... + @typing.overload + def insert(self, int: int, string: String | str) -> StringBuilder: ... + @typing.overload + def insert(self, int: int, long: int) -> StringBuilder: ... + @typing.overload + def lastIndexOf(self, string: String | str) -> int: ... + @typing.overload + def lastIndexOf(self, string: String | str, int: int) -> int: ... + @typing.overload + def repeat(self, int: int, int2: int) -> StringBuilder: ... + @typing.overload + def repeat(self, charSequence: CharSequence | str, int: int) -> StringBuilder: ... + def replace(self, int: int, int2: int, string: String | str) -> StringBuilder: ... + def reverse(self) -> StringBuilder: ... + def toString(self) -> String: ... + +class Thread(Runnable, _JThread): + MIN_PRIORITY: typing.ClassVar[int] = ... + NORM_PRIORITY: typing.ClassVar[int] = ... + MAX_PRIORITY: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, runnable: Runnable | typing.Callable): ... + @typing.overload + def __init__(self, runnable: Runnable | typing.Callable, string: String | str): ... + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__( + self, threadGroup: ThreadGroup, runnable: Runnable | typing.Callable + ): ... + @typing.overload + def __init__( + self, + threadGroup: ThreadGroup, + runnable: Runnable | typing.Callable, + string: String | str, + ): ... + @typing.overload + def __init__( + self, + threadGroup: ThreadGroup, + runnable: Runnable | typing.Callable, + string: String | str, + long: int, + ): ... + @typing.overload + def __init__( + self, + threadGroup: ThreadGroup, + runnable: Runnable | typing.Callable, + string: String | str, + long: int, + boolean: bool, + ): ... + @typing.overload + def __init__(self, threadGroup: ThreadGroup, string: String | str): ... + @staticmethod + def activeCount() -> int: ... + def checkAccess(self) -> None: ... + @staticmethod + def currentThread() -> Thread: ... + @staticmethod + def dumpStack() -> None: ... + @staticmethod + def enumerate(threadArray: list[Thread] | jpype.JArray) -> int: ... + @staticmethod + def getAllStackTraces() -> java.util.Map[ + Thread, typing.MutableSequence[StackTraceElement] + ]: ... + def getContextClassLoader(self) -> ClassLoader: ... + @staticmethod + def getDefaultUncaughtExceptionHandler() -> Thread.UncaughtExceptionHandler: ... + def getId(self) -> int: ... + def getName(self) -> String: ... + def getPriority(self) -> int: ... + def getStackTrace(self) -> typing.MutableSequence[StackTraceElement]: ... + def getState(self) -> Thread.State: ... + def getThreadGroup(self) -> ThreadGroup: ... + def getUncaughtExceptionHandler(self) -> Thread.UncaughtExceptionHandler: ... + @staticmethod + def holdsLock(object: typing.Any) -> bool: ... + def interrupt(self) -> None: ... + @staticmethod + def interrupted() -> bool: ... + def isAlive(self) -> bool: ... + def isDaemon(self) -> bool: ... + def isInterrupted(self) -> bool: ... + def isVirtual(self) -> bool: ... + @typing.overload + def join(self, duration: java.time.Duration) -> bool: ... + @typing.overload + def join(self) -> None: ... + @typing.overload + def join(self, long: int) -> None: ... + @typing.overload + def join(self, long: int, int: int) -> None: ... + @staticmethod + def ofPlatform() -> Thread.Builder.OfPlatform: ... + @staticmethod + def ofVirtual() -> Thread.Builder.OfVirtual: ... + @staticmethod + def onSpinWait() -> None: ... + def run(self) -> None: ... + def setContextClassLoader(self, classLoader: ClassLoader) -> None: ... + def setDaemon(self, boolean: bool) -> None: ... + @staticmethod + def setDefaultUncaughtExceptionHandler( + uncaughtExceptionHandler: Thread.UncaughtExceptionHandler | typing.Callable, + ) -> None: ... + def setName(self, string: String | str) -> None: ... + def setPriority(self, int: int) -> None: ... + def setUncaughtExceptionHandler( + self, + uncaughtExceptionHandler: Thread.UncaughtExceptionHandler | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def sleep(duration: java.time.Duration) -> None: ... + @typing.overload + @staticmethod + def sleep(long: int) -> None: ... + @typing.overload + @staticmethod + def sleep(long: int, int: int) -> None: ... + def start(self) -> None: ... + @staticmethod + def startVirtualThread(runnable: Runnable | typing.Callable) -> Thread: ... + def stop(self) -> None: ... + def threadId(self) -> int: ... + def toString(self) -> String: ... + @staticmethod + def yield_() -> None: ... + class Builder: + def factory(self) -> java.util.concurrent.ThreadFactory: ... + def inheritInheritableThreadLocals(self, boolean: bool) -> Thread.Builder: ... + @typing.overload + def name(self, string: String | str) -> Thread.Builder: ... + @typing.overload + def name(self, string: String | str, long: int) -> Thread.Builder: ... + def start(self, runnable: Runnable | typing.Callable) -> Thread: ... + def uncaughtExceptionHandler( + self, + uncaughtExceptionHandler: Thread.UncaughtExceptionHandler | typing.Callable, + ) -> Thread.Builder: ... + def unstarted(self, runnable: Runnable | typing.Callable) -> Thread: ... + class OfPlatform(java.lang.Thread.Builder): + @typing.overload + def daemon(self, boolean: bool) -> Thread.Builder.OfPlatform: ... + @typing.overload + def daemon(self) -> Thread.Builder.OfPlatform: ... + def group(self, threadGroup: ThreadGroup) -> Thread.Builder.OfPlatform: ... + def inheritInheritableThreadLocals( + self, boolean: bool + ) -> Thread.Builder.OfPlatform: ... + @typing.overload + def name(self, string: String | str) -> Thread.Builder.OfPlatform: ... + @typing.overload + def name( + self, string: String | str, long: int + ) -> Thread.Builder.OfPlatform: ... + def priority(self, int: int) -> Thread.Builder.OfPlatform: ... + def stackSize(self, long: int) -> Thread.Builder.OfPlatform: ... + def uncaughtExceptionHandler( + self, + uncaughtExceptionHandler: Thread.UncaughtExceptionHandler + | typing.Callable, + ) -> Thread.Builder.OfPlatform: ... + + class OfVirtual(java.lang.Thread.Builder): + def inheritInheritableThreadLocals( + self, boolean: bool + ) -> Thread.Builder.OfVirtual: ... + @typing.overload + def name(self, string: String | str) -> Thread.Builder.OfVirtual: ... + @typing.overload + def name( + self, string: String | str, long: int + ) -> Thread.Builder.OfVirtual: ... + def uncaughtExceptionHandler( + self, + uncaughtExceptionHandler: Thread.UncaughtExceptionHandler + | typing.Callable, + ) -> Thread.Builder.OfVirtual: ... + + class State(Enum["Thread.State"]): + NEW: typing.ClassVar[Thread.State] = ... + RUNNABLE: typing.ClassVar[Thread.State] = ... + BLOCKED: typing.ClassVar[Thread.State] = ... + WAITING: typing.ClassVar[Thread.State] = ... + TIMED_WAITING: typing.ClassVar[Thread.State] = ... + TERMINATED: typing.ClassVar[Thread.State] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: String | str) -> Thread.State: ... + @staticmethod + def values() -> typing.MutableSequence[Thread.State]: ... + + class UncaughtExceptionHandler: + def uncaughtException(self, thread: Thread, throwable: Throwable) -> None: ... + +class ThreadGroup(Thread.UncaughtExceptionHandler): + @typing.overload + def __init__(self, string: String | str): ... + @typing.overload + def __init__(self, threadGroup: ThreadGroup, string: String | str): ... + def activeCount(self) -> int: ... + def activeGroupCount(self) -> int: ... + def checkAccess(self) -> None: ... + def destroy(self) -> None: ... + @typing.overload + def enumerate( + self, threadGroupArray: builtins.list[ThreadGroup] | jpype.JArray + ) -> int: ... + @typing.overload + def enumerate( + self, threadGroupArray: builtins.list[ThreadGroup] | jpype.JArray, boolean: bool + ) -> int: ... + @typing.overload + def enumerate(self, threadArray: builtins.list[Thread] | jpype.JArray) -> int: ... + @typing.overload + def enumerate( + self, threadArray: builtins.list[Thread] | jpype.JArray, boolean: bool + ) -> int: ... + def getMaxPriority(self) -> int: ... + def getName(self) -> String: ... + def getParent(self) -> ThreadGroup: ... + def interrupt(self) -> None: ... + def isDaemon(self) -> bool: ... + def isDestroyed(self) -> bool: ... + def list(self) -> None: ... + def parentOf(self, threadGroup: ThreadGroup) -> bool: ... + def setDaemon(self, boolean: bool) -> None: ... + def setMaxPriority(self, int: int) -> None: ... + def toString(self) -> String: ... + def uncaughtException(self, thread: Thread, throwable: Throwable) -> None: ... + +class AbstractStringBuilder: ... +class NamedPackage: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang")``. + + AbstractMethodError: type[AbstractMethodError] + AbstractStringBuilder: type[AbstractStringBuilder] + Appendable: type[Appendable] + ArithmeticException: type[ArithmeticException] + ArrayIndexOutOfBoundsException: type[ArrayIndexOutOfBoundsException] + ArrayStoreException: type[ArrayStoreException] + AssertionError: type[AssertionError] + AutoCloseable: type[AutoCloseable] + Boolean: type[Boolean] + BootstrapMethodError: type[BootstrapMethodError] + Byte: type[Byte] + CharSequence: type[CharSequence] + Character: type[Character] + Class: type[Class] + ClassCastException: type[ClassCastException] + ClassCircularityError: type[ClassCircularityError] + ClassFormatError: type[ClassFormatError] + ClassLoader: type[ClassLoader] + ClassNotFoundException: type[ClassNotFoundException] + ClassValue: type[ClassValue] + CloneNotSupportedException: type[CloneNotSupportedException] + Cloneable: type[Cloneable] + Comparable: type[Comparable] + Deprecated: type[Deprecated] + Double: type[Double] + Enum: type[Enum] + EnumConstantNotPresentException: type[EnumConstantNotPresentException] + Error: type[Error] + Exception: type[Exception] + ExceptionInInitializerError: type[ExceptionInInitializerError] + Float: type[Float] + FunctionalInterface: type[FunctionalInterface] + IO: type[IO] + IllegalAccessError: type[IllegalAccessError] + IllegalAccessException: type[IllegalAccessException] + IllegalArgumentException: type[IllegalArgumentException] + IllegalCallerException: type[IllegalCallerException] + IllegalMonitorStateException: type[IllegalMonitorStateException] + IllegalStateException: type[IllegalStateException] + IllegalThreadStateException: type[IllegalThreadStateException] + IncompatibleClassChangeError: type[IncompatibleClassChangeError] + IndexOutOfBoundsException: type[IndexOutOfBoundsException] + InheritableThreadLocal: type[InheritableThreadLocal] + InstantiationError: type[InstantiationError] + InstantiationException: type[InstantiationException] + Integer: type[Integer] + InternalError: type[InternalError] + InterruptedException: type[InterruptedException] + Iterable: type[Iterable] + LayerInstantiationException: type[LayerInstantiationException] + LinkageError: type[LinkageError] + Long: type[Long] + MatchException: type[MatchException] + Math: type[Math] + Module: type[Module] + ModuleLayer: type[ModuleLayer] + NamedPackage: type[NamedPackage] + NegativeArraySizeException: type[NegativeArraySizeException] + NoClassDefFoundError: type[NoClassDefFoundError] + NoSuchFieldError: type[NoSuchFieldError] + NoSuchFieldException: type[NoSuchFieldException] + NoSuchMethodError: type[NoSuchMethodError] + NoSuchMethodException: type[NoSuchMethodException] + NullPointerException: type[NullPointerException] + Number: type[Number] + NumberFormatException: type[NumberFormatException] + Object: type[Object] + OutOfMemoryError: type[OutOfMemoryError] + Override: type[Override] + Package: type[Package] + Process: type[Process] + ProcessBuilder: type[ProcessBuilder] + ProcessHandle: type[ProcessHandle] + Readable: type[Readable] + Record: type[Record] + ReflectiveOperationException: type[ReflectiveOperationException] + Runnable: type[Runnable] + Runtime: type[Runtime] + RuntimeException: type[RuntimeException] + RuntimePermission: type[RuntimePermission] + SafeVarargs: type[SafeVarargs] + ScopedValue: type[ScopedValue] + SecurityException: type[SecurityException] + SecurityManager: type[SecurityManager] + Short: type[Short] + StableValue: type[StableValue] + StackOverflowError: type[StackOverflowError] + StackTraceElement: type[StackTraceElement] + StackWalker: type[StackWalker] + StrictMath: type[StrictMath] + String: type[String] + StringBuffer: type[StringBuffer] + StringBuilder: type[StringBuilder] + StringIndexOutOfBoundsException: type[StringIndexOutOfBoundsException] + SuppressWarnings: type[SuppressWarnings] + System: type[System] + Thread: type[Thread] + ThreadDeath: type[ThreadDeath] + ThreadGroup: type[ThreadGroup] + ThreadLocal: type[ThreadLocal] + Throwable: type[Throwable] + TypeNotPresentException: type[TypeNotPresentException] + UnknownError: type[UnknownError] + UnsatisfiedLinkError: type[UnsatisfiedLinkError] + UnsupportedClassVersionError: type[UnsupportedClassVersionError] + UnsupportedOperationException: type[UnsupportedOperationException] + VerifyError: type[VerifyError] + VirtualMachineError: type[VirtualMachineError] + Void: type[Void] + WrongThreadException: type[WrongThreadException] + annotation: java.lang.annotation.__module_protocol__ + classfile: java.lang.classfile.__module_protocol__ + constant: java.lang.constant.__module_protocol__ + foreign: java.lang.foreign.__module_protocol__ + instrument: java.lang.instrument.__module_protocol__ + invoke: java.lang.invoke.__module_protocol__ + management: java.lang.management.__module_protocol__ + module: java.lang.module.__module_protocol__ + ref: java.lang.ref.__module_protocol__ + reflect: java.lang.reflect.__module_protocol__ + runtime: java.lang.runtime.__module_protocol__ diff --git a/typings/java/lang/annotation/__init__.pyi b/typings/java/lang/annotation/__init__.pyi new file mode 100644 index 0000000..1c3bf73 --- /dev/null +++ b/typings/java/lang/annotation/__init__.pyi @@ -0,0 +1,123 @@ +import typing +from typing import Protocol + +import java.lang +import java.lang.reflect + +class Annotation: + def annotationType(self) -> type[Annotation]: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class AnnotationFormatError(java.lang.Error): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class AnnotationTypeMismatchException(java.lang.RuntimeException): + def __init__( + self, method: java.lang.reflect.Method, string: java.lang.String | str + ): ... + def element(self) -> java.lang.reflect.Method: ... + def foundType(self) -> java.lang.String: ... + +class ElementType(java.lang.Enum["ElementType"]): + TYPE: typing.ClassVar[ElementType] = ... + FIELD: typing.ClassVar[ElementType] = ... + METHOD: typing.ClassVar[ElementType] = ... + PARAMETER: typing.ClassVar[ElementType] = ... + CONSTRUCTOR: typing.ClassVar[ElementType] = ... + LOCAL_VARIABLE: typing.ClassVar[ElementType] = ... + ANNOTATION_TYPE: typing.ClassVar[ElementType] = ... + PACKAGE: typing.ClassVar[ElementType] = ... + TYPE_PARAMETER: typing.ClassVar[ElementType] = ... + TYPE_USE: typing.ClassVar[ElementType] = ... + MODULE: typing.ClassVar[ElementType] = ... + RECORD_COMPONENT: typing.ClassVar[ElementType] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ElementType: ... + @staticmethod + def values() -> typing.MutableSequence[ElementType]: ... + +class IncompleteAnnotationException(java.lang.RuntimeException): + def __init__(self, class_: type[Annotation], string: java.lang.String | str): ... + def annotationType(self) -> type[Annotation]: ... + def elementName(self) -> java.lang.String: ... + +class RetentionPolicy(java.lang.Enum["RetentionPolicy"]): + SOURCE: typing.ClassVar[RetentionPolicy] = ... + CLASS: typing.ClassVar[RetentionPolicy] = ... + RUNTIME: typing.ClassVar[RetentionPolicy] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> RetentionPolicy: ... + @staticmethod + def values() -> typing.MutableSequence[RetentionPolicy]: ... + +class Documented(Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class Inherited(Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class Native(Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class Repeatable(Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def value(self) -> type[Annotation]: ... + +class Retention(Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def value(self) -> RetentionPolicy: ... + +class Target(Annotation): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def value(self) -> typing.MutableSequence[ElementType]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.annotation")``. + + Annotation: type[Annotation] + AnnotationFormatError: type[AnnotationFormatError] + AnnotationTypeMismatchException: type[AnnotationTypeMismatchException] + Documented: type[Documented] + ElementType: type[ElementType] + IncompleteAnnotationException: type[IncompleteAnnotationException] + Inherited: type[Inherited] + Native: type[Native] + Repeatable: type[Repeatable] + Retention: type[Retention] + RetentionPolicy: type[RetentionPolicy] + Target: type[Target] diff --git a/typings/java/lang/classfile/__init__.pyi b/typings/java/lang/classfile/__init__.pyi new file mode 100644 index 0000000..2e5dc39 --- /dev/null +++ b/typings/java/lang/classfile/__init__.pyi @@ -0,0 +1,2684 @@ +import typing +from typing import Protocol + +import java +import java.io +import java.lang +import java.lang.classfile.attribute +import java.lang.classfile.constantpool +import java.lang.classfile.instruction +import java.lang.constant +import java.lang.invoke +import java.lang.reflect +import java.nio.file +import java.util +import java.util.function +import java.util.stream +import jpype +import jpype.protocol + +class Annotation: + def className(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def classSymbol(self) -> java.lang.constant.ClassDesc: ... + def elements(self) -> java.util.List[AnnotationElement]: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + *annotationElement: AnnotationElement, + ) -> Annotation: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + list: java.util.List[AnnotationElement], + ) -> Annotation: ... + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, *annotationElement: AnnotationElement + ) -> Annotation: ... + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, list: java.util.List[AnnotationElement] + ) -> Annotation: ... + +class AnnotationElement: + def name(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, annotationValue: AnnotationValue + ) -> AnnotationElement: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + annotationValue: AnnotationValue, + ) -> AnnotationElement: ... + @staticmethod + def ofAnnotation( + string: java.lang.String | str, annotation: Annotation + ) -> AnnotationElement: ... + @staticmethod + def ofArray( + string: java.lang.String | str, *annotationValue: AnnotationValue + ) -> AnnotationElement: ... + @staticmethod + def ofBoolean( + string: java.lang.String | str, boolean: bool + ) -> AnnotationElement: ... + @staticmethod + def ofByte(string: java.lang.String | str, byte: int) -> AnnotationElement: ... + @staticmethod + def ofChar(string: java.lang.String | str, char: str) -> AnnotationElement: ... + @staticmethod + def ofClass( + string: java.lang.String | str, classDesc: java.lang.constant.ClassDesc + ) -> AnnotationElement: ... + @staticmethod + def ofDouble( + string: java.lang.String | str, double: float + ) -> AnnotationElement: ... + @staticmethod + def ofFloat(string: java.lang.String | str, float: float) -> AnnotationElement: ... + @staticmethod + def ofInt(string: java.lang.String | str, int: int) -> AnnotationElement: ... + @staticmethod + def ofLong(string: java.lang.String | str, long: int) -> AnnotationElement: ... + @staticmethod + def ofShort(string: java.lang.String | str, short: int) -> AnnotationElement: ... + @staticmethod + def ofString( + string: java.lang.String | str, string2: java.lang.String | str + ) -> AnnotationElement: ... + def value(self) -> AnnotationValue: ... + +_AttributeMapper__A = typing.TypeVar("_AttributeMapper__A", bound="Attribute") # + +class AttributeMapper(typing.Generic[_AttributeMapper__A]): + def allowMultiple(self) -> bool: ... + def name(self) -> java.lang.String: ... + def readAttribute( + self, attributedElement: AttributedElement, classReader: ClassReader, int: int + ) -> _AttributeMapper__A: ... + def stability(self) -> AttributeMapper.AttributeStability: ... + def writeAttribute(self, bufWriter: BufWriter, a: _AttributeMapper__A) -> None: ... + class AttributeStability(java.lang.Enum["AttributeMapper.AttributeStability"]): + STATELESS: typing.ClassVar[AttributeMapper.AttributeStability] = ... + CP_REFS: typing.ClassVar[AttributeMapper.AttributeStability] = ... + LABELS: typing.ClassVar[AttributeMapper.AttributeStability] = ... + UNSTABLE: typing.ClassVar[AttributeMapper.AttributeStability] = ... + UNKNOWN: typing.ClassVar[AttributeMapper.AttributeStability] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> AttributeMapper.AttributeStability: ... + @staticmethod + def values() -> typing.MutableSequence[AttributeMapper.AttributeStability]: ... + +class Attributes: + NAME_ANNOTATION_DEFAULT: typing.ClassVar[java.lang.String] = ... + NAME_BOOTSTRAP_METHODS: typing.ClassVar[java.lang.String] = ... + NAME_CHARACTER_RANGE_TABLE: typing.ClassVar[java.lang.String] = ... + NAME_CODE: typing.ClassVar[java.lang.String] = ... + NAME_COMPILATION_ID: typing.ClassVar[java.lang.String] = ... + NAME_CONSTANT_VALUE: typing.ClassVar[java.lang.String] = ... + NAME_DEPRECATED: typing.ClassVar[java.lang.String] = ... + NAME_ENCLOSING_METHOD: typing.ClassVar[java.lang.String] = ... + NAME_EXCEPTIONS: typing.ClassVar[java.lang.String] = ... + NAME_INNER_CLASSES: typing.ClassVar[java.lang.String] = ... + NAME_LINE_NUMBER_TABLE: typing.ClassVar[java.lang.String] = ... + NAME_LOCAL_VARIABLE_TABLE: typing.ClassVar[java.lang.String] = ... + NAME_LOCAL_VARIABLE_TYPE_TABLE: typing.ClassVar[java.lang.String] = ... + NAME_METHOD_PARAMETERS: typing.ClassVar[java.lang.String] = ... + NAME_MODULE: typing.ClassVar[java.lang.String] = ... + NAME_MODULE_HASHES: typing.ClassVar[java.lang.String] = ... + NAME_MODULE_MAIN_CLASS: typing.ClassVar[java.lang.String] = ... + NAME_MODULE_PACKAGES: typing.ClassVar[java.lang.String] = ... + NAME_MODULE_RESOLUTION: typing.ClassVar[java.lang.String] = ... + NAME_MODULE_TARGET: typing.ClassVar[java.lang.String] = ... + NAME_NEST_HOST: typing.ClassVar[java.lang.String] = ... + NAME_NEST_MEMBERS: typing.ClassVar[java.lang.String] = ... + NAME_PERMITTED_SUBCLASSES: typing.ClassVar[java.lang.String] = ... + NAME_RECORD: typing.ClassVar[java.lang.String] = ... + NAME_RUNTIME_INVISIBLE_ANNOTATIONS: typing.ClassVar[java.lang.String] = ... + NAME_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS: typing.ClassVar[ + java.lang.String + ] = ... + NAME_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS: typing.ClassVar[java.lang.String] = ... + NAME_RUNTIME_VISIBLE_ANNOTATIONS: typing.ClassVar[java.lang.String] = ... + NAME_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS: typing.ClassVar[java.lang.String] = ... + NAME_RUNTIME_VISIBLE_TYPE_ANNOTATIONS: typing.ClassVar[java.lang.String] = ... + NAME_SIGNATURE: typing.ClassVar[java.lang.String] = ... + NAME_SOURCE_DEBUG_EXTENSION: typing.ClassVar[java.lang.String] = ... + NAME_SOURCE_FILE: typing.ClassVar[java.lang.String] = ... + NAME_SOURCE_ID: typing.ClassVar[java.lang.String] = ... + NAME_STACK_MAP_TABLE: typing.ClassVar[java.lang.String] = ... + NAME_SYNTHETIC: typing.ClassVar[java.lang.String] = ... + @staticmethod + def annotationDefault() -> AttributeMapper[ + java.lang.classfile.attribute.AnnotationDefaultAttribute + ]: ... + @staticmethod + def bootstrapMethods() -> AttributeMapper[ + java.lang.classfile.attribute.BootstrapMethodsAttribute + ]: ... + @staticmethod + def characterRangeTable() -> AttributeMapper[ + java.lang.classfile.attribute.CharacterRangeTableAttribute + ]: ... + @staticmethod + def code() -> AttributeMapper[java.lang.classfile.attribute.CodeAttribute]: ... + @staticmethod + def compilationId() -> AttributeMapper[ + java.lang.classfile.attribute.CompilationIDAttribute + ]: ... + @staticmethod + def constantValue() -> AttributeMapper[ + java.lang.classfile.attribute.ConstantValueAttribute + ]: ... + @staticmethod + def deprecated() -> AttributeMapper[ + java.lang.classfile.attribute.DeprecatedAttribute + ]: ... + @staticmethod + def enclosingMethod() -> AttributeMapper[ + java.lang.classfile.attribute.EnclosingMethodAttribute + ]: ... + @staticmethod + def exceptions() -> AttributeMapper[ + java.lang.classfile.attribute.ExceptionsAttribute + ]: ... + @staticmethod + def innerClasses() -> AttributeMapper[ + java.lang.classfile.attribute.InnerClassesAttribute + ]: ... + @staticmethod + def lineNumberTable() -> AttributeMapper[ + java.lang.classfile.attribute.LineNumberTableAttribute + ]: ... + @staticmethod + def localVariableTable() -> AttributeMapper[ + java.lang.classfile.attribute.LocalVariableTableAttribute + ]: ... + @staticmethod + def localVariableTypeTable() -> AttributeMapper[ + java.lang.classfile.attribute.LocalVariableTypeTableAttribute + ]: ... + @staticmethod + def methodParameters() -> AttributeMapper[ + java.lang.classfile.attribute.MethodParametersAttribute + ]: ... + @staticmethod + def module() -> AttributeMapper[java.lang.classfile.attribute.ModuleAttribute]: ... + @staticmethod + def moduleHashes() -> AttributeMapper[ + java.lang.classfile.attribute.ModuleHashesAttribute + ]: ... + @staticmethod + def moduleMainClass() -> AttributeMapper[ + java.lang.classfile.attribute.ModuleMainClassAttribute + ]: ... + @staticmethod + def modulePackages() -> AttributeMapper[ + java.lang.classfile.attribute.ModulePackagesAttribute + ]: ... + @staticmethod + def moduleResolution() -> AttributeMapper[ + java.lang.classfile.attribute.ModuleResolutionAttribute + ]: ... + @staticmethod + def moduleTarget() -> AttributeMapper[ + java.lang.classfile.attribute.ModuleTargetAttribute + ]: ... + @staticmethod + def nestHost() -> AttributeMapper[ + java.lang.classfile.attribute.NestHostAttribute + ]: ... + @staticmethod + def nestMembers() -> AttributeMapper[ + java.lang.classfile.attribute.NestMembersAttribute + ]: ... + @staticmethod + def permittedSubclasses() -> AttributeMapper[ + java.lang.classfile.attribute.PermittedSubclassesAttribute + ]: ... + @staticmethod + def record() -> AttributeMapper[java.lang.classfile.attribute.RecordAttribute]: ... + @staticmethod + def runtimeInvisibleAnnotations() -> AttributeMapper[ + java.lang.classfile.attribute.RuntimeInvisibleAnnotationsAttribute + ]: ... + @staticmethod + def runtimeInvisibleParameterAnnotations() -> AttributeMapper[ + java.lang.classfile.attribute.RuntimeInvisibleParameterAnnotationsAttribute + ]: ... + @staticmethod + def runtimeInvisibleTypeAnnotations() -> AttributeMapper[ + java.lang.classfile.attribute.RuntimeInvisibleTypeAnnotationsAttribute + ]: ... + @staticmethod + def runtimeVisibleAnnotations() -> AttributeMapper[ + java.lang.classfile.attribute.RuntimeVisibleAnnotationsAttribute + ]: ... + @staticmethod + def runtimeVisibleParameterAnnotations() -> AttributeMapper[ + java.lang.classfile.attribute.RuntimeVisibleParameterAnnotationsAttribute + ]: ... + @staticmethod + def runtimeVisibleTypeAnnotations() -> AttributeMapper[ + java.lang.classfile.attribute.RuntimeVisibleTypeAnnotationsAttribute + ]: ... + @staticmethod + def signature() -> AttributeMapper[ + java.lang.classfile.attribute.SignatureAttribute + ]: ... + @staticmethod + def sourceDebugExtension() -> AttributeMapper[ + java.lang.classfile.attribute.SourceDebugExtensionAttribute + ]: ... + @staticmethod + def sourceFile() -> AttributeMapper[ + java.lang.classfile.attribute.SourceFileAttribute + ]: ... + @staticmethod + def sourceId() -> AttributeMapper[ + java.lang.classfile.attribute.SourceIDAttribute + ]: ... + @staticmethod + def stackMapTable() -> AttributeMapper[ + java.lang.classfile.attribute.StackMapTableAttribute + ]: ... + @staticmethod + def synthetic() -> AttributeMapper[ + java.lang.classfile.attribute.SyntheticAttribute + ]: ... + +class BootstrapMethodEntry: + def arguments( + self, + ) -> java.util.List[java.lang.classfile.constantpool.LoadableConstantEntry]: ... + def bootstrapMethod(self) -> java.lang.classfile.constantpool.MethodHandleEntry: ... + def bsmIndex(self) -> int: ... + def constantPool(self) -> java.lang.classfile.constantpool.ConstantPool: ... + +class BufWriter: + def canWriteDirect( + self, constantPool: java.lang.classfile.constantpool.ConstantPool + ) -> bool: ... + def constantPool(self) -> java.lang.classfile.constantpool.ConstantPoolBuilder: ... + def patchInt(self, int: int, int2: int, int3: int) -> None: ... + def reserveSpace(self, int: int) -> None: ... + def size(self) -> int: ... + @typing.overload + def writeBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeIndex( + self, poolEntry: java.lang.classfile.constantpool.PoolEntry + ) -> None: ... + def writeIndexOrZero( + self, poolEntry: java.lang.classfile.constantpool.PoolEntry + ) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeIntBytes(self, int: int, long: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeU1(self, int: int) -> None: ... + def writeU2(self, int: int) -> None: ... + +_ClassFileBuilder__E = typing.TypeVar( + "_ClassFileBuilder__E", bound="ClassFileElement" +) # +_ClassFileBuilder__B = typing.TypeVar( + "_ClassFileBuilder__B", bound="ClassFileBuilder" +) # + +class ClassFileBuilder( + java.util.function.Consumer[_ClassFileBuilder__E], + typing.Generic[_ClassFileBuilder__E, _ClassFileBuilder__B], +): + def accept(self, e: _ClassFileBuilder__E) -> None: ... + def constantPool(self) -> java.lang.classfile.constantpool.ConstantPoolBuilder: ... + def transform( + self, + compoundElement: CompoundElement[_ClassFileBuilder__E], + classFileTransform: ClassFileTransform[ + typing.Any, _ClassFileBuilder__E, _ClassFileBuilder__B + ], + ) -> _ClassFileBuilder__B: ... + def with_(self, e: _ClassFileBuilder__E) -> _ClassFileBuilder__B: ... + +class ClassFileElement: ... + +_ClassFileTransform__C = typing.TypeVar( + "_ClassFileTransform__C", bound="ClassFileTransform" +) # +_ClassFileTransform__E = typing.TypeVar( + "_ClassFileTransform__E", bound=ClassFileElement +) # +_ClassFileTransform__B = typing.TypeVar( + "_ClassFileTransform__B", bound=ClassFileBuilder +) # + +class ClassFileTransform( + typing.Generic[ + _ClassFileTransform__C, _ClassFileTransform__E, _ClassFileTransform__B + ] +): + def accept(self, b: _ClassFileTransform__B, e: _ClassFileTransform__E) -> None: ... + def andThen(self, c: _ClassFileTransform__C) -> _ClassFileTransform__C: ... + def atEnd(self, b: _ClassFileTransform__B) -> None: ... + def atStart(self, b: _ClassFileTransform__B) -> None: ... + +class ClassHierarchyResolver: + @typing.overload + def cached(self) -> ClassHierarchyResolver: ... + @typing.overload + def cached( + self, + supplier: java.util.function.Supplier[ + java.util.Map[ + java.lang.constant.ClassDesc, ClassHierarchyResolver.ClassHierarchyInfo + ] + | typing.Mapping[ + java.lang.constant.ClassDesc, ClassHierarchyResolver.ClassHierarchyInfo + ] + ] + | typing.Callable[ + [], + java.util.Map[ + java.lang.constant.ClassDesc, ClassHierarchyResolver.ClassHierarchyInfo + ] + | typing.Mapping[ + java.lang.constant.ClassDesc, ClassHierarchyResolver.ClassHierarchyInfo + ], + ], + ) -> ClassHierarchyResolver: ... + @staticmethod + def defaultResolver() -> ClassHierarchyResolver: ... + def getClassInfo( + self, classDesc: java.lang.constant.ClassDesc + ) -> ClassHierarchyResolver.ClassHierarchyInfo: ... + @staticmethod + def of( + collection: java.util.Collection[java.lang.constant.ClassDesc] + | typing.Sequence[java.lang.constant.ClassDesc] + | set[java.lang.constant.ClassDesc], + map: java.util.Map[java.lang.constant.ClassDesc, java.lang.constant.ClassDesc] + | typing.Mapping[java.lang.constant.ClassDesc, java.lang.constant.ClassDesc], + ) -> ClassHierarchyResolver: ... + @typing.overload + @staticmethod + def ofClassLoading( + classLoader: java.lang.ClassLoader, + ) -> ClassHierarchyResolver: ... + @typing.overload + @staticmethod + def ofClassLoading( + lookup: java.lang.invoke.MethodHandles.Lookup, + ) -> ClassHierarchyResolver: ... + @typing.overload + @staticmethod + def ofResourceParsing( + classLoader: java.lang.ClassLoader, + ) -> ClassHierarchyResolver: ... + @typing.overload + @staticmethod + def ofResourceParsing( + function: java.util.function.Function[ + java.lang.constant.ClassDesc, java.io.InputStream + ] + | typing.Callable[[java.lang.constant.ClassDesc], java.io.InputStream], + ) -> ClassHierarchyResolver: ... + def orElse( + self, classHierarchyResolver: ClassHierarchyResolver | typing.Callable + ) -> ClassHierarchyResolver: ... + class ClassHierarchyInfo: + @staticmethod + def ofClass( + classDesc: java.lang.constant.ClassDesc, + ) -> ClassHierarchyResolver.ClassHierarchyInfo: ... + @staticmethod + def ofInterface() -> ClassHierarchyResolver.ClassHierarchyInfo: ... + +class ClassReader(java.lang.classfile.constantpool.ConstantPool): + def classfileLength(self) -> int: ... + def copyBytesTo(self, bufWriter: BufWriter, int: int, int2: int) -> None: ... + def customAttributes( + self, + ) -> java.util.function.Function[ + java.lang.classfile.constantpool.Utf8Entry, AttributeMapper[typing.Any] + ]: ... + def flags(self) -> int: ... + def readBytes(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def readDouble(self, int: int) -> float: ... + _readEntry_1__T = typing.TypeVar( + "_readEntry_1__T", bound=java.lang.classfile.constantpool.PoolEntry + ) # + @typing.overload + def readEntry(self, int: int) -> java.lang.classfile.constantpool.PoolEntry: ... + @typing.overload + def readEntry(self, int: int, class_: type[_readEntry_1__T]) -> _readEntry_1__T: ... + _readEntryOrNull_1__T = typing.TypeVar( + "_readEntryOrNull_1__T", bound=java.lang.classfile.constantpool.PoolEntry + ) # + @typing.overload + def readEntryOrNull( + self, int: int + ) -> java.lang.classfile.constantpool.PoolEntry: ... + @typing.overload + def readEntryOrNull( + self, int: int, class_: type[_readEntryOrNull_1__T] + ) -> _readEntryOrNull_1__T: ... + def readFloat(self, int: int) -> float: ... + def readInt(self, int: int) -> int: ... + def readLong(self, int: int) -> int: ... + def readS1(self, int: int) -> int: ... + def readS2(self, int: int) -> int: ... + def readU1(self, int: int) -> int: ... + def readU2(self, int: int) -> int: ... + def superclassEntry( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.ClassEntry]: ... + def thisClassEntry(self) -> java.lang.classfile.constantpool.ClassEntry: ... + +class ClassSignature: + @typing.overload + @staticmethod + def of( + classTypeSig: Signature.ClassTypeSig, *classTypeSig2: Signature.ClassTypeSig + ) -> ClassSignature: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[Signature.TypeParam], + classTypeSig: Signature.ClassTypeSig, + *classTypeSig2: Signature.ClassTypeSig, + ) -> ClassSignature: ... + @staticmethod + def parseFrom(string: java.lang.String | str) -> ClassSignature: ... + def signatureString(self) -> java.lang.String: ... + def superclassSignature(self) -> Signature.ClassTypeSig: ... + def superinterfaceSignatures(self) -> java.util.List[Signature.ClassTypeSig]: ... + def typeParameters(self) -> java.util.List[Signature.TypeParam]: ... + +class Label: ... + +class MethodSignature: + def arguments(self) -> java.util.List[Signature]: ... + @typing.overload + @staticmethod + def of(signature: Signature, *signature2: Signature) -> MethodSignature: ... + @typing.overload + @staticmethod + def of(methodTypeDesc: java.lang.constant.MethodTypeDesc) -> MethodSignature: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[Signature.TypeParam], + list2: java.util.List[Signature.ThrowableSig], + signature: Signature, + *signature2: Signature, + ) -> MethodSignature: ... + @staticmethod + def parseFrom(string: java.lang.String | str) -> MethodSignature: ... + def result(self) -> Signature: ... + def signatureString(self) -> java.lang.String: ... + def throwableSignatures(self) -> java.util.List[Signature.ThrowableSig]: ... + def typeParameters(self) -> java.util.List[Signature.TypeParam]: ... + +class Opcode(java.lang.Enum["Opcode"]): + NOP: typing.ClassVar[Opcode] = ... + ACONST_NULL: typing.ClassVar[Opcode] = ... + ICONST_M1: typing.ClassVar[Opcode] = ... + ICONST_0: typing.ClassVar[Opcode] = ... + ICONST_1: typing.ClassVar[Opcode] = ... + ICONST_2: typing.ClassVar[Opcode] = ... + ICONST_3: typing.ClassVar[Opcode] = ... + ICONST_4: typing.ClassVar[Opcode] = ... + ICONST_5: typing.ClassVar[Opcode] = ... + LCONST_0: typing.ClassVar[Opcode] = ... + LCONST_1: typing.ClassVar[Opcode] = ... + FCONST_0: typing.ClassVar[Opcode] = ... + FCONST_1: typing.ClassVar[Opcode] = ... + FCONST_2: typing.ClassVar[Opcode] = ... + DCONST_0: typing.ClassVar[Opcode] = ... + DCONST_1: typing.ClassVar[Opcode] = ... + BIPUSH: typing.ClassVar[Opcode] = ... + SIPUSH: typing.ClassVar[Opcode] = ... + LDC: typing.ClassVar[Opcode] = ... + LDC_W: typing.ClassVar[Opcode] = ... + LDC2_W: typing.ClassVar[Opcode] = ... + ILOAD: typing.ClassVar[Opcode] = ... + LLOAD: typing.ClassVar[Opcode] = ... + FLOAD: typing.ClassVar[Opcode] = ... + DLOAD: typing.ClassVar[Opcode] = ... + ALOAD: typing.ClassVar[Opcode] = ... + ILOAD_0: typing.ClassVar[Opcode] = ... + ILOAD_1: typing.ClassVar[Opcode] = ... + ILOAD_2: typing.ClassVar[Opcode] = ... + ILOAD_3: typing.ClassVar[Opcode] = ... + LLOAD_0: typing.ClassVar[Opcode] = ... + LLOAD_1: typing.ClassVar[Opcode] = ... + LLOAD_2: typing.ClassVar[Opcode] = ... + LLOAD_3: typing.ClassVar[Opcode] = ... + FLOAD_0: typing.ClassVar[Opcode] = ... + FLOAD_1: typing.ClassVar[Opcode] = ... + FLOAD_2: typing.ClassVar[Opcode] = ... + FLOAD_3: typing.ClassVar[Opcode] = ... + DLOAD_0: typing.ClassVar[Opcode] = ... + DLOAD_1: typing.ClassVar[Opcode] = ... + DLOAD_2: typing.ClassVar[Opcode] = ... + DLOAD_3: typing.ClassVar[Opcode] = ... + ALOAD_0: typing.ClassVar[Opcode] = ... + ALOAD_1: typing.ClassVar[Opcode] = ... + ALOAD_2: typing.ClassVar[Opcode] = ... + ALOAD_3: typing.ClassVar[Opcode] = ... + IALOAD: typing.ClassVar[Opcode] = ... + LALOAD: typing.ClassVar[Opcode] = ... + FALOAD: typing.ClassVar[Opcode] = ... + DALOAD: typing.ClassVar[Opcode] = ... + AALOAD: typing.ClassVar[Opcode] = ... + BALOAD: typing.ClassVar[Opcode] = ... + CALOAD: typing.ClassVar[Opcode] = ... + SALOAD: typing.ClassVar[Opcode] = ... + ISTORE: typing.ClassVar[Opcode] = ... + LSTORE: typing.ClassVar[Opcode] = ... + FSTORE: typing.ClassVar[Opcode] = ... + DSTORE: typing.ClassVar[Opcode] = ... + ASTORE: typing.ClassVar[Opcode] = ... + ISTORE_0: typing.ClassVar[Opcode] = ... + ISTORE_1: typing.ClassVar[Opcode] = ... + ISTORE_2: typing.ClassVar[Opcode] = ... + ISTORE_3: typing.ClassVar[Opcode] = ... + LSTORE_0: typing.ClassVar[Opcode] = ... + LSTORE_1: typing.ClassVar[Opcode] = ... + LSTORE_2: typing.ClassVar[Opcode] = ... + LSTORE_3: typing.ClassVar[Opcode] = ... + FSTORE_0: typing.ClassVar[Opcode] = ... + FSTORE_1: typing.ClassVar[Opcode] = ... + FSTORE_2: typing.ClassVar[Opcode] = ... + FSTORE_3: typing.ClassVar[Opcode] = ... + DSTORE_0: typing.ClassVar[Opcode] = ... + DSTORE_1: typing.ClassVar[Opcode] = ... + DSTORE_2: typing.ClassVar[Opcode] = ... + DSTORE_3: typing.ClassVar[Opcode] = ... + ASTORE_0: typing.ClassVar[Opcode] = ... + ASTORE_1: typing.ClassVar[Opcode] = ... + ASTORE_2: typing.ClassVar[Opcode] = ... + ASTORE_3: typing.ClassVar[Opcode] = ... + IASTORE: typing.ClassVar[Opcode] = ... + LASTORE: typing.ClassVar[Opcode] = ... + FASTORE: typing.ClassVar[Opcode] = ... + DASTORE: typing.ClassVar[Opcode] = ... + AASTORE: typing.ClassVar[Opcode] = ... + BASTORE: typing.ClassVar[Opcode] = ... + CASTORE: typing.ClassVar[Opcode] = ... + SASTORE: typing.ClassVar[Opcode] = ... + POP: typing.ClassVar[Opcode] = ... + POP2: typing.ClassVar[Opcode] = ... + DUP: typing.ClassVar[Opcode] = ... + DUP_X1: typing.ClassVar[Opcode] = ... + DUP_X2: typing.ClassVar[Opcode] = ... + DUP2: typing.ClassVar[Opcode] = ... + DUP2_X1: typing.ClassVar[Opcode] = ... + DUP2_X2: typing.ClassVar[Opcode] = ... + SWAP: typing.ClassVar[Opcode] = ... + IADD: typing.ClassVar[Opcode] = ... + LADD: typing.ClassVar[Opcode] = ... + FADD: typing.ClassVar[Opcode] = ... + DADD: typing.ClassVar[Opcode] = ... + ISUB: typing.ClassVar[Opcode] = ... + LSUB: typing.ClassVar[Opcode] = ... + FSUB: typing.ClassVar[Opcode] = ... + DSUB: typing.ClassVar[Opcode] = ... + IMUL: typing.ClassVar[Opcode] = ... + LMUL: typing.ClassVar[Opcode] = ... + FMUL: typing.ClassVar[Opcode] = ... + DMUL: typing.ClassVar[Opcode] = ... + IDIV: typing.ClassVar[Opcode] = ... + LDIV: typing.ClassVar[Opcode] = ... + FDIV: typing.ClassVar[Opcode] = ... + DDIV: typing.ClassVar[Opcode] = ... + IREM: typing.ClassVar[Opcode] = ... + LREM: typing.ClassVar[Opcode] = ... + FREM: typing.ClassVar[Opcode] = ... + DREM: typing.ClassVar[Opcode] = ... + INEG: typing.ClassVar[Opcode] = ... + LNEG: typing.ClassVar[Opcode] = ... + FNEG: typing.ClassVar[Opcode] = ... + DNEG: typing.ClassVar[Opcode] = ... + ISHL: typing.ClassVar[Opcode] = ... + LSHL: typing.ClassVar[Opcode] = ... + ISHR: typing.ClassVar[Opcode] = ... + LSHR: typing.ClassVar[Opcode] = ... + IUSHR: typing.ClassVar[Opcode] = ... + LUSHR: typing.ClassVar[Opcode] = ... + IAND: typing.ClassVar[Opcode] = ... + LAND: typing.ClassVar[Opcode] = ... + IOR: typing.ClassVar[Opcode] = ... + LOR: typing.ClassVar[Opcode] = ... + IXOR: typing.ClassVar[Opcode] = ... + LXOR: typing.ClassVar[Opcode] = ... + IINC: typing.ClassVar[Opcode] = ... + I2L: typing.ClassVar[Opcode] = ... + I2F: typing.ClassVar[Opcode] = ... + I2D: typing.ClassVar[Opcode] = ... + L2I: typing.ClassVar[Opcode] = ... + L2F: typing.ClassVar[Opcode] = ... + L2D: typing.ClassVar[Opcode] = ... + F2I: typing.ClassVar[Opcode] = ... + F2L: typing.ClassVar[Opcode] = ... + F2D: typing.ClassVar[Opcode] = ... + D2I: typing.ClassVar[Opcode] = ... + D2L: typing.ClassVar[Opcode] = ... + D2F: typing.ClassVar[Opcode] = ... + I2B: typing.ClassVar[Opcode] = ... + I2C: typing.ClassVar[Opcode] = ... + I2S: typing.ClassVar[Opcode] = ... + LCMP: typing.ClassVar[Opcode] = ... + FCMPL: typing.ClassVar[Opcode] = ... + FCMPG: typing.ClassVar[Opcode] = ... + DCMPL: typing.ClassVar[Opcode] = ... + DCMPG: typing.ClassVar[Opcode] = ... + IFEQ: typing.ClassVar[Opcode] = ... + IFNE: typing.ClassVar[Opcode] = ... + IFLT: typing.ClassVar[Opcode] = ... + IFGE: typing.ClassVar[Opcode] = ... + IFGT: typing.ClassVar[Opcode] = ... + IFLE: typing.ClassVar[Opcode] = ... + IF_ICMPEQ: typing.ClassVar[Opcode] = ... + IF_ICMPNE: typing.ClassVar[Opcode] = ... + IF_ICMPLT: typing.ClassVar[Opcode] = ... + IF_ICMPGE: typing.ClassVar[Opcode] = ... + IF_ICMPGT: typing.ClassVar[Opcode] = ... + IF_ICMPLE: typing.ClassVar[Opcode] = ... + IF_ACMPEQ: typing.ClassVar[Opcode] = ... + IF_ACMPNE: typing.ClassVar[Opcode] = ... + GOTO: typing.ClassVar[Opcode] = ... + JSR: typing.ClassVar[Opcode] = ... + RET: typing.ClassVar[Opcode] = ... + TABLESWITCH: typing.ClassVar[Opcode] = ... + LOOKUPSWITCH: typing.ClassVar[Opcode] = ... + IRETURN: typing.ClassVar[Opcode] = ... + LRETURN: typing.ClassVar[Opcode] = ... + FRETURN: typing.ClassVar[Opcode] = ... + DRETURN: typing.ClassVar[Opcode] = ... + ARETURN: typing.ClassVar[Opcode] = ... + RETURN: typing.ClassVar[Opcode] = ... + GETSTATIC: typing.ClassVar[Opcode] = ... + PUTSTATIC: typing.ClassVar[Opcode] = ... + GETFIELD: typing.ClassVar[Opcode] = ... + PUTFIELD: typing.ClassVar[Opcode] = ... + INVOKEVIRTUAL: typing.ClassVar[Opcode] = ... + INVOKESPECIAL: typing.ClassVar[Opcode] = ... + INVOKESTATIC: typing.ClassVar[Opcode] = ... + INVOKEINTERFACE: typing.ClassVar[Opcode] = ... + INVOKEDYNAMIC: typing.ClassVar[Opcode] = ... + NEW: typing.ClassVar[Opcode] = ... + NEWARRAY: typing.ClassVar[Opcode] = ... + ANEWARRAY: typing.ClassVar[Opcode] = ... + ARRAYLENGTH: typing.ClassVar[Opcode] = ... + ATHROW: typing.ClassVar[Opcode] = ... + CHECKCAST: typing.ClassVar[Opcode] = ... + INSTANCEOF: typing.ClassVar[Opcode] = ... + MONITORENTER: typing.ClassVar[Opcode] = ... + MONITOREXIT: typing.ClassVar[Opcode] = ... + MULTIANEWARRAY: typing.ClassVar[Opcode] = ... + IFNULL: typing.ClassVar[Opcode] = ... + IFNONNULL: typing.ClassVar[Opcode] = ... + GOTO_W: typing.ClassVar[Opcode] = ... + JSR_W: typing.ClassVar[Opcode] = ... + ILOAD_W: typing.ClassVar[Opcode] = ... + LLOAD_W: typing.ClassVar[Opcode] = ... + FLOAD_W: typing.ClassVar[Opcode] = ... + DLOAD_W: typing.ClassVar[Opcode] = ... + ALOAD_W: typing.ClassVar[Opcode] = ... + ISTORE_W: typing.ClassVar[Opcode] = ... + LSTORE_W: typing.ClassVar[Opcode] = ... + FSTORE_W: typing.ClassVar[Opcode] = ... + DSTORE_W: typing.ClassVar[Opcode] = ... + ASTORE_W: typing.ClassVar[Opcode] = ... + RET_W: typing.ClassVar[Opcode] = ... + IINC_W: typing.ClassVar[Opcode] = ... + def bytecode(self) -> int: ... + def isWide(self) -> bool: ... + def kind(self) -> Opcode.Kind: ... + def sizeIfFixed(self) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Opcode: ... + @staticmethod + def values() -> typing.MutableSequence[Opcode]: ... + class Kind(java.lang.Enum["Opcode.Kind"]): + LOAD: typing.ClassVar[Opcode.Kind] = ... + STORE: typing.ClassVar[Opcode.Kind] = ... + INCREMENT: typing.ClassVar[Opcode.Kind] = ... + BRANCH: typing.ClassVar[Opcode.Kind] = ... + LOOKUP_SWITCH: typing.ClassVar[Opcode.Kind] = ... + TABLE_SWITCH: typing.ClassVar[Opcode.Kind] = ... + RETURN: typing.ClassVar[Opcode.Kind] = ... + THROW_EXCEPTION: typing.ClassVar[Opcode.Kind] = ... + FIELD_ACCESS: typing.ClassVar[Opcode.Kind] = ... + INVOKE: typing.ClassVar[Opcode.Kind] = ... + INVOKE_DYNAMIC: typing.ClassVar[Opcode.Kind] = ... + NEW_OBJECT: typing.ClassVar[Opcode.Kind] = ... + NEW_PRIMITIVE_ARRAY: typing.ClassVar[Opcode.Kind] = ... + NEW_REF_ARRAY: typing.ClassVar[Opcode.Kind] = ... + NEW_MULTI_ARRAY: typing.ClassVar[Opcode.Kind] = ... + TYPE_CHECK: typing.ClassVar[Opcode.Kind] = ... + ARRAY_LOAD: typing.ClassVar[Opcode.Kind] = ... + ARRAY_STORE: typing.ClassVar[Opcode.Kind] = ... + STACK: typing.ClassVar[Opcode.Kind] = ... + CONVERT: typing.ClassVar[Opcode.Kind] = ... + OPERATOR: typing.ClassVar[Opcode.Kind] = ... + CONSTANT: typing.ClassVar[Opcode.Kind] = ... + MONITOR: typing.ClassVar[Opcode.Kind] = ... + NOP: typing.ClassVar[Opcode.Kind] = ... + DISCONTINUED_JSR: typing.ClassVar[Opcode.Kind] = ... + DISCONTINUED_RET: typing.ClassVar[Opcode.Kind] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Opcode.Kind: ... + @staticmethod + def values() -> typing.MutableSequence[Opcode.Kind]: ... + +class TypeKind(java.lang.Enum["TypeKind"]): + BOOLEAN: typing.ClassVar[TypeKind] = ... + BYTE: typing.ClassVar[TypeKind] = ... + CHAR: typing.ClassVar[TypeKind] = ... + SHORT: typing.ClassVar[TypeKind] = ... + INT: typing.ClassVar[TypeKind] = ... + LONG: typing.ClassVar[TypeKind] = ... + FLOAT: typing.ClassVar[TypeKind] = ... + DOUBLE: typing.ClassVar[TypeKind] = ... + REFERENCE: typing.ClassVar[TypeKind] = ... + VOID: typing.ClassVar[TypeKind] = ... + def asLoadable(self) -> TypeKind: ... + @staticmethod + def fromDescriptor(charSequence: java.lang.CharSequence | str) -> TypeKind: ... + @staticmethod + def fromNewarrayCode(int: int) -> TypeKind: ... + @staticmethod + def from_( + ofField: java.lang.invoke.TypeDescriptor.OfField[typing.Any], + ) -> TypeKind: ... + def newarrayCode(self) -> int: ... + def slotSize(self) -> int: ... + def upperBound(self) -> java.lang.constant.ClassDesc: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> TypeKind: ... + @staticmethod + def values() -> typing.MutableSequence[TypeKind]: ... + +_Attribute__A = typing.TypeVar("_Attribute__A", bound="Attribute") # + +class Attribute(ClassFileElement, typing.Generic[_Attribute__A]): + def attributeMapper(self) -> AttributeMapper[_Attribute__A]: ... + def attributeName(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + +class AttributedElement(ClassFileElement): + def attributes(self) -> java.util.List[Attribute[typing.Any]]: ... + _findAttribute__T = typing.TypeVar("_findAttribute__T", bound=Attribute) # + def findAttribute( + self, attributeMapper: AttributeMapper[_findAttribute__T] + ) -> java.util.Optional[_findAttribute__T]: ... + _findAttributes__T = typing.TypeVar("_findAttributes__T", bound=Attribute) # + def findAttributes( + self, attributeMapper: AttributeMapper[_findAttributes__T] + ) -> java.util.List[_findAttributes__T]: ... + +class ClassBuilder(ClassFileBuilder["ClassElement", "ClassBuilder"]): + def transformField( + self, fieldModel: FieldModel, fieldTransform: FieldTransform | typing.Callable + ) -> ClassBuilder: ... + def transformMethod( + self, + methodModel: MethodModel, + methodTransform: MethodTransform | typing.Callable, + ) -> ClassBuilder: ... + @typing.overload + def withField( + self, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + consumer: java.util.function.Consumer[FieldBuilder] + | typing.Callable[[FieldBuilder], None], + ) -> ClassBuilder: ... + @typing.overload + def withField( + self, + string: java.lang.String | str, + classDesc: java.lang.constant.ClassDesc, + int: int, + ) -> ClassBuilder: ... + @typing.overload + def withField( + self, + string: java.lang.String | str, + classDesc: java.lang.constant.ClassDesc, + consumer: java.util.function.Consumer[FieldBuilder] + | typing.Callable[[FieldBuilder], None], + ) -> ClassBuilder: ... + @typing.overload + def withField( + self, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + int: int, + ) -> ClassBuilder: ... + @typing.overload + def withFlags(self, int: int) -> ClassBuilder: ... + @typing.overload + def withFlags(self, *accessFlag: java.lang.reflect.AccessFlag) -> ClassBuilder: ... + @typing.overload + def withInterfaceSymbols( + self, *classDesc: java.lang.constant.ClassDesc + ) -> ClassBuilder: ... + @typing.overload + def withInterfaceSymbols( + self, list: java.util.List[java.lang.constant.ClassDesc] + ) -> ClassBuilder: ... + @typing.overload + def withInterfaces( + self, *classEntry: java.lang.classfile.constantpool.ClassEntry + ) -> ClassBuilder: ... + @typing.overload + def withInterfaces( + self, list: java.util.List[java.lang.classfile.constantpool.ClassEntry] + ) -> ClassBuilder: ... + @typing.overload + def withMethod( + self, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + int: int, + consumer: java.util.function.Consumer[MethodBuilder] + | typing.Callable[[MethodBuilder], None], + ) -> ClassBuilder: ... + @typing.overload + def withMethod( + self, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + int: int, + consumer: java.util.function.Consumer[MethodBuilder] + | typing.Callable[[MethodBuilder], None], + ) -> ClassBuilder: ... + @typing.overload + def withMethodBody( + self, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + int: int, + consumer: java.util.function.Consumer[CodeBuilder] + | typing.Callable[[CodeBuilder], None], + ) -> ClassBuilder: ... + @typing.overload + def withMethodBody( + self, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + int: int, + consumer: java.util.function.Consumer[CodeBuilder] + | typing.Callable[[CodeBuilder], None], + ) -> ClassBuilder: ... + @typing.overload + def withSuperclass( + self, classEntry: java.lang.classfile.constantpool.ClassEntry + ) -> ClassBuilder: ... + @typing.overload + def withSuperclass( + self, classDesc: java.lang.constant.ClassDesc + ) -> ClassBuilder: ... + def withVersion(self, int: int, int2: int) -> ClassBuilder: ... + +class ClassElement(ClassFileElement): ... + +class ClassTransform(ClassFileTransform["ClassTransform", ClassElement, ClassBuilder]): + ACCEPT_ALL: typing.ClassVar[ClassTransform] = ... + def andThen( + self, classTransform: ClassTransform | typing.Callable + ) -> ClassTransform: ... + @staticmethod + def dropping( + predicate: java.util.function.Predicate[ClassElement] + | typing.Callable[[ClassElement], bool], + ) -> ClassTransform: ... + @staticmethod + def endHandler( + consumer: java.util.function.Consumer[ClassBuilder] + | typing.Callable[[ClassBuilder], None], + ) -> ClassTransform: ... + @staticmethod + def ofStateful( + supplier: java.util.function.Supplier[ClassTransform | typing.Callable] + | typing.Callable[[], ClassTransform | typing.Callable], + ) -> ClassTransform: ... + @staticmethod + def transformingFields( + fieldTransform: FieldTransform | typing.Callable, + ) -> ClassTransform: ... + @typing.overload + @staticmethod + def transformingMethodBodies( + codeTransform: CodeTransform | typing.Callable, + ) -> ClassTransform: ... + @typing.overload + @staticmethod + def transformingMethodBodies( + predicate: java.util.function.Predicate[MethodModel] + | typing.Callable[[MethodModel], bool], + codeTransform: CodeTransform | typing.Callable, + ) -> ClassTransform: ... + @typing.overload + @staticmethod + def transformingMethods( + methodTransform: MethodTransform | typing.Callable, + ) -> ClassTransform: ... + @typing.overload + @staticmethod + def transformingMethods( + predicate: java.util.function.Predicate[MethodModel] + | typing.Callable[[MethodModel], bool], + methodTransform: MethodTransform | typing.Callable, + ) -> ClassTransform: ... + +class CodeElement(ClassFileElement): ... + +class CodeTransform(ClassFileTransform["CodeTransform", CodeElement, "CodeBuilder"]): + ACCEPT_ALL: typing.ClassVar[CodeTransform] = ... + def andThen( + self, codeTransform: CodeTransform | typing.Callable + ) -> CodeTransform: ... + @staticmethod + def endHandler( + consumer: java.util.function.Consumer[CodeBuilder] + | typing.Callable[[CodeBuilder], None], + ) -> CodeTransform: ... + @staticmethod + def ofStateful( + supplier: java.util.function.Supplier[CodeTransform | typing.Callable] + | typing.Callable[[], CodeTransform | typing.Callable], + ) -> CodeTransform: ... + +_CompoundElement__E = typing.TypeVar( + "_CompoundElement__E", bound=ClassFileElement +) # + +class CompoundElement( + ClassFileElement, + java.lang.Iterable[_CompoundElement__E], + typing.Generic[_CompoundElement__E], +): + def elementList(self) -> java.util.List[_CompoundElement__E]: ... + def elementStream(self) -> java.util.stream.Stream[_CompoundElement__E]: ... + def forEach( + self, + consumer: java.util.function.Consumer[_CompoundElement__E] + | typing.Callable[[_CompoundElement__E], None], + ) -> None: ... + def iterator(self) -> java.util.Iterator[_CompoundElement__E]: ... + def toDebugString(self) -> java.lang.String: ... + +class FieldBuilder(ClassFileBuilder["FieldElement", "FieldBuilder"]): + @typing.overload + def withFlags(self, int: int) -> FieldBuilder: ... + @typing.overload + def withFlags(self, *accessFlag: java.lang.reflect.AccessFlag) -> FieldBuilder: ... + +class FieldElement(ClassFileElement): ... + +class FieldTransform(ClassFileTransform["FieldTransform", FieldElement, FieldBuilder]): + ACCEPT_ALL: typing.ClassVar[FieldTransform] = ... + def andThen( + self, fieldTransform: FieldTransform | typing.Callable + ) -> FieldTransform: ... + @staticmethod + def dropping( + predicate: java.util.function.Predicate[FieldElement] + | typing.Callable[[FieldElement], bool], + ) -> FieldTransform: ... + @staticmethod + def endHandler( + consumer: java.util.function.Consumer[FieldBuilder] + | typing.Callable[[FieldBuilder], None], + ) -> FieldTransform: ... + @staticmethod + def ofStateful( + supplier: java.util.function.Supplier[FieldTransform | typing.Callable] + | typing.Callable[[], FieldTransform | typing.Callable], + ) -> FieldTransform: ... + +class MethodBuilder(ClassFileBuilder["MethodElement", "MethodBuilder"]): + def transformCode( + self, codeModel: CodeModel, codeTransform: CodeTransform | typing.Callable + ) -> MethodBuilder: ... + def withCode( + self, + consumer: java.util.function.Consumer[CodeBuilder] + | typing.Callable[[CodeBuilder], None], + ) -> MethodBuilder: ... + @typing.overload + def withFlags(self, int: int) -> MethodBuilder: ... + @typing.overload + def withFlags(self, *accessFlag: java.lang.reflect.AccessFlag) -> MethodBuilder: ... + +class MethodElement(ClassFileElement): ... + +class MethodTransform( + ClassFileTransform["MethodTransform", MethodElement, MethodBuilder] +): + ACCEPT_ALL: typing.ClassVar[MethodTransform] = ... + def andThen( + self, methodTransform: MethodTransform | typing.Callable + ) -> MethodTransform: ... + @staticmethod + def dropping( + predicate: java.util.function.Predicate[MethodElement] + | typing.Callable[[MethodElement], bool], + ) -> MethodTransform: ... + @staticmethod + def endHandler( + consumer: java.util.function.Consumer[MethodBuilder] + | typing.Callable[[MethodBuilder], None], + ) -> MethodTransform: ... + @staticmethod + def ofStateful( + supplier: java.util.function.Supplier[MethodTransform | typing.Callable] + | typing.Callable[[], MethodTransform | typing.Callable], + ) -> MethodTransform: ... + @staticmethod + def transformingCode( + codeTransform: CodeTransform | typing.Callable, + ) -> MethodTransform: ... + +class AccessFlags(ClassElement, MethodElement, FieldElement): + def flags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def flagsMask(self) -> int: ... + def has(self, accessFlag: java.lang.reflect.AccessFlag) -> bool: ... + def location(self) -> java.lang.reflect.AccessFlag.Location: ... + +class ClassFileVersion(ClassElement): + def majorVersion(self) -> int: ... + def minorVersion(self) -> int: ... + @staticmethod + def of(int: int, int2: int) -> ClassFileVersion: ... + +class ClassModel(CompoundElement[ClassElement], AttributedElement): + def constantPool(self) -> java.lang.classfile.constantpool.ConstantPool: ... + def fields(self) -> java.util.List[FieldModel]: ... + def flags(self) -> AccessFlags: ... + def interfaces( + self, + ) -> java.util.List[java.lang.classfile.constantpool.ClassEntry]: ... + def isModuleInfo(self) -> bool: ... + def majorVersion(self) -> int: ... + def methods(self) -> java.util.List[MethodModel]: ... + def minorVersion(self) -> int: ... + def superclass( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.ClassEntry]: ... + def thisClass(self) -> java.lang.classfile.constantpool.ClassEntry: ... + +class CodeModel(CompoundElement[CodeElement], AttributedElement, MethodElement): + def exceptionHandlers( + self, + ) -> java.util.List[java.lang.classfile.instruction.ExceptionCatch]: ... + def parent(self) -> java.util.Optional[MethodModel]: ... + +_CustomAttribute__T = typing.TypeVar( + "_CustomAttribute__T", bound="CustomAttribute" +) # + +class CustomAttribute( + Attribute[_CustomAttribute__T], + CodeElement, + ClassElement, + MethodElement, + FieldElement, + typing.Generic[_CustomAttribute__T], +): + def attributeMapper(self) -> AttributeMapper[_CustomAttribute__T]: ... + def attributeName(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def toString(self) -> java.lang.String: ... + +class FieldModel(CompoundElement[FieldElement], AttributedElement, ClassElement): + def fieldName(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def fieldType(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def fieldTypeSymbol(self) -> java.lang.constant.ClassDesc: ... + def flags(self) -> AccessFlags: ... + def parent(self) -> java.util.Optional[ClassModel]: ... + +class Instruction(CodeElement): + def opcode(self) -> Opcode: ... + def sizeInBytes(self) -> int: ... + +class Interfaces(ClassElement): + def interfaces( + self, + ) -> java.util.List[java.lang.classfile.constantpool.ClassEntry]: ... + @typing.overload + @staticmethod + def of(*classEntry: java.lang.classfile.constantpool.ClassEntry) -> Interfaces: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[java.lang.classfile.constantpool.ClassEntry], + ) -> Interfaces: ... + @typing.overload + @staticmethod + def ofSymbols(*classDesc: java.lang.constant.ClassDesc) -> Interfaces: ... + @typing.overload + @staticmethod + def ofSymbols(list: java.util.List[java.lang.constant.ClassDesc]) -> Interfaces: ... + +class MethodModel(CompoundElement[MethodElement], AttributedElement, ClassElement): + def code(self) -> java.util.Optional[CodeModel]: ... + def flags(self) -> AccessFlags: ... + def methodName(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def methodType(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def methodTypeSymbol(self) -> java.lang.constant.MethodTypeDesc: ... + def parent(self) -> java.util.Optional[ClassModel]: ... + +class PseudoInstruction(CodeElement): ... + +class Superclass(ClassElement): + @staticmethod + def of(classEntry: java.lang.classfile.constantpool.ClassEntry) -> Superclass: ... + def superclassEntry(self) -> java.lang.classfile.constantpool.ClassEntry: ... + +class AnnotationValue: + TAG_BYTE: typing.ClassVar[int] = ... + TAG_CHAR: typing.ClassVar[int] = ... + TAG_DOUBLE: typing.ClassVar[int] = ... + TAG_FLOAT: typing.ClassVar[int] = ... + TAG_INT: typing.ClassVar[int] = ... + TAG_LONG: typing.ClassVar[int] = ... + TAG_SHORT: typing.ClassVar[int] = ... + TAG_BOOLEAN: typing.ClassVar[int] = ... + TAG_STRING: typing.ClassVar[int] = ... + TAG_ENUM: typing.ClassVar[int] = ... + TAG_CLASS: typing.ClassVar[int] = ... + TAG_ANNOTATION: typing.ClassVar[int] = ... + TAG_ARRAY: typing.ClassVar[int] = ... + @staticmethod + def of(object: typing.Any) -> AnnotationValue: ... + @staticmethod + def ofAnnotation(annotation: Annotation) -> AnnotationValue.OfAnnotation: ... + @typing.overload + @staticmethod + def ofArray(*annotationValue: AnnotationValue) -> AnnotationValue.OfArray: ... + @typing.overload + @staticmethod + def ofArray(list: java.util.List[AnnotationValue]) -> AnnotationValue.OfArray: ... + @typing.overload + @staticmethod + def ofBoolean(boolean: bool) -> AnnotationValue.OfBoolean: ... + @typing.overload + @staticmethod + def ofBoolean( + integerEntry: java.lang.classfile.constantpool.IntegerEntry, + ) -> AnnotationValue.OfBoolean: ... + @typing.overload + @staticmethod + def ofByte(byte: int) -> AnnotationValue.OfByte: ... + @typing.overload + @staticmethod + def ofByte( + integerEntry: java.lang.classfile.constantpool.IntegerEntry, + ) -> AnnotationValue.OfByte: ... + @typing.overload + @staticmethod + def ofChar(char: str) -> AnnotationValue.OfChar: ... + @typing.overload + @staticmethod + def ofChar( + integerEntry: java.lang.classfile.constantpool.IntegerEntry, + ) -> AnnotationValue.OfChar: ... + @typing.overload + @staticmethod + def ofClass( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + ) -> AnnotationValue.OfClass: ... + @typing.overload + @staticmethod + def ofClass(classDesc: java.lang.constant.ClassDesc) -> AnnotationValue.OfClass: ... + @typing.overload + @staticmethod + def ofDouble(double: float) -> AnnotationValue.OfDouble: ... + @typing.overload + @staticmethod + def ofDouble( + doubleEntry: java.lang.classfile.constantpool.DoubleEntry, + ) -> AnnotationValue.OfDouble: ... + @typing.overload + @staticmethod + def ofEnum( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + ) -> AnnotationValue.OfEnum: ... + @typing.overload + @staticmethod + def ofEnum( + classDesc: java.lang.constant.ClassDesc, string: java.lang.String | str + ) -> AnnotationValue.OfEnum: ... + @typing.overload + @staticmethod + def ofFloat(float: float) -> AnnotationValue.OfFloat: ... + @typing.overload + @staticmethod + def ofFloat( + floatEntry: java.lang.classfile.constantpool.FloatEntry, + ) -> AnnotationValue.OfFloat: ... + @typing.overload + @staticmethod + def ofInt(int: int) -> AnnotationValue.OfInt: ... + @typing.overload + @staticmethod + def ofInt( + integerEntry: java.lang.classfile.constantpool.IntegerEntry, + ) -> AnnotationValue.OfInt: ... + @typing.overload + @staticmethod + def ofLong( + longEntry: java.lang.classfile.constantpool.LongEntry, + ) -> AnnotationValue.OfLong: ... + @typing.overload + @staticmethod + def ofLong(long: int) -> AnnotationValue.OfLong: ... + @typing.overload + @staticmethod + def ofShort( + integerEntry: java.lang.classfile.constantpool.IntegerEntry, + ) -> AnnotationValue.OfShort: ... + @typing.overload + @staticmethod + def ofShort(short: int) -> AnnotationValue.OfShort: ... + @typing.overload + @staticmethod + def ofString(string: java.lang.String | str) -> AnnotationValue.OfString: ... + @typing.overload + @staticmethod + def ofString( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + ) -> AnnotationValue.OfString: ... + def tag(self) -> int: ... + class OfAnnotation(java.lang.classfile.AnnotationValue): + def annotation(self) -> Annotation: ... + + class OfArray(java.lang.classfile.AnnotationValue): + def values(self) -> java.util.List[AnnotationValue]: ... + + class OfBoolean(java.lang.classfile.AnnotationValue.OfConstant): + def booleanValue(self) -> bool: ... + def constant(self) -> java.lang.classfile.constantpool.IntegerEntry: ... + def resolvedValue(self) -> bool: ... + + class OfByte(java.lang.classfile.AnnotationValue.OfConstant): + def byteValue(self) -> int: ... + def constant(self) -> java.lang.classfile.constantpool.IntegerEntry: ... + def resolvedValue(self) -> int: ... + + class OfChar(java.lang.classfile.AnnotationValue.OfConstant): + def charValue(self) -> str: ... + def constant(self) -> java.lang.classfile.constantpool.IntegerEntry: ... + def resolvedValue(self) -> str: ... + + class OfClass(java.lang.classfile.AnnotationValue): + def className(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def classSymbol(self) -> java.lang.constant.ClassDesc: ... + + class OfConstant(java.lang.classfile.AnnotationValue): + def constant( + self, + ) -> java.lang.classfile.constantpool.AnnotationConstantValueEntry: ... + def resolvedValue(self) -> java.lang.constant.Constable: ... + + class OfDouble(java.lang.classfile.AnnotationValue.OfConstant): + def constant(self) -> java.lang.classfile.constantpool.DoubleEntry: ... + def doubleValue(self) -> float: ... + def resolvedValue(self) -> float: ... + + class OfEnum(java.lang.classfile.AnnotationValue): + def className(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def classSymbol(self) -> java.lang.constant.ClassDesc: ... + def constantName(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + + class OfFloat(java.lang.classfile.AnnotationValue.OfConstant): + def constant(self) -> java.lang.classfile.constantpool.FloatEntry: ... + def floatValue(self) -> float: ... + def resolvedValue(self) -> float: ... + + class OfInt(java.lang.classfile.AnnotationValue.OfConstant): + def constant(self) -> java.lang.classfile.constantpool.IntegerEntry: ... + def intValue(self) -> int: ... + def resolvedValue(self) -> int: ... + + class OfLong(java.lang.classfile.AnnotationValue.OfConstant): + def constant(self) -> java.lang.classfile.constantpool.LongEntry: ... + def longValue(self) -> int: ... + def resolvedValue(self) -> int: ... + + class OfShort(java.lang.classfile.AnnotationValue.OfConstant): + def constant(self) -> java.lang.classfile.constantpool.IntegerEntry: ... + def resolvedValue(self) -> int: ... + def shortValue(self) -> int: ... + + class OfString(java.lang.classfile.AnnotationValue.OfConstant): + def constant(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def resolvedValue(self) -> java.lang.String: ... + def stringValue(self) -> java.lang.String: ... + +class ClassFile: + MAGIC_NUMBER: typing.ClassVar[int] = ... + ACC_PUBLIC: typing.ClassVar[int] = ... + ACC_PROTECTED: typing.ClassVar[int] = ... + ACC_PRIVATE: typing.ClassVar[int] = ... + ACC_INTERFACE: typing.ClassVar[int] = ... + ACC_ENUM: typing.ClassVar[int] = ... + ACC_ANNOTATION: typing.ClassVar[int] = ... + ACC_SUPER: typing.ClassVar[int] = ... + ACC_ABSTRACT: typing.ClassVar[int] = ... + ACC_VOLATILE: typing.ClassVar[int] = ... + ACC_TRANSIENT: typing.ClassVar[int] = ... + ACC_SYNTHETIC: typing.ClassVar[int] = ... + ACC_STATIC: typing.ClassVar[int] = ... + ACC_FINAL: typing.ClassVar[int] = ... + ACC_SYNCHRONIZED: typing.ClassVar[int] = ... + ACC_BRIDGE: typing.ClassVar[int] = ... + ACC_VARARGS: typing.ClassVar[int] = ... + ACC_NATIVE: typing.ClassVar[int] = ... + ACC_STRICT: typing.ClassVar[int] = ... + ACC_MODULE: typing.ClassVar[int] = ... + ACC_OPEN: typing.ClassVar[int] = ... + ACC_MANDATED: typing.ClassVar[int] = ... + ACC_TRANSITIVE: typing.ClassVar[int] = ... + ACC_STATIC_PHASE: typing.ClassVar[int] = ... + JAVA_1_VERSION: typing.ClassVar[int] = ... + JAVA_2_VERSION: typing.ClassVar[int] = ... + JAVA_3_VERSION: typing.ClassVar[int] = ... + JAVA_4_VERSION: typing.ClassVar[int] = ... + JAVA_5_VERSION: typing.ClassVar[int] = ... + JAVA_6_VERSION: typing.ClassVar[int] = ... + JAVA_7_VERSION: typing.ClassVar[int] = ... + JAVA_8_VERSION: typing.ClassVar[int] = ... + JAVA_9_VERSION: typing.ClassVar[int] = ... + JAVA_10_VERSION: typing.ClassVar[int] = ... + JAVA_11_VERSION: typing.ClassVar[int] = ... + JAVA_12_VERSION: typing.ClassVar[int] = ... + JAVA_13_VERSION: typing.ClassVar[int] = ... + JAVA_14_VERSION: typing.ClassVar[int] = ... + JAVA_15_VERSION: typing.ClassVar[int] = ... + JAVA_16_VERSION: typing.ClassVar[int] = ... + JAVA_17_VERSION: typing.ClassVar[int] = ... + JAVA_18_VERSION: typing.ClassVar[int] = ... + JAVA_19_VERSION: typing.ClassVar[int] = ... + JAVA_20_VERSION: typing.ClassVar[int] = ... + JAVA_21_VERSION: typing.ClassVar[int] = ... + JAVA_22_VERSION: typing.ClassVar[int] = ... + JAVA_23_VERSION: typing.ClassVar[int] = ... + JAVA_24_VERSION: typing.ClassVar[int] = ... + JAVA_25_VERSION: typing.ClassVar[int] = ... + PREVIEW_MINOR_VERSION: typing.ClassVar[int] = ... + @typing.overload + def build( + self, + classEntry: java.lang.classfile.constantpool.ClassEntry, + constantPoolBuilder: java.lang.classfile.constantpool.ConstantPoolBuilder, + consumer: java.util.function.Consumer[ClassBuilder] + | typing.Callable[[ClassBuilder], None], + ) -> typing.MutableSequence[int]: ... + @typing.overload + def build( + self, + classDesc: java.lang.constant.ClassDesc, + consumer: java.util.function.Consumer[ClassBuilder] + | typing.Callable[[ClassBuilder], None], + ) -> typing.MutableSequence[int]: ... + @typing.overload + def buildModule( + self, moduleAttribute: java.lang.classfile.attribute.ModuleAttribute + ) -> typing.MutableSequence[int]: ... + @typing.overload + def buildModule( + self, + moduleAttribute: java.lang.classfile.attribute.ModuleAttribute, + consumer: java.util.function.Consumer[ClassBuilder] + | typing.Callable[[ClassBuilder], None], + ) -> typing.MutableSequence[int]: ... + @typing.overload + def buildModuleTo( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + moduleAttribute: java.lang.classfile.attribute.ModuleAttribute, + ) -> None: ... + @typing.overload + def buildModuleTo( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + moduleAttribute: java.lang.classfile.attribute.ModuleAttribute, + consumer: java.util.function.Consumer[ClassBuilder] + | typing.Callable[[ClassBuilder], None], + ) -> None: ... + @typing.overload + def buildTo( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + classEntry: java.lang.classfile.constantpool.ClassEntry, + constantPoolBuilder: java.lang.classfile.constantpool.ConstantPoolBuilder, + consumer: java.util.function.Consumer[ClassBuilder] + | typing.Callable[[ClassBuilder], None], + ) -> None: ... + @typing.overload + def buildTo( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + classDesc: java.lang.constant.ClassDesc, + consumer: java.util.function.Consumer[ClassBuilder] + | typing.Callable[[ClassBuilder], None], + ) -> None: ... + @staticmethod + def latestMajorVersion() -> int: ... + @staticmethod + def latestMinorVersion() -> int: ... + @typing.overload + @staticmethod + def of() -> ClassFile: ... + @typing.overload + @staticmethod + def of(*option: ClassFile.Option) -> ClassFile: ... + @typing.overload + def parse(self, byteArray: list[int] | jpype.JArray | bytes) -> ClassModel: ... + @typing.overload + def parse( + self, path: java.nio.file.Path | jpype.protocol.SupportsPath + ) -> ClassModel: ... + @typing.overload + def transformClass( + self, + classModel: ClassModel, + classEntry: java.lang.classfile.constantpool.ClassEntry, + classTransform: ClassTransform | typing.Callable, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def transformClass( + self, classModel: ClassModel, classTransform: ClassTransform | typing.Callable + ) -> typing.MutableSequence[int]: ... + @typing.overload + def transformClass( + self, + classModel: ClassModel, + classDesc: java.lang.constant.ClassDesc, + classTransform: ClassTransform | typing.Callable, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def verify( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> java.util.List[java.lang.VerifyError]: ... + @typing.overload + def verify( + self, classModel: ClassModel + ) -> java.util.List[java.lang.VerifyError]: ... + @typing.overload + def verify( + self, path: java.nio.file.Path | jpype.protocol.SupportsPath + ) -> java.util.List[java.lang.VerifyError]: ... + def withOptions(self, *option: ClassFile.Option) -> ClassFile: ... + class AttributeMapperOption(java.lang.classfile.ClassFile.Option): + def attributeMapper( + self, + ) -> java.util.function.Function[ + java.lang.classfile.constantpool.Utf8Entry, AttributeMapper[typing.Any] + ]: ... + @staticmethod + def of( + function: java.util.function.Function[ + java.lang.classfile.constantpool.Utf8Entry, AttributeMapper[typing.Any] + ] + | typing.Callable[ + [java.lang.classfile.constantpool.Utf8Entry], + AttributeMapper[typing.Any], + ], + ) -> ClassFile.AttributeMapperOption: ... + + class AttributesProcessingOption( + java.lang.Enum["ClassFile.AttributesProcessingOption"], + java.lang.classfile.ClassFile.Option, + ): + PASS_ALL_ATTRIBUTES: typing.ClassVar[ClassFile.AttributesProcessingOption] = ... + DROP_UNKNOWN_ATTRIBUTES: typing.ClassVar[ + ClassFile.AttributesProcessingOption + ] = ... + DROP_UNSTABLE_ATTRIBUTES: typing.ClassVar[ + ClassFile.AttributesProcessingOption + ] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> ClassFile.AttributesProcessingOption: ... + @staticmethod + def values() -> typing.MutableSequence[ + ClassFile.AttributesProcessingOption + ]: ... + + class ClassHierarchyResolverOption(java.lang.classfile.ClassFile.Option): + def classHierarchyResolver(self) -> ClassHierarchyResolver: ... + @staticmethod + def of( + classHierarchyResolver: ClassHierarchyResolver | typing.Callable, + ) -> ClassFile.ClassHierarchyResolverOption: ... + + class ConstantPoolSharingOption( + java.lang.Enum["ClassFile.ConstantPoolSharingOption"], + java.lang.classfile.ClassFile.Option, + ): + SHARED_POOL: typing.ClassVar[ClassFile.ConstantPoolSharingOption] = ... + NEW_POOL: typing.ClassVar[ClassFile.ConstantPoolSharingOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> ClassFile.ConstantPoolSharingOption: ... + @staticmethod + def values() -> typing.MutableSequence[ClassFile.ConstantPoolSharingOption]: ... + + class DeadCodeOption( + java.lang.Enum["ClassFile.DeadCodeOption"], java.lang.classfile.ClassFile.Option + ): + PATCH_DEAD_CODE: typing.ClassVar[ClassFile.DeadCodeOption] = ... + KEEP_DEAD_CODE: typing.ClassVar[ClassFile.DeadCodeOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ClassFile.DeadCodeOption: ... + @staticmethod + def values() -> typing.MutableSequence[ClassFile.DeadCodeOption]: ... + + class DeadLabelsOption( + java.lang.Enum["ClassFile.DeadLabelsOption"], + java.lang.classfile.ClassFile.Option, + ): + FAIL_ON_DEAD_LABELS: typing.ClassVar[ClassFile.DeadLabelsOption] = ... + DROP_DEAD_LABELS: typing.ClassVar[ClassFile.DeadLabelsOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ClassFile.DeadLabelsOption: ... + @staticmethod + def values() -> typing.MutableSequence[ClassFile.DeadLabelsOption]: ... + + class DebugElementsOption( + java.lang.Enum["ClassFile.DebugElementsOption"], + java.lang.classfile.ClassFile.Option, + ): + PASS_DEBUG: typing.ClassVar[ClassFile.DebugElementsOption] = ... + DROP_DEBUG: typing.ClassVar[ClassFile.DebugElementsOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> ClassFile.DebugElementsOption: ... + @staticmethod + def values() -> typing.MutableSequence[ClassFile.DebugElementsOption]: ... + + class LineNumbersOption( + java.lang.Enum["ClassFile.LineNumbersOption"], + java.lang.classfile.ClassFile.Option, + ): + PASS_LINE_NUMBERS: typing.ClassVar[ClassFile.LineNumbersOption] = ... + DROP_LINE_NUMBERS: typing.ClassVar[ClassFile.LineNumbersOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ClassFile.LineNumbersOption: ... + @staticmethod + def values() -> typing.MutableSequence[ClassFile.LineNumbersOption]: ... + + class Option: ... + + class ShortJumpsOption( + java.lang.Enum["ClassFile.ShortJumpsOption"], + java.lang.classfile.ClassFile.Option, + ): + FIX_SHORT_JUMPS: typing.ClassVar[ClassFile.ShortJumpsOption] = ... + FAIL_ON_SHORT_JUMPS: typing.ClassVar[ClassFile.ShortJumpsOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ClassFile.ShortJumpsOption: ... + @staticmethod + def values() -> typing.MutableSequence[ClassFile.ShortJumpsOption]: ... + + class StackMapsOption( + java.lang.Enum["ClassFile.StackMapsOption"], + java.lang.classfile.ClassFile.Option, + ): + STACK_MAPS_WHEN_REQUIRED: typing.ClassVar[ClassFile.StackMapsOption] = ... + GENERATE_STACK_MAPS: typing.ClassVar[ClassFile.StackMapsOption] = ... + DROP_STACK_MAPS: typing.ClassVar[ClassFile.StackMapsOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ClassFile.StackMapsOption: ... + @staticmethod + def values() -> typing.MutableSequence[ClassFile.StackMapsOption]: ... + +class CodeBuilder(ClassFileBuilder[CodeElement, "CodeBuilder"]): + def aaload(self) -> CodeBuilder: ... + def aastore(self) -> CodeBuilder: ... + def aconst_null(self) -> CodeBuilder: ... + def allocateLocal(self, typeKind: TypeKind) -> int: ... + def aload(self, int: int) -> CodeBuilder: ... + @typing.overload + def anewarray( + self, classEntry: java.lang.classfile.constantpool.ClassEntry + ) -> CodeBuilder: ... + @typing.overload + def anewarray(self, classDesc: java.lang.constant.ClassDesc) -> CodeBuilder: ... + def areturn(self) -> CodeBuilder: ... + def arrayLoad(self, typeKind: TypeKind) -> CodeBuilder: ... + def arrayStore(self, typeKind: TypeKind) -> CodeBuilder: ... + def arraylength(self) -> CodeBuilder: ... + def astore(self, int: int) -> CodeBuilder: ... + def athrow(self) -> CodeBuilder: ... + def baload(self) -> CodeBuilder: ... + def bastore(self) -> CodeBuilder: ... + def bipush(self, int: int) -> CodeBuilder: ... + def block( + self, + consumer: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + ) -> CodeBuilder: ... + def branch(self, opcode: Opcode, label: Label) -> CodeBuilder: ... + def caload(self) -> CodeBuilder: ... + def castore(self) -> CodeBuilder: ... + def characterRange( + self, label: Label, label2: Label, int: int, int2: int, int3: int + ) -> CodeBuilder: ... + @typing.overload + def checkcast( + self, classEntry: java.lang.classfile.constantpool.ClassEntry + ) -> CodeBuilder: ... + @typing.overload + def checkcast(self, classDesc: java.lang.constant.ClassDesc) -> CodeBuilder: ... + def conversion(self, typeKind: TypeKind, typeKind2: TypeKind) -> CodeBuilder: ... + def d2f(self) -> CodeBuilder: ... + def d2i(self) -> CodeBuilder: ... + def d2l(self) -> CodeBuilder: ... + def dadd(self) -> CodeBuilder: ... + def daload(self) -> CodeBuilder: ... + def dastore(self) -> CodeBuilder: ... + def dcmpg(self) -> CodeBuilder: ... + def dcmpl(self) -> CodeBuilder: ... + def dconst_0(self) -> CodeBuilder: ... + def dconst_1(self) -> CodeBuilder: ... + def ddiv(self) -> CodeBuilder: ... + def dload(self, int: int) -> CodeBuilder: ... + def dmul(self) -> CodeBuilder: ... + def dneg(self) -> CodeBuilder: ... + def drem(self) -> CodeBuilder: ... + def dreturn(self) -> CodeBuilder: ... + def dstore(self, int: int) -> CodeBuilder: ... + def dsub(self) -> CodeBuilder: ... + def dup(self) -> CodeBuilder: ... + def dup2(self) -> CodeBuilder: ... + def dup2_x1(self) -> CodeBuilder: ... + def dup2_x2(self) -> CodeBuilder: ... + def dup_x1(self) -> CodeBuilder: ... + def dup_x2(self) -> CodeBuilder: ... + def endLabel(self) -> Label: ... + @typing.overload + def exceptionCatch( + self, + label: Label, + label2: Label, + label3: Label, + classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> CodeBuilder: ... + @typing.overload + def exceptionCatch( + self, + label: Label, + label2: Label, + label3: Label, + classDesc: java.lang.constant.ClassDesc, + ) -> CodeBuilder: ... + @typing.overload + def exceptionCatch( + self, + label: Label, + label2: Label, + label3: Label, + optional: java.util.Optional[java.lang.classfile.constantpool.ClassEntry], + ) -> CodeBuilder: ... + def exceptionCatchAll( + self, label: Label, label2: Label, label3: Label + ) -> CodeBuilder: ... + def f2d(self) -> CodeBuilder: ... + def f2i(self) -> CodeBuilder: ... + def f2l(self) -> CodeBuilder: ... + def fadd(self) -> CodeBuilder: ... + def faload(self) -> CodeBuilder: ... + def fastore(self) -> CodeBuilder: ... + def fcmpg(self) -> CodeBuilder: ... + def fcmpl(self) -> CodeBuilder: ... + def fconst_0(self) -> CodeBuilder: ... + def fconst_1(self) -> CodeBuilder: ... + def fconst_2(self) -> CodeBuilder: ... + def fdiv(self) -> CodeBuilder: ... + @typing.overload + def fieldAccess( + self, + opcode: Opcode, + fieldRefEntry: java.lang.classfile.constantpool.FieldRefEntry, + ) -> CodeBuilder: ... + @typing.overload + def fieldAccess( + self, + opcode: Opcode, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + classDesc2: java.lang.constant.ClassDesc, + ) -> CodeBuilder: ... + def fload(self, int: int) -> CodeBuilder: ... + def fmul(self) -> CodeBuilder: ... + def fneg(self) -> CodeBuilder: ... + def frem(self) -> CodeBuilder: ... + def freturn(self) -> CodeBuilder: ... + def fstore(self, int: int) -> CodeBuilder: ... + def fsub(self) -> CodeBuilder: ... + @typing.overload + def getfield( + self, fieldRefEntry: java.lang.classfile.constantpool.FieldRefEntry + ) -> CodeBuilder: ... + @typing.overload + def getfield( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + classDesc2: java.lang.constant.ClassDesc, + ) -> CodeBuilder: ... + @typing.overload + def getstatic( + self, fieldRefEntry: java.lang.classfile.constantpool.FieldRefEntry + ) -> CodeBuilder: ... + @typing.overload + def getstatic( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + classDesc2: java.lang.constant.ClassDesc, + ) -> CodeBuilder: ... + def goto_(self, label: Label) -> CodeBuilder: ... + def goto_w(self, label: Label) -> CodeBuilder: ... + def i2b(self) -> CodeBuilder: ... + def i2c(self) -> CodeBuilder: ... + def i2d(self) -> CodeBuilder: ... + def i2f(self) -> CodeBuilder: ... + def i2l(self) -> CodeBuilder: ... + def i2s(self) -> CodeBuilder: ... + def iadd(self) -> CodeBuilder: ... + def iaload(self) -> CodeBuilder: ... + def iand(self) -> CodeBuilder: ... + def iastore(self) -> CodeBuilder: ... + def iconst_0(self) -> CodeBuilder: ... + def iconst_1(self) -> CodeBuilder: ... + def iconst_2(self) -> CodeBuilder: ... + def iconst_3(self) -> CodeBuilder: ... + def iconst_4(self) -> CodeBuilder: ... + def iconst_5(self) -> CodeBuilder: ... + def iconst_m1(self) -> CodeBuilder: ... + def idiv(self) -> CodeBuilder: ... + @typing.overload + def ifThen( + self, + opcode: Opcode, + consumer: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + ) -> CodeBuilder: ... + @typing.overload + def ifThen( + self, + consumer: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + ) -> CodeBuilder: ... + @typing.overload + def ifThenElse( + self, + opcode: Opcode, + consumer: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + consumer2: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + ) -> CodeBuilder: ... + @typing.overload + def ifThenElse( + self, + consumer: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + consumer2: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + ) -> CodeBuilder: ... + def if_acmpeq(self, label: Label) -> CodeBuilder: ... + def if_acmpne(self, label: Label) -> CodeBuilder: ... + def if_icmpeq(self, label: Label) -> CodeBuilder: ... + def if_icmpge(self, label: Label) -> CodeBuilder: ... + def if_icmpgt(self, label: Label) -> CodeBuilder: ... + def if_icmple(self, label: Label) -> CodeBuilder: ... + def if_icmplt(self, label: Label) -> CodeBuilder: ... + def if_icmpne(self, label: Label) -> CodeBuilder: ... + def ifeq(self, label: Label) -> CodeBuilder: ... + def ifge(self, label: Label) -> CodeBuilder: ... + def ifgt(self, label: Label) -> CodeBuilder: ... + def ifle(self, label: Label) -> CodeBuilder: ... + def iflt(self, label: Label) -> CodeBuilder: ... + def ifne(self, label: Label) -> CodeBuilder: ... + def ifnonnull(self, label: Label) -> CodeBuilder: ... + def ifnull(self, label: Label) -> CodeBuilder: ... + def iinc(self, int: int, int2: int) -> CodeBuilder: ... + def iload(self, int: int) -> CodeBuilder: ... + def imul(self) -> CodeBuilder: ... + def ineg(self) -> CodeBuilder: ... + @typing.overload + def instanceOf( + self, classEntry: java.lang.classfile.constantpool.ClassEntry + ) -> CodeBuilder: ... + @typing.overload + def instanceOf(self, classDesc: java.lang.constant.ClassDesc) -> CodeBuilder: ... + @typing.overload + def invoke( + self, + opcode: Opcode, + memberRefEntry: java.lang.classfile.constantpool.MemberRefEntry, + ) -> CodeBuilder: ... + @typing.overload + def invoke( + self, + opcode: Opcode, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + boolean: bool, + ) -> CodeBuilder: ... + @typing.overload + def invokedynamic( + self, invokeDynamicEntry: java.lang.classfile.constantpool.InvokeDynamicEntry + ) -> CodeBuilder: ... + @typing.overload + def invokedynamic( + self, dynamicCallSiteDesc: java.lang.constant.DynamicCallSiteDesc + ) -> CodeBuilder: ... + @typing.overload + def invokeinterface( + self, + interfaceMethodRefEntry: java.lang.classfile.constantpool.InterfaceMethodRefEntry, + ) -> CodeBuilder: ... + @typing.overload + def invokeinterface( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + ) -> CodeBuilder: ... + @typing.overload + def invokespecial( + self, + interfaceMethodRefEntry: java.lang.classfile.constantpool.InterfaceMethodRefEntry, + ) -> CodeBuilder: ... + @typing.overload + def invokespecial( + self, methodRefEntry: java.lang.classfile.constantpool.MethodRefEntry + ) -> CodeBuilder: ... + @typing.overload + def invokespecial( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + ) -> CodeBuilder: ... + @typing.overload + def invokespecial( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + boolean: bool, + ) -> CodeBuilder: ... + @typing.overload + def invokestatic( + self, + interfaceMethodRefEntry: java.lang.classfile.constantpool.InterfaceMethodRefEntry, + ) -> CodeBuilder: ... + @typing.overload + def invokestatic( + self, methodRefEntry: java.lang.classfile.constantpool.MethodRefEntry + ) -> CodeBuilder: ... + @typing.overload + def invokestatic( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + ) -> CodeBuilder: ... + @typing.overload + def invokestatic( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + boolean: bool, + ) -> CodeBuilder: ... + @typing.overload + def invokevirtual( + self, methodRefEntry: java.lang.classfile.constantpool.MethodRefEntry + ) -> CodeBuilder: ... + @typing.overload + def invokevirtual( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + ) -> CodeBuilder: ... + def ior(self) -> CodeBuilder: ... + def irem(self) -> CodeBuilder: ... + def ireturn(self) -> CodeBuilder: ... + def ishl(self) -> CodeBuilder: ... + def ishr(self) -> CodeBuilder: ... + def istore(self, int: int) -> CodeBuilder: ... + def isub(self) -> CodeBuilder: ... + def iushr(self) -> CodeBuilder: ... + def ixor(self) -> CodeBuilder: ... + def l2d(self) -> CodeBuilder: ... + def l2f(self) -> CodeBuilder: ... + def l2i(self) -> CodeBuilder: ... + def labelBinding(self, label: Label) -> CodeBuilder: ... + def ladd(self) -> CodeBuilder: ... + def laload(self) -> CodeBuilder: ... + def land(self) -> CodeBuilder: ... + def lastore(self) -> CodeBuilder: ... + def lcmp(self) -> CodeBuilder: ... + def lconst_0(self) -> CodeBuilder: ... + def lconst_1(self) -> CodeBuilder: ... + @typing.overload + def ldc( + self, + loadableConstantEntry: java.lang.classfile.constantpool.LoadableConstantEntry, + ) -> CodeBuilder: ... + @typing.overload + def ldc(self, constantDesc: java.lang.constant.ConstantDesc) -> CodeBuilder: ... + def ldiv(self) -> CodeBuilder: ... + def lineNumber(self, int: int) -> CodeBuilder: ... + def lload(self, int: int) -> CodeBuilder: ... + def lmul(self) -> CodeBuilder: ... + def lneg(self) -> CodeBuilder: ... + @typing.overload + def loadConstant(self, double: float) -> CodeBuilder: ... + @typing.overload + def loadConstant(self, float: float) -> CodeBuilder: ... + @typing.overload + def loadConstant(self, int: int) -> CodeBuilder: ... + @typing.overload + def loadConstant( + self, constantDesc: java.lang.constant.ConstantDesc + ) -> CodeBuilder: ... + @typing.overload + def loadConstant(self, long: int) -> CodeBuilder: ... + def loadLocal(self, typeKind: TypeKind, int: int) -> CodeBuilder: ... + @typing.overload + def localVariable( + self, + int: int, + string: java.lang.String | str, + classDesc: java.lang.constant.ClassDesc, + label: Label, + label2: Label, + ) -> CodeBuilder: ... + @typing.overload + def localVariable( + self, + int: int, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + label: Label, + label2: Label, + ) -> CodeBuilder: ... + @typing.overload + def localVariableType( + self, + int: int, + string: java.lang.String | str, + signature: Signature, + label: Label, + label2: Label, + ) -> CodeBuilder: ... + @typing.overload + def localVariableType( + self, + int: int, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + label: Label, + label2: Label, + ) -> CodeBuilder: ... + def lookupswitch( + self, + label: Label, + list: java.util.List[java.lang.classfile.instruction.SwitchCase], + ) -> CodeBuilder: ... + def lor(self) -> CodeBuilder: ... + def lrem(self) -> CodeBuilder: ... + def lreturn(self) -> CodeBuilder: ... + def lshl(self) -> CodeBuilder: ... + def lshr(self) -> CodeBuilder: ... + def lstore(self, int: int) -> CodeBuilder: ... + def lsub(self) -> CodeBuilder: ... + def lushr(self) -> CodeBuilder: ... + def lxor(self) -> CodeBuilder: ... + def monitorenter(self) -> CodeBuilder: ... + def monitorexit(self) -> CodeBuilder: ... + @typing.overload + def multianewarray( + self, classEntry: java.lang.classfile.constantpool.ClassEntry, int: int + ) -> CodeBuilder: ... + @typing.overload + def multianewarray( + self, classDesc: java.lang.constant.ClassDesc, int: int + ) -> CodeBuilder: ... + def newBoundLabel(self) -> Label: ... + def newLabel(self) -> Label: ... + @typing.overload + def new_( + self, classEntry: java.lang.classfile.constantpool.ClassEntry + ) -> CodeBuilder: ... + @typing.overload + def new_(self, classDesc: java.lang.constant.ClassDesc) -> CodeBuilder: ... + def newarray(self, typeKind: TypeKind) -> CodeBuilder: ... + def nop(self) -> CodeBuilder: ... + def parameterSlot(self, int: int) -> int: ... + def pop(self) -> CodeBuilder: ... + def pop2(self) -> CodeBuilder: ... + @typing.overload + def putfield( + self, fieldRefEntry: java.lang.classfile.constantpool.FieldRefEntry + ) -> CodeBuilder: ... + @typing.overload + def putfield( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + classDesc2: java.lang.constant.ClassDesc, + ) -> CodeBuilder: ... + @typing.overload + def putstatic( + self, fieldRefEntry: java.lang.classfile.constantpool.FieldRefEntry + ) -> CodeBuilder: ... + @typing.overload + def putstatic( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + classDesc2: java.lang.constant.ClassDesc, + ) -> CodeBuilder: ... + def receiverSlot(self) -> int: ... + @typing.overload + def return_(self) -> CodeBuilder: ... + @typing.overload + def return_(self, typeKind: TypeKind) -> CodeBuilder: ... + def saload(self) -> CodeBuilder: ... + def sastore(self) -> CodeBuilder: ... + def sipush(self, int: int) -> CodeBuilder: ... + def startLabel(self) -> Label: ... + def storeLocal(self, typeKind: TypeKind, int: int) -> CodeBuilder: ... + def swap(self) -> CodeBuilder: ... + @typing.overload + def tableswitch( + self, + int: int, + int2: int, + label: Label, + list: java.util.List[java.lang.classfile.instruction.SwitchCase], + ) -> CodeBuilder: ... + @typing.overload + def tableswitch( + self, + label: Label, + list: java.util.List[java.lang.classfile.instruction.SwitchCase], + ) -> CodeBuilder: ... + def transforming( + self, + codeTransform: CodeTransform | typing.Callable, + consumer: java.util.function.Consumer[CodeBuilder] + | typing.Callable[[CodeBuilder], None], + ) -> CodeBuilder: ... + def trying( + self, + consumer: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + consumer2: java.util.function.Consumer[CodeBuilder.CatchBuilder] + | typing.Callable[[CodeBuilder.CatchBuilder], None], + ) -> CodeBuilder: ... + class BlockCodeBuilder(java.lang.classfile.CodeBuilder): + def breakLabel(self) -> Label: ... + + class CatchBuilder: + def catching( + self, + classDesc: java.lang.constant.ClassDesc, + consumer: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + ) -> CodeBuilder.CatchBuilder: ... + def catchingAll( + self, + consumer: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + ) -> None: ... + def catchingMulti( + self, + list: java.util.List[java.lang.constant.ClassDesc], + consumer: java.util.function.Consumer[CodeBuilder.BlockCodeBuilder] + | typing.Callable[[CodeBuilder.BlockCodeBuilder], None], + ) -> CodeBuilder.CatchBuilder: ... + +class Signature: + @staticmethod + def of(classDesc: java.lang.constant.ClassDesc) -> Signature: ... + @staticmethod + def parseFrom(string: java.lang.String | str) -> Signature: ... + def signatureString(self) -> java.lang.String: ... + class ArrayTypeSig(java.lang.classfile.Signature.RefTypeSig): + def componentSignature(self) -> Signature: ... + @typing.overload + @staticmethod + def of(int: int, signature: Signature) -> Signature.ArrayTypeSig: ... + @typing.overload + @staticmethod + def of(signature: Signature) -> Signature.ArrayTypeSig: ... + + class BaseTypeSig(java.lang.classfile.Signature): + def baseType(self) -> str: ... + @typing.overload + @staticmethod + def of(char: str) -> Signature.BaseTypeSig: ... + @typing.overload + @staticmethod + def of(classDesc: java.lang.constant.ClassDesc) -> Signature.BaseTypeSig: ... + + class ClassTypeSig( + java.lang.classfile.Signature.RefTypeSig, + java.lang.classfile.Signature.ThrowableSig, + ): + def classDesc(self) -> java.lang.constant.ClassDesc: ... + def className(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, *typeArg: Signature.TypeArg + ) -> Signature.ClassTypeSig: ... + @typing.overload + @staticmethod + def of( + classTypeSig: Signature.ClassTypeSig, + string: java.lang.String | str, + *typeArg: Signature.TypeArg, + ) -> Signature.ClassTypeSig: ... + @typing.overload + @staticmethod + def of( + classTypeSig: Signature.ClassTypeSig, + classDesc: java.lang.constant.ClassDesc, + *typeArg: Signature.TypeArg, + ) -> Signature.ClassTypeSig: ... + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, *typeArg: Signature.TypeArg + ) -> Signature.ClassTypeSig: ... + def outerType(self) -> java.util.Optional[Signature.ClassTypeSig]: ... + def typeArgs(self) -> java.util.List[Signature.TypeArg]: ... + + class RefTypeSig(java.lang.classfile.Signature): ... + class ThrowableSig(java.lang.classfile.Signature): ... + + class TypeArg: + @staticmethod + def bounded( + wildcardIndicator: Signature.TypeArg.Bounded.WildcardIndicator, + refTypeSig: Signature.RefTypeSig, + ) -> Signature.TypeArg.Bounded: ... + @staticmethod + def extendsOf( + refTypeSig: Signature.RefTypeSig, + ) -> Signature.TypeArg.Bounded: ... + @staticmethod + def of(refTypeSig: Signature.RefTypeSig) -> Signature.TypeArg.Bounded: ... + @staticmethod + def superOf(refTypeSig: Signature.RefTypeSig) -> Signature.TypeArg.Bounded: ... + @staticmethod + def unbounded() -> Signature.TypeArg.Unbounded: ... + class Bounded(java.lang.classfile.Signature.TypeArg): + def boundType(self) -> Signature.RefTypeSig: ... + def wildcardIndicator( + self, + ) -> Signature.TypeArg.Bounded.WildcardIndicator: ... + class WildcardIndicator( + java.lang.Enum["Signature.TypeArg.Bounded.WildcardIndicator"] + ): + NONE: typing.ClassVar[Signature.TypeArg.Bounded.WildcardIndicator] = ... + EXTENDS: typing.ClassVar[ + Signature.TypeArg.Bounded.WildcardIndicator + ] = ... + SUPER: typing.ClassVar[ + Signature.TypeArg.Bounded.WildcardIndicator + ] = ... + _valueOf_0__T = typing.TypeVar( + "_valueOf_0__T", bound=java.lang.Enum + ) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> Signature.TypeArg.Bounded.WildcardIndicator: ... + @staticmethod + def values() -> typing.MutableSequence[ + Signature.TypeArg.Bounded.WildcardIndicator + ]: ... + + class Unbounded(java.lang.classfile.Signature.TypeArg): ... + + class TypeParam: + def classBound(self) -> java.util.Optional[Signature.RefTypeSig]: ... + def identifier(self) -> java.lang.String: ... + def interfaceBounds(self) -> java.util.List[Signature.RefTypeSig]: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, + refTypeSig: Signature.RefTypeSig, + *refTypeSig2: Signature.RefTypeSig, + ) -> Signature.TypeParam: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, + optional: java.util.Optional[Signature.RefTypeSig], + *refTypeSig: Signature.RefTypeSig, + ) -> Signature.TypeParam: ... + + class TypeVarSig( + java.lang.classfile.Signature.RefTypeSig, + java.lang.classfile.Signature.ThrowableSig, + ): + def identifier(self) -> java.lang.String: ... + @staticmethod + def of(string: java.lang.String | str) -> Signature.TypeVarSig: ... + +class TypeAnnotation: + def annotation(self) -> Annotation: ... + @staticmethod + def of( + targetInfo: TypeAnnotation.TargetInfo, + list: java.util.List[TypeAnnotation.TypePathComponent], + annotation: Annotation, + ) -> TypeAnnotation: ... + def targetInfo(self) -> TypeAnnotation.TargetInfo: ... + def targetPath(self) -> java.util.List[TypeAnnotation.TypePathComponent]: ... + class CatchTarget(java.lang.classfile.TypeAnnotation.TargetInfo): + def exceptionTableIndex(self) -> int: ... + + class EmptyTarget(java.lang.classfile.TypeAnnotation.TargetInfo): ... + + class FormalParameterTarget(java.lang.classfile.TypeAnnotation.TargetInfo): + def formalParameterIndex(self) -> int: ... + + class LocalVarTarget(java.lang.classfile.TypeAnnotation.TargetInfo): + def table(self) -> java.util.List[TypeAnnotation.LocalVarTargetInfo]: ... + + class LocalVarTargetInfo: + def endLabel(self) -> Label: ... + def index(self) -> int: ... + @staticmethod + def of( + label: Label, label2: Label, int: int + ) -> TypeAnnotation.LocalVarTargetInfo: ... + def startLabel(self) -> Label: ... + + class OffsetTarget(java.lang.classfile.TypeAnnotation.TargetInfo): + def target(self) -> Label: ... + + class SupertypeTarget(java.lang.classfile.TypeAnnotation.TargetInfo): + def supertypeIndex(self) -> int: ... + + class TargetInfo: + TARGET_CLASS_TYPE_PARAMETER: typing.ClassVar[int] = ... + TARGET_METHOD_TYPE_PARAMETER: typing.ClassVar[int] = ... + TARGET_CLASS_EXTENDS: typing.ClassVar[int] = ... + TARGET_CLASS_TYPE_PARAMETER_BOUND: typing.ClassVar[int] = ... + TARGET_METHOD_TYPE_PARAMETER_BOUND: typing.ClassVar[int] = ... + TARGET_FIELD: typing.ClassVar[int] = ... + TARGET_METHOD_RETURN: typing.ClassVar[int] = ... + TARGET_METHOD_RECEIVER: typing.ClassVar[int] = ... + TARGET_METHOD_FORMAL_PARAMETER: typing.ClassVar[int] = ... + TARGET_THROWS: typing.ClassVar[int] = ... + TARGET_LOCAL_VARIABLE: typing.ClassVar[int] = ... + TARGET_RESOURCE_VARIABLE: typing.ClassVar[int] = ... + TARGET_EXCEPTION_PARAMETER: typing.ClassVar[int] = ... + TARGET_INSTANCEOF: typing.ClassVar[int] = ... + TARGET_NEW: typing.ClassVar[int] = ... + TARGET_CONSTRUCTOR_REFERENCE: typing.ClassVar[int] = ... + TARGET_METHOD_REFERENCE: typing.ClassVar[int] = ... + TARGET_CAST: typing.ClassVar[int] = ... + TARGET_CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT: typing.ClassVar[int] = ... + TARGET_METHOD_INVOCATION_TYPE_ARGUMENT: typing.ClassVar[int] = ... + TARGET_CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT: typing.ClassVar[int] = ... + TARGET_METHOD_REFERENCE_TYPE_ARGUMENT: typing.ClassVar[int] = ... + @staticmethod + def of(targetType: TypeAnnotation.TargetType) -> TypeAnnotation.EmptyTarget: ... + @staticmethod + def ofCastExpr(label: Label, int: int) -> TypeAnnotation.TypeArgumentTarget: ... + @staticmethod + def ofClassExtends(int: int) -> TypeAnnotation.SupertypeTarget: ... + @staticmethod + def ofClassTypeParameter(int: int) -> TypeAnnotation.TypeParameterTarget: ... + @staticmethod + def ofClassTypeParameterBound( + int: int, int2: int + ) -> TypeAnnotation.TypeParameterBoundTarget: ... + @staticmethod + def ofConstructorInvocationTypeArgument( + label: Label, int: int + ) -> TypeAnnotation.TypeArgumentTarget: ... + @staticmethod + def ofConstructorReference(label: Label) -> TypeAnnotation.OffsetTarget: ... + @staticmethod + def ofConstructorReferenceTypeArgument( + label: Label, int: int + ) -> TypeAnnotation.TypeArgumentTarget: ... + @staticmethod + def ofExceptionParameter(int: int) -> TypeAnnotation.CatchTarget: ... + @staticmethod + def ofField() -> TypeAnnotation.EmptyTarget: ... + @staticmethod + def ofInstanceofExpr(label: Label) -> TypeAnnotation.OffsetTarget: ... + @staticmethod + def ofLocalVariable( + list: java.util.List[TypeAnnotation.LocalVarTargetInfo], + ) -> TypeAnnotation.LocalVarTarget: ... + @staticmethod + def ofMethodFormalParameter( + int: int, + ) -> TypeAnnotation.FormalParameterTarget: ... + @staticmethod + def ofMethodInvocationTypeArgument( + label: Label, int: int + ) -> TypeAnnotation.TypeArgumentTarget: ... + @staticmethod + def ofMethodReceiver() -> TypeAnnotation.EmptyTarget: ... + @staticmethod + def ofMethodReference(label: Label) -> TypeAnnotation.OffsetTarget: ... + @staticmethod + def ofMethodReferenceTypeArgument( + label: Label, int: int + ) -> TypeAnnotation.TypeArgumentTarget: ... + @staticmethod + def ofMethodReturn() -> TypeAnnotation.EmptyTarget: ... + @staticmethod + def ofMethodTypeParameter(int: int) -> TypeAnnotation.TypeParameterTarget: ... + @staticmethod + def ofMethodTypeParameterBound( + int: int, int2: int + ) -> TypeAnnotation.TypeParameterBoundTarget: ... + @staticmethod + def ofNewExpr(label: Label) -> TypeAnnotation.OffsetTarget: ... + @staticmethod + def ofOffset( + targetType: TypeAnnotation.TargetType, label: Label + ) -> TypeAnnotation.OffsetTarget: ... + @staticmethod + def ofResourceVariable( + list: java.util.List[TypeAnnotation.LocalVarTargetInfo], + ) -> TypeAnnotation.LocalVarTarget: ... + @staticmethod + def ofThrows(int: int) -> TypeAnnotation.ThrowsTarget: ... + @staticmethod + def ofTypeArgument( + targetType: TypeAnnotation.TargetType, label: Label, int: int + ) -> TypeAnnotation.TypeArgumentTarget: ... + @staticmethod + def ofTypeParameter( + targetType: TypeAnnotation.TargetType, int: int + ) -> TypeAnnotation.TypeParameterTarget: ... + @staticmethod + def ofTypeParameterBound( + targetType: TypeAnnotation.TargetType, int: int, int2: int + ) -> TypeAnnotation.TypeParameterBoundTarget: ... + @staticmethod + def ofVariable( + targetType: TypeAnnotation.TargetType, + list: java.util.List[TypeAnnotation.LocalVarTargetInfo], + ) -> TypeAnnotation.LocalVarTarget: ... + def size(self) -> int: ... + def targetType(self) -> TypeAnnotation.TargetType: ... + + class TargetType(java.lang.Enum["TypeAnnotation.TargetType"]): + CLASS_TYPE_PARAMETER: typing.ClassVar[TypeAnnotation.TargetType] = ... + METHOD_TYPE_PARAMETER: typing.ClassVar[TypeAnnotation.TargetType] = ... + CLASS_EXTENDS: typing.ClassVar[TypeAnnotation.TargetType] = ... + CLASS_TYPE_PARAMETER_BOUND: typing.ClassVar[TypeAnnotation.TargetType] = ... + METHOD_TYPE_PARAMETER_BOUND: typing.ClassVar[TypeAnnotation.TargetType] = ... + FIELD: typing.ClassVar[TypeAnnotation.TargetType] = ... + METHOD_RETURN: typing.ClassVar[TypeAnnotation.TargetType] = ... + METHOD_RECEIVER: typing.ClassVar[TypeAnnotation.TargetType] = ... + METHOD_FORMAL_PARAMETER: typing.ClassVar[TypeAnnotation.TargetType] = ... + THROWS: typing.ClassVar[TypeAnnotation.TargetType] = ... + LOCAL_VARIABLE: typing.ClassVar[TypeAnnotation.TargetType] = ... + RESOURCE_VARIABLE: typing.ClassVar[TypeAnnotation.TargetType] = ... + EXCEPTION_PARAMETER: typing.ClassVar[TypeAnnotation.TargetType] = ... + INSTANCEOF: typing.ClassVar[TypeAnnotation.TargetType] = ... + NEW: typing.ClassVar[TypeAnnotation.TargetType] = ... + CONSTRUCTOR_REFERENCE: typing.ClassVar[TypeAnnotation.TargetType] = ... + METHOD_REFERENCE: typing.ClassVar[TypeAnnotation.TargetType] = ... + CAST: typing.ClassVar[TypeAnnotation.TargetType] = ... + CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT: typing.ClassVar[ + TypeAnnotation.TargetType + ] = ... + METHOD_INVOCATION_TYPE_ARGUMENT: typing.ClassVar[ + TypeAnnotation.TargetType + ] = ... + CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT: typing.ClassVar[ + TypeAnnotation.TargetType + ] = ... + METHOD_REFERENCE_TYPE_ARGUMENT: typing.ClassVar[TypeAnnotation.TargetType] = ... + def sizeIfFixed(self) -> int: ... + def targetTypeValue(self) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> TypeAnnotation.TargetType: ... + @staticmethod + def values() -> typing.MutableSequence[TypeAnnotation.TargetType]: ... + + class ThrowsTarget(java.lang.classfile.TypeAnnotation.TargetInfo): + def throwsTargetIndex(self) -> int: ... + + class TypeArgumentTarget(java.lang.classfile.TypeAnnotation.TargetInfo): + def target(self) -> Label: ... + def typeArgumentIndex(self) -> int: ... + + class TypeParameterBoundTarget(java.lang.classfile.TypeAnnotation.TargetInfo): + def boundIndex(self) -> int: ... + def typeParameterIndex(self) -> int: ... + + class TypeParameterTarget(java.lang.classfile.TypeAnnotation.TargetInfo): + def typeParameterIndex(self) -> int: ... + + class TypePathComponent: + ARRAY: typing.ClassVar[TypeAnnotation.TypePathComponent] = ... + INNER_TYPE: typing.ClassVar[TypeAnnotation.TypePathComponent] = ... + WILDCARD: typing.ClassVar[TypeAnnotation.TypePathComponent] = ... + @staticmethod + def of( + kind: TypeAnnotation.TypePathComponent.Kind, int: int + ) -> TypeAnnotation.TypePathComponent: ... + def typeArgumentIndex(self) -> int: ... + def typePathKind(self) -> TypeAnnotation.TypePathComponent.Kind: ... + class Kind(java.lang.Enum["TypeAnnotation.TypePathComponent.Kind"]): + ARRAY: typing.ClassVar[TypeAnnotation.TypePathComponent.Kind] = ... + INNER_TYPE: typing.ClassVar[TypeAnnotation.TypePathComponent.Kind] = ... + WILDCARD: typing.ClassVar[TypeAnnotation.TypePathComponent.Kind] = ... + TYPE_ARGUMENT: typing.ClassVar[TypeAnnotation.TypePathComponent.Kind] = ... + def tag(self) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> TypeAnnotation.TypePathComponent.Kind: ... + @staticmethod + def values() -> typing.MutableSequence[ + TypeAnnotation.TypePathComponent.Kind + ]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.classfile")``. + + AccessFlags: type[AccessFlags] + Annotation: type[Annotation] + AnnotationElement: type[AnnotationElement] + AnnotationValue: type[AnnotationValue] + Attribute: type[Attribute] + AttributeMapper: type[AttributeMapper] + AttributedElement: type[AttributedElement] + Attributes: type[Attributes] + BootstrapMethodEntry: type[BootstrapMethodEntry] + BufWriter: type[BufWriter] + ClassBuilder: type[ClassBuilder] + ClassElement: type[ClassElement] + ClassFile: type[ClassFile] + ClassFileBuilder: type[ClassFileBuilder] + ClassFileElement: type[ClassFileElement] + ClassFileTransform: type[ClassFileTransform] + ClassFileVersion: type[ClassFileVersion] + ClassHierarchyResolver: type[ClassHierarchyResolver] + ClassModel: type[ClassModel] + ClassReader: type[ClassReader] + ClassSignature: type[ClassSignature] + ClassTransform: type[ClassTransform] + CodeBuilder: type[CodeBuilder] + CodeElement: type[CodeElement] + CodeModel: type[CodeModel] + CodeTransform: type[CodeTransform] + CompoundElement: type[CompoundElement] + CustomAttribute: type[CustomAttribute] + FieldBuilder: type[FieldBuilder] + FieldElement: type[FieldElement] + FieldModel: type[FieldModel] + FieldTransform: type[FieldTransform] + Instruction: type[Instruction] + Interfaces: type[Interfaces] + Label: type[Label] + MethodBuilder: type[MethodBuilder] + MethodElement: type[MethodElement] + MethodModel: type[MethodModel] + MethodSignature: type[MethodSignature] + MethodTransform: type[MethodTransform] + Opcode: type[Opcode] + PseudoInstruction: type[PseudoInstruction] + Signature: type[Signature] + Superclass: type[Superclass] + TypeAnnotation: type[TypeAnnotation] + TypeKind: type[TypeKind] + attribute: java.lang.classfile.attribute.__module_protocol__ + constantpool: java.lang.classfile.constantpool.__module_protocol__ + instruction: java.lang.classfile.instruction.__module_protocol__ diff --git a/typings/java/lang/classfile/attribute/__init__.pyi b/typings/java/lang/classfile/attribute/__init__.pyi new file mode 100644 index 0000000..c15ae43 --- /dev/null +++ b/typings/java/lang/classfile/attribute/__init__.pyi @@ -0,0 +1,1189 @@ +import typing +from typing import Protocol + +import java +import java.lang +import java.lang.classfile +import java.lang.classfile.constantpool +import java.lang.constant +import java.lang.reflect +import java.util +import java.util.function +import jpype + +class AnnotationDefaultAttribute( + java.lang.classfile.Attribute["AnnotationDefaultAttribute"], + java.lang.classfile.MethodElement, +): + def defaultValue(self) -> java.lang.classfile.AnnotationValue: ... + @staticmethod + def of( + annotationValue: java.lang.classfile.AnnotationValue, + ) -> AnnotationDefaultAttribute: ... + +class BootstrapMethodsAttribute( + java.lang.classfile.Attribute["BootstrapMethodsAttribute"] +): + def bootstrapMethods( + self, + ) -> java.util.List[java.lang.classfile.BootstrapMethodEntry]: ... + def bootstrapMethodsSize(self) -> int: ... + +class CharacterRangeInfo: + def characterRangeEnd(self) -> int: ... + def characterRangeStart(self) -> int: ... + def endPc(self) -> int: ... + def flags(self) -> int: ... + @staticmethod + def of( + int: int, int2: int, int3: int, int4: int, int5: int + ) -> CharacterRangeInfo: ... + def startPc(self) -> int: ... + +class CharacterRangeTableAttribute( + java.lang.classfile.Attribute["CharacterRangeTableAttribute"] +): + def characterRangeTable(self) -> java.util.List[CharacterRangeInfo]: ... + @staticmethod + def of( + list: java.util.List[CharacterRangeInfo], + ) -> CharacterRangeTableAttribute: ... + +class CodeAttribute( + java.lang.classfile.Attribute["CodeAttribute"], java.lang.classfile.CodeModel +): + def codeArray(self) -> typing.MutableSequence[int]: ... + def codeLength(self) -> int: ... + def labelToBci(self, label: java.lang.classfile.Label) -> int: ... + def maxLocals(self) -> int: ... + def maxStack(self) -> int: ... + +class CompilationIDAttribute( + java.lang.classfile.Attribute["CompilationIDAttribute"], + java.lang.classfile.ClassElement, +): + def compilationId(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> CompilationIDAttribute: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + ) -> CompilationIDAttribute: ... + +class ConstantValueAttribute( + java.lang.classfile.Attribute["ConstantValueAttribute"], + java.lang.classfile.FieldElement, +): + def constant(self) -> java.lang.classfile.constantpool.ConstantValueEntry: ... + @typing.overload + @staticmethod + def of( + constantValueEntry: java.lang.classfile.constantpool.ConstantValueEntry, + ) -> ConstantValueAttribute: ... + @typing.overload + @staticmethod + def of(constantDesc: java.lang.constant.ConstantDesc) -> ConstantValueAttribute: ... + +class DeprecatedAttribute( + java.lang.classfile.Attribute["DeprecatedAttribute"], + java.lang.classfile.ClassElement, + java.lang.classfile.MethodElement, + java.lang.classfile.FieldElement, +): + @staticmethod + def of() -> DeprecatedAttribute: ... + +class EnclosingMethodAttribute( + java.lang.classfile.Attribute["EnclosingMethodAttribute"], + java.lang.classfile.ClassElement, +): + def enclosingClass(self) -> java.lang.classfile.constantpool.ClassEntry: ... + def enclosingMethod( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.NameAndTypeEntry]: ... + def enclosingMethodName( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.Utf8Entry]: ... + def enclosingMethodType( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.Utf8Entry]: ... + def enclosingMethodTypeSymbol( + self, + ) -> java.util.Optional[java.lang.constant.MethodTypeDesc]: ... + @typing.overload + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, + optional: java.util.Optional[java.lang.classfile.constantpool.NameAndTypeEntry], + ) -> EnclosingMethodAttribute: ... + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, + optional: java.util.Optional[java.lang.String | str], + optional2: java.util.Optional[java.lang.constant.MethodTypeDesc], + ) -> EnclosingMethodAttribute: ... + +class ExceptionsAttribute( + java.lang.classfile.Attribute["ExceptionsAttribute"], + java.lang.classfile.MethodElement, +): + def exceptions( + self, + ) -> java.util.List[java.lang.classfile.constantpool.ClassEntry]: ... + @typing.overload + @staticmethod + def of( + *classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> ExceptionsAttribute: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[java.lang.classfile.constantpool.ClassEntry], + ) -> ExceptionsAttribute: ... + @typing.overload + @staticmethod + def ofSymbols(*classDesc: java.lang.constant.ClassDesc) -> ExceptionsAttribute: ... + @typing.overload + @staticmethod + def ofSymbols( + list: java.util.List[java.lang.constant.ClassDesc], + ) -> ExceptionsAttribute: ... + +class InnerClassInfo: + def flags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def flagsMask(self) -> int: ... + def has(self, accessFlag: java.lang.reflect.AccessFlag) -> bool: ... + def innerClass(self) -> java.lang.classfile.constantpool.ClassEntry: ... + def innerName( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.Utf8Entry]: ... + @typing.overload + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, + optional: java.util.Optional[java.lang.classfile.constantpool.ClassEntry], + optional2: java.util.Optional[java.lang.classfile.constantpool.Utf8Entry], + int: int, + ) -> InnerClassInfo: ... + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, + optional: java.util.Optional[java.lang.constant.ClassDesc], + optional2: java.util.Optional[java.lang.String | str], + int: int, + ) -> InnerClassInfo: ... + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, + optional: java.util.Optional[java.lang.constant.ClassDesc], + optional2: java.util.Optional[java.lang.String | str], + *accessFlag: java.lang.reflect.AccessFlag, + ) -> InnerClassInfo: ... + def outerClass( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.ClassEntry]: ... + +class InnerClassesAttribute( + java.lang.classfile.Attribute["InnerClassesAttribute"], + java.lang.classfile.ClassElement, +): + def classes(self) -> java.util.List[InnerClassInfo]: ... + @typing.overload + @staticmethod + def of(*innerClassInfo: InnerClassInfo) -> InnerClassesAttribute: ... + @typing.overload + @staticmethod + def of(list: java.util.List[InnerClassInfo]) -> InnerClassesAttribute: ... + +class LineNumberInfo: + def lineNumber(self) -> int: ... + @staticmethod + def of(int: int, int2: int) -> LineNumberInfo: ... + def startPc(self) -> int: ... + +class LineNumberTableAttribute( + java.lang.classfile.Attribute["LineNumberTableAttribute"] +): + def lineNumbers(self) -> java.util.List[LineNumberInfo]: ... + @staticmethod + def of(list: java.util.List[LineNumberInfo]) -> LineNumberTableAttribute: ... + +class LocalVariableInfo: + def length(self) -> int: ... + def name(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def slot(self) -> int: ... + def startPc(self) -> int: ... + def type(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def typeSymbol(self) -> java.lang.constant.ClassDesc: ... + +class LocalVariableTableAttribute( + java.lang.classfile.Attribute["LocalVariableTableAttribute"] +): + def localVariables(self) -> java.util.List[LocalVariableInfo]: ... + @staticmethod + def of(list: java.util.List[LocalVariableInfo]) -> LocalVariableTableAttribute: ... + +class LocalVariableTypeInfo: + def length(self) -> int: ... + def name(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def signature(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def slot(self) -> int: ... + def startPc(self) -> int: ... + +class LocalVariableTypeTableAttribute( + java.lang.classfile.Attribute["LocalVariableTypeTableAttribute"] +): + def localVariableTypes(self) -> java.util.List[LocalVariableTypeInfo]: ... + @staticmethod + def of( + list: java.util.List[LocalVariableTypeInfo], + ) -> LocalVariableTypeTableAttribute: ... + +class MethodParameterInfo: + def flags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def flagsMask(self) -> int: ... + def has(self, accessFlag: java.lang.reflect.AccessFlag) -> bool: ... + def name( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.Utf8Entry]: ... + @typing.overload + @staticmethod + def of( + optional: java.util.Optional[java.lang.classfile.constantpool.Utf8Entry], + int: int, + ) -> MethodParameterInfo: ... + @typing.overload + @staticmethod + def of( + optional: java.util.Optional[java.lang.String | str], + *accessFlag: java.lang.reflect.AccessFlag, + ) -> MethodParameterInfo: ... + @staticmethod + def ofParameter( + optional: java.util.Optional[java.lang.String | str], int: int + ) -> MethodParameterInfo: ... + +class MethodParametersAttribute( + java.lang.classfile.Attribute["MethodParametersAttribute"], + java.lang.classfile.MethodElement, +): + @typing.overload + @staticmethod + def of(*methodParameterInfo: MethodParameterInfo) -> MethodParametersAttribute: ... + @typing.overload + @staticmethod + def of(list: java.util.List[MethodParameterInfo]) -> MethodParametersAttribute: ... + def parameters(self) -> java.util.List[MethodParameterInfo]: ... + +class ModuleAttribute( + java.lang.classfile.Attribute["ModuleAttribute"], java.lang.classfile.ClassElement +): + def exports(self) -> java.util.List[ModuleExportInfo]: ... + def has(self, accessFlag: java.lang.reflect.AccessFlag) -> bool: ... + def moduleFlags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def moduleFlagsMask(self) -> int: ... + def moduleName(self) -> java.lang.classfile.constantpool.ModuleEntry: ... + def moduleVersion( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.Utf8Entry]: ... + @typing.overload + @staticmethod + def of( + moduleEntry: java.lang.classfile.constantpool.ModuleEntry, + int: int, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + collection: java.util.Collection[ModuleRequireInfo] + | typing.Sequence[ModuleRequireInfo] + | set[ModuleRequireInfo], + collection2: java.util.Collection[ModuleExportInfo] + | typing.Sequence[ModuleExportInfo] + | set[ModuleExportInfo], + collection3: java.util.Collection[ModuleOpenInfo] + | typing.Sequence[ModuleOpenInfo] + | set[ModuleOpenInfo], + collection4: java.util.Collection[java.lang.classfile.constantpool.ClassEntry] + | typing.Sequence[java.lang.classfile.constantpool.ClassEntry] + | set[java.lang.classfile.constantpool.ClassEntry], + collection5: java.util.Collection[ModuleProvideInfo] + | typing.Sequence[ModuleProvideInfo] + | set[ModuleProvideInfo], + ) -> ModuleAttribute: ... + @typing.overload + @staticmethod + def of( + moduleEntry: java.lang.classfile.constantpool.ModuleEntry, + consumer: java.util.function.Consumer[ModuleAttribute.ModuleAttributeBuilder] + | typing.Callable[[ModuleAttribute.ModuleAttributeBuilder], None], + ) -> ModuleAttribute: ... + @typing.overload + @staticmethod + def of( + moduleDesc: java.lang.constant.ModuleDesc, + consumer: java.util.function.Consumer[ModuleAttribute.ModuleAttributeBuilder] + | typing.Callable[[ModuleAttribute.ModuleAttributeBuilder], None], + ) -> ModuleAttribute: ... + def opens(self) -> java.util.List[ModuleOpenInfo]: ... + def provides(self) -> java.util.List[ModuleProvideInfo]: ... + def requires(self) -> java.util.List[ModuleRequireInfo]: ... + def uses(self) -> java.util.List[java.lang.classfile.constantpool.ClassEntry]: ... + class ModuleAttributeBuilder: + @typing.overload + def exports( + self, moduleExportInfo: ModuleExportInfo + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def exports( + self, + packageDesc: java.lang.constant.PackageDesc, + int: int, + *moduleDesc: java.lang.constant.ModuleDesc, + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def exports( + self, + packageDesc: java.lang.constant.PackageDesc, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + *moduleDesc: java.lang.constant.ModuleDesc, + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def moduleFlags(self, int: int) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def moduleFlags( + self, *accessFlag: java.lang.reflect.AccessFlag + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + def moduleName( + self, moduleDesc: java.lang.constant.ModuleDesc + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + def moduleVersion( + self, string: java.lang.String | str + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def opens( + self, moduleOpenInfo: ModuleOpenInfo + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def opens( + self, + packageDesc: java.lang.constant.PackageDesc, + int: int, + *moduleDesc: java.lang.constant.ModuleDesc, + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def opens( + self, + packageDesc: java.lang.constant.PackageDesc, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + *moduleDesc: java.lang.constant.ModuleDesc, + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def provides( + self, moduleProvideInfo: ModuleProvideInfo + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def provides( + self, + classDesc: java.lang.constant.ClassDesc, + *classDesc2: java.lang.constant.ClassDesc, + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def requires( + self, moduleRequireInfo: ModuleRequireInfo + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def requires( + self, + moduleDesc: java.lang.constant.ModuleDesc, + int: int, + string: java.lang.String | str, + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def requires( + self, + moduleDesc: java.lang.constant.ModuleDesc, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + string: java.lang.String | str, + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def uses( + self, classEntry: java.lang.classfile.constantpool.ClassEntry + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + @typing.overload + def uses( + self, classDesc: java.lang.constant.ClassDesc + ) -> ModuleAttribute.ModuleAttributeBuilder: ... + +class ModuleExportInfo: + def exportedPackage(self) -> java.lang.classfile.constantpool.PackageEntry: ... + def exportsFlags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def exportsFlagsMask(self) -> int: ... + def exportsTo( + self, + ) -> java.util.List[java.lang.classfile.constantpool.ModuleEntry]: ... + def has(self, accessFlag: java.lang.reflect.AccessFlag) -> bool: ... + @typing.overload + @staticmethod + def of( + packageEntry: java.lang.classfile.constantpool.PackageEntry, + int: int, + *moduleEntry: java.lang.classfile.constantpool.ModuleEntry, + ) -> ModuleExportInfo: ... + @typing.overload + @staticmethod + def of( + packageEntry: java.lang.classfile.constantpool.PackageEntry, + int: int, + list: java.util.List[java.lang.classfile.constantpool.ModuleEntry], + ) -> ModuleExportInfo: ... + @typing.overload + @staticmethod + def of( + packageEntry: java.lang.classfile.constantpool.PackageEntry, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + *moduleEntry: java.lang.classfile.constantpool.ModuleEntry, + ) -> ModuleExportInfo: ... + @typing.overload + @staticmethod + def of( + packageEntry: java.lang.classfile.constantpool.PackageEntry, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + list: java.util.List[java.lang.classfile.constantpool.ModuleEntry], + ) -> ModuleExportInfo: ... + @typing.overload + @staticmethod + def of( + packageDesc: java.lang.constant.PackageDesc, + int: int, + *moduleDesc: java.lang.constant.ModuleDesc, + ) -> ModuleExportInfo: ... + @typing.overload + @staticmethod + def of( + packageDesc: java.lang.constant.PackageDesc, + int: int, + list: java.util.List[java.lang.constant.ModuleDesc], + ) -> ModuleExportInfo: ... + @typing.overload + @staticmethod + def of( + packageDesc: java.lang.constant.PackageDesc, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + *moduleDesc: java.lang.constant.ModuleDesc, + ) -> ModuleExportInfo: ... + @typing.overload + @staticmethod + def of( + packageDesc: java.lang.constant.PackageDesc, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + list: java.util.List[java.lang.constant.ModuleDesc], + ) -> ModuleExportInfo: ... + +class ModuleHashInfo: + def hash(self) -> typing.MutableSequence[int]: ... + def moduleName(self) -> java.lang.classfile.constantpool.ModuleEntry: ... + @typing.overload + @staticmethod + def of( + moduleEntry: java.lang.classfile.constantpool.ModuleEntry, + byteArray: list[int] | jpype.JArray | bytes, + ) -> ModuleHashInfo: ... + @typing.overload + @staticmethod + def of( + moduleDesc: java.lang.constant.ModuleDesc, + byteArray: list[int] | jpype.JArray | bytes, + ) -> ModuleHashInfo: ... + +class ModuleHashesAttribute( + java.lang.classfile.Attribute["ModuleHashesAttribute"], + java.lang.classfile.ClassElement, +): + def algorithm(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def hashes(self) -> java.util.List[ModuleHashInfo]: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, *moduleHashInfo: ModuleHashInfo + ) -> ModuleHashesAttribute: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, list: java.util.List[ModuleHashInfo] + ) -> ModuleHashesAttribute: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + *moduleHashInfo: ModuleHashInfo, + ) -> ModuleHashesAttribute: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + list: java.util.List[ModuleHashInfo], + ) -> ModuleHashesAttribute: ... + +class ModuleMainClassAttribute( + java.lang.classfile.Attribute["ModuleMainClassAttribute"], + java.lang.classfile.ClassElement, +): + def mainClass(self) -> java.lang.classfile.constantpool.ClassEntry: ... + @typing.overload + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> ModuleMainClassAttribute: ... + @typing.overload + @staticmethod + def of(classDesc: java.lang.constant.ClassDesc) -> ModuleMainClassAttribute: ... + +class ModuleOpenInfo: + def has(self, accessFlag: java.lang.reflect.AccessFlag) -> bool: ... + @typing.overload + @staticmethod + def of( + packageEntry: java.lang.classfile.constantpool.PackageEntry, + int: int, + *moduleEntry: java.lang.classfile.constantpool.ModuleEntry, + ) -> ModuleOpenInfo: ... + @typing.overload + @staticmethod + def of( + packageEntry: java.lang.classfile.constantpool.PackageEntry, + int: int, + list: java.util.List[java.lang.classfile.constantpool.ModuleEntry], + ) -> ModuleOpenInfo: ... + @typing.overload + @staticmethod + def of( + packageEntry: java.lang.classfile.constantpool.PackageEntry, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + *moduleEntry: java.lang.classfile.constantpool.ModuleEntry, + ) -> ModuleOpenInfo: ... + @typing.overload + @staticmethod + def of( + packageEntry: java.lang.classfile.constantpool.PackageEntry, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + list: java.util.List[java.lang.classfile.constantpool.ModuleEntry], + ) -> ModuleOpenInfo: ... + @typing.overload + @staticmethod + def of( + packageDesc: java.lang.constant.PackageDesc, + int: int, + *moduleDesc: java.lang.constant.ModuleDesc, + ) -> ModuleOpenInfo: ... + @typing.overload + @staticmethod + def of( + packageDesc: java.lang.constant.PackageDesc, + int: int, + list: java.util.List[java.lang.constant.ModuleDesc], + ) -> ModuleOpenInfo: ... + @typing.overload + @staticmethod + def of( + packageDesc: java.lang.constant.PackageDesc, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + *moduleDesc: java.lang.constant.ModuleDesc, + ) -> ModuleOpenInfo: ... + @typing.overload + @staticmethod + def of( + packageDesc: java.lang.constant.PackageDesc, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + list: java.util.List[java.lang.constant.ModuleDesc], + ) -> ModuleOpenInfo: ... + def openedPackage(self) -> java.lang.classfile.constantpool.PackageEntry: ... + def opensFlags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def opensFlagsMask(self) -> int: ... + def opensTo( + self, + ) -> java.util.List[java.lang.classfile.constantpool.ModuleEntry]: ... + +class ModulePackagesAttribute( + java.lang.classfile.Attribute["ModulePackagesAttribute"], + java.lang.classfile.ClassElement, +): + @typing.overload + @staticmethod + def of( + *packageEntry: java.lang.classfile.constantpool.PackageEntry, + ) -> ModulePackagesAttribute: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[java.lang.classfile.constantpool.PackageEntry], + ) -> ModulePackagesAttribute: ... + @typing.overload + @staticmethod + def ofNames( + *packageDesc: java.lang.constant.PackageDesc, + ) -> ModulePackagesAttribute: ... + @typing.overload + @staticmethod + def ofNames( + list: java.util.List[java.lang.constant.PackageDesc], + ) -> ModulePackagesAttribute: ... + def packages( + self, + ) -> java.util.List[java.lang.classfile.constantpool.PackageEntry]: ... + +class ModuleProvideInfo: + @typing.overload + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, + *classEntry2: java.lang.classfile.constantpool.ClassEntry, + ) -> ModuleProvideInfo: ... + @typing.overload + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, + list: java.util.List[java.lang.classfile.constantpool.ClassEntry], + ) -> ModuleProvideInfo: ... + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, + *classDesc2: java.lang.constant.ClassDesc, + ) -> ModuleProvideInfo: ... + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, + list: java.util.List[java.lang.constant.ClassDesc], + ) -> ModuleProvideInfo: ... + def provides(self) -> java.lang.classfile.constantpool.ClassEntry: ... + def providesWith( + self, + ) -> java.util.List[java.lang.classfile.constantpool.ClassEntry]: ... + +class ModuleRequireInfo: + def has(self, accessFlag: java.lang.reflect.AccessFlag) -> bool: ... + @typing.overload + @staticmethod + def of( + moduleEntry: java.lang.classfile.constantpool.ModuleEntry, + int: int, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + ) -> ModuleRequireInfo: ... + @typing.overload + @staticmethod + def of( + moduleEntry: java.lang.classfile.constantpool.ModuleEntry, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + ) -> ModuleRequireInfo: ... + @typing.overload + @staticmethod + def of( + moduleDesc: java.lang.constant.ModuleDesc, + int: int, + string: java.lang.String | str, + ) -> ModuleRequireInfo: ... + @typing.overload + @staticmethod + def of( + moduleDesc: java.lang.constant.ModuleDesc, + collection: java.util.Collection[java.lang.reflect.AccessFlag] + | typing.Sequence[java.lang.reflect.AccessFlag] + | set[java.lang.reflect.AccessFlag], + string: java.lang.String | str, + ) -> ModuleRequireInfo: ... + def requires(self) -> java.lang.classfile.constantpool.ModuleEntry: ... + def requiresFlags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def requiresFlagsMask(self) -> int: ... + def requiresVersion( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.Utf8Entry]: ... + +class ModuleResolutionAttribute( + java.lang.classfile.Attribute["ModuleResolutionAttribute"], + java.lang.classfile.ClassElement, +): + @staticmethod + def of(int: int) -> ModuleResolutionAttribute: ... + def resolutionFlags(self) -> int: ... + +class ModuleTargetAttribute( + java.lang.classfile.Attribute["ModuleTargetAttribute"], + java.lang.classfile.ClassElement, +): + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> ModuleTargetAttribute: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + ) -> ModuleTargetAttribute: ... + def targetPlatform(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + +class NestHostAttribute( + java.lang.classfile.Attribute["NestHostAttribute"], java.lang.classfile.ClassElement +): + def nestHost(self) -> java.lang.classfile.constantpool.ClassEntry: ... + @typing.overload + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> NestHostAttribute: ... + @typing.overload + @staticmethod + def of(classDesc: java.lang.constant.ClassDesc) -> NestHostAttribute: ... + +class NestMembersAttribute( + java.lang.classfile.Attribute["NestMembersAttribute"], + java.lang.classfile.ClassElement, +): + def nestMembers( + self, + ) -> java.util.List[java.lang.classfile.constantpool.ClassEntry]: ... + @typing.overload + @staticmethod + def of( + *classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> NestMembersAttribute: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[java.lang.classfile.constantpool.ClassEntry], + ) -> NestMembersAttribute: ... + @typing.overload + @staticmethod + def ofSymbols(*classDesc: java.lang.constant.ClassDesc) -> NestMembersAttribute: ... + @typing.overload + @staticmethod + def ofSymbols( + list: java.util.List[java.lang.constant.ClassDesc], + ) -> NestMembersAttribute: ... + +class PermittedSubclassesAttribute( + java.lang.classfile.Attribute["PermittedSubclassesAttribute"], + java.lang.classfile.ClassElement, +): + @typing.overload + @staticmethod + def of( + *classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> PermittedSubclassesAttribute: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[java.lang.classfile.constantpool.ClassEntry], + ) -> PermittedSubclassesAttribute: ... + @typing.overload + @staticmethod + def ofSymbols( + *classDesc: java.lang.constant.ClassDesc, + ) -> PermittedSubclassesAttribute: ... + @typing.overload + @staticmethod + def ofSymbols( + list: java.util.List[java.lang.constant.ClassDesc], + ) -> PermittedSubclassesAttribute: ... + def permittedSubclasses( + self, + ) -> java.util.List[java.lang.classfile.constantpool.ClassEntry]: ... + +class RecordAttribute( + java.lang.classfile.Attribute["RecordAttribute"], java.lang.classfile.ClassElement +): + def components(self) -> java.util.List[RecordComponentInfo]: ... + @typing.overload + @staticmethod + def of(*recordComponentInfo: RecordComponentInfo) -> RecordAttribute: ... + @typing.overload + @staticmethod + def of(list: java.util.List[RecordComponentInfo]) -> RecordAttribute: ... + +class RecordComponentInfo(java.lang.classfile.AttributedElement): + def descriptor(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def descriptorSymbol(self) -> java.lang.constant.ClassDesc: ... + def name(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, + classDesc: java.lang.constant.ClassDesc, + *attribute: java.lang.classfile.Attribute[typing.Any], + ) -> RecordComponentInfo: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, + classDesc: java.lang.constant.ClassDesc, + list: java.util.List[java.lang.classfile.Attribute[typing.Any]], + ) -> RecordComponentInfo: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + *attribute: java.lang.classfile.Attribute[typing.Any], + ) -> RecordComponentInfo: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + list: java.util.List[java.lang.classfile.Attribute[typing.Any]], + ) -> RecordComponentInfo: ... + +class RuntimeInvisibleAnnotationsAttribute( + java.lang.classfile.Attribute["RuntimeInvisibleAnnotationsAttribute"], + java.lang.classfile.ClassElement, + java.lang.classfile.MethodElement, + java.lang.classfile.FieldElement, +): + def annotations(self) -> java.util.List[java.lang.classfile.Annotation]: ... + @typing.overload + @staticmethod + def of( + *annotation: java.lang.classfile.Annotation, + ) -> RuntimeInvisibleAnnotationsAttribute: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[java.lang.classfile.Annotation], + ) -> RuntimeInvisibleAnnotationsAttribute: ... + +class RuntimeInvisibleParameterAnnotationsAttribute( + java.lang.classfile.Attribute["RuntimeInvisibleParameterAnnotationsAttribute"], + java.lang.classfile.MethodElement, +): + @staticmethod + def of( + list: java.util.List[java.util.List[java.lang.classfile.Annotation]], + ) -> RuntimeInvisibleParameterAnnotationsAttribute: ... + def parameterAnnotations( + self, + ) -> java.util.List[java.util.List[java.lang.classfile.Annotation]]: ... + +class RuntimeInvisibleTypeAnnotationsAttribute( + java.lang.classfile.Attribute["RuntimeInvisibleTypeAnnotationsAttribute"], + java.lang.classfile.ClassElement, + java.lang.classfile.MethodElement, + java.lang.classfile.FieldElement, + java.lang.classfile.CodeElement, +): + def annotations(self) -> java.util.List[java.lang.classfile.TypeAnnotation]: ... + @typing.overload + @staticmethod + def of( + *typeAnnotation: java.lang.classfile.TypeAnnotation, + ) -> RuntimeInvisibleTypeAnnotationsAttribute: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[java.lang.classfile.TypeAnnotation], + ) -> RuntimeInvisibleTypeAnnotationsAttribute: ... + +class RuntimeVisibleAnnotationsAttribute( + java.lang.classfile.Attribute["RuntimeVisibleAnnotationsAttribute"], + java.lang.classfile.ClassElement, + java.lang.classfile.MethodElement, + java.lang.classfile.FieldElement, +): + def annotations(self) -> java.util.List[java.lang.classfile.Annotation]: ... + @typing.overload + @staticmethod + def of( + *annotation: java.lang.classfile.Annotation, + ) -> RuntimeVisibleAnnotationsAttribute: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[java.lang.classfile.Annotation], + ) -> RuntimeVisibleAnnotationsAttribute: ... + +class RuntimeVisibleParameterAnnotationsAttribute( + java.lang.classfile.Attribute["RuntimeVisibleParameterAnnotationsAttribute"], + java.lang.classfile.MethodElement, +): + @staticmethod + def of( + list: java.util.List[java.util.List[java.lang.classfile.Annotation]], + ) -> RuntimeVisibleParameterAnnotationsAttribute: ... + def parameterAnnotations( + self, + ) -> java.util.List[java.util.List[java.lang.classfile.Annotation]]: ... + +class RuntimeVisibleTypeAnnotationsAttribute( + java.lang.classfile.Attribute["RuntimeVisibleTypeAnnotationsAttribute"], + java.lang.classfile.ClassElement, + java.lang.classfile.MethodElement, + java.lang.classfile.FieldElement, + java.lang.classfile.CodeElement, +): + def annotations(self) -> java.util.List[java.lang.classfile.TypeAnnotation]: ... + @typing.overload + @staticmethod + def of( + *typeAnnotation: java.lang.classfile.TypeAnnotation, + ) -> RuntimeVisibleTypeAnnotationsAttribute: ... + @typing.overload + @staticmethod + def of( + list: java.util.List[java.lang.classfile.TypeAnnotation], + ) -> RuntimeVisibleTypeAnnotationsAttribute: ... + +class SignatureAttribute( + java.lang.classfile.Attribute["SignatureAttribute"], + java.lang.classfile.ClassElement, + java.lang.classfile.MethodElement, + java.lang.classfile.FieldElement, +): + def asClassSignature(self) -> java.lang.classfile.ClassSignature: ... + def asMethodSignature(self) -> java.lang.classfile.MethodSignature: ... + def asTypeSignature(self) -> java.lang.classfile.Signature: ... + @typing.overload + @staticmethod + def of( + classSignature: java.lang.classfile.ClassSignature, + ) -> SignatureAttribute: ... + @typing.overload + @staticmethod + def of( + methodSignature: java.lang.classfile.MethodSignature, + ) -> SignatureAttribute: ... + @typing.overload + @staticmethod + def of(signature: java.lang.classfile.Signature) -> SignatureAttribute: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + ) -> SignatureAttribute: ... + def signature(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + +class SourceDebugExtensionAttribute( + java.lang.classfile.Attribute["SourceDebugExtensionAttribute"], + java.lang.classfile.ClassElement, +): + def contents(self) -> typing.MutableSequence[int]: ... + @staticmethod + def of( + byteArray: list[int] | jpype.JArray | bytes, + ) -> SourceDebugExtensionAttribute: ... + +class SourceFileAttribute( + java.lang.classfile.Attribute["SourceFileAttribute"], + java.lang.classfile.ClassElement, +): + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> SourceFileAttribute: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + ) -> SourceFileAttribute: ... + def sourceFile(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + +class SourceIDAttribute( + java.lang.classfile.Attribute["SourceIDAttribute"], java.lang.classfile.ClassElement +): + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> SourceIDAttribute: ... + @typing.overload + @staticmethod + def of( + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + ) -> SourceIDAttribute: ... + def sourceId(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + +class StackMapTableAttribute( + java.lang.classfile.Attribute["StackMapTableAttribute"], + java.lang.classfile.CodeElement, +): + def entries(self) -> java.util.List[StackMapFrameInfo]: ... + @staticmethod + def of(list: java.util.List[StackMapFrameInfo]) -> StackMapTableAttribute: ... + +class SyntheticAttribute( + java.lang.classfile.Attribute["SyntheticAttribute"], + java.lang.classfile.ClassElement, + java.lang.classfile.MethodElement, + java.lang.classfile.FieldElement, +): + @staticmethod + def of() -> SyntheticAttribute: ... + +class UnknownAttribute( + java.lang.classfile.Attribute["UnknownAttribute"], + java.lang.classfile.ClassElement, + java.lang.classfile.MethodElement, + java.lang.classfile.FieldElement, + java.lang.classfile.CodeElement, +): + def contents(self) -> typing.MutableSequence[int]: ... + +class StackMapFrameInfo: + def frameType(self) -> int: ... + def locals(self) -> java.util.List[StackMapFrameInfo.VerificationTypeInfo]: ... + @staticmethod + def of( + label: java.lang.classfile.Label, + list: java.util.List[StackMapFrameInfo.VerificationTypeInfo], + list2: java.util.List[StackMapFrameInfo.VerificationTypeInfo], + ) -> StackMapFrameInfo: ... + def stack(self) -> java.util.List[StackMapFrameInfo.VerificationTypeInfo]: ... + def target(self) -> java.lang.classfile.Label: ... + class ObjectVerificationTypeInfo( + java.lang.classfile.attribute.StackMapFrameInfo.VerificationTypeInfo + ): + def className(self) -> java.lang.classfile.constantpool.ClassEntry: ... + def classSymbol(self) -> java.lang.constant.ClassDesc: ... + @typing.overload + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> StackMapFrameInfo.ObjectVerificationTypeInfo: ... + @typing.overload + @staticmethod + def of( + classDesc: java.lang.constant.ClassDesc, + ) -> StackMapFrameInfo.ObjectVerificationTypeInfo: ... + + class SimpleVerificationTypeInfo( + java.lang.Enum["StackMapFrameInfo.SimpleVerificationTypeInfo"], + java.lang.classfile.attribute.StackMapFrameInfo.VerificationTypeInfo, + ): + TOP: typing.ClassVar[StackMapFrameInfo.SimpleVerificationTypeInfo] = ... + INTEGER: typing.ClassVar[StackMapFrameInfo.SimpleVerificationTypeInfo] = ... + FLOAT: typing.ClassVar[StackMapFrameInfo.SimpleVerificationTypeInfo] = ... + DOUBLE: typing.ClassVar[StackMapFrameInfo.SimpleVerificationTypeInfo] = ... + LONG: typing.ClassVar[StackMapFrameInfo.SimpleVerificationTypeInfo] = ... + NULL: typing.ClassVar[StackMapFrameInfo.SimpleVerificationTypeInfo] = ... + UNINITIALIZED_THIS: typing.ClassVar[ + StackMapFrameInfo.SimpleVerificationTypeInfo + ] = ... + def tag(self) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> StackMapFrameInfo.SimpleVerificationTypeInfo: ... + @staticmethod + def values() -> typing.MutableSequence[ + StackMapFrameInfo.SimpleVerificationTypeInfo + ]: ... + + class UninitializedVerificationTypeInfo( + java.lang.classfile.attribute.StackMapFrameInfo.VerificationTypeInfo + ): + def newTarget(self) -> java.lang.classfile.Label: ... + @staticmethod + def of( + label: java.lang.classfile.Label, + ) -> StackMapFrameInfo.UninitializedVerificationTypeInfo: ... + + class VerificationTypeInfo: + ITEM_TOP: typing.ClassVar[int] = ... + ITEM_INTEGER: typing.ClassVar[int] = ... + ITEM_FLOAT: typing.ClassVar[int] = ... + ITEM_DOUBLE: typing.ClassVar[int] = ... + ITEM_LONG: typing.ClassVar[int] = ... + ITEM_NULL: typing.ClassVar[int] = ... + ITEM_UNINITIALIZED_THIS: typing.ClassVar[int] = ... + ITEM_OBJECT: typing.ClassVar[int] = ... + ITEM_UNINITIALIZED: typing.ClassVar[int] = ... + def tag(self) -> int: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.classfile.attribute")``. + + AnnotationDefaultAttribute: type[AnnotationDefaultAttribute] + BootstrapMethodsAttribute: type[BootstrapMethodsAttribute] + CharacterRangeInfo: type[CharacterRangeInfo] + CharacterRangeTableAttribute: type[CharacterRangeTableAttribute] + CodeAttribute: type[CodeAttribute] + CompilationIDAttribute: type[CompilationIDAttribute] + ConstantValueAttribute: type[ConstantValueAttribute] + DeprecatedAttribute: type[DeprecatedAttribute] + EnclosingMethodAttribute: type[EnclosingMethodAttribute] + ExceptionsAttribute: type[ExceptionsAttribute] + InnerClassInfo: type[InnerClassInfo] + InnerClassesAttribute: type[InnerClassesAttribute] + LineNumberInfo: type[LineNumberInfo] + LineNumberTableAttribute: type[LineNumberTableAttribute] + LocalVariableInfo: type[LocalVariableInfo] + LocalVariableTableAttribute: type[LocalVariableTableAttribute] + LocalVariableTypeInfo: type[LocalVariableTypeInfo] + LocalVariableTypeTableAttribute: type[LocalVariableTypeTableAttribute] + MethodParameterInfo: type[MethodParameterInfo] + MethodParametersAttribute: type[MethodParametersAttribute] + ModuleAttribute: type[ModuleAttribute] + ModuleExportInfo: type[ModuleExportInfo] + ModuleHashInfo: type[ModuleHashInfo] + ModuleHashesAttribute: type[ModuleHashesAttribute] + ModuleMainClassAttribute: type[ModuleMainClassAttribute] + ModuleOpenInfo: type[ModuleOpenInfo] + ModulePackagesAttribute: type[ModulePackagesAttribute] + ModuleProvideInfo: type[ModuleProvideInfo] + ModuleRequireInfo: type[ModuleRequireInfo] + ModuleResolutionAttribute: type[ModuleResolutionAttribute] + ModuleTargetAttribute: type[ModuleTargetAttribute] + NestHostAttribute: type[NestHostAttribute] + NestMembersAttribute: type[NestMembersAttribute] + PermittedSubclassesAttribute: type[PermittedSubclassesAttribute] + RecordAttribute: type[RecordAttribute] + RecordComponentInfo: type[RecordComponentInfo] + RuntimeInvisibleAnnotationsAttribute: type[RuntimeInvisibleAnnotationsAttribute] + RuntimeInvisibleParameterAnnotationsAttribute: type[ + RuntimeInvisibleParameterAnnotationsAttribute + ] + RuntimeInvisibleTypeAnnotationsAttribute: type[ + RuntimeInvisibleTypeAnnotationsAttribute + ] + RuntimeVisibleAnnotationsAttribute: type[RuntimeVisibleAnnotationsAttribute] + RuntimeVisibleParameterAnnotationsAttribute: type[ + RuntimeVisibleParameterAnnotationsAttribute + ] + RuntimeVisibleTypeAnnotationsAttribute: type[RuntimeVisibleTypeAnnotationsAttribute] + SignatureAttribute: type[SignatureAttribute] + SourceDebugExtensionAttribute: type[SourceDebugExtensionAttribute] + SourceFileAttribute: type[SourceFileAttribute] + SourceIDAttribute: type[SourceIDAttribute] + StackMapFrameInfo: type[StackMapFrameInfo] + StackMapTableAttribute: type[StackMapTableAttribute] + SyntheticAttribute: type[SyntheticAttribute] + UnknownAttribute: type[UnknownAttribute] diff --git a/typings/java/lang/classfile/constantpool/__init__.pyi b/typings/java/lang/classfile/constantpool/__init__.pyi new file mode 100644 index 0000000..a5ed0c5 --- /dev/null +++ b/typings/java/lang/classfile/constantpool/__init__.pyi @@ -0,0 +1,330 @@ +import typing +from typing import Protocol + +import java.lang +import java.lang.classfile +import java.lang.constant +import java.util + +class ConstantPool(java.lang.Iterable["PoolEntry"]): + def bootstrapMethodCount(self) -> int: ... + def bootstrapMethodEntry( + self, int: int + ) -> java.lang.classfile.BootstrapMethodEntry: ... + _entryByIndex_1__T = typing.TypeVar("_entryByIndex_1__T", bound="PoolEntry") # + @typing.overload + def entryByIndex(self, int: int) -> PoolEntry: ... + @typing.overload + def entryByIndex( + self, int: int, class_: type[_entryByIndex_1__T] + ) -> _entryByIndex_1__T: ... + def iterator(self) -> java.util.Iterator[PoolEntry]: ... + def size(self) -> int: ... + +class ConstantPoolException(java.lang.IllegalArgumentException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class PoolEntry: + TAG_CLASS: typing.ClassVar[int] = ... + TAG_DOUBLE: typing.ClassVar[int] = ... + TAG_DYNAMIC: typing.ClassVar[int] = ... + TAG_FIELDREF: typing.ClassVar[int] = ... + TAG_FLOAT: typing.ClassVar[int] = ... + TAG_INTEGER: typing.ClassVar[int] = ... + TAG_INTERFACE_METHODREF: typing.ClassVar[int] = ... + TAG_INVOKE_DYNAMIC: typing.ClassVar[int] = ... + TAG_LONG: typing.ClassVar[int] = ... + TAG_METHOD_HANDLE: typing.ClassVar[int] = ... + TAG_METHODREF: typing.ClassVar[int] = ... + TAG_METHOD_TYPE: typing.ClassVar[int] = ... + TAG_MODULE: typing.ClassVar[int] = ... + TAG_NAME_AND_TYPE: typing.ClassVar[int] = ... + TAG_PACKAGE: typing.ClassVar[int] = ... + TAG_STRING: typing.ClassVar[int] = ... + TAG_UTF8: typing.ClassVar[int] = ... + def constantPool(self) -> ConstantPool: ... + def index(self) -> int: ... + def tag(self) -> int: ... + def width(self) -> int: ... + +class AnnotationConstantValueEntry(PoolEntry): + def constantValue(self) -> java.lang.constant.ConstantDesc: ... + +class ConstantPoolBuilder(ConstantPool): + @typing.overload + def bsmEntry( + self, + methodHandleEntry: MethodHandleEntry, + list: java.util.List[LoadableConstantEntry], + ) -> java.lang.classfile.BootstrapMethodEntry: ... + @typing.overload + def bsmEntry( + self, + directMethodHandleDesc: java.lang.constant.DirectMethodHandleDesc, + list: java.util.List[java.lang.constant.ConstantDesc], + ) -> java.lang.classfile.BootstrapMethodEntry: ... + def canWriteDirect(self, constantPool: ConstantPool) -> bool: ... + @typing.overload + def classEntry(self, utf8Entry: Utf8Entry) -> ClassEntry: ... + @typing.overload + def classEntry(self, classDesc: java.lang.constant.ClassDesc) -> ClassEntry: ... + @typing.overload + def constantDynamicEntry( + self, + bootstrapMethodEntry: java.lang.classfile.BootstrapMethodEntry, + nameAndTypeEntry: NameAndTypeEntry, + ) -> ConstantDynamicEntry: ... + @typing.overload + def constantDynamicEntry( + self, dynamicConstantDesc: java.lang.constant.DynamicConstantDesc[typing.Any] + ) -> ConstantDynamicEntry: ... + def constantValueEntry( + self, constantDesc: java.lang.constant.ConstantDesc + ) -> ConstantValueEntry: ... + def doubleEntry(self, double: float) -> DoubleEntry: ... + @typing.overload + def fieldRefEntry( + self, classEntry: ClassEntry, nameAndTypeEntry: NameAndTypeEntry + ) -> FieldRefEntry: ... + @typing.overload + def fieldRefEntry( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + classDesc2: java.lang.constant.ClassDesc, + ) -> FieldRefEntry: ... + def floatEntry(self, float: float) -> FloatEntry: ... + def intEntry(self, int: int) -> IntegerEntry: ... + @typing.overload + def interfaceMethodRefEntry( + self, classEntry: ClassEntry, nameAndTypeEntry: NameAndTypeEntry + ) -> InterfaceMethodRefEntry: ... + @typing.overload + def interfaceMethodRefEntry( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + ) -> InterfaceMethodRefEntry: ... + @typing.overload + def invokeDynamicEntry( + self, + bootstrapMethodEntry: java.lang.classfile.BootstrapMethodEntry, + nameAndTypeEntry: NameAndTypeEntry, + ) -> InvokeDynamicEntry: ... + @typing.overload + def invokeDynamicEntry( + self, dynamicCallSiteDesc: java.lang.constant.DynamicCallSiteDesc + ) -> InvokeDynamicEntry: ... + def loadableConstantEntry( + self, constantDesc: java.lang.constant.ConstantDesc + ) -> LoadableConstantEntry: ... + def longEntry(self, long: int) -> LongEntry: ... + @typing.overload + def methodHandleEntry( + self, int: int, memberRefEntry: MemberRefEntry + ) -> MethodHandleEntry: ... + @typing.overload + def methodHandleEntry( + self, directMethodHandleDesc: java.lang.constant.DirectMethodHandleDesc + ) -> MethodHandleEntry: ... + @typing.overload + def methodRefEntry( + self, classEntry: ClassEntry, nameAndTypeEntry: NameAndTypeEntry + ) -> MethodRefEntry: ... + @typing.overload + def methodRefEntry( + self, + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + ) -> MethodRefEntry: ... + @typing.overload + def methodTypeEntry(self, utf8Entry: Utf8Entry) -> MethodTypeEntry: ... + @typing.overload + def methodTypeEntry( + self, methodTypeDesc: java.lang.constant.MethodTypeDesc + ) -> MethodTypeEntry: ... + @typing.overload + def moduleEntry(self, utf8Entry: Utf8Entry) -> ModuleEntry: ... + @typing.overload + def moduleEntry(self, moduleDesc: java.lang.constant.ModuleDesc) -> ModuleEntry: ... + @typing.overload + def nameAndTypeEntry( + self, utf8Entry: Utf8Entry, utf8Entry2: Utf8Entry + ) -> NameAndTypeEntry: ... + @typing.overload + def nameAndTypeEntry( + self, string: java.lang.String | str, classDesc: java.lang.constant.ClassDesc + ) -> NameAndTypeEntry: ... + @typing.overload + def nameAndTypeEntry( + self, + string: java.lang.String | str, + methodTypeDesc: java.lang.constant.MethodTypeDesc, + ) -> NameAndTypeEntry: ... + @typing.overload + @staticmethod + def of() -> ConstantPoolBuilder: ... + @typing.overload + @staticmethod + def of(classModel: java.lang.classfile.ClassModel) -> ConstantPoolBuilder: ... + @typing.overload + def packageEntry(self, utf8Entry: Utf8Entry) -> PackageEntry: ... + @typing.overload + def packageEntry( + self, packageDesc: java.lang.constant.PackageDesc + ) -> PackageEntry: ... + @typing.overload + def stringEntry(self, utf8Entry: Utf8Entry) -> StringEntry: ... + @typing.overload + def stringEntry(self, string: java.lang.String | str) -> StringEntry: ... + @typing.overload + def utf8Entry(self, string: java.lang.String | str) -> Utf8Entry: ... + @typing.overload + def utf8Entry(self, classDesc: java.lang.constant.ClassDesc) -> Utf8Entry: ... + @typing.overload + def utf8Entry( + self, methodTypeDesc: java.lang.constant.MethodTypeDesc + ) -> Utf8Entry: ... + +class DynamicConstantPoolEntry(PoolEntry): + def bootstrap(self) -> java.lang.classfile.BootstrapMethodEntry: ... + def bootstrapMethodIndex(self) -> int: ... + def name(self) -> Utf8Entry: ... + def nameAndType(self) -> NameAndTypeEntry: ... + def type(self) -> Utf8Entry: ... + +class LoadableConstantEntry(PoolEntry): + def constantValue(self) -> java.lang.constant.ConstantDesc: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class MemberRefEntry(PoolEntry): + def name(self) -> Utf8Entry: ... + def nameAndType(self) -> NameAndTypeEntry: ... + def owner(self) -> ClassEntry: ... + def type(self) -> Utf8Entry: ... + +class ModuleEntry(PoolEntry): + def asSymbol(self) -> java.lang.constant.ModuleDesc: ... + def matches(self, moduleDesc: java.lang.constant.ModuleDesc) -> bool: ... + def name(self) -> Utf8Entry: ... + +class NameAndTypeEntry(PoolEntry): + def name(self) -> Utf8Entry: ... + def type(self) -> Utf8Entry: ... + +class PackageEntry(PoolEntry): + def asSymbol(self) -> java.lang.constant.PackageDesc: ... + def matches(self, packageDesc: java.lang.constant.PackageDesc) -> bool: ... + def name(self) -> Utf8Entry: ... + +class ClassEntry(LoadableConstantEntry): + def asInternalName(self) -> java.lang.String: ... + def asSymbol(self) -> java.lang.constant.ClassDesc: ... + def constantValue(self) -> java.lang.constant.ConstantDesc: ... + def matches(self, classDesc: java.lang.constant.ClassDesc) -> bool: ... + def name(self) -> Utf8Entry: ... + +class ConstantDynamicEntry(DynamicConstantPoolEntry, LoadableConstantEntry): + def asSymbol(self) -> java.lang.constant.DynamicConstantDesc[typing.Any]: ... + def constantValue(self) -> java.lang.constant.ConstantDesc: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + def typeSymbol(self) -> java.lang.constant.ClassDesc: ... + +class ConstantValueEntry(LoadableConstantEntry): + def constantValue(self) -> java.lang.constant.ConstantDesc: ... + +class FieldRefEntry(MemberRefEntry): + def typeSymbol(self) -> java.lang.constant.ClassDesc: ... + +class InterfaceMethodRefEntry(MemberRefEntry): + def typeSymbol(self) -> java.lang.constant.MethodTypeDesc: ... + +class InvokeDynamicEntry(DynamicConstantPoolEntry): + def asSymbol(self) -> java.lang.constant.DynamicCallSiteDesc: ... + def typeSymbol(self) -> java.lang.constant.MethodTypeDesc: ... + +class MethodHandleEntry(LoadableConstantEntry): + def asSymbol(self) -> java.lang.constant.DirectMethodHandleDesc: ... + def constantValue(self) -> java.lang.constant.ConstantDesc: ... + def kind(self) -> int: ... + def reference(self) -> MemberRefEntry: ... + +class MethodRefEntry(MemberRefEntry): + def typeSymbol(self) -> java.lang.constant.MethodTypeDesc: ... + +class MethodTypeEntry(LoadableConstantEntry): + def asSymbol(self) -> java.lang.constant.MethodTypeDesc: ... + def constantValue(self) -> java.lang.constant.ConstantDesc: ... + def descriptor(self) -> Utf8Entry: ... + def matches(self, methodTypeDesc: java.lang.constant.MethodTypeDesc) -> bool: ... + +class Utf8Entry(java.lang.CharSequence, AnnotationConstantValueEntry): + def equalsString(self, string: java.lang.String | str) -> bool: ... + def isFieldType(self, classDesc: java.lang.constant.ClassDesc) -> bool: ... + def isMethodType( + self, methodTypeDesc: java.lang.constant.MethodTypeDesc + ) -> bool: ... + def stringValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class DoubleEntry(AnnotationConstantValueEntry, ConstantValueEntry): + def doubleValue(self) -> float: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class FloatEntry(AnnotationConstantValueEntry, ConstantValueEntry): + def floatValue(self) -> float: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class IntegerEntry(AnnotationConstantValueEntry, ConstantValueEntry): + def intValue(self) -> int: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class LongEntry(AnnotationConstantValueEntry, ConstantValueEntry): + def longValue(self) -> int: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class StringEntry(ConstantValueEntry): + def equalsString(self, string: java.lang.String | str) -> bool: ... + def stringValue(self) -> java.lang.String: ... + def utf8(self) -> Utf8Entry: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.classfile.constantpool")``. + + AnnotationConstantValueEntry: type[AnnotationConstantValueEntry] + ClassEntry: type[ClassEntry] + ConstantDynamicEntry: type[ConstantDynamicEntry] + ConstantPool: type[ConstantPool] + ConstantPoolBuilder: type[ConstantPoolBuilder] + ConstantPoolException: type[ConstantPoolException] + ConstantValueEntry: type[ConstantValueEntry] + DoubleEntry: type[DoubleEntry] + DynamicConstantPoolEntry: type[DynamicConstantPoolEntry] + FieldRefEntry: type[FieldRefEntry] + FloatEntry: type[FloatEntry] + IntegerEntry: type[IntegerEntry] + InterfaceMethodRefEntry: type[InterfaceMethodRefEntry] + InvokeDynamicEntry: type[InvokeDynamicEntry] + LoadableConstantEntry: type[LoadableConstantEntry] + LongEntry: type[LongEntry] + MemberRefEntry: type[MemberRefEntry] + MethodHandleEntry: type[MethodHandleEntry] + MethodRefEntry: type[MethodRefEntry] + MethodTypeEntry: type[MethodTypeEntry] + ModuleEntry: type[ModuleEntry] + NameAndTypeEntry: type[NameAndTypeEntry] + PackageEntry: type[PackageEntry] + PoolEntry: type[PoolEntry] + StringEntry: type[StringEntry] + Utf8Entry: type[Utf8Entry] diff --git a/typings/java/lang/classfile/instruction/__init__.pyi b/typings/java/lang/classfile/instruction/__init__.pyi new file mode 100644 index 0000000..e4c99c2 --- /dev/null +++ b/typings/java/lang/classfile/instruction/__init__.pyi @@ -0,0 +1,435 @@ +import typing +from typing import Protocol + +import java +import java.lang +import java.lang.classfile +import java.lang.classfile.constantpool +import java.lang.constant +import java.util + +class ArrayLoadInstruction(java.lang.classfile.Instruction): + @staticmethod + def of(opcode: java.lang.classfile.Opcode) -> ArrayLoadInstruction: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class ArrayStoreInstruction(java.lang.classfile.Instruction): + @staticmethod + def of(opcode: java.lang.classfile.Opcode) -> ArrayStoreInstruction: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class BranchInstruction(java.lang.classfile.Instruction): + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, label: java.lang.classfile.Label + ) -> BranchInstruction: ... + def target(self) -> java.lang.classfile.Label: ... + +class CharacterRange(java.lang.classfile.PseudoInstruction): + FLAG_STATEMENT: typing.ClassVar[int] = ... + FLAG_BLOCK: typing.ClassVar[int] = ... + FLAG_ASSIGNMENT: typing.ClassVar[int] = ... + FLAG_FLOW_CONTROLLER: typing.ClassVar[int] = ... + FLAG_FLOW_TARGET: typing.ClassVar[int] = ... + FLAG_INVOKE: typing.ClassVar[int] = ... + FLAG_CREATE: typing.ClassVar[int] = ... + FLAG_BRANCH_TRUE: typing.ClassVar[int] = ... + FLAG_BRANCH_FALSE: typing.ClassVar[int] = ... + def characterRangeEnd(self) -> int: ... + def characterRangeStart(self) -> int: ... + def endScope(self) -> java.lang.classfile.Label: ... + def flags(self) -> int: ... + @staticmethod + def of( + label: java.lang.classfile.Label, + label2: java.lang.classfile.Label, + int: int, + int2: int, + int3: int, + ) -> CharacterRange: ... + def startScope(self) -> java.lang.classfile.Label: ... + +class ConvertInstruction(java.lang.classfile.Instruction): + def fromType(self) -> java.lang.classfile.TypeKind: ... + @typing.overload + @staticmethod + def of(opcode: java.lang.classfile.Opcode) -> ConvertInstruction: ... + @typing.overload + @staticmethod + def of( + typeKind: java.lang.classfile.TypeKind, typeKind2: java.lang.classfile.TypeKind + ) -> ConvertInstruction: ... + def toType(self) -> java.lang.classfile.TypeKind: ... + +class ExceptionCatch(java.lang.classfile.PseudoInstruction): + def catchType( + self, + ) -> java.util.Optional[java.lang.classfile.constantpool.ClassEntry]: ... + def handler(self) -> java.lang.classfile.Label: ... + @typing.overload + @staticmethod + def of( + label: java.lang.classfile.Label, + label2: java.lang.classfile.Label, + label3: java.lang.classfile.Label, + ) -> ExceptionCatch: ... + @typing.overload + @staticmethod + def of( + label: java.lang.classfile.Label, + label2: java.lang.classfile.Label, + label3: java.lang.classfile.Label, + optional: java.util.Optional[java.lang.classfile.constantpool.ClassEntry], + ) -> ExceptionCatch: ... + def tryEnd(self) -> java.lang.classfile.Label: ... + def tryStart(self) -> java.lang.classfile.Label: ... + +class FieldInstruction(java.lang.classfile.Instruction): + def field(self) -> java.lang.classfile.constantpool.FieldRefEntry: ... + def name(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, + classEntry: java.lang.classfile.constantpool.ClassEntry, + nameAndTypeEntry: java.lang.classfile.constantpool.NameAndTypeEntry, + ) -> FieldInstruction: ... + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, + classEntry: java.lang.classfile.constantpool.ClassEntry, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + ) -> FieldInstruction: ... + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, + fieldRefEntry: java.lang.classfile.constantpool.FieldRefEntry, + ) -> FieldInstruction: ... + def owner(self) -> java.lang.classfile.constantpool.ClassEntry: ... + def type(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def typeSymbol(self) -> java.lang.constant.ClassDesc: ... + +class IncrementInstruction(java.lang.classfile.Instruction): + def constant(self) -> int: ... + @staticmethod + def of(int: int, int2: int) -> IncrementInstruction: ... + def slot(self) -> int: ... + +class InvokeDynamicInstruction(java.lang.classfile.Instruction): + def bootstrapArgs(self) -> java.util.List[java.lang.constant.ConstantDesc]: ... + def bootstrapMethod(self) -> java.lang.constant.DirectMethodHandleDesc: ... + def invokedynamic(self) -> java.lang.classfile.constantpool.InvokeDynamicEntry: ... + def name(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + @staticmethod + def of( + invokeDynamicEntry: java.lang.classfile.constantpool.InvokeDynamicEntry, + ) -> InvokeDynamicInstruction: ... + def type(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def typeSymbol(self) -> java.lang.constant.MethodTypeDesc: ... + +class InvokeInstruction(java.lang.classfile.Instruction): + def count(self) -> int: ... + def isInterface(self) -> bool: ... + def method(self) -> java.lang.classfile.constantpool.MemberRefEntry: ... + def name(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, + classEntry: java.lang.classfile.constantpool.ClassEntry, + nameAndTypeEntry: java.lang.classfile.constantpool.NameAndTypeEntry, + boolean: bool, + ) -> InvokeInstruction: ... + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, + classEntry: java.lang.classfile.constantpool.ClassEntry, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + boolean: bool, + ) -> InvokeInstruction: ... + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, + memberRefEntry: java.lang.classfile.constantpool.MemberRefEntry, + ) -> InvokeInstruction: ... + def owner(self) -> java.lang.classfile.constantpool.ClassEntry: ... + def type(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def typeSymbol(self) -> java.lang.constant.MethodTypeDesc: ... + +class LabelTarget(java.lang.classfile.PseudoInstruction): + def label(self) -> java.lang.classfile.Label: ... + +class LineNumber(java.lang.classfile.PseudoInstruction): + def line(self) -> int: ... + @staticmethod + def of(int: int) -> LineNumber: ... + +class LoadInstruction(java.lang.classfile.Instruction): + @typing.overload + @staticmethod + def of(opcode: java.lang.classfile.Opcode, int: int) -> LoadInstruction: ... + @typing.overload + @staticmethod + def of(typeKind: java.lang.classfile.TypeKind, int: int) -> LoadInstruction: ... + def slot(self) -> int: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class LocalVariable(java.lang.classfile.PseudoInstruction): + def endScope(self) -> java.lang.classfile.Label: ... + def name(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + @typing.overload + @staticmethod + def of( + int: int, + string: java.lang.String | str, + classDesc: java.lang.constant.ClassDesc, + label: java.lang.classfile.Label, + label2: java.lang.classfile.Label, + ) -> LocalVariable: ... + @typing.overload + @staticmethod + def of( + int: int, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + label: java.lang.classfile.Label, + label2: java.lang.classfile.Label, + ) -> LocalVariable: ... + def slot(self) -> int: ... + def startScope(self) -> java.lang.classfile.Label: ... + def type(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def typeSymbol(self) -> java.lang.constant.ClassDesc: ... + +class LocalVariableType(java.lang.classfile.PseudoInstruction): + def endScope(self) -> java.lang.classfile.Label: ... + def name(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + @typing.overload + @staticmethod + def of( + int: int, + string: java.lang.String | str, + signature: java.lang.classfile.Signature, + label: java.lang.classfile.Label, + label2: java.lang.classfile.Label, + ) -> LocalVariableType: ... + @typing.overload + @staticmethod + def of( + int: int, + utf8Entry: java.lang.classfile.constantpool.Utf8Entry, + utf8Entry2: java.lang.classfile.constantpool.Utf8Entry, + label: java.lang.classfile.Label, + label2: java.lang.classfile.Label, + ) -> LocalVariableType: ... + def signature(self) -> java.lang.classfile.constantpool.Utf8Entry: ... + def signatureSymbol(self) -> java.lang.classfile.Signature: ... + def slot(self) -> int: ... + def startScope(self) -> java.lang.classfile.Label: ... + +class LookupSwitchInstruction(java.lang.classfile.Instruction): + def cases(self) -> java.util.List[SwitchCase]: ... + def defaultTarget(self) -> java.lang.classfile.Label: ... + @staticmethod + def of( + label: java.lang.classfile.Label, list: java.util.List[SwitchCase] + ) -> LookupSwitchInstruction: ... + +class MonitorInstruction(java.lang.classfile.Instruction): + @staticmethod + def of(opcode: java.lang.classfile.Opcode) -> MonitorInstruction: ... + +class NewMultiArrayInstruction(java.lang.classfile.Instruction): + def arrayType(self) -> java.lang.classfile.constantpool.ClassEntry: ... + def dimensions(self) -> int: ... + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, int: int + ) -> NewMultiArrayInstruction: ... + +class NewObjectInstruction(java.lang.classfile.Instruction): + def className(self) -> java.lang.classfile.constantpool.ClassEntry: ... + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> NewObjectInstruction: ... + +class NewPrimitiveArrayInstruction(java.lang.classfile.Instruction): + @staticmethod + def of(typeKind: java.lang.classfile.TypeKind) -> NewPrimitiveArrayInstruction: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class NewReferenceArrayInstruction(java.lang.classfile.Instruction): + def componentType(self) -> java.lang.classfile.constantpool.ClassEntry: ... + @staticmethod + def of( + classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> NewReferenceArrayInstruction: ... + +class NopInstruction(java.lang.classfile.Instruction): + @staticmethod + def of() -> NopInstruction: ... + +class OperatorInstruction(java.lang.classfile.Instruction): + @staticmethod + def of(opcode: java.lang.classfile.Opcode) -> OperatorInstruction: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class ReturnInstruction(java.lang.classfile.Instruction): + @typing.overload + @staticmethod + def of(opcode: java.lang.classfile.Opcode) -> ReturnInstruction: ... + @typing.overload + @staticmethod + def of(typeKind: java.lang.classfile.TypeKind) -> ReturnInstruction: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class StackInstruction(java.lang.classfile.Instruction): + @staticmethod + def of(opcode: java.lang.classfile.Opcode) -> StackInstruction: ... + +class StoreInstruction(java.lang.classfile.Instruction): + @typing.overload + @staticmethod + def of(opcode: java.lang.classfile.Opcode, int: int) -> StoreInstruction: ... + @typing.overload + @staticmethod + def of(typeKind: java.lang.classfile.TypeKind, int: int) -> StoreInstruction: ... + def slot(self) -> int: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class SwitchCase: + def caseValue(self) -> int: ... + @staticmethod + def of(int: int, label: java.lang.classfile.Label) -> SwitchCase: ... + def target(self) -> java.lang.classfile.Label: ... + +class TableSwitchInstruction(java.lang.classfile.Instruction): + def cases(self) -> java.util.List[SwitchCase]: ... + def defaultTarget(self) -> java.lang.classfile.Label: ... + def highValue(self) -> int: ... + def lowValue(self) -> int: ... + @staticmethod + def of( + int: int, + int2: int, + label: java.lang.classfile.Label, + list: java.util.List[SwitchCase], + ) -> TableSwitchInstruction: ... + +class ThrowInstruction(java.lang.classfile.Instruction): + @staticmethod + def of() -> ThrowInstruction: ... + +class TypeCheckInstruction(java.lang.classfile.Instruction): + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, + classEntry: java.lang.classfile.constantpool.ClassEntry, + ) -> TypeCheckInstruction: ... + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, classDesc: java.lang.constant.ClassDesc + ) -> TypeCheckInstruction: ... + def type(self) -> java.lang.classfile.constantpool.ClassEntry: ... + +class ConstantInstruction(java.lang.classfile.Instruction): + def constantValue(self) -> java.lang.constant.ConstantDesc: ... + @staticmethod + def ofArgument( + opcode: java.lang.classfile.Opcode, int: int + ) -> ConstantInstruction.ArgumentConstantInstruction: ... + @staticmethod + def ofIntrinsic( + opcode: java.lang.classfile.Opcode, + ) -> ConstantInstruction.IntrinsicConstantInstruction: ... + @staticmethod + def ofLoad( + opcode: java.lang.classfile.Opcode, + loadableConstantEntry: java.lang.classfile.constantpool.LoadableConstantEntry, + ) -> ConstantInstruction.LoadConstantInstruction: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + class ArgumentConstantInstruction( + java.lang.classfile.instruction.ConstantInstruction + ): + def constantValue(self) -> int: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + + class IntrinsicConstantInstruction( + java.lang.classfile.instruction.ConstantInstruction + ): + def typeKind(self) -> java.lang.classfile.TypeKind: ... + + class LoadConstantInstruction(java.lang.classfile.instruction.ConstantInstruction): + def constantEntry( + self, + ) -> java.lang.classfile.constantpool.LoadableConstantEntry: ... + def typeKind(self) -> java.lang.classfile.TypeKind: ... + +class DiscontinuedInstruction(java.lang.classfile.Instruction): + class JsrInstruction(java.lang.classfile.instruction.DiscontinuedInstruction): + @typing.overload + @staticmethod + def of( + label: java.lang.classfile.Label, + ) -> DiscontinuedInstruction.JsrInstruction: ... + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, label: java.lang.classfile.Label + ) -> DiscontinuedInstruction.JsrInstruction: ... + def target(self) -> java.lang.classfile.Label: ... + + class RetInstruction(java.lang.classfile.instruction.DiscontinuedInstruction): + @typing.overload + @staticmethod + def of(int: int) -> DiscontinuedInstruction.RetInstruction: ... + @typing.overload + @staticmethod + def of( + opcode: java.lang.classfile.Opcode, int: int + ) -> DiscontinuedInstruction.RetInstruction: ... + def slot(self) -> int: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.classfile.instruction")``. + + ArrayLoadInstruction: type[ArrayLoadInstruction] + ArrayStoreInstruction: type[ArrayStoreInstruction] + BranchInstruction: type[BranchInstruction] + CharacterRange: type[CharacterRange] + ConstantInstruction: type[ConstantInstruction] + ConvertInstruction: type[ConvertInstruction] + DiscontinuedInstruction: type[DiscontinuedInstruction] + ExceptionCatch: type[ExceptionCatch] + FieldInstruction: type[FieldInstruction] + IncrementInstruction: type[IncrementInstruction] + InvokeDynamicInstruction: type[InvokeDynamicInstruction] + InvokeInstruction: type[InvokeInstruction] + LabelTarget: type[LabelTarget] + LineNumber: type[LineNumber] + LoadInstruction: type[LoadInstruction] + LocalVariable: type[LocalVariable] + LocalVariableType: type[LocalVariableType] + LookupSwitchInstruction: type[LookupSwitchInstruction] + MonitorInstruction: type[MonitorInstruction] + NewMultiArrayInstruction: type[NewMultiArrayInstruction] + NewObjectInstruction: type[NewObjectInstruction] + NewPrimitiveArrayInstruction: type[NewPrimitiveArrayInstruction] + NewReferenceArrayInstruction: type[NewReferenceArrayInstruction] + NopInstruction: type[NopInstruction] + OperatorInstruction: type[OperatorInstruction] + ReturnInstruction: type[ReturnInstruction] + StackInstruction: type[StackInstruction] + StoreInstruction: type[StoreInstruction] + SwitchCase: type[SwitchCase] + TableSwitchInstruction: type[TableSwitchInstruction] + ThrowInstruction: type[ThrowInstruction] + TypeCheckInstruction: type[TypeCheckInstruction] diff --git a/typings/java/lang/constant/__init__.pyi b/typings/java/lang/constant/__init__.pyi new file mode 100644 index 0000000..64acc55 --- /dev/null +++ b/typings/java/lang/constant/__init__.pyi @@ -0,0 +1,344 @@ +import typing +from typing import Protocol + +import java.lang +import java.lang.invoke +import java.util +import jpype + +class Constable: + def describeConstable(self) -> java.util.Optional[ConstantDesc]: ... + +class ConstantDesc: + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> typing.Any: ... + +class ConstantDescs: + DEFAULT_NAME: typing.ClassVar[java.lang.String] = ... + CD_Object: typing.ClassVar[ClassDesc] = ... + CD_String: typing.ClassVar[ClassDesc] = ... + CD_Class: typing.ClassVar[ClassDesc] = ... + CD_Number: typing.ClassVar[ClassDesc] = ... + CD_Integer: typing.ClassVar[ClassDesc] = ... + CD_Long: typing.ClassVar[ClassDesc] = ... + CD_Float: typing.ClassVar[ClassDesc] = ... + CD_Double: typing.ClassVar[ClassDesc] = ... + CD_Short: typing.ClassVar[ClassDesc] = ... + CD_Byte: typing.ClassVar[ClassDesc] = ... + CD_Character: typing.ClassVar[ClassDesc] = ... + CD_Boolean: typing.ClassVar[ClassDesc] = ... + CD_Void: typing.ClassVar[ClassDesc] = ... + CD_Throwable: typing.ClassVar[ClassDesc] = ... + CD_Exception: typing.ClassVar[ClassDesc] = ... + CD_Enum: typing.ClassVar[ClassDesc] = ... + CD_VarHandle: typing.ClassVar[ClassDesc] = ... + CD_MethodHandles: typing.ClassVar[ClassDesc] = ... + CD_MethodHandles_Lookup: typing.ClassVar[ClassDesc] = ... + CD_MethodHandle: typing.ClassVar[ClassDesc] = ... + CD_MethodType: typing.ClassVar[ClassDesc] = ... + CD_CallSite: typing.ClassVar[ClassDesc] = ... + CD_Collection: typing.ClassVar[ClassDesc] = ... + CD_List: typing.ClassVar[ClassDesc] = ... + CD_Set: typing.ClassVar[ClassDesc] = ... + CD_Map: typing.ClassVar[ClassDesc] = ... + CD_ConstantDesc: typing.ClassVar[ClassDesc] = ... + CD_ClassDesc: typing.ClassVar[ClassDesc] = ... + CD_EnumDesc: typing.ClassVar[ClassDesc] = ... + CD_MethodTypeDesc: typing.ClassVar[ClassDesc] = ... + CD_MethodHandleDesc: typing.ClassVar[ClassDesc] = ... + CD_DirectMethodHandleDesc: typing.ClassVar[ClassDesc] = ... + CD_VarHandleDesc: typing.ClassVar[ClassDesc] = ... + CD_MethodHandleDesc_Kind: typing.ClassVar[ClassDesc] = ... + CD_DynamicConstantDesc: typing.ClassVar[ClassDesc] = ... + CD_DynamicCallSiteDesc: typing.ClassVar[ClassDesc] = ... + CD_ConstantBootstraps: typing.ClassVar[ClassDesc] = ... + BSM_PRIMITIVE_CLASS: typing.ClassVar[DirectMethodHandleDesc] = ... + BSM_ENUM_CONSTANT: typing.ClassVar[DirectMethodHandleDesc] = ... + BSM_GET_STATIC_FINAL: typing.ClassVar[DirectMethodHandleDesc] = ... + BSM_NULL_CONSTANT: typing.ClassVar[DirectMethodHandleDesc] = ... + BSM_VARHANDLE_FIELD: typing.ClassVar[DirectMethodHandleDesc] = ... + BSM_VARHANDLE_STATIC_FIELD: typing.ClassVar[DirectMethodHandleDesc] = ... + BSM_VARHANDLE_ARRAY: typing.ClassVar[DirectMethodHandleDesc] = ... + BSM_INVOKE: typing.ClassVar[DirectMethodHandleDesc] = ... + BSM_EXPLICIT_CAST: typing.ClassVar[DirectMethodHandleDesc] = ... + CD_int: typing.ClassVar[ClassDesc] = ... + CD_long: typing.ClassVar[ClassDesc] = ... + CD_float: typing.ClassVar[ClassDesc] = ... + CD_double: typing.ClassVar[ClassDesc] = ... + CD_short: typing.ClassVar[ClassDesc] = ... + CD_byte: typing.ClassVar[ClassDesc] = ... + CD_char: typing.ClassVar[ClassDesc] = ... + CD_boolean: typing.ClassVar[ClassDesc] = ... + CD_void: typing.ClassVar[ClassDesc] = ... + BSM_CLASS_DATA: typing.ClassVar[DirectMethodHandleDesc] = ... + BSM_CLASS_DATA_AT: typing.ClassVar[DirectMethodHandleDesc] = ... + NULL: typing.ClassVar[ConstantDesc] = ... + TRUE: typing.ClassVar[DynamicConstantDesc] = ... + FALSE: typing.ClassVar[DynamicConstantDesc] = ... + INIT_NAME: typing.ClassVar[java.lang.String] = ... + CLASS_INIT_NAME: typing.ClassVar[java.lang.String] = ... + MTD_void: typing.ClassVar[MethodTypeDesc] = ... + @staticmethod + def ofCallsiteBootstrap( + classDesc: ClassDesc, + string: java.lang.String | str, + classDesc2: ClassDesc, + *classDesc3: ClassDesc, + ) -> DirectMethodHandleDesc: ... + @staticmethod + def ofConstantBootstrap( + classDesc: ClassDesc, + string: java.lang.String | str, + classDesc2: ClassDesc, + *classDesc3: ClassDesc, + ) -> DirectMethodHandleDesc: ... + +class DynamicCallSiteDesc: + def bootstrapArgs(self) -> typing.MutableSequence[ConstantDesc]: ... + def bootstrapMethod(self) -> MethodHandleDesc: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def invocationName(self) -> java.lang.String: ... + def invocationType(self) -> MethodTypeDesc: ... + @typing.overload + @staticmethod + def of( + directMethodHandleDesc: DirectMethodHandleDesc, + string: java.lang.String | str, + methodTypeDesc: MethodTypeDesc, + ) -> DynamicCallSiteDesc: ... + @typing.overload + @staticmethod + def of( + directMethodHandleDesc: DirectMethodHandleDesc, + string: java.lang.String | str, + methodTypeDesc: MethodTypeDesc, + *constantDesc: ConstantDesc, + ) -> DynamicCallSiteDesc: ... + @typing.overload + @staticmethod + def of( + directMethodHandleDesc: DirectMethodHandleDesc, methodTypeDesc: MethodTypeDesc + ) -> DynamicCallSiteDesc: ... + def resolveCallSiteDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> java.lang.invoke.CallSite: ... + def toString(self) -> java.lang.String: ... + def withArgs(self, *constantDesc: ConstantDesc) -> DynamicCallSiteDesc: ... + def withNameAndType( + self, string: java.lang.String | str, methodTypeDesc: MethodTypeDesc + ) -> DynamicCallSiteDesc: ... + +class ModuleDesc: + def equals(self, object: typing.Any) -> bool: ... + def name(self) -> java.lang.String: ... + @staticmethod + def of(string: java.lang.String | str) -> ModuleDesc: ... + +class PackageDesc: + def equals(self, object: typing.Any) -> bool: ... + def internalName(self) -> java.lang.String: ... + def name(self) -> java.lang.String: ... + @staticmethod + def of(string: java.lang.String | str) -> PackageDesc: ... + @staticmethod + def ofInternalName(string: java.lang.String | str) -> PackageDesc: ... + +class ClassDesc(ConstantDesc, java.lang.invoke.TypeDescriptor.OfField["ClassDesc"]): + @typing.overload + def arrayType(self) -> ClassDesc: ... + @typing.overload + def arrayType(self, int: int) -> ClassDesc: ... + def componentType(self) -> ClassDesc: ... + def descriptorString(self) -> java.lang.String: ... + def displayName(self) -> java.lang.String: ... + def equals(self, object: typing.Any) -> bool: ... + def isArray(self) -> bool: ... + def isClassOrInterface(self) -> bool: ... + def isPrimitive(self) -> bool: ... + @typing.overload + def nested(self, string: java.lang.String | str) -> ClassDesc: ... + @typing.overload + def nested( + self, string: java.lang.String | str, *string2: java.lang.String | str + ) -> ClassDesc: ... + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> ClassDesc: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, string2: java.lang.String | str + ) -> ClassDesc: ... + @staticmethod + def ofDescriptor(string: java.lang.String | str) -> ClassDesc: ... + @staticmethod + def ofInternalName(string: java.lang.String | str) -> ClassDesc: ... + def packageName(self) -> java.lang.String: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> type[typing.Any]: ... + +_DynamicConstantDesc__T = typing.TypeVar("_DynamicConstantDesc__T") # + +class DynamicConstantDesc(ConstantDesc, typing.Generic[_DynamicConstantDesc__T]): + def bootstrapArgs(self) -> typing.MutableSequence[ConstantDesc]: ... + def bootstrapArgsList(self) -> java.util.List[ConstantDesc]: ... + def bootstrapMethod(self) -> DirectMethodHandleDesc: ... + def constantName(self) -> java.lang.String: ... + def constantType(self) -> ClassDesc: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + _of_0__T = typing.TypeVar("_of_0__T") # + _of_1__T = typing.TypeVar("_of_1__T") # + @typing.overload + @staticmethod + def of( + directMethodHandleDesc: DirectMethodHandleDesc, + ) -> DynamicConstantDesc[_of_0__T]: ... + @typing.overload + @staticmethod + def of( + directMethodHandleDesc: DirectMethodHandleDesc, *constantDesc: ConstantDesc + ) -> DynamicConstantDesc[_of_1__T]: ... + _ofCanonical__T = typing.TypeVar("_ofCanonical__T") # + @staticmethod + def ofCanonical( + directMethodHandleDesc: DirectMethodHandleDesc, + string: java.lang.String | str, + classDesc: ClassDesc, + constantDescArray: list[ConstantDesc] | jpype.JArray, + ) -> ConstantDesc: ... + _ofNamed__T = typing.TypeVar("_ofNamed__T") # + @staticmethod + def ofNamed( + directMethodHandleDesc: DirectMethodHandleDesc, + string: java.lang.String | str, + classDesc: ClassDesc, + *constantDesc: ConstantDesc, + ) -> DynamicConstantDesc[_ofNamed__T]: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> _DynamicConstantDesc__T: ... + def toString(self) -> java.lang.String: ... + +class MethodHandleDesc(ConstantDesc): + def asType(self, methodTypeDesc: MethodTypeDesc) -> MethodHandleDesc: ... + def equals(self, object: typing.Any) -> bool: ... + def invocationType(self) -> MethodTypeDesc: ... + @staticmethod + def of( + kind: DirectMethodHandleDesc.Kind, + classDesc: ClassDesc, + string: java.lang.String | str, + string2: java.lang.String | str, + ) -> DirectMethodHandleDesc: ... + @staticmethod + def ofConstructor( + classDesc: ClassDesc, *classDesc2: ClassDesc + ) -> DirectMethodHandleDesc: ... + @staticmethod + def ofField( + kind: DirectMethodHandleDesc.Kind, + classDesc: ClassDesc, + string: java.lang.String | str, + classDesc2: ClassDesc, + ) -> DirectMethodHandleDesc: ... + @staticmethod + def ofMethod( + kind: DirectMethodHandleDesc.Kind, + classDesc: ClassDesc, + string: java.lang.String | str, + methodTypeDesc: MethodTypeDesc, + ) -> DirectMethodHandleDesc: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> java.lang.invoke.MethodHandle: ... + +class MethodTypeDesc( + ConstantDesc, java.lang.invoke.TypeDescriptor.OfMethod[ClassDesc, "MethodTypeDesc"] +): + def changeParameterType(self, int: int, classDesc: ClassDesc) -> MethodTypeDesc: ... + def changeReturnType(self, classDesc: ClassDesc) -> MethodTypeDesc: ... + def descriptorString(self) -> java.lang.String: ... + def displayDescriptor(self) -> java.lang.String: ... + def dropParameterTypes(self, int: int, int2: int) -> MethodTypeDesc: ... + def equals(self, object: typing.Any) -> bool: ... + def insertParameterTypes( + self, int: int, *classDesc: ClassDesc + ) -> MethodTypeDesc: ... + @typing.overload + @staticmethod + def of(classDesc: ClassDesc) -> MethodTypeDesc: ... + @typing.overload + @staticmethod + def of(classDesc: ClassDesc, *classDesc2: ClassDesc) -> MethodTypeDesc: ... + @typing.overload + @staticmethod + def of(classDesc: ClassDesc, list: java.util.List[ClassDesc]) -> MethodTypeDesc: ... + @staticmethod + def ofDescriptor(string: java.lang.String | str) -> MethodTypeDesc: ... + def parameterArray(self) -> typing.MutableSequence[ClassDesc]: ... + def parameterCount(self) -> int: ... + def parameterList(self) -> java.util.List[ClassDesc]: ... + def parameterType(self, int: int) -> ClassDesc: ... + def resolveConstantDesc( + self, lookup: java.lang.invoke.MethodHandles.Lookup + ) -> java.lang.invoke.MethodType: ... + def returnType(self) -> ClassDesc: ... + +class DirectMethodHandleDesc(MethodHandleDesc): + def equals(self, object: typing.Any) -> bool: ... + def isOwnerInterface(self) -> bool: ... + def kind(self) -> DirectMethodHandleDesc.Kind: ... + def lookupDescriptor(self) -> java.lang.String: ... + def methodName(self) -> java.lang.String: ... + def owner(self) -> ClassDesc: ... + def refKind(self) -> int: ... + class Kind(java.lang.Enum["DirectMethodHandleDesc.Kind"]): + STATIC: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + INTERFACE_STATIC: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + VIRTUAL: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + INTERFACE_VIRTUAL: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + SPECIAL: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + INTERFACE_SPECIAL: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + CONSTRUCTOR: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + GETTER: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + SETTER: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + STATIC_GETTER: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + STATIC_SETTER: typing.ClassVar[DirectMethodHandleDesc.Kind] = ... + refKind: int = ... + isInterface: bool = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(int: int) -> DirectMethodHandleDesc.Kind: ... + @typing.overload + @staticmethod + def valueOf(int: int, boolean: bool) -> DirectMethodHandleDesc.Kind: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> DirectMethodHandleDesc.Kind: ... + @staticmethod + def values() -> typing.MutableSequence[DirectMethodHandleDesc.Kind]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.constant")``. + + ClassDesc: type[ClassDesc] + Constable: type[Constable] + ConstantDesc: type[ConstantDesc] + ConstantDescs: type[ConstantDescs] + DirectMethodHandleDesc: type[DirectMethodHandleDesc] + DynamicCallSiteDesc: type[DynamicCallSiteDesc] + DynamicConstantDesc: type[DynamicConstantDesc] + MethodHandleDesc: type[MethodHandleDesc] + MethodTypeDesc: type[MethodTypeDesc] + ModuleDesc: type[ModuleDesc] + PackageDesc: type[PackageDesc] diff --git a/typings/java/lang/foreign/__init__.pyi b/typings/java/lang/foreign/__init__.pyi new file mode 100644 index 0000000..1e9967a --- /dev/null +++ b/typings/java/lang/foreign/__init__.pyi @@ -0,0 +1,667 @@ +import typing +from typing import Protocol + +import java +import java.lang +import java.lang.invoke +import java.nio +import java.nio.charset +import java.nio.file +import java.util +import java.util.function +import java.util.stream +import jpype +import jpype.protocol + +class FunctionDescriptor: + def appendArgumentLayouts( + self, *memoryLayout: MemoryLayout + ) -> FunctionDescriptor: ... + def argumentLayouts(self) -> java.util.List[MemoryLayout]: ... + def changeReturnLayout(self, memoryLayout: MemoryLayout) -> FunctionDescriptor: ... + def dropReturnLayout(self) -> FunctionDescriptor: ... + def insertArgumentLayouts( + self, int: int, *memoryLayout: MemoryLayout + ) -> FunctionDescriptor: ... + @staticmethod + def of( + memoryLayout: MemoryLayout, *memoryLayout2: MemoryLayout + ) -> FunctionDescriptor: ... + @staticmethod + def ofVoid(*memoryLayout: MemoryLayout) -> FunctionDescriptor: ... + def returnLayout(self) -> java.util.Optional[MemoryLayout]: ... + def toMethodType(self) -> java.lang.invoke.MethodType: ... + +class Linker: + def canonicalLayouts(self) -> java.util.Map[java.lang.String, MemoryLayout]: ... + def defaultLookup(self) -> SymbolLookup: ... + @typing.overload + def downcallHandle( + self, functionDescriptor: FunctionDescriptor, *option: Linker.Option + ) -> java.lang.invoke.MethodHandle: ... + @typing.overload + def downcallHandle( + self, + memorySegment: MemorySegment, + functionDescriptor: FunctionDescriptor, + *option: Linker.Option, + ) -> java.lang.invoke.MethodHandle: ... + @staticmethod + def nativeLinker() -> Linker: ... + def upcallStub( + self, + methodHandle: java.lang.invoke.MethodHandle, + functionDescriptor: FunctionDescriptor, + arena: Arena, + *option: Linker.Option, + ) -> MemorySegment: ... + class Option: + @staticmethod + def captureCallState(*string: java.lang.String | str) -> Linker.Option: ... + @staticmethod + def captureStateLayout() -> StructLayout: ... + @staticmethod + def critical(boolean: bool) -> Linker.Option: ... + @staticmethod + def firstVariadicArg(int: int) -> Linker.Option: ... + +class MemoryLayout: + def arrayElementVarHandle( + self, *pathElement: MemoryLayout.PathElement + ) -> java.lang.invoke.VarHandle: ... + def byteAlignment(self) -> int: ... + def byteOffset(self, *pathElement: MemoryLayout.PathElement) -> int: ... + def byteOffsetHandle( + self, *pathElement: MemoryLayout.PathElement + ) -> java.lang.invoke.MethodHandle: ... + def byteSize(self) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def name(self) -> java.util.Optional[java.lang.String]: ... + @staticmethod + def paddingLayout(long: int) -> PaddingLayout: ... + def scale(self, long: int, long2: int) -> int: ... + def scaleHandle(self) -> java.lang.invoke.MethodHandle: ... + def select(self, *pathElement: MemoryLayout.PathElement) -> MemoryLayout: ... + @staticmethod + def sequenceLayout(long: int, memoryLayout: MemoryLayout) -> SequenceLayout: ... + def sliceHandle( + self, *pathElement: MemoryLayout.PathElement + ) -> java.lang.invoke.MethodHandle: ... + @staticmethod + def structLayout(*memoryLayout: MemoryLayout) -> StructLayout: ... + def toString(self) -> java.lang.String: ... + @staticmethod + def unionLayout(*memoryLayout: MemoryLayout) -> UnionLayout: ... + def varHandle( + self, *pathElement: MemoryLayout.PathElement + ) -> java.lang.invoke.VarHandle: ... + def withByteAlignment(self, long: int) -> MemoryLayout: ... + def withName(self, string: java.lang.String | str) -> MemoryLayout: ... + def withoutName(self) -> MemoryLayout: ... + class PathElement: + @staticmethod + def dereferenceElement() -> MemoryLayout.PathElement: ... + @typing.overload + @staticmethod + def groupElement( + string: java.lang.String | str, + ) -> MemoryLayout.PathElement: ... + @typing.overload + @staticmethod + def groupElement(long: int) -> MemoryLayout.PathElement: ... + @typing.overload + @staticmethod + def sequenceElement() -> MemoryLayout.PathElement: ... + @typing.overload + @staticmethod + def sequenceElement(long: int) -> MemoryLayout.PathElement: ... + @typing.overload + @staticmethod + def sequenceElement(long: int, long2: int) -> MemoryLayout.PathElement: ... + +class MemorySegment: + NULL: typing.ClassVar[MemorySegment] = ... + def address(self) -> int: ... + def asByteBuffer(self) -> java.nio.ByteBuffer: ... + def asOverlappingSlice( + self, memorySegment: MemorySegment + ) -> java.util.Optional[MemorySegment]: ... + def asReadOnly(self) -> MemorySegment: ... + @typing.overload + def asSlice(self, long: int) -> MemorySegment: ... + @typing.overload + def asSlice(self, long: int, memoryLayout: MemoryLayout) -> MemorySegment: ... + @typing.overload + def asSlice(self, long: int, long2: int) -> MemorySegment: ... + @typing.overload + def asSlice(self, long: int, long2: int, long3: int) -> MemorySegment: ... + def byteSize(self) -> int: ... + @typing.overload + @staticmethod + def copy( + object: typing.Any, + int: int, + memorySegment: MemorySegment, + valueLayout: ValueLayout, + long: int, + int2: int, + ) -> None: ... + @typing.overload + @staticmethod + def copy( + memorySegment: MemorySegment, + valueLayout: ValueLayout, + long: int, + object: typing.Any, + int: int, + int2: int, + ) -> None: ... + @typing.overload + @staticmethod + def copy( + memorySegment: MemorySegment, + valueLayout: ValueLayout, + long: int, + memorySegment2: MemorySegment, + valueLayout2: ValueLayout, + long2: int, + long3: int, + ) -> None: ... + @typing.overload + @staticmethod + def copy( + memorySegment: MemorySegment, + long: int, + memorySegment2: MemorySegment, + long2: int, + long3: int, + ) -> None: ... + def copyFrom(self, memorySegment: MemorySegment) -> MemorySegment: ... + def elements( + self, memoryLayout: MemoryLayout + ) -> java.util.stream.Stream[MemorySegment]: ... + def equals(self, object: typing.Any) -> bool: ... + def fill(self, byte: int) -> MemorySegment: ... + def force(self) -> None: ... + @typing.overload + def get(self, ofBoolean: ValueLayout.OfBoolean, long: int) -> bool: ... + @typing.overload + def get(self, ofByte: ValueLayout.OfByte, long: int) -> int: ... + @typing.overload + def get(self, ofChar: ValueLayout.OfChar, long: int) -> str: ... + @typing.overload + def get(self, ofDouble: ValueLayout.OfDouble, long: int) -> float: ... + @typing.overload + def get(self, ofFloat: ValueLayout.OfFloat, long: int) -> float: ... + @typing.overload + def get(self, ofInt: ValueLayout.OfInt, long: int) -> int: ... + @typing.overload + def get(self, addressLayout: AddressLayout, long: int) -> MemorySegment: ... + @typing.overload + def get(self, ofLong: ValueLayout.OfLong, long: int) -> int: ... + @typing.overload + def get(self, ofShort: ValueLayout.OfShort, long: int) -> int: ... + @typing.overload + def getAtIndex(self, ofBoolean: ValueLayout.OfBoolean, long: int) -> bool: ... + @typing.overload + def getAtIndex(self, ofByte: ValueLayout.OfByte, long: int) -> int: ... + @typing.overload + def getAtIndex(self, ofChar: ValueLayout.OfChar, long: int) -> str: ... + @typing.overload + def getAtIndex(self, ofDouble: ValueLayout.OfDouble, long: int) -> float: ... + @typing.overload + def getAtIndex(self, ofFloat: ValueLayout.OfFloat, long: int) -> float: ... + @typing.overload + def getAtIndex(self, ofInt: ValueLayout.OfInt, long: int) -> int: ... + @typing.overload + def getAtIndex(self, addressLayout: AddressLayout, long: int) -> MemorySegment: ... + @typing.overload + def getAtIndex(self, ofLong: ValueLayout.OfLong, long: int) -> int: ... + @typing.overload + def getAtIndex(self, ofShort: ValueLayout.OfShort, long: int) -> int: ... + @typing.overload + def getString(self, long: int) -> java.lang.String: ... + @typing.overload + def getString( + self, long: int, charset: java.nio.charset.Charset + ) -> java.lang.String: ... + def hashCode(self) -> int: ... + def heapBase(self) -> java.util.Optional[typing.Any]: ... + def isAccessibleBy(self, thread: java.lang.Thread) -> bool: ... + def isLoaded(self) -> bool: ... + def isMapped(self) -> bool: ... + def isNative(self) -> bool: ... + def isReadOnly(self) -> bool: ... + def load(self) -> None: ... + def maxByteAlignment(self) -> int: ... + @typing.overload + def mismatch(self, memorySegment: MemorySegment) -> int: ... + @typing.overload + @staticmethod + def mismatch( + memorySegment: MemorySegment, + long: int, + long2: int, + memorySegment2: MemorySegment, + long3: int, + long4: int, + ) -> int: ... + @staticmethod + def ofAddress(long: int) -> MemorySegment: ... + @typing.overload + @staticmethod + def ofArray(byteArray: list[int] | jpype.JArray | bytes) -> MemorySegment: ... + @typing.overload + @staticmethod + def ofArray(charArray: list[str] | jpype.JArray) -> MemorySegment: ... + @typing.overload + @staticmethod + def ofArray(doubleArray: list[float] | jpype.JArray) -> MemorySegment: ... + @typing.overload + @staticmethod + def ofArray(floatArray: list[float] | jpype.JArray) -> MemorySegment: ... + @typing.overload + @staticmethod + def ofArray(intArray: list[int] | jpype.JArray) -> MemorySegment: ... + @typing.overload + @staticmethod + def ofArray(longArray: list[int] | jpype.JArray) -> MemorySegment: ... + @typing.overload + @staticmethod + def ofArray(shortArray: list[int] | jpype.JArray) -> MemorySegment: ... + @staticmethod + def ofBuffer(buffer: java.nio.Buffer) -> MemorySegment: ... + @typing.overload + def reinterpret( + self, + arena: Arena, + consumer: java.util.function.Consumer[MemorySegment] + | typing.Callable[[MemorySegment], None], + ) -> MemorySegment: ... + @typing.overload + def reinterpret(self, long: int) -> MemorySegment: ... + @typing.overload + def reinterpret( + self, + long: int, + arena: Arena, + consumer: java.util.function.Consumer[MemorySegment] + | typing.Callable[[MemorySegment], None], + ) -> MemorySegment: ... + def scope(self) -> MemorySegment.Scope: ... + @typing.overload + def set( + self, addressLayout: AddressLayout, long: int, memorySegment: MemorySegment + ) -> None: ... + @typing.overload + def set( + self, ofBoolean: ValueLayout.OfBoolean, long: int, boolean: bool + ) -> None: ... + @typing.overload + def set(self, ofByte: ValueLayout.OfByte, long: int, byte: int) -> None: ... + @typing.overload + def set(self, ofChar: ValueLayout.OfChar, long: int, char: str) -> None: ... + @typing.overload + def set(self, ofDouble: ValueLayout.OfDouble, long: int, double: float) -> None: ... + @typing.overload + def set(self, ofFloat: ValueLayout.OfFloat, long: int, float: float) -> None: ... + @typing.overload + def set(self, ofInt: ValueLayout.OfInt, long: int, int: int) -> None: ... + @typing.overload + def set(self, ofLong: ValueLayout.OfLong, long: int, long2: int) -> None: ... + @typing.overload + def set(self, ofShort: ValueLayout.OfShort, long: int, short: int) -> None: ... + @typing.overload + def setAtIndex( + self, addressLayout: AddressLayout, long: int, memorySegment: MemorySegment + ) -> None: ... + @typing.overload + def setAtIndex( + self, ofBoolean: ValueLayout.OfBoolean, long: int, boolean: bool + ) -> None: ... + @typing.overload + def setAtIndex(self, ofByte: ValueLayout.OfByte, long: int, byte: int) -> None: ... + @typing.overload + def setAtIndex(self, ofChar: ValueLayout.OfChar, long: int, char: str) -> None: ... + @typing.overload + def setAtIndex( + self, ofDouble: ValueLayout.OfDouble, long: int, double: float + ) -> None: ... + @typing.overload + def setAtIndex( + self, ofFloat: ValueLayout.OfFloat, long: int, float: float + ) -> None: ... + @typing.overload + def setAtIndex(self, ofInt: ValueLayout.OfInt, long: int, int: int) -> None: ... + @typing.overload + def setAtIndex(self, ofLong: ValueLayout.OfLong, long: int, long2: int) -> None: ... + @typing.overload + def setAtIndex( + self, ofShort: ValueLayout.OfShort, long: int, short: int + ) -> None: ... + @typing.overload + def setString(self, long: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setString( + self, + long: int, + string: java.lang.String | str, + charset: java.nio.charset.Charset, + ) -> None: ... + def spliterator( + self, memoryLayout: MemoryLayout + ) -> java.util.Spliterator[MemorySegment]: ... + @typing.overload + def toArray(self, ofByte: ValueLayout.OfByte) -> typing.MutableSequence[int]: ... + @typing.overload + def toArray(self, ofChar: ValueLayout.OfChar) -> typing.MutableSequence[str]: ... + @typing.overload + def toArray( + self, ofDouble: ValueLayout.OfDouble + ) -> typing.MutableSequence[float]: ... + @typing.overload + def toArray( + self, ofFloat: ValueLayout.OfFloat + ) -> typing.MutableSequence[float]: ... + @typing.overload + def toArray(self, ofInt: ValueLayout.OfInt) -> typing.MutableSequence[int]: ... + @typing.overload + def toArray(self, ofLong: ValueLayout.OfLong) -> typing.MutableSequence[int]: ... + @typing.overload + def toArray(self, ofShort: ValueLayout.OfShort) -> typing.MutableSequence[int]: ... + def unload(self) -> None: ... + class Scope: + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def isAlive(self) -> bool: ... + +class SegmentAllocator: + @typing.overload + def allocate(self, long: int, long2: int) -> MemorySegment: ... + @typing.overload + def allocate(self, memoryLayout: MemoryLayout) -> MemorySegment: ... + @typing.overload + def allocate(self, memoryLayout: MemoryLayout, long: int) -> MemorySegment: ... + @typing.overload + def allocate(self, long: int) -> MemorySegment: ... + @typing.overload + def allocateFrom(self, string: java.lang.String | str) -> MemorySegment: ... + @typing.overload + def allocateFrom( + self, string: java.lang.String | str, charset: java.nio.charset.Charset + ) -> MemorySegment: ... + @typing.overload + def allocateFrom( + self, addressLayout: AddressLayout, memorySegment: MemorySegment + ) -> MemorySegment: ... + @typing.overload + def allocateFrom(self, ofByte: ValueLayout.OfByte, byte: int) -> MemorySegment: ... + @typing.overload + def allocateFrom(self, ofByte: ValueLayout.OfByte, *byte: int) -> MemorySegment: ... + @typing.overload + def allocateFrom(self, ofChar: ValueLayout.OfChar, char: str) -> MemorySegment: ... + @typing.overload + def allocateFrom(self, ofChar: ValueLayout.OfChar, *char: str) -> MemorySegment: ... + @typing.overload + def allocateFrom( + self, ofDouble: ValueLayout.OfDouble, double: float + ) -> MemorySegment: ... + @typing.overload + def allocateFrom( + self, ofDouble: ValueLayout.OfDouble, *double: float + ) -> MemorySegment: ... + @typing.overload + def allocateFrom( + self, ofFloat: ValueLayout.OfFloat, float: float + ) -> MemorySegment: ... + @typing.overload + def allocateFrom( + self, ofFloat: ValueLayout.OfFloat, *float: float + ) -> MemorySegment: ... + @typing.overload + def allocateFrom(self, ofInt: ValueLayout.OfInt, int: int) -> MemorySegment: ... + @typing.overload + def allocateFrom(self, ofInt: ValueLayout.OfInt, *int: int) -> MemorySegment: ... + @typing.overload + def allocateFrom(self, ofLong: ValueLayout.OfLong, long: int) -> MemorySegment: ... + @typing.overload + def allocateFrom(self, ofLong: ValueLayout.OfLong, *long: int) -> MemorySegment: ... + @typing.overload + def allocateFrom( + self, ofShort: ValueLayout.OfShort, short: int + ) -> MemorySegment: ... + @typing.overload + def allocateFrom( + self, ofShort: ValueLayout.OfShort, *short: int + ) -> MemorySegment: ... + @typing.overload + def allocateFrom( + self, + valueLayout: ValueLayout, + memorySegment: MemorySegment, + valueLayout2: ValueLayout, + long: int, + long2: int, + ) -> MemorySegment: ... + @staticmethod + def prefixAllocator(memorySegment: MemorySegment) -> SegmentAllocator: ... + @staticmethod + def slicingAllocator(memorySegment: MemorySegment) -> SegmentAllocator: ... + +class SymbolLookup: + def find( + self, string: java.lang.String | str + ) -> java.util.Optional[MemorySegment]: ... + def findOrThrow(self, string: java.lang.String | str) -> MemorySegment: ... + @typing.overload + @staticmethod + def libraryLookup(string: java.lang.String | str, arena: Arena) -> SymbolLookup: ... + @typing.overload + @staticmethod + def libraryLookup( + path: java.nio.file.Path | jpype.protocol.SupportsPath, arena: Arena + ) -> SymbolLookup: ... + @staticmethod + def loaderLookup() -> SymbolLookup: ... + def or_(self, symbolLookup: SymbolLookup | typing.Callable) -> SymbolLookup: ... + +class Arena(SegmentAllocator, java.lang.AutoCloseable): + @typing.overload + def allocate(self, long: int, long2: int) -> MemorySegment: ... + @typing.overload + def allocate(self, memoryLayout: MemoryLayout) -> MemorySegment: ... + @typing.overload + def allocate(self, memoryLayout: MemoryLayout, long: int) -> MemorySegment: ... + @typing.overload + def allocate(self, long: int) -> MemorySegment: ... + def close(self) -> None: ... + @staticmethod + def global_() -> Arena: ... + @staticmethod + def ofAuto() -> Arena: ... + @staticmethod + def ofConfined() -> Arena: ... + @staticmethod + def ofShared() -> Arena: ... + def scope(self) -> MemorySegment.Scope: ... + +class GroupLayout(MemoryLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def memberLayouts(self) -> java.util.List[MemoryLayout]: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> GroupLayout: ... + def withName(self, string: java.lang.String | str) -> GroupLayout: ... + def withoutName(self) -> GroupLayout: ... + +class PaddingLayout(MemoryLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> PaddingLayout: ... + def withName(self, string: java.lang.String | str) -> PaddingLayout: ... + def withoutName(self) -> PaddingLayout: ... + +class SequenceLayout(MemoryLayout): + def elementCount(self) -> int: ... + def elementLayout(self) -> MemoryLayout: ... + def equals(self, object: typing.Any) -> bool: ... + def flatten(self) -> SequenceLayout: ... + def hashCode(self) -> int: ... + def reshape(self, *long: int) -> SequenceLayout: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> SequenceLayout: ... + def withElementCount(self, long: int) -> SequenceLayout: ... + def withName(self, string: java.lang.String | str) -> SequenceLayout: ... + def withoutName(self) -> MemoryLayout: ... + +class StructLayout(GroupLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> StructLayout: ... + def withName(self, string: java.lang.String | str) -> StructLayout: ... + def withoutName(self) -> StructLayout: ... + +class UnionLayout(GroupLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> UnionLayout: ... + def withName(self, string: java.lang.String | str) -> UnionLayout: ... + def withoutName(self) -> UnionLayout: ... + +class AddressLayout(java.lang.foreign.ValueLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def targetLayout(self) -> java.util.Optional[MemoryLayout]: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> AddressLayout: ... + def withName(self, string: java.lang.String | str) -> AddressLayout: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> AddressLayout: ... + def withTargetLayout(self, memoryLayout: MemoryLayout) -> AddressLayout: ... + def withoutName(self) -> AddressLayout: ... + def withoutTargetLayout(self) -> AddressLayout: ... + +class ValueLayout(MemoryLayout): + ADDRESS: typing.ClassVar[AddressLayout] = ... + JAVA_BYTE: typing.ClassVar[ValueLayout.OfByte] = ... + JAVA_BOOLEAN: typing.ClassVar[ValueLayout.OfBoolean] = ... + JAVA_CHAR: typing.ClassVar[ValueLayout.OfChar] = ... + JAVA_SHORT: typing.ClassVar[ValueLayout.OfShort] = ... + JAVA_INT: typing.ClassVar[ValueLayout.OfInt] = ... + JAVA_LONG: typing.ClassVar[ValueLayout.OfLong] = ... + JAVA_FLOAT: typing.ClassVar[ValueLayout.OfFloat] = ... + JAVA_DOUBLE: typing.ClassVar[ValueLayout.OfDouble] = ... + ADDRESS_UNALIGNED: typing.ClassVar[AddressLayout] = ... + JAVA_CHAR_UNALIGNED: typing.ClassVar[ValueLayout.OfChar] = ... + JAVA_SHORT_UNALIGNED: typing.ClassVar[ValueLayout.OfShort] = ... + JAVA_INT_UNALIGNED: typing.ClassVar[ValueLayout.OfInt] = ... + JAVA_LONG_UNALIGNED: typing.ClassVar[ValueLayout.OfLong] = ... + JAVA_FLOAT_UNALIGNED: typing.ClassVar[ValueLayout.OfFloat] = ... + JAVA_DOUBLE_UNALIGNED: typing.ClassVar[ValueLayout.OfDouble] = ... + def carrier(self) -> type[typing.Any]: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def order(self) -> java.nio.ByteOrder: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def varHandle( + self, *pathElement: MemoryLayout.PathElement + ) -> java.lang.invoke.VarHandle: ... + @typing.overload + def varHandle(self) -> java.lang.invoke.VarHandle: ... + def withByteAlignment(self, long: int) -> ValueLayout: ... + def withName(self, string: java.lang.String | str) -> ValueLayout: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> ValueLayout: ... + def withoutName(self) -> ValueLayout: ... + class OfBoolean(java.lang.foreign.ValueLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> ValueLayout.OfBoolean: ... + def withName(self, string: java.lang.String | str) -> ValueLayout.OfBoolean: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> ValueLayout.OfBoolean: ... + def withoutName(self) -> ValueLayout.OfBoolean: ... + + class OfByte(java.lang.foreign.ValueLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> ValueLayout.OfByte: ... + def withName(self, string: java.lang.String | str) -> ValueLayout.OfByte: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> ValueLayout.OfByte: ... + def withoutName(self) -> ValueLayout.OfByte: ... + + class OfChar(java.lang.foreign.ValueLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> ValueLayout.OfChar: ... + def withName(self, string: java.lang.String | str) -> ValueLayout.OfChar: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> ValueLayout.OfChar: ... + def withoutName(self) -> ValueLayout.OfChar: ... + + class OfDouble(java.lang.foreign.ValueLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> ValueLayout.OfDouble: ... + def withName(self, string: java.lang.String | str) -> ValueLayout.OfDouble: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> ValueLayout.OfDouble: ... + def withoutName(self) -> ValueLayout.OfDouble: ... + + class OfFloat(java.lang.foreign.ValueLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> ValueLayout.OfFloat: ... + def withName(self, string: java.lang.String | str) -> ValueLayout.OfFloat: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> ValueLayout.OfFloat: ... + def withoutName(self) -> ValueLayout.OfFloat: ... + + class OfInt(java.lang.foreign.ValueLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> ValueLayout.OfInt: ... + def withName(self, string: java.lang.String | str) -> ValueLayout.OfInt: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> ValueLayout.OfInt: ... + def withoutName(self) -> ValueLayout.OfInt: ... + + class OfLong(java.lang.foreign.ValueLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> ValueLayout.OfLong: ... + def withName(self, string: java.lang.String | str) -> ValueLayout.OfLong: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> ValueLayout.OfLong: ... + def withoutName(self) -> ValueLayout.OfLong: ... + + class OfShort(java.lang.foreign.ValueLayout): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def withByteAlignment(self, long: int) -> ValueLayout.OfShort: ... + def withName(self, string: java.lang.String | str) -> ValueLayout.OfShort: ... + def withOrder(self, byteOrder: java.nio.ByteOrder) -> ValueLayout.OfShort: ... + def withoutName(self) -> ValueLayout.OfShort: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.foreign")``. + + AddressLayout: type[AddressLayout] + Arena: type[Arena] + FunctionDescriptor: type[FunctionDescriptor] + GroupLayout: type[GroupLayout] + Linker: type[Linker] + MemoryLayout: type[MemoryLayout] + MemorySegment: type[MemorySegment] + PaddingLayout: type[PaddingLayout] + SegmentAllocator: type[SegmentAllocator] + SequenceLayout: type[SequenceLayout] + StructLayout: type[StructLayout] + SymbolLookup: type[SymbolLookup] + UnionLayout: type[UnionLayout] + ValueLayout: type[ValueLayout] diff --git a/typings/java/lang/instrument/__init__.pyi b/typings/java/lang/instrument/__init__.pyi new file mode 100644 index 0000000..af367e8 --- /dev/null +++ b/typings/java/lang/instrument/__init__.pyi @@ -0,0 +1,106 @@ +import typing +from typing import Protocol + +import java.lang +import java.security +import java.util +import java.util.jar +import jpype + +class ClassDefinition: + def __init__( + self, class_: type[typing.Any], byteArray: list[int] | jpype.JArray | bytes + ): ... + def getDefinitionClass(self) -> type[typing.Any]: ... + def getDefinitionClassFile(self) -> typing.MutableSequence[int]: ... + +class ClassFileTransformer: + @typing.overload + def transform( + self, + classLoader: java.lang.ClassLoader, + string: java.lang.String | str, + class2: type[typing.Any], + protectionDomain: java.security.ProtectionDomain, + byteArray: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def transform( + self, + module: java.lang.Module, + classLoader: java.lang.ClassLoader, + string: java.lang.String | str, + class2: type[typing.Any], + protectionDomain: java.security.ProtectionDomain, + byteArray: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[int]: ... + +class IllegalClassFormatException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Instrumentation: + @typing.overload + def addTransformer(self, classFileTransformer: ClassFileTransformer) -> None: ... + @typing.overload + def addTransformer( + self, classFileTransformer: ClassFileTransformer, boolean: bool + ) -> None: ... + def appendToBootstrapClassLoaderSearch( + self, jarFile: java.util.jar.JarFile + ) -> None: ... + def appendToSystemClassLoaderSearch( + self, jarFile: java.util.jar.JarFile + ) -> None: ... + def getAllLoadedClasses(self) -> typing.MutableSequence[type]: ... + def getInitiatedClasses( + self, classLoader: java.lang.ClassLoader + ) -> typing.MutableSequence[type]: ... + def getObjectSize(self, object: typing.Any) -> int: ... + def isModifiableClass(self, class_: type[typing.Any]) -> bool: ... + def isModifiableModule(self, module: java.lang.Module) -> bool: ... + def isNativeMethodPrefixSupported(self) -> bool: ... + def isRedefineClassesSupported(self) -> bool: ... + def isRetransformClassesSupported(self) -> bool: ... + def redefineClasses(self, *classDefinition: ClassDefinition) -> None: ... + def redefineModule( + self, + module: java.lang.Module, + set: java.util.Set[java.lang.Module], + map: java.util.Map[java.lang.String | str, java.util.Set[java.lang.Module]] + | typing.Mapping[java.lang.String | str, java.util.Set[java.lang.Module]], + map2: java.util.Map[java.lang.String | str, java.util.Set[java.lang.Module]] + | typing.Mapping[java.lang.String | str, java.util.Set[java.lang.Module]], + set2: java.util.Set[type[typing.Any]], + map3: java.util.Map[type[typing.Any], java.util.List[type[typing.Any]]] + | typing.Mapping[type[typing.Any], java.util.List[type[typing.Any]]], + ) -> None: ... + def removeTransformer(self, classFileTransformer: ClassFileTransformer) -> bool: ... + def retransformClasses(self, *class_: type[typing.Any]) -> None: ... + def setNativeMethodPrefix( + self, classFileTransformer: ClassFileTransformer, string: java.lang.String | str + ) -> None: ... + +class UnmodifiableClassException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class UnmodifiableModuleException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.instrument")``. + + ClassDefinition: type[ClassDefinition] + ClassFileTransformer: type[ClassFileTransformer] + IllegalClassFormatException: type[IllegalClassFormatException] + Instrumentation: type[Instrumentation] + UnmodifiableClassException: type[UnmodifiableClassException] + UnmodifiableModuleException: type[UnmodifiableModuleException] diff --git a/typings/java/lang/invoke/__init__.pyi b/typings/java/lang/invoke/__init__.pyi new file mode 100644 index 0000000..65dc146 --- /dev/null +++ b/typings/java/lang/invoke/__init__.pyi @@ -0,0 +1,874 @@ +import builtins +import typing +from typing import Protocol + +import java +import java.io +import java.lang +import java.lang.constant +import java.lang.reflect +import java.nio +import java.util +import jpype + +class CallSite: + def dynamicInvoker(self) -> MethodHandle: ... + def getTarget(self) -> MethodHandle: ... + def setTarget(self, methodHandle: MethodHandle) -> None: ... + def type(self) -> MethodType: ... + +class ConstantBootstraps: + @staticmethod + def arrayVarHandle( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[VarHandle], + class2: type[typing.Any], + ) -> VarHandle: ... + _enumConstant__E = typing.TypeVar("_enumConstant__E", bound=java.lang.Enum) # + @staticmethod + def enumConstant( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[_enumConstant__E], + ) -> _enumConstant__E: ... + @staticmethod + def explicitCast( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[typing.Any], + object: typing.Any, + ) -> typing.Any: ... + @staticmethod + def fieldVarHandle( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[VarHandle], + class2: type[typing.Any], + class3: type[typing.Any], + ) -> VarHandle: ... + @typing.overload + @staticmethod + def getStaticFinal( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[typing.Any], + ) -> typing.Any: ... + @typing.overload + @staticmethod + def getStaticFinal( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[typing.Any], + class2: type[typing.Any], + ) -> typing.Any: ... + @staticmethod + def invoke( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[typing.Any], + methodHandle: MethodHandle, + *object: typing.Any, + ) -> typing.Any: ... + @staticmethod + def nullConstant( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[typing.Any], + ) -> typing.Any: ... + @staticmethod + def primitiveClass( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[typing.Any], + ) -> type[typing.Any]: ... + @staticmethod + def staticFieldVarHandle( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[VarHandle], + class2: type[typing.Any], + class3: type[typing.Any], + ) -> VarHandle: ... + +class LambdaConversionException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + throwable: java.lang.Throwable, + boolean: bool, + boolean2: bool, + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class LambdaMetafactory: + FLAG_SERIALIZABLE: typing.ClassVar[int] = ... + FLAG_MARKERS: typing.ClassVar[int] = ... + FLAG_BRIDGES: typing.ClassVar[int] = ... + @staticmethod + def altMetafactory( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + methodType: MethodType, + *object: typing.Any, + ) -> CallSite: ... + @staticmethod + def metafactory( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + methodType: MethodType, + methodType2: MethodType, + methodHandle: MethodHandle, + methodType3: MethodType, + ) -> CallSite: ... + +class MethodHandle(java.lang.constant.Constable): + @typing.overload + def asCollector( + self, int: int, class_: builtins.type[typing.Any], int2: int + ) -> MethodHandle: ... + @typing.overload + def asCollector( + self, class_: builtins.type[typing.Any], int: int + ) -> MethodHandle: ... + def asFixedArity(self) -> MethodHandle: ... + @typing.overload + def asSpreader( + self, int: int, class_: builtins.type[typing.Any], int2: int + ) -> MethodHandle: ... + @typing.overload + def asSpreader( + self, class_: builtins.type[typing.Any], int: int + ) -> MethodHandle: ... + def asType(self, methodType: MethodType) -> MethodHandle: ... + def asVarargsCollector(self, class_: builtins.type[typing.Any]) -> MethodHandle: ... + def bindTo(self, object: typing.Any) -> MethodHandle: ... + def describeConstable( + self, + ) -> java.util.Optional[java.lang.constant.MethodHandleDesc]: ... + def invoke(self, *object: typing.Any) -> typing.Any: ... + def invokeExact(self, *object: typing.Any) -> typing.Any: ... + @typing.overload + def invokeWithArguments(self, *object: typing.Any) -> typing.Any: ... + @typing.overload + def invokeWithArguments(self, list: java.util.List[typing.Any]) -> typing.Any: ... + def isVarargsCollector(self) -> bool: ... + def toString(self) -> java.lang.String: ... + def type(self) -> MethodType: ... + def withVarargs(self, boolean: bool) -> MethodHandle: ... + +class MethodHandleInfo: + REF_getField: typing.ClassVar[int] = ... + REF_getStatic: typing.ClassVar[int] = ... + REF_putField: typing.ClassVar[int] = ... + REF_putStatic: typing.ClassVar[int] = ... + REF_invokeVirtual: typing.ClassVar[int] = ... + REF_invokeStatic: typing.ClassVar[int] = ... + REF_invokeSpecial: typing.ClassVar[int] = ... + REF_newInvokeSpecial: typing.ClassVar[int] = ... + REF_invokeInterface: typing.ClassVar[int] = ... + def getDeclaringClass(self) -> type[typing.Any]: ... + def getMethodType(self) -> MethodType: ... + def getModifiers(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getReferenceKind(self) -> int: ... + def isVarArgs(self) -> bool: ... + @staticmethod + def referenceKindToString(int: int) -> java.lang.String: ... + _reflectAs__T = typing.TypeVar( + "_reflectAs__T", bound=java.lang.reflect.Member + ) # + def reflectAs( + self, class_: type[_reflectAs__T], lookup: MethodHandles.Lookup + ) -> _reflectAs__T: ... + @staticmethod + def toString( + int: int, + class_: type[typing.Any], + string: java.lang.String | str, + methodType: MethodType, + ) -> java.lang.String: ... + +class MethodHandleProxies: + _asInterfaceInstance__T = typing.TypeVar("_asInterfaceInstance__T") # + @staticmethod + def asInterfaceInstance( + class_: type[_asInterfaceInstance__T], methodHandle: MethodHandle + ) -> _asInterfaceInstance__T: ... + @staticmethod + def isWrapperInstance(object: typing.Any) -> bool: ... + @staticmethod + def wrapperInstanceTarget(object: typing.Any) -> MethodHandle: ... + @staticmethod + def wrapperInstanceType(object: typing.Any) -> type[typing.Any]: ... + +class MethodHandles: + @staticmethod + def arrayConstructor(class_: type[typing.Any]) -> MethodHandle: ... + @staticmethod + def arrayElementGetter(class_: type[typing.Any]) -> MethodHandle: ... + @staticmethod + def arrayElementSetter(class_: type[typing.Any]) -> MethodHandle: ... + @staticmethod + def arrayElementVarHandle(class_: type[typing.Any]) -> VarHandle: ... + @staticmethod + def arrayLength(class_: type[typing.Any]) -> MethodHandle: ... + @staticmethod + def byteArrayViewVarHandle( + class_: type[typing.Any], byteOrder: java.nio.ByteOrder + ) -> VarHandle: ... + @staticmethod + def byteBufferViewVarHandle( + class_: type[typing.Any], byteOrder: java.nio.ByteOrder + ) -> VarHandle: ... + @staticmethod + def catchException( + methodHandle: MethodHandle, + class_: type[java.lang.Throwable], + methodHandle2: MethodHandle, + ) -> MethodHandle: ... + _classData__T = typing.TypeVar("_classData__T") # + @staticmethod + def classData( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[_classData__T], + ) -> _classData__T: ... + _classDataAt__T = typing.TypeVar("_classDataAt__T") # + @staticmethod + def classDataAt( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + class_: type[_classDataAt__T], + int: int, + ) -> _classDataAt__T: ... + @staticmethod + def collectArguments( + methodHandle: MethodHandle, int: int, methodHandle2: MethodHandle + ) -> MethodHandle: ... + @staticmethod + def collectCoordinates( + varHandle: VarHandle, int: int, methodHandle: MethodHandle + ) -> VarHandle: ... + @staticmethod + def constant(class_: type[typing.Any], object: typing.Any) -> MethodHandle: ... + @typing.overload + @staticmethod + def countedLoop( + methodHandle: MethodHandle, + methodHandle2: MethodHandle, + methodHandle3: MethodHandle, + ) -> MethodHandle: ... + @typing.overload + @staticmethod + def countedLoop( + methodHandle: MethodHandle, + methodHandle2: MethodHandle, + methodHandle3: MethodHandle, + methodHandle4: MethodHandle, + ) -> MethodHandle: ... + @staticmethod + def doWhileLoop( + methodHandle: MethodHandle, + methodHandle2: MethodHandle, + methodHandle3: MethodHandle, + ) -> MethodHandle: ... + @typing.overload + @staticmethod + def dropArguments( + methodHandle: MethodHandle, int: int, *class_: type[typing.Any] + ) -> MethodHandle: ... + @typing.overload + @staticmethod + def dropArguments( + methodHandle: MethodHandle, int: int, list: java.util.List[type[typing.Any]] + ) -> MethodHandle: ... + @staticmethod + def dropArgumentsToMatch( + methodHandle: MethodHandle, + int: int, + list: java.util.List[type[typing.Any]], + int2: int, + ) -> MethodHandle: ... + @staticmethod + def dropCoordinates( + varHandle: VarHandle, int: int, *class_: type[typing.Any] + ) -> VarHandle: ... + @staticmethod + def dropReturn(methodHandle: MethodHandle) -> MethodHandle: ... + @staticmethod + def empty(methodType: MethodType) -> MethodHandle: ... + @staticmethod + def exactInvoker(methodType: MethodType) -> MethodHandle: ... + @staticmethod + def explicitCastArguments( + methodHandle: MethodHandle, methodType: MethodType + ) -> MethodHandle: ... + @staticmethod + def filterArguments( + methodHandle: MethodHandle, int: int, *methodHandle2: MethodHandle + ) -> MethodHandle: ... + @staticmethod + def filterCoordinates( + varHandle: VarHandle, int: int, *methodHandle: MethodHandle + ) -> VarHandle: ... + @staticmethod + def filterReturnValue( + methodHandle: MethodHandle, methodHandle2: MethodHandle + ) -> MethodHandle: ... + @staticmethod + def filterValue( + varHandle: VarHandle, methodHandle: MethodHandle, methodHandle2: MethodHandle + ) -> VarHandle: ... + @typing.overload + @staticmethod + def foldArguments( + methodHandle: MethodHandle, int: int, methodHandle2: MethodHandle + ) -> MethodHandle: ... + @typing.overload + @staticmethod + def foldArguments( + methodHandle: MethodHandle, methodHandle2: MethodHandle + ) -> MethodHandle: ... + @staticmethod + def guardWithTest( + methodHandle: MethodHandle, + methodHandle2: MethodHandle, + methodHandle3: MethodHandle, + ) -> MethodHandle: ... + @staticmethod + def identity(class_: type[typing.Any]) -> MethodHandle: ... + @staticmethod + def insertArguments( + methodHandle: MethodHandle, int: int, *object: typing.Any + ) -> MethodHandle: ... + @staticmethod + def insertCoordinates( + varHandle: VarHandle, int: int, *object: typing.Any + ) -> VarHandle: ... + @staticmethod + def invoker(methodType: MethodType) -> MethodHandle: ... + @staticmethod + def iteratedLoop( + methodHandle: MethodHandle, + methodHandle2: MethodHandle, + methodHandle3: MethodHandle, + ) -> MethodHandle: ... + @staticmethod + def lookup() -> MethodHandles.Lookup: ... + @staticmethod + def loop(*methodHandleArray: list[MethodHandle] | jpype.JArray) -> MethodHandle: ... + @staticmethod + def permuteArguments( + methodHandle: MethodHandle, methodType: MethodType, *int: int + ) -> MethodHandle: ... + @staticmethod + def permuteCoordinates( + varHandle: VarHandle, list: java.util.List[type[typing.Any]], *int: int + ) -> VarHandle: ... + @staticmethod + def privateLookupIn( + class_: type[typing.Any], lookup: MethodHandles.Lookup + ) -> MethodHandles.Lookup: ... + @staticmethod + def publicLookup() -> MethodHandles.Lookup: ... + _reflectAs__T = typing.TypeVar( + "_reflectAs__T", bound=java.lang.reflect.Member + ) # + @staticmethod + def reflectAs( + class_: type[_reflectAs__T], methodHandle: MethodHandle + ) -> _reflectAs__T: ... + @staticmethod + def spreadInvoker(methodType: MethodType, int: int) -> MethodHandle: ... + @staticmethod + def tableSwitch( + methodHandle: MethodHandle, *methodHandle2: MethodHandle + ) -> MethodHandle: ... + @staticmethod + def throwException( + class_: type[typing.Any], class2: type[java.lang.Throwable] + ) -> MethodHandle: ... + @staticmethod + def tryFinally( + methodHandle: MethodHandle, methodHandle2: MethodHandle + ) -> MethodHandle: ... + @staticmethod + def varHandleExactInvoker( + accessMode: VarHandle.AccessMode, methodType: MethodType + ) -> MethodHandle: ... + @staticmethod + def varHandleInvoker( + accessMode: VarHandle.AccessMode, methodType: MethodType + ) -> MethodHandle: ... + @staticmethod + def whileLoop( + methodHandle: MethodHandle, + methodHandle2: MethodHandle, + methodHandle3: MethodHandle, + ) -> MethodHandle: ... + @staticmethod + def zero(class_: type[typing.Any]) -> MethodHandle: ... + class Lookup: + PUBLIC: typing.ClassVar[int] = ... + PRIVATE: typing.ClassVar[int] = ... + PROTECTED: typing.ClassVar[int] = ... + PACKAGE: typing.ClassVar[int] = ... + MODULE: typing.ClassVar[int] = ... + UNCONDITIONAL: typing.ClassVar[int] = ... + ORIGINAL: typing.ClassVar[int] = ... + _accessClass__T = typing.TypeVar("_accessClass__T") # + def accessClass( + self, class_: type[_accessClass__T] + ) -> type[_accessClass__T]: ... + def bind( + self, + object: typing.Any, + string: java.lang.String | str, + methodType: MethodType, + ) -> MethodHandle: ... + def defineClass( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> type[typing.Any]: ... + def defineHiddenClass( + self, + byteArray: list[int] | jpype.JArray | bytes, + boolean: bool, + *classOption: MethodHandles.Lookup.ClassOption, + ) -> MethodHandles.Lookup: ... + def defineHiddenClassWithClassData( + self, + byteArray: list[int] | jpype.JArray | bytes, + object: typing.Any, + boolean: bool, + *classOption: MethodHandles.Lookup.ClassOption, + ) -> MethodHandles.Lookup: ... + def dropLookupMode(self, int: int) -> MethodHandles.Lookup: ... + _ensureInitialized__T = typing.TypeVar("_ensureInitialized__T") # + def ensureInitialized( + self, class_: type[_ensureInitialized__T] + ) -> type[_ensureInitialized__T]: ... + def findClass(self, string: java.lang.String | str) -> type[typing.Any]: ... + def findConstructor( + self, class_: type[typing.Any], methodType: MethodType + ) -> MethodHandle: ... + def findGetter( + self, + class_: type[typing.Any], + string: java.lang.String | str, + class2: type[typing.Any], + ) -> MethodHandle: ... + def findSetter( + self, + class_: type[typing.Any], + string: java.lang.String | str, + class2: type[typing.Any], + ) -> MethodHandle: ... + def findSpecial( + self, + class_: type[typing.Any], + string: java.lang.String | str, + methodType: MethodType, + class2: type[typing.Any], + ) -> MethodHandle: ... + def findStatic( + self, + class_: type[typing.Any], + string: java.lang.String | str, + methodType: MethodType, + ) -> MethodHandle: ... + def findStaticGetter( + self, + class_: type[typing.Any], + string: java.lang.String | str, + class2: type[typing.Any], + ) -> MethodHandle: ... + def findStaticSetter( + self, + class_: type[typing.Any], + string: java.lang.String | str, + class2: type[typing.Any], + ) -> MethodHandle: ... + def findStaticVarHandle( + self, + class_: type[typing.Any], + string: java.lang.String | str, + class2: type[typing.Any], + ) -> VarHandle: ... + def findVarHandle( + self, + class_: type[typing.Any], + string: java.lang.String | str, + class2: type[typing.Any], + ) -> VarHandle: ... + def findVirtual( + self, + class_: type[typing.Any], + string: java.lang.String | str, + methodType: MethodType, + ) -> MethodHandle: ... + def hasFullPrivilegeAccess(self) -> bool: ... + def hasPrivateAccess(self) -> bool: ... + def in_(self, class_: type[typing.Any]) -> MethodHandles.Lookup: ... + def lookupClass(self) -> type[typing.Any]: ... + def lookupModes(self) -> int: ... + def previousLookupClass(self) -> type[typing.Any]: ... + def revealDirect(self, methodHandle: MethodHandle) -> MethodHandleInfo: ... + def toString(self) -> java.lang.String: ... + def unreflect(self, method: java.lang.reflect.Method) -> MethodHandle: ... + def unreflectConstructor( + self, constructor: java.lang.reflect.Constructor[typing.Any] + ) -> MethodHandle: ... + def unreflectGetter(self, field: java.lang.reflect.Field) -> MethodHandle: ... + def unreflectSetter(self, field: java.lang.reflect.Field) -> MethodHandle: ... + def unreflectSpecial( + self, method: java.lang.reflect.Method, class_: type[typing.Any] + ) -> MethodHandle: ... + def unreflectVarHandle(self, field: java.lang.reflect.Field) -> VarHandle: ... + class ClassOption(java.lang.Enum["MethodHandles.Lookup.ClassOption"]): + NESTMATE: typing.ClassVar[MethodHandles.Lookup.ClassOption] = ... + STRONG: typing.ClassVar[MethodHandles.Lookup.ClassOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> MethodHandles.Lookup.ClassOption: ... + @staticmethod + def values() -> typing.MutableSequence[ + MethodHandles.Lookup.ClassOption + ]: ... + +class SerializedLambda(java.io.Serializable): + def __init__( + self, + class_: type[typing.Any], + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + int: int, + string4: java.lang.String | str, + string5: java.lang.String | str, + string6: java.lang.String | str, + string7: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ): ... + def getCapturedArg(self, int: int) -> typing.Any: ... + def getCapturedArgCount(self) -> int: ... + def getCapturingClass(self) -> java.lang.String: ... + def getFunctionalInterfaceClass(self) -> java.lang.String: ... + def getFunctionalInterfaceMethodName(self) -> java.lang.String: ... + def getFunctionalInterfaceMethodSignature(self) -> java.lang.String: ... + def getImplClass(self) -> java.lang.String: ... + def getImplMethodKind(self) -> int: ... + def getImplMethodName(self) -> java.lang.String: ... + def getImplMethodSignature(self) -> java.lang.String: ... + def getInstantiatedMethodType(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class StringConcatException(java.lang.Exception): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + +class StringConcatFactory: + @staticmethod + def makeConcat( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + methodType: MethodType, + ) -> CallSite: ... + @staticmethod + def makeConcatWithConstants( + lookup: MethodHandles.Lookup, + string: java.lang.String | str, + methodType: MethodType, + string2: java.lang.String | str, + *object: typing.Any, + ) -> CallSite: ... + +class SwitchPoint: + def __init__(self): ... + def guardWithTest( + self, methodHandle: MethodHandle, methodHandle2: MethodHandle + ) -> MethodHandle: ... + def hasBeenInvalidated(self) -> bool: ... + @staticmethod + def invalidateAll(switchPointArray: list[SwitchPoint] | jpype.JArray) -> None: ... + +class TypeDescriptor: + def descriptorString(self) -> java.lang.String: ... + +class VarHandle(java.lang.constant.Constable): + def accessModeType(self, accessMode: VarHandle.AccessMode) -> MethodType: ... + @staticmethod + def acquireFence() -> None: ... + def compareAndExchange(self, *object: typing.Any) -> typing.Any: ... + def compareAndExchangeAcquire(self, *object: typing.Any) -> typing.Any: ... + def compareAndExchangeRelease(self, *object: typing.Any) -> typing.Any: ... + def compareAndSet(self, *object: typing.Any) -> bool: ... + def coordinateTypes(self) -> java.util.List[type[typing.Any]]: ... + def describeConstable(self) -> java.util.Optional[VarHandle.VarHandleDesc]: ... + @staticmethod + def fullFence() -> None: ... + def get(self, *object: typing.Any) -> typing.Any: ... + def getAcquire(self, *object: typing.Any) -> typing.Any: ... + def getAndAdd(self, *object: typing.Any) -> typing.Any: ... + def getAndAddAcquire(self, *object: typing.Any) -> typing.Any: ... + def getAndAddRelease(self, *object: typing.Any) -> typing.Any: ... + def getAndBitwiseAnd(self, *object: typing.Any) -> typing.Any: ... + def getAndBitwiseAndAcquire(self, *object: typing.Any) -> typing.Any: ... + def getAndBitwiseAndRelease(self, *object: typing.Any) -> typing.Any: ... + def getAndBitwiseOr(self, *object: typing.Any) -> typing.Any: ... + def getAndBitwiseOrAcquire(self, *object: typing.Any) -> typing.Any: ... + def getAndBitwiseOrRelease(self, *object: typing.Any) -> typing.Any: ... + def getAndBitwiseXor(self, *object: typing.Any) -> typing.Any: ... + def getAndBitwiseXorAcquire(self, *object: typing.Any) -> typing.Any: ... + def getAndBitwiseXorRelease(self, *object: typing.Any) -> typing.Any: ... + def getAndSet(self, *object: typing.Any) -> typing.Any: ... + def getAndSetAcquire(self, *object: typing.Any) -> typing.Any: ... + def getAndSetRelease(self, *object: typing.Any) -> typing.Any: ... + def getOpaque(self, *object: typing.Any) -> typing.Any: ... + def getVolatile(self, *object: typing.Any) -> typing.Any: ... + def hasInvokeExactBehavior(self) -> bool: ... + def isAccessModeSupported(self, accessMode: VarHandle.AccessMode) -> bool: ... + @staticmethod + def loadLoadFence() -> None: ... + @staticmethod + def releaseFence() -> None: ... + def set(self, *object: typing.Any) -> None: ... + def setOpaque(self, *object: typing.Any) -> None: ... + def setRelease(self, *object: typing.Any) -> None: ... + def setVolatile(self, *object: typing.Any) -> None: ... + @staticmethod + def storeStoreFence() -> None: ... + def toMethodHandle(self, accessMode: VarHandle.AccessMode) -> MethodHandle: ... + def toString(self) -> java.lang.String: ... + def varType(self) -> type[typing.Any]: ... + def weakCompareAndSet(self, *object: typing.Any) -> bool: ... + def weakCompareAndSetAcquire(self, *object: typing.Any) -> bool: ... + def weakCompareAndSetPlain(self, *object: typing.Any) -> bool: ... + def weakCompareAndSetRelease(self, *object: typing.Any) -> bool: ... + def withInvokeBehavior(self) -> VarHandle: ... + def withInvokeExactBehavior(self) -> VarHandle: ... + class AccessMode(java.lang.Enum["VarHandle.AccessMode"]): + GET: typing.ClassVar[VarHandle.AccessMode] = ... + SET: typing.ClassVar[VarHandle.AccessMode] = ... + GET_VOLATILE: typing.ClassVar[VarHandle.AccessMode] = ... + SET_VOLATILE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_ACQUIRE: typing.ClassVar[VarHandle.AccessMode] = ... + SET_RELEASE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_OPAQUE: typing.ClassVar[VarHandle.AccessMode] = ... + SET_OPAQUE: typing.ClassVar[VarHandle.AccessMode] = ... + COMPARE_AND_SET: typing.ClassVar[VarHandle.AccessMode] = ... + COMPARE_AND_EXCHANGE: typing.ClassVar[VarHandle.AccessMode] = ... + COMPARE_AND_EXCHANGE_ACQUIRE: typing.ClassVar[VarHandle.AccessMode] = ... + COMPARE_AND_EXCHANGE_RELEASE: typing.ClassVar[VarHandle.AccessMode] = ... + WEAK_COMPARE_AND_SET_PLAIN: typing.ClassVar[VarHandle.AccessMode] = ... + WEAK_COMPARE_AND_SET: typing.ClassVar[VarHandle.AccessMode] = ... + WEAK_COMPARE_AND_SET_ACQUIRE: typing.ClassVar[VarHandle.AccessMode] = ... + WEAK_COMPARE_AND_SET_RELEASE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_SET: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_SET_ACQUIRE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_SET_RELEASE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_ADD: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_ADD_ACQUIRE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_ADD_RELEASE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_BITWISE_OR: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_BITWISE_OR_RELEASE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_BITWISE_OR_ACQUIRE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_BITWISE_AND: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_BITWISE_AND_RELEASE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_BITWISE_AND_ACQUIRE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_BITWISE_XOR: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_BITWISE_XOR_RELEASE: typing.ClassVar[VarHandle.AccessMode] = ... + GET_AND_BITWISE_XOR_ACQUIRE: typing.ClassVar[VarHandle.AccessMode] = ... + def methodName(self) -> java.lang.String: ... + @staticmethod + def valueFromMethodName( + string: java.lang.String | str, + ) -> VarHandle.AccessMode: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> VarHandle.AccessMode: ... + @staticmethod + def values() -> typing.MutableSequence[VarHandle.AccessMode]: ... + + class VarHandleDesc(java.lang.constant.DynamicConstantDesc["VarHandle"]): + @staticmethod + def ofArray( + classDesc: java.lang.constant.ClassDesc, + ) -> VarHandle.VarHandleDesc: ... + @staticmethod + def ofField( + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + classDesc2: java.lang.constant.ClassDesc, + ) -> VarHandle.VarHandleDesc: ... + @staticmethod + def ofStaticField( + classDesc: java.lang.constant.ClassDesc, + string: java.lang.String | str, + classDesc2: java.lang.constant.ClassDesc, + ) -> VarHandle.VarHandleDesc: ... + def resolveConstantDesc(self, lookup: MethodHandles.Lookup) -> VarHandle: ... + def toString(self) -> java.lang.String: ... + def varType(self) -> java.lang.constant.ClassDesc: ... + +class WrongMethodTypeException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class ConstantCallSite(CallSite): + def __init__(self, methodHandle: MethodHandle): ... + def dynamicInvoker(self) -> MethodHandle: ... + def getTarget(self) -> MethodHandle: ... + def setTarget(self, methodHandle: MethodHandle) -> None: ... + +class MutableCallSite(CallSite): + @typing.overload + def __init__(self, methodHandle: MethodHandle): ... + @typing.overload + def __init__(self, methodType: MethodType): ... + def dynamicInvoker(self) -> MethodHandle: ... + def getTarget(self) -> MethodHandle: ... + def setTarget(self, methodHandle: MethodHandle) -> None: ... + @staticmethod + def syncAll(mutableCallSiteArray: list[MutableCallSite] | jpype.JArray) -> None: ... + +class VolatileCallSite(CallSite): + @typing.overload + def __init__(self, methodHandle: MethodHandle): ... + @typing.overload + def __init__(self, methodType: MethodType): ... + def dynamicInvoker(self) -> MethodHandle: ... + def getTarget(self) -> MethodHandle: ... + def setTarget(self, methodHandle: MethodHandle) -> None: ... + +class MethodType( + java.lang.constant.Constable, + java.lang.invoke.TypeDescriptor.OfMethod[type[typing.Any], "MethodType"], + java.io.Serializable, +): + @typing.overload + def appendParameterTypes(self, *class_: type[typing.Any]) -> MethodType: ... + @typing.overload + def appendParameterTypes( + self, list: java.util.List[type[typing.Any]] + ) -> MethodType: ... + def changeParameterType(self, int: int, class_: type[typing.Any]) -> MethodType: ... + def changeReturnType(self, class_: type[typing.Any]) -> MethodType: ... + def describeConstable( + self, + ) -> java.util.Optional[java.lang.constant.MethodTypeDesc]: ... + def descriptorString(self) -> java.lang.String: ... + def dropParameterTypes(self, int: int, int2: int) -> MethodType: ... + def equals(self, object: typing.Any) -> bool: ... + def erase(self) -> MethodType: ... + @staticmethod + def fromMethodDescriptorString( + string: java.lang.String | str, classLoader: java.lang.ClassLoader + ) -> MethodType: ... + def generic(self) -> MethodType: ... + @typing.overload + @staticmethod + def genericMethodType(int: int) -> MethodType: ... + @typing.overload + @staticmethod + def genericMethodType(int: int, boolean: bool) -> MethodType: ... + def hasPrimitives(self) -> bool: ... + def hasWrappers(self) -> bool: ... + def hashCode(self) -> int: ... + @typing.overload + def insertParameterTypes( + self, int: int, *class_: type[typing.Any] + ) -> MethodType: ... + @typing.overload + def insertParameterTypes( + self, int: int, list: java.util.List[type[typing.Any]] + ) -> MethodType: ... + def lastParameterType(self) -> type[typing.Any]: ... + @typing.overload + @staticmethod + def methodType(class_: type[typing.Any]) -> MethodType: ... + @typing.overload + @staticmethod + def methodType( + class_: type[typing.Any], class2: type[typing.Any] + ) -> MethodType: ... + @typing.overload + @staticmethod + def methodType( + class_: type[typing.Any], class2: type[typing.Any], *class3: type[typing.Any] + ) -> MethodType: ... + @typing.overload + @staticmethod + def methodType( + class_: type[typing.Any], classArray: list[type[typing.Any]] | jpype.JArray + ) -> MethodType: ... + @typing.overload + @staticmethod + def methodType(class_: type[typing.Any], methodType: MethodType) -> MethodType: ... + @typing.overload + @staticmethod + def methodType( + class_: type[typing.Any], list: java.util.List[type[typing.Any]] + ) -> MethodType: ... + def parameterArray(self) -> typing.MutableSequence[type[typing.Any]]: ... + def parameterCount(self) -> int: ... + def parameterList(self) -> java.util.List[type[typing.Any]]: ... + def parameterType(self, int: int) -> type[typing.Any]: ... + def returnType(self) -> type[typing.Any]: ... + def toMethodDescriptorString(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def unwrap(self) -> MethodType: ... + def wrap(self) -> MethodType: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.invoke")``. + + CallSite: type[CallSite] + ConstantBootstraps: type[ConstantBootstraps] + ConstantCallSite: type[ConstantCallSite] + LambdaConversionException: type[LambdaConversionException] + LambdaMetafactory: type[LambdaMetafactory] + MethodHandle: type[MethodHandle] + MethodHandleInfo: type[MethodHandleInfo] + MethodHandleProxies: type[MethodHandleProxies] + MethodHandles: type[MethodHandles] + MethodType: type[MethodType] + MutableCallSite: type[MutableCallSite] + SerializedLambda: type[SerializedLambda] + StringConcatException: type[StringConcatException] + StringConcatFactory: type[StringConcatFactory] + SwitchPoint: type[SwitchPoint] + TypeDescriptor: type[TypeDescriptor] + VarHandle: type[VarHandle] + VolatileCallSite: type[VolatileCallSite] + WrongMethodTypeException: type[WrongMethodTypeException] diff --git a/typings/java/lang/management/__init__.pyi b/typings/java/lang/management/__init__.pyi new file mode 100644 index 0000000..be413c8 --- /dev/null +++ b/typings/java/lang/management/__init__.pyi @@ -0,0 +1,362 @@ +import typing +from typing import Protocol + +import java.lang +import java.security +import java.util +import javax.management +import javax.management.openmbean +import jpype + +class LockInfo: + def __init__(self, string: java.lang.String | str, int: int): ... + @staticmethod + def from_(compositeData: javax.management.openmbean.CompositeData) -> LockInfo: ... + def getClassName(self) -> java.lang.String: ... + def getIdentityHashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class ManagementFactory: + CLASS_LOADING_MXBEAN_NAME: typing.ClassVar[java.lang.String] = ... + COMPILATION_MXBEAN_NAME: typing.ClassVar[java.lang.String] = ... + MEMORY_MXBEAN_NAME: typing.ClassVar[java.lang.String] = ... + OPERATING_SYSTEM_MXBEAN_NAME: typing.ClassVar[java.lang.String] = ... + RUNTIME_MXBEAN_NAME: typing.ClassVar[java.lang.String] = ... + THREAD_MXBEAN_NAME: typing.ClassVar[java.lang.String] = ... + GARBAGE_COLLECTOR_MXBEAN_DOMAIN_TYPE: typing.ClassVar[java.lang.String] = ... + MEMORY_MANAGER_MXBEAN_DOMAIN_TYPE: typing.ClassVar[java.lang.String] = ... + MEMORY_POOL_MXBEAN_DOMAIN_TYPE: typing.ClassVar[java.lang.String] = ... + @staticmethod + def getClassLoadingMXBean() -> ClassLoadingMXBean: ... + @staticmethod + def getCompilationMXBean() -> CompilationMXBean: ... + @staticmethod + def getGarbageCollectorMXBeans() -> java.util.List[GarbageCollectorMXBean]: ... + @staticmethod + def getMemoryMXBean() -> MemoryMXBean: ... + @staticmethod + def getMemoryManagerMXBeans() -> java.util.List[MemoryManagerMXBean]: ... + @staticmethod + def getMemoryPoolMXBeans() -> java.util.List[MemoryPoolMXBean]: ... + @staticmethod + def getOperatingSystemMXBean() -> OperatingSystemMXBean: ... + @staticmethod + def getPlatformMBeanServer() -> javax.management.MBeanServer: ... + _getPlatformMXBean_0__T = typing.TypeVar( + "_getPlatformMXBean_0__T", bound="PlatformManagedObject" + ) # + _getPlatformMXBean_1__T = typing.TypeVar( + "_getPlatformMXBean_1__T", bound="PlatformManagedObject" + ) # + @typing.overload + @staticmethod + def getPlatformMXBean( + class_: type[_getPlatformMXBean_0__T], + ) -> _getPlatformMXBean_0__T: ... + @typing.overload + @staticmethod + def getPlatformMXBean( + mBeanServerConnection: javax.management.MBeanServerConnection, + class_: type[_getPlatformMXBean_1__T], + ) -> _getPlatformMXBean_1__T: ... + _getPlatformMXBeans_0__T = typing.TypeVar( + "_getPlatformMXBeans_0__T", bound="PlatformManagedObject" + ) # + _getPlatformMXBeans_1__T = typing.TypeVar( + "_getPlatformMXBeans_1__T", bound="PlatformManagedObject" + ) # + @typing.overload + @staticmethod + def getPlatformMXBeans( + class_: type[_getPlatformMXBeans_0__T], + ) -> java.util.List[_getPlatformMXBeans_0__T]: ... + @typing.overload + @staticmethod + def getPlatformMXBeans( + mBeanServerConnection: javax.management.MBeanServerConnection, + class_: type[_getPlatformMXBeans_1__T], + ) -> java.util.List[_getPlatformMXBeans_1__T]: ... + @staticmethod + def getPlatformManagementInterfaces() -> java.util.Set[ + type[PlatformManagedObject] + ]: ... + @staticmethod + def getRuntimeMXBean() -> RuntimeMXBean: ... + @staticmethod + def getThreadMXBean() -> ThreadMXBean: ... + _newPlatformMXBeanProxy__T = typing.TypeVar("_newPlatformMXBeanProxy__T") # + @staticmethod + def newPlatformMXBeanProxy( + mBeanServerConnection: javax.management.MBeanServerConnection, + string: java.lang.String | str, + class_: type[_newPlatformMXBeanProxy__T], + ) -> _newPlatformMXBeanProxy__T: ... + +class ManagementPermission(java.security.BasicPermission): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class MemoryNotificationInfo: + MEMORY_THRESHOLD_EXCEEDED: typing.ClassVar[java.lang.String] = ... + MEMORY_COLLECTION_THRESHOLD_EXCEEDED: typing.ClassVar[java.lang.String] = ... + def __init__( + self, string: java.lang.String | str, memoryUsage: MemoryUsage, long: int + ): ... + @staticmethod + def from_( + compositeData: javax.management.openmbean.CompositeData, + ) -> MemoryNotificationInfo: ... + def getCount(self) -> int: ... + def getPoolName(self) -> java.lang.String: ... + def getUsage(self) -> MemoryUsage: ... + +class MemoryType(java.lang.Enum["MemoryType"]): + HEAP: typing.ClassVar[MemoryType] = ... + NON_HEAP: typing.ClassVar[MemoryType] = ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> MemoryType: ... + @staticmethod + def values() -> typing.MutableSequence[MemoryType]: ... + +class MemoryUsage: + def __init__(self, long: int, long2: int, long3: int, long4: int): ... + @staticmethod + def from_( + compositeData: javax.management.openmbean.CompositeData, + ) -> MemoryUsage: ... + def getCommitted(self) -> int: ... + def getInit(self) -> int: ... + def getMax(self) -> int: ... + def getUsed(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class PlatformManagedObject: + def getObjectName(self) -> javax.management.ObjectName: ... + +class ThreadInfo: + @staticmethod + def from_( + compositeData: javax.management.openmbean.CompositeData, + ) -> ThreadInfo: ... + def getBlockedCount(self) -> int: ... + def getBlockedTime(self) -> int: ... + def getLockInfo(self) -> LockInfo: ... + def getLockName(self) -> java.lang.String: ... + def getLockOwnerId(self) -> int: ... + def getLockOwnerName(self) -> java.lang.String: ... + def getLockedMonitors(self) -> typing.MutableSequence[MonitorInfo]: ... + def getLockedSynchronizers(self) -> typing.MutableSequence[LockInfo]: ... + def getPriority(self) -> int: ... + def getStackTrace(self) -> typing.MutableSequence[java.lang.StackTraceElement]: ... + def getThreadId(self) -> int: ... + def getThreadName(self) -> java.lang.String: ... + def getThreadState(self) -> java.lang.Thread.State: ... + def getWaitedCount(self) -> int: ... + def getWaitedTime(self) -> int: ... + def isDaemon(self) -> bool: ... + def isInNative(self) -> bool: ... + def isSuspended(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class BufferPoolMXBean(PlatformManagedObject): + def getCount(self) -> int: ... + def getMemoryUsed(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getTotalCapacity(self) -> int: ... + +class ClassLoadingMXBean(PlatformManagedObject): + def getLoadedClassCount(self) -> int: ... + def getTotalLoadedClassCount(self) -> int: ... + def getUnloadedClassCount(self) -> int: ... + def isVerbose(self) -> bool: ... + def setVerbose(self, boolean: bool) -> None: ... + +class CompilationMXBean(PlatformManagedObject): + def getName(self) -> java.lang.String: ... + def getTotalCompilationTime(self) -> int: ... + def isCompilationTimeMonitoringSupported(self) -> bool: ... + +class MemoryMXBean(PlatformManagedObject): + def gc(self) -> None: ... + def getHeapMemoryUsage(self) -> MemoryUsage: ... + def getNonHeapMemoryUsage(self) -> MemoryUsage: ... + def getObjectPendingFinalizationCount(self) -> int: ... + def isVerbose(self) -> bool: ... + def setVerbose(self, boolean: bool) -> None: ... + +class MemoryManagerMXBean(PlatformManagedObject): + def getMemoryPoolNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getName(self) -> java.lang.String: ... + def isValid(self) -> bool: ... + +class MemoryPoolMXBean(PlatformManagedObject): + def getCollectionUsage(self) -> MemoryUsage: ... + def getCollectionUsageThreshold(self) -> int: ... + def getCollectionUsageThresholdCount(self) -> int: ... + def getMemoryManagerNames(self) -> typing.MutableSequence[java.lang.String]: ... + def getName(self) -> java.lang.String: ... + def getPeakUsage(self) -> MemoryUsage: ... + def getType(self) -> MemoryType: ... + def getUsage(self) -> MemoryUsage: ... + def getUsageThreshold(self) -> int: ... + def getUsageThresholdCount(self) -> int: ... + def isCollectionUsageThresholdExceeded(self) -> bool: ... + def isCollectionUsageThresholdSupported(self) -> bool: ... + def isUsageThresholdExceeded(self) -> bool: ... + def isUsageThresholdSupported(self) -> bool: ... + def isValid(self) -> bool: ... + def resetPeakUsage(self) -> None: ... + def setCollectionUsageThreshold(self, long: int) -> None: ... + def setUsageThreshold(self, long: int) -> None: ... + +class MonitorInfo(LockInfo): + def __init__( + self, + string: java.lang.String | str, + int: int, + int2: int, + stackTraceElement: java.lang.StackTraceElement, + ): ... + @typing.overload + @staticmethod + def from_(compositeData: javax.management.openmbean.CompositeData) -> LockInfo: ... + @typing.overload + @staticmethod + def from_( + compositeData: javax.management.openmbean.CompositeData, + ) -> MonitorInfo: ... + def getLockedStackDepth(self) -> int: ... + def getLockedStackFrame(self) -> java.lang.StackTraceElement: ... + +class OperatingSystemMXBean(PlatformManagedObject): + def getArch(self) -> java.lang.String: ... + def getAvailableProcessors(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getSystemLoadAverage(self) -> float: ... + def getVersion(self) -> java.lang.String: ... + +class PlatformLoggingMXBean(PlatformManagedObject): + def getLoggerLevel(self, string: java.lang.String | str) -> java.lang.String: ... + def getLoggerNames(self) -> java.util.List[java.lang.String]: ... + def getParentLoggerName( + self, string: java.lang.String | str + ) -> java.lang.String: ... + def setLoggerLevel( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + +class RuntimeMXBean(PlatformManagedObject): + def getBootClassPath(self) -> java.lang.String: ... + def getClassPath(self) -> java.lang.String: ... + def getInputArguments(self) -> java.util.List[java.lang.String]: ... + def getLibraryPath(self) -> java.lang.String: ... + def getManagementSpecVersion(self) -> java.lang.String: ... + def getName(self) -> java.lang.String: ... + def getPid(self) -> int: ... + def getSpecName(self) -> java.lang.String: ... + def getSpecVendor(self) -> java.lang.String: ... + def getSpecVersion(self) -> java.lang.String: ... + def getStartTime(self) -> int: ... + def getSystemProperties( + self, + ) -> java.util.Map[java.lang.String, java.lang.String]: ... + def getUptime(self) -> int: ... + def getVmName(self) -> java.lang.String: ... + def getVmVendor(self) -> java.lang.String: ... + def getVmVersion(self) -> java.lang.String: ... + def isBootClassPathSupported(self) -> bool: ... + +class ThreadMXBean(PlatformManagedObject): + @typing.overload + def dumpAllThreads( + self, boolean: bool, boolean2: bool + ) -> typing.MutableSequence[ThreadInfo]: ... + @typing.overload + def dumpAllThreads( + self, boolean: bool, boolean2: bool, int: int + ) -> typing.MutableSequence[ThreadInfo]: ... + def findDeadlockedThreads(self) -> typing.MutableSequence[int]: ... + def findMonitorDeadlockedThreads(self) -> typing.MutableSequence[int]: ... + def getAllThreadIds(self) -> typing.MutableSequence[int]: ... + def getCurrentThreadCpuTime(self) -> int: ... + def getCurrentThreadUserTime(self) -> int: ... + def getDaemonThreadCount(self) -> int: ... + def getPeakThreadCount(self) -> int: ... + def getThreadCount(self) -> int: ... + def getThreadCpuTime(self, long: int) -> int: ... + @typing.overload + def getThreadInfo(self, long: int) -> ThreadInfo: ... + @typing.overload + def getThreadInfo(self, long: int, int: int) -> ThreadInfo: ... + @typing.overload + def getThreadInfo( + self, longArray: list[int] | jpype.JArray + ) -> typing.MutableSequence[ThreadInfo]: ... + @typing.overload + def getThreadInfo( + self, longArray: list[int] | jpype.JArray, boolean: bool, boolean2: bool + ) -> typing.MutableSequence[ThreadInfo]: ... + @typing.overload + def getThreadInfo( + self, longArray: list[int] | jpype.JArray, int: int + ) -> typing.MutableSequence[ThreadInfo]: ... + @typing.overload + def getThreadInfo( + self, + longArray: list[int] | jpype.JArray, + boolean: bool, + boolean2: bool, + int: int, + ) -> typing.MutableSequence[ThreadInfo]: ... + def getThreadUserTime(self, long: int) -> int: ... + def getTotalStartedThreadCount(self) -> int: ... + def isCurrentThreadCpuTimeSupported(self) -> bool: ... + def isObjectMonitorUsageSupported(self) -> bool: ... + def isSynchronizerUsageSupported(self) -> bool: ... + def isThreadContentionMonitoringEnabled(self) -> bool: ... + def isThreadContentionMonitoringSupported(self) -> bool: ... + def isThreadCpuTimeEnabled(self) -> bool: ... + def isThreadCpuTimeSupported(self) -> bool: ... + def resetPeakThreadCount(self) -> None: ... + def setThreadContentionMonitoringEnabled(self, boolean: bool) -> None: ... + def setThreadCpuTimeEnabled(self, boolean: bool) -> None: ... + +class GarbageCollectorMXBean(MemoryManagerMXBean): + def getCollectionCount(self) -> int: ... + def getCollectionTime(self) -> int: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.management")``. + + BufferPoolMXBean: type[BufferPoolMXBean] + ClassLoadingMXBean: type[ClassLoadingMXBean] + CompilationMXBean: type[CompilationMXBean] + GarbageCollectorMXBean: type[GarbageCollectorMXBean] + LockInfo: type[LockInfo] + ManagementFactory: type[ManagementFactory] + ManagementPermission: type[ManagementPermission] + MemoryMXBean: type[MemoryMXBean] + MemoryManagerMXBean: type[MemoryManagerMXBean] + MemoryNotificationInfo: type[MemoryNotificationInfo] + MemoryPoolMXBean: type[MemoryPoolMXBean] + MemoryType: type[MemoryType] + MemoryUsage: type[MemoryUsage] + MonitorInfo: type[MonitorInfo] + OperatingSystemMXBean: type[OperatingSystemMXBean] + PlatformLoggingMXBean: type[PlatformLoggingMXBean] + PlatformManagedObject: type[PlatformManagedObject] + RuntimeMXBean: type[RuntimeMXBean] + ThreadInfo: type[ThreadInfo] + ThreadMXBean: type[ThreadMXBean] diff --git a/typings/java/lang/module/__init__.pyi b/typings/java/lang/module/__init__.pyi new file mode 100644 index 0000000..5be0201 --- /dev/null +++ b/typings/java/lang/module/__init__.pyi @@ -0,0 +1,417 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.lang.reflect +import java.net +import java.nio +import java.nio.file +import java.util +import java.util.function +import java.util.stream +import jpype.protocol + +class Configuration: + @staticmethod + def empty() -> Configuration: ... + def findModule( + self, string: java.lang.String | str + ) -> java.util.Optional[ResolvedModule]: ... + def modules(self) -> java.util.Set[ResolvedModule]: ... + def parents(self) -> java.util.List[Configuration]: ... + @typing.overload + def resolve( + self, + moduleFinder: ModuleFinder, + moduleFinder2: ModuleFinder, + collection: java.util.Collection[java.lang.String | str] + | typing.Sequence[java.lang.String | str] + | set[java.lang.String | str], + ) -> Configuration: ... + @typing.overload + @staticmethod + def resolve( + moduleFinder: ModuleFinder, + list: java.util.List[Configuration], + moduleFinder2: ModuleFinder, + collection: java.util.Collection[java.lang.String | str] + | typing.Sequence[java.lang.String | str] + | set[java.lang.String | str], + ) -> Configuration: ... + @typing.overload + def resolveAndBind( + self, + moduleFinder: ModuleFinder, + moduleFinder2: ModuleFinder, + collection: java.util.Collection[java.lang.String | str] + | typing.Sequence[java.lang.String | str] + | set[java.lang.String | str], + ) -> Configuration: ... + @typing.overload + @staticmethod + def resolveAndBind( + moduleFinder: ModuleFinder, + list: java.util.List[Configuration], + moduleFinder2: ModuleFinder, + collection: java.util.Collection[java.lang.String | str] + | typing.Sequence[java.lang.String | str] + | set[java.lang.String | str], + ) -> Configuration: ... + def toString(self) -> java.lang.String: ... + +class FindException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class InvalidModuleDescriptorException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class ModuleDescriptor(java.lang.Comparable["ModuleDescriptor"]): + def accessFlags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def compareTo(self, moduleDescriptor: ModuleDescriptor) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def exports(self) -> java.util.Set[ModuleDescriptor.Exports]: ... + def hashCode(self) -> int: ... + def isAutomatic(self) -> bool: ... + def isOpen(self) -> bool: ... + def mainClass(self) -> java.util.Optional[java.lang.String]: ... + def modifiers(self) -> java.util.Set[ModuleDescriptor.Modifier]: ... + def name(self) -> java.lang.String: ... + @staticmethod + def newAutomaticModule( + string: java.lang.String | str, + ) -> ModuleDescriptor.Builder: ... + @typing.overload + @staticmethod + def newModule(string: java.lang.String | str) -> ModuleDescriptor.Builder: ... + @typing.overload + @staticmethod + def newModule( + string: java.lang.String | str, set: java.util.Set[ModuleDescriptor.Modifier] + ) -> ModuleDescriptor.Builder: ... + @staticmethod + def newOpenModule(string: java.lang.String | str) -> ModuleDescriptor.Builder: ... + def opens(self) -> java.util.Set[ModuleDescriptor.Opens]: ... + def packages(self) -> java.util.Set[java.lang.String]: ... + def provides(self) -> java.util.Set[ModuleDescriptor.Provides]: ... + def rawVersion(self) -> java.util.Optional[java.lang.String]: ... + @typing.overload + @staticmethod + def read(inputStream: java.io.InputStream) -> ModuleDescriptor: ... + @typing.overload + @staticmethod + def read( + inputStream: java.io.InputStream, + supplier: java.util.function.Supplier[java.util.Set[java.lang.String | str]] + | typing.Callable[[], java.util.Set[java.lang.String | str]], + ) -> ModuleDescriptor: ... + @typing.overload + @staticmethod + def read(byteBuffer: java.nio.ByteBuffer) -> ModuleDescriptor: ... + @typing.overload + @staticmethod + def read( + byteBuffer: java.nio.ByteBuffer, + supplier: java.util.function.Supplier[java.util.Set[java.lang.String | str]] + | typing.Callable[[], java.util.Set[java.lang.String | str]], + ) -> ModuleDescriptor: ... + def requires(self) -> java.util.Set[ModuleDescriptor.Requires]: ... + def toNameAndVersion(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def uses(self) -> java.util.Set[java.lang.String]: ... + def version(self) -> java.util.Optional[ModuleDescriptor.Version]: ... + class Builder: + def build(self) -> ModuleDescriptor: ... + @typing.overload + def exports( + self, string: java.lang.String | str + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def exports( + self, + string: java.lang.String | str, + set: java.util.Set[java.lang.String | str], + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def exports( + self, exports: ModuleDescriptor.Exports + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def exports( + self, + set: java.util.Set[ModuleDescriptor.Exports.Modifier], + string: java.lang.String | str, + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def exports( + self, + set: java.util.Set[ModuleDescriptor.Exports.Modifier], + string: java.lang.String | str, + set2: java.util.Set[java.lang.String | str], + ) -> ModuleDescriptor.Builder: ... + def mainClass( + self, string: java.lang.String | str + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def opens(self, string: java.lang.String | str) -> ModuleDescriptor.Builder: ... + @typing.overload + def opens( + self, + string: java.lang.String | str, + set: java.util.Set[java.lang.String | str], + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def opens(self, opens: ModuleDescriptor.Opens) -> ModuleDescriptor.Builder: ... + @typing.overload + def opens( + self, + set: java.util.Set[ModuleDescriptor.Opens.Modifier], + string: java.lang.String | str, + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def opens( + self, + set: java.util.Set[ModuleDescriptor.Opens.Modifier], + string: java.lang.String | str, + set2: java.util.Set[java.lang.String | str], + ) -> ModuleDescriptor.Builder: ... + def packages( + self, set: java.util.Set[java.lang.String | str] + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def provides( + self, + string: java.lang.String | str, + list: java.util.List[java.lang.String | str], + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def provides( + self, provides: ModuleDescriptor.Provides + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def requires( + self, string: java.lang.String | str + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def requires( + self, requires: ModuleDescriptor.Requires + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def requires( + self, + set: java.util.Set[ModuleDescriptor.Requires.Modifier], + string: java.lang.String | str, + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def requires( + self, + set: java.util.Set[ModuleDescriptor.Requires.Modifier], + string: java.lang.String | str, + version: ModuleDescriptor.Version, + ) -> ModuleDescriptor.Builder: ... + def uses(self, string: java.lang.String | str) -> ModuleDescriptor.Builder: ... + @typing.overload + def version( + self, string: java.lang.String | str + ) -> ModuleDescriptor.Builder: ... + @typing.overload + def version( + self, version: ModuleDescriptor.Version + ) -> ModuleDescriptor.Builder: ... + + class Exports(java.lang.Comparable["ModuleDescriptor.Exports"]): + def accessFlags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def compareTo(self, exports: ModuleDescriptor.Exports) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def isQualified(self) -> bool: ... + def modifiers(self) -> java.util.Set[ModuleDescriptor.Exports.Modifier]: ... + def source(self) -> java.lang.String: ... + def targets(self) -> java.util.Set[java.lang.String]: ... + def toString(self) -> java.lang.String: ... + class Modifier(java.lang.Enum["ModuleDescriptor.Exports.Modifier"]): + SYNTHETIC: typing.ClassVar[ModuleDescriptor.Exports.Modifier] = ... + MANDATED: typing.ClassVar[ModuleDescriptor.Exports.Modifier] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> ModuleDescriptor.Exports.Modifier: ... + @staticmethod + def values() -> typing.MutableSequence[ + ModuleDescriptor.Exports.Modifier + ]: ... + + class Modifier(java.lang.Enum["ModuleDescriptor.Modifier"]): + OPEN: typing.ClassVar[ModuleDescriptor.Modifier] = ... + AUTOMATIC: typing.ClassVar[ModuleDescriptor.Modifier] = ... + SYNTHETIC: typing.ClassVar[ModuleDescriptor.Modifier] = ... + MANDATED: typing.ClassVar[ModuleDescriptor.Modifier] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ModuleDescriptor.Modifier: ... + @staticmethod + def values() -> typing.MutableSequence[ModuleDescriptor.Modifier]: ... + + class Opens(java.lang.Comparable["ModuleDescriptor.Opens"]): + def accessFlags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def compareTo(self, opens: ModuleDescriptor.Opens) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def isQualified(self) -> bool: ... + def modifiers(self) -> java.util.Set[ModuleDescriptor.Opens.Modifier]: ... + def source(self) -> java.lang.String: ... + def targets(self) -> java.util.Set[java.lang.String]: ... + def toString(self) -> java.lang.String: ... + class Modifier(java.lang.Enum["ModuleDescriptor.Opens.Modifier"]): + SYNTHETIC: typing.ClassVar[ModuleDescriptor.Opens.Modifier] = ... + MANDATED: typing.ClassVar[ModuleDescriptor.Opens.Modifier] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> ModuleDescriptor.Opens.Modifier: ... + @staticmethod + def values() -> typing.MutableSequence[ModuleDescriptor.Opens.Modifier]: ... + + class Provides(java.lang.Comparable["ModuleDescriptor.Provides"]): + def compareTo(self, provides: ModuleDescriptor.Provides) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def providers(self) -> java.util.List[java.lang.String]: ... + def service(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + + class Requires(java.lang.Comparable["ModuleDescriptor.Requires"]): + def accessFlags(self) -> java.util.Set[java.lang.reflect.AccessFlag]: ... + def compareTo(self, requires: ModuleDescriptor.Requires) -> int: ... + def compiledVersion(self) -> java.util.Optional[ModuleDescriptor.Version]: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def modifiers(self) -> java.util.Set[ModuleDescriptor.Requires.Modifier]: ... + def name(self) -> java.lang.String: ... + def rawCompiledVersion(self) -> java.util.Optional[java.lang.String]: ... + def toString(self) -> java.lang.String: ... + class Modifier(java.lang.Enum["ModuleDescriptor.Requires.Modifier"]): + TRANSITIVE: typing.ClassVar[ModuleDescriptor.Requires.Modifier] = ... + STATIC: typing.ClassVar[ModuleDescriptor.Requires.Modifier] = ... + SYNTHETIC: typing.ClassVar[ModuleDescriptor.Requires.Modifier] = ... + MANDATED: typing.ClassVar[ModuleDescriptor.Requires.Modifier] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> ModuleDescriptor.Requires.Modifier: ... + @staticmethod + def values() -> typing.MutableSequence[ + ModuleDescriptor.Requires.Modifier + ]: ... + + class Version(java.lang.Comparable["ModuleDescriptor.Version"]): + def compareTo(self, version: ModuleDescriptor.Version) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + @staticmethod + def parse(string: java.lang.String | str) -> ModuleDescriptor.Version: ... + def toString(self) -> java.lang.String: ... + +class ModuleFinder: + @staticmethod + def compose(*moduleFinder: ModuleFinder) -> ModuleFinder: ... + def find( + self, string: java.lang.String | str + ) -> java.util.Optional[ModuleReference]: ... + def findAll(self) -> java.util.Set[ModuleReference]: ... + @staticmethod + def of(*path: java.nio.file.Path | jpype.protocol.SupportsPath) -> ModuleFinder: ... + @staticmethod + def ofSystem() -> ModuleFinder: ... + +class ModuleReader(java.io.Closeable): + def close(self) -> None: ... + def find( + self, string: java.lang.String | str + ) -> java.util.Optional[java.net.URI]: ... + def list(self) -> java.util.stream.Stream[java.lang.String]: ... + def open( + self, string: java.lang.String | str + ) -> java.util.Optional[java.io.InputStream]: ... + def read( + self, string: java.lang.String | str + ) -> java.util.Optional[java.nio.ByteBuffer]: ... + def release(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + +class ModuleReference: + def descriptor(self) -> ModuleDescriptor: ... + def location(self) -> java.util.Optional[java.net.URI]: ... + def open(self) -> ModuleReader: ... + +class ResolutionException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class ResolvedModule: + def configuration(self) -> Configuration: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def name(self) -> java.lang.String: ... + def reads(self) -> java.util.Set[ResolvedModule]: ... + def reference(self) -> ModuleReference: ... + def toString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.module")``. + + Configuration: type[Configuration] + FindException: type[FindException] + InvalidModuleDescriptorException: type[InvalidModuleDescriptorException] + ModuleDescriptor: type[ModuleDescriptor] + ModuleFinder: type[ModuleFinder] + ModuleReader: type[ModuleReader] + ModuleReference: type[ModuleReference] + ResolutionException: type[ResolutionException] + ResolvedModule: type[ResolvedModule] diff --git a/typings/java/lang/ref/__init__.pyi b/typings/java/lang/ref/__init__.pyi new file mode 100644 index 0000000..9175fcd --- /dev/null +++ b/typings/java/lang/ref/__init__.pyi @@ -0,0 +1,84 @@ +import typing +from typing import Protocol + +import java.lang +import java.util.concurrent + +class Cleaner: + @typing.overload + @staticmethod + def create() -> Cleaner: ... + @typing.overload + @staticmethod + def create( + threadFactory: java.util.concurrent.ThreadFactory | typing.Callable, + ) -> Cleaner: ... + def register( + self, object: typing.Any, runnable: java.lang.Runnable | typing.Callable + ) -> Cleaner.Cleanable: ... + class Cleanable: + def clean(self) -> None: ... + +_Reference__T = typing.TypeVar("_Reference__T") # + +class Reference(typing.Generic[_Reference__T]): + def clear(self) -> None: ... + def enqueue(self) -> bool: ... + def get(self) -> _Reference__T: ... + def isEnqueued(self) -> bool: ... + @staticmethod + def reachabilityFence(object: typing.Any) -> None: ... + def refersTo(self, t: _Reference__T) -> bool: ... + +_ReferenceQueue__T = typing.TypeVar("_ReferenceQueue__T") # + +class ReferenceQueue(typing.Generic[_ReferenceQueue__T]): + def __init__(self): ... + def poll(self) -> Reference[_ReferenceQueue__T]: ... + @typing.overload + def remove(self) -> Reference[_ReferenceQueue__T]: ... + @typing.overload + def remove(self, long: int) -> Reference[_ReferenceQueue__T]: ... + +_PhantomReference__T = typing.TypeVar("_PhantomReference__T") # + +class PhantomReference( + Reference[_PhantomReference__T], typing.Generic[_PhantomReference__T] +): + def __init__( + self, + t: _PhantomReference__T, + referenceQueue: ReferenceQueue[_PhantomReference__T], + ): ... + def get(self) -> _PhantomReference__T: ... + +_SoftReference__T = typing.TypeVar("_SoftReference__T") # + +class SoftReference(Reference[_SoftReference__T], typing.Generic[_SoftReference__T]): + @typing.overload + def __init__(self, t: _SoftReference__T): ... + @typing.overload + def __init__( + self, t: _SoftReference__T, referenceQueue: ReferenceQueue[_SoftReference__T] + ): ... + def get(self) -> _SoftReference__T: ... + +_WeakReference__T = typing.TypeVar("_WeakReference__T") # + +class WeakReference(Reference[_WeakReference__T], typing.Generic[_WeakReference__T]): + @typing.overload + def __init__(self, t: _WeakReference__T): ... + @typing.overload + def __init__( + self, t: _WeakReference__T, referenceQueue: ReferenceQueue[_WeakReference__T] + ): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.ref")``. + + Cleaner: type[Cleaner] + PhantomReference: type[PhantomReference] + Reference: type[Reference] + ReferenceQueue: type[ReferenceQueue] + SoftReference: type[SoftReference] + WeakReference: type[WeakReference] diff --git a/typings/java/lang/reflect/__init__.pyi b/typings/java/lang/reflect/__init__.pyi new file mode 100644 index 0000000..373a8f9 --- /dev/null +++ b/typings/java/lang/reflect/__init__.pyi @@ -0,0 +1,748 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.lang.annotation +import java.security +import java.util +import jpype + +class AccessFlag(java.lang.Enum["AccessFlag"]): + PUBLIC: typing.ClassVar[AccessFlag] = ... + PRIVATE: typing.ClassVar[AccessFlag] = ... + PROTECTED: typing.ClassVar[AccessFlag] = ... + STATIC: typing.ClassVar[AccessFlag] = ... + FINAL: typing.ClassVar[AccessFlag] = ... + SUPER: typing.ClassVar[AccessFlag] = ... + OPEN: typing.ClassVar[AccessFlag] = ... + TRANSITIVE: typing.ClassVar[AccessFlag] = ... + SYNCHRONIZED: typing.ClassVar[AccessFlag] = ... + STATIC_PHASE: typing.ClassVar[AccessFlag] = ... + VOLATILE: typing.ClassVar[AccessFlag] = ... + BRIDGE: typing.ClassVar[AccessFlag] = ... + TRANSIENT: typing.ClassVar[AccessFlag] = ... + VARARGS: typing.ClassVar[AccessFlag] = ... + NATIVE: typing.ClassVar[AccessFlag] = ... + INTERFACE: typing.ClassVar[AccessFlag] = ... + ABSTRACT: typing.ClassVar[AccessFlag] = ... + STRICT: typing.ClassVar[AccessFlag] = ... + SYNTHETIC: typing.ClassVar[AccessFlag] = ... + ANNOTATION: typing.ClassVar[AccessFlag] = ... + ENUM: typing.ClassVar[AccessFlag] = ... + MANDATED: typing.ClassVar[AccessFlag] = ... + MODULE: typing.ClassVar[AccessFlag] = ... + @typing.overload + def locations(self) -> java.util.Set[AccessFlag.Location]: ... + @typing.overload + def locations( + self, classFileFormatVersion: ClassFileFormatVersion + ) -> java.util.Set[AccessFlag.Location]: ... + def mask(self) -> int: ... + @typing.overload + @staticmethod + def maskToAccessFlags( + int: int, location: AccessFlag.Location + ) -> java.util.Set[AccessFlag]: ... + @typing.overload + @staticmethod + def maskToAccessFlags( + int: int, + location: AccessFlag.Location, + classFileFormatVersion: ClassFileFormatVersion, + ) -> java.util.Set[AccessFlag]: ... + def sourceModifier(self) -> bool: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> AccessFlag: ... + @staticmethod + def values() -> typing.MutableSequence[AccessFlag]: ... + class Location(java.lang.Enum["AccessFlag.Location"]): + CLASS: typing.ClassVar[AccessFlag.Location] = ... + FIELD: typing.ClassVar[AccessFlag.Location] = ... + METHOD: typing.ClassVar[AccessFlag.Location] = ... + INNER_CLASS: typing.ClassVar[AccessFlag.Location] = ... + METHOD_PARAMETER: typing.ClassVar[AccessFlag.Location] = ... + MODULE: typing.ClassVar[AccessFlag.Location] = ... + MODULE_REQUIRES: typing.ClassVar[AccessFlag.Location] = ... + MODULE_EXPORTS: typing.ClassVar[AccessFlag.Location] = ... + MODULE_OPENS: typing.ClassVar[AccessFlag.Location] = ... + @typing.overload + def flags(self) -> java.util.Set[AccessFlag]: ... + @typing.overload + def flags( + self, classFileFormatVersion: ClassFileFormatVersion + ) -> java.util.Set[AccessFlag]: ... + @typing.overload + def flagsMask(self) -> int: ... + @typing.overload + def flagsMask(self, classFileFormatVersion: ClassFileFormatVersion) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> AccessFlag.Location: ... + @staticmethod + def values() -> typing.MutableSequence[AccessFlag.Location]: ... + +class AnnotatedElement: + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__T]) -> _getAnnotation__T: ... + def getAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getAnnotationsByType__T = typing.TypeVar( + "_getAnnotationsByType__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotationsByType( + self, class_: type[_getAnnotationsByType__T] + ) -> typing.MutableSequence[_getAnnotationsByType__T]: ... + _getDeclaredAnnotation__T = typing.TypeVar( + "_getDeclaredAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotation( + self, class_: type[_getDeclaredAnnotation__T] + ) -> _getDeclaredAnnotation__T: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getDeclaredAnnotationsByType__T = typing.TypeVar( + "_getDeclaredAnnotationsByType__T", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotationsByType( + self, class_: type[_getDeclaredAnnotationsByType__T] + ) -> typing.MutableSequence[_getDeclaredAnnotationsByType__T]: ... + def isAnnotationPresent( + self, class_: type[java.lang.annotation.Annotation] + ) -> bool: ... + +class Array: + @staticmethod + def get(object: typing.Any, int: int) -> typing.Any: ... + @staticmethod + def getBoolean(object: typing.Any, int: int) -> bool: ... + @staticmethod + def getByte(object: typing.Any, int: int) -> int: ... + @staticmethod + def getChar(object: typing.Any, int: int) -> str: ... + @staticmethod + def getDouble(object: typing.Any, int: int) -> float: ... + @staticmethod + def getFloat(object: typing.Any, int: int) -> float: ... + @staticmethod + def getInt(object: typing.Any, int: int) -> int: ... + @staticmethod + def getLength(object: typing.Any) -> int: ... + @staticmethod + def getLong(object: typing.Any, int: int) -> int: ... + @staticmethod + def getShort(object: typing.Any, int: int) -> int: ... + @typing.overload + @staticmethod + def newInstance(class_: type[typing.Any], int: int) -> typing.Any: ... + @typing.overload + @staticmethod + def newInstance(class_: type[typing.Any], *int: int) -> typing.Any: ... + @staticmethod + def set(object: typing.Any, int: int, object2: typing.Any) -> None: ... + @staticmethod + def setBoolean(object: typing.Any, int: int, boolean: bool) -> None: ... + @staticmethod + def setByte(object: typing.Any, int: int, byte: int) -> None: ... + @staticmethod + def setChar(object: typing.Any, int: int, char: str) -> None: ... + @staticmethod + def setDouble(object: typing.Any, int: int, double: float) -> None: ... + @staticmethod + def setFloat(object: typing.Any, int: int, float: float) -> None: ... + @staticmethod + def setInt(object: typing.Any, int: int, int2: int) -> None: ... + @staticmethod + def setLong(object: typing.Any, int: int, long: int) -> None: ... + @staticmethod + def setShort(object: typing.Any, int: int, short: int) -> None: ... + +class ClassFileFormatVersion(java.lang.Enum["ClassFileFormatVersion"]): + RELEASE_0: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_1: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_2: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_3: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_4: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_5: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_6: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_7: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_8: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_9: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_10: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_11: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_12: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_13: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_14: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_15: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_16: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_17: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_18: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_19: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_20: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_21: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_22: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_23: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_24: typing.ClassVar[ClassFileFormatVersion] = ... + RELEASE_25: typing.ClassVar[ClassFileFormatVersion] = ... + @staticmethod + def fromMajor(int: int) -> ClassFileFormatVersion: ... + @staticmethod + def latest() -> ClassFileFormatVersion: ... + def major(self) -> int: ... + def runtimeVersion(self) -> java.lang.Runtime.Version: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(version: java.lang.Runtime.Version) -> ClassFileFormatVersion: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ClassFileFormatVersion: ... + @staticmethod + def values() -> typing.MutableSequence[ClassFileFormatVersion]: ... + +class GenericSignatureFormatError(java.lang.ClassFormatError): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class InaccessibleObjectException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class InvocationHandler: + def invoke( + self, + object: typing.Any, + method: Method, + objectArray: list[typing.Any] | jpype.JArray, + ) -> typing.Any: ... + @staticmethod + def invokeDefault( + object: typing.Any, method: Method, *object2: typing.Any + ) -> typing.Any: ... + +class InvocationTargetException(java.lang.ReflectiveOperationException): + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + @typing.overload + def __init__( + self, throwable: java.lang.Throwable, string: java.lang.String | str + ): ... + def getCause(self) -> java.lang.Throwable: ... + def getTargetException(self) -> java.lang.Throwable: ... + +class MalformedParameterizedTypeException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class MalformedParametersException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Member: + PUBLIC: typing.ClassVar[int] = ... + DECLARED: typing.ClassVar[int] = ... + def accessFlags(self) -> java.util.Set[AccessFlag]: ... + def getDeclaringClass(self) -> type[typing.Any]: ... + def getModifiers(self) -> int: ... + def getName(self) -> java.lang.String: ... + def isSynthetic(self) -> bool: ... + +class Modifier: + PUBLIC: typing.ClassVar[int] = ... + PRIVATE: typing.ClassVar[int] = ... + PROTECTED: typing.ClassVar[int] = ... + STATIC: typing.ClassVar[int] = ... + FINAL: typing.ClassVar[int] = ... + SYNCHRONIZED: typing.ClassVar[int] = ... + VOLATILE: typing.ClassVar[int] = ... + TRANSIENT: typing.ClassVar[int] = ... + NATIVE: typing.ClassVar[int] = ... + INTERFACE: typing.ClassVar[int] = ... + ABSTRACT: typing.ClassVar[int] = ... + STRICT: typing.ClassVar[int] = ... + @staticmethod + def classModifiers() -> int: ... + @staticmethod + def constructorModifiers() -> int: ... + @staticmethod + def fieldModifiers() -> int: ... + @staticmethod + def interfaceModifiers() -> int: ... + @staticmethod + def isAbstract(int: int) -> bool: ... + @staticmethod + def isFinal(int: int) -> bool: ... + @staticmethod + def isInterface(int: int) -> bool: ... + @staticmethod + def isNative(int: int) -> bool: ... + @staticmethod + def isPrivate(int: int) -> bool: ... + @staticmethod + def isProtected(int: int) -> bool: ... + @staticmethod + def isPublic(int: int) -> bool: ... + @staticmethod + def isStatic(int: int) -> bool: ... + @staticmethod + def isStrict(int: int) -> bool: ... + @staticmethod + def isSynchronized(int: int) -> bool: ... + @staticmethod + def isTransient(int: int) -> bool: ... + @staticmethod + def isVolatile(int: int) -> bool: ... + @staticmethod + def methodModifiers() -> int: ... + @staticmethod + def parameterModifiers() -> int: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(int: int) -> java.lang.String: ... + +class Proxy(java.io.Serializable): + @staticmethod + def getInvocationHandler(object: typing.Any) -> InvocationHandler: ... + @staticmethod + def getProxyClass( + classLoader: java.lang.ClassLoader, *class2: type[typing.Any] + ) -> type[typing.Any]: ... + @staticmethod + def isProxyClass(class_: type[typing.Any]) -> bool: ... + @staticmethod + def newProxyInstance( + classLoader: java.lang.ClassLoader, + classArray: list[type[typing.Any]] | jpype.JArray, + invocationHandler: InvocationHandler | typing.Callable, + ) -> typing.Any: ... + +class ReflectPermission(java.security.BasicPermission): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class Type: + def getTypeName(self) -> java.lang.String: ... + +class UndeclaredThrowableException(java.lang.RuntimeException): + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + @typing.overload + def __init__( + self, throwable: java.lang.Throwable, string: java.lang.String | str + ): ... + def getUndeclaredThrowable(self) -> java.lang.Throwable: ... + +class AccessibleObject(AnnotatedElement): + def canAccess(self, object: typing.Any) -> bool: ... + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__T]) -> _getAnnotation__T: ... + def getAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getAnnotationsByType__T = typing.TypeVar( + "_getAnnotationsByType__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotationsByType( + self, class_: type[_getAnnotationsByType__T] + ) -> typing.MutableSequence[_getAnnotationsByType__T]: ... + _getDeclaredAnnotation__T = typing.TypeVar( + "_getDeclaredAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotation( + self, class_: type[_getDeclaredAnnotation__T] + ) -> _getDeclaredAnnotation__T: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getDeclaredAnnotationsByType__T = typing.TypeVar( + "_getDeclaredAnnotationsByType__T", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotationsByType( + self, class_: type[_getDeclaredAnnotationsByType__T] + ) -> typing.MutableSequence[_getDeclaredAnnotationsByType__T]: ... + def isAccessible(self) -> bool: ... + def isAnnotationPresent( + self, class_: type[java.lang.annotation.Annotation] + ) -> bool: ... + @typing.overload + @staticmethod + def setAccessible( + accessibleObjectArray: list[AccessibleObject] | jpype.JArray, boolean: bool + ) -> None: ... + @typing.overload + def setAccessible(self, boolean: bool) -> None: ... + def trySetAccessible(self) -> bool: ... + +class AnnotatedType(AnnotatedElement): + def getAnnotatedOwnerType(self) -> AnnotatedType: ... + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__T]) -> _getAnnotation__T: ... + def getAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getType(self) -> Type: ... + +class GenericArrayType(Type): + def getGenericComponentType(self) -> Type: ... + +class GenericDeclaration(AnnotatedElement): + def getTypeParameters(self) -> typing.MutableSequence[TypeVariable[typing.Any]]: ... + +class Parameter(AnnotatedElement): + def accessFlags(self) -> java.util.Set[AccessFlag]: ... + def equals(self, object: typing.Any) -> bool: ... + def getAnnotatedType(self) -> AnnotatedType: ... + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__T]) -> _getAnnotation__T: ... + def getAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getAnnotationsByType__T = typing.TypeVar( + "_getAnnotationsByType__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotationsByType( + self, class_: type[_getAnnotationsByType__T] + ) -> typing.MutableSequence[_getAnnotationsByType__T]: ... + _getDeclaredAnnotation__T = typing.TypeVar( + "_getDeclaredAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotation( + self, class_: type[_getDeclaredAnnotation__T] + ) -> _getDeclaredAnnotation__T: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + _getDeclaredAnnotationsByType__T = typing.TypeVar( + "_getDeclaredAnnotationsByType__T", bound=java.lang.annotation.Annotation + ) # + def getDeclaredAnnotationsByType( + self, class_: type[_getDeclaredAnnotationsByType__T] + ) -> typing.MutableSequence[_getDeclaredAnnotationsByType__T]: ... + def getDeclaringExecutable(self) -> Executable: ... + def getModifiers(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getParameterizedType(self) -> Type: ... + def getType(self) -> type[typing.Any]: ... + def hashCode(self) -> int: ... + def isImplicit(self) -> bool: ... + def isNamePresent(self) -> bool: ... + def isSynthetic(self) -> bool: ... + def isVarArgs(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class ParameterizedType(Type): + def getActualTypeArguments(self) -> typing.MutableSequence[Type]: ... + def getOwnerType(self) -> Type: ... + def getRawType(self) -> Type: ... + +class RecordComponent(AnnotatedElement): + def getAccessor(self) -> Method: ... + def getAnnotatedType(self) -> AnnotatedType: ... + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__T]) -> _getAnnotation__T: ... + def getAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getDeclaringRecord(self) -> type[typing.Any]: ... + def getGenericSignature(self) -> java.lang.String: ... + def getGenericType(self) -> Type: ... + def getName(self) -> java.lang.String: ... + def getType(self) -> type[typing.Any]: ... + def toString(self) -> java.lang.String: ... + +_TypeVariable__D = typing.TypeVar("_TypeVariable__D", bound=GenericDeclaration) # + +class TypeVariable(Type, AnnotatedElement, typing.Generic[_TypeVariable__D]): + def getAnnotatedBounds(self) -> typing.MutableSequence[AnnotatedType]: ... + def getBounds(self) -> typing.MutableSequence[Type]: ... + def getGenericDeclaration(self) -> _TypeVariable__D: ... + def getName(self) -> java.lang.String: ... + +class WildcardType(Type): + def getLowerBounds(self) -> typing.MutableSequence[Type]: ... + def getUpperBounds(self) -> typing.MutableSequence[Type]: ... + +class AnnotatedArrayType(AnnotatedType): + def getAnnotatedGenericComponentType(self) -> AnnotatedType: ... + def getAnnotatedOwnerType(self) -> AnnotatedType: ... + +class AnnotatedParameterizedType(AnnotatedType): + def getAnnotatedActualTypeArguments( + self, + ) -> typing.MutableSequence[AnnotatedType]: ... + def getAnnotatedOwnerType(self) -> AnnotatedType: ... + +class AnnotatedTypeVariable(AnnotatedType): + def getAnnotatedBounds(self) -> typing.MutableSequence[AnnotatedType]: ... + def getAnnotatedOwnerType(self) -> AnnotatedType: ... + +class AnnotatedWildcardType(AnnotatedType): + def getAnnotatedLowerBounds(self) -> typing.MutableSequence[AnnotatedType]: ... + def getAnnotatedOwnerType(self) -> AnnotatedType: ... + def getAnnotatedUpperBounds(self) -> typing.MutableSequence[AnnotatedType]: ... + +class Executable(AccessibleObject, Member, GenericDeclaration): + def accessFlags(self) -> java.util.Set[AccessFlag]: ... + def getAnnotatedExceptionTypes(self) -> typing.MutableSequence[AnnotatedType]: ... + def getAnnotatedParameterTypes(self) -> typing.MutableSequence[AnnotatedType]: ... + def getAnnotatedReceiverType(self) -> AnnotatedType: ... + def getAnnotatedReturnType(self) -> AnnotatedType: ... + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__T]) -> _getAnnotation__T: ... + _getAnnotationsByType__T = typing.TypeVar( + "_getAnnotationsByType__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotationsByType( + self, class_: type[_getAnnotationsByType__T] + ) -> typing.MutableSequence[_getAnnotationsByType__T]: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getDeclaringClass(self) -> type[typing.Any]: ... + def getExceptionTypes(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getGenericExceptionTypes(self) -> typing.MutableSequence[Type]: ... + def getGenericParameterTypes(self) -> typing.MutableSequence[Type]: ... + def getModifiers(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getParameterAnnotations( + self, + ) -> typing.MutableSequence[ + typing.MutableSequence[java.lang.annotation.Annotation] + ]: ... + def getParameterCount(self) -> int: ... + def getParameterTypes(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getParameters(self) -> typing.MutableSequence[Parameter]: ... + def getTypeParameters(self) -> typing.MutableSequence[TypeVariable[typing.Any]]: ... + def isSynthetic(self) -> bool: ... + def isVarArgs(self) -> bool: ... + def toGenericString(self) -> java.lang.String: ... + +class Field(AccessibleObject, Member): + def accessFlags(self) -> java.util.Set[AccessFlag]: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, object: typing.Any) -> typing.Any: ... + def getAnnotatedType(self) -> AnnotatedType: ... + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__T]) -> _getAnnotation__T: ... + _getAnnotationsByType__T = typing.TypeVar( + "_getAnnotationsByType__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotationsByType( + self, class_: type[_getAnnotationsByType__T] + ) -> typing.MutableSequence[_getAnnotationsByType__T]: ... + def getBoolean(self, object: typing.Any) -> bool: ... + def getByte(self, object: typing.Any) -> int: ... + def getChar(self, object: typing.Any) -> str: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getDeclaringClass(self) -> type[typing.Any]: ... + def getDouble(self, object: typing.Any) -> float: ... + def getFloat(self, object: typing.Any) -> float: ... + def getGenericType(self) -> Type: ... + def getInt(self, object: typing.Any) -> int: ... + def getLong(self, object: typing.Any) -> int: ... + def getModifiers(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getShort(self, object: typing.Any) -> int: ... + def getType(self) -> type[typing.Any]: ... + def hashCode(self) -> int: ... + def isEnumConstant(self) -> bool: ... + def isSynthetic(self) -> bool: ... + def set(self, object: typing.Any, object2: typing.Any) -> None: ... + @typing.overload + @staticmethod + def setAccessible( + accessibleObjectArray: list[AccessibleObject] | jpype.JArray, boolean: bool + ) -> None: ... + @typing.overload + def setAccessible(self, boolean: bool) -> None: ... + def setBoolean(self, object: typing.Any, boolean: bool) -> None: ... + def setByte(self, object: typing.Any, byte: int) -> None: ... + def setChar(self, object: typing.Any, char: str) -> None: ... + def setDouble(self, object: typing.Any, double: float) -> None: ... + def setFloat(self, object: typing.Any, float: float) -> None: ... + def setInt(self, object: typing.Any, int: int) -> None: ... + def setLong(self, object: typing.Any, long: int) -> None: ... + def setShort(self, object: typing.Any, short: int) -> None: ... + def toGenericString(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +_Constructor__T = typing.TypeVar("_Constructor__T") # + +class Constructor(Executable, typing.Generic[_Constructor__T]): + def equals(self, object: typing.Any) -> bool: ... + def getAnnotatedReceiverType(self) -> AnnotatedType: ... + def getAnnotatedReturnType(self) -> AnnotatedType: ... + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation( + self, class_: type[java.lang.annotation.Annotation] + ) -> java.lang.annotation.Annotation: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getDeclaringClass(self) -> type[_Constructor__T]: ... + def getExceptionTypes(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getGenericExceptionTypes(self) -> typing.MutableSequence[Type]: ... + def getGenericParameterTypes(self) -> typing.MutableSequence[Type]: ... + def getModifiers(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getParameterAnnotations( + self, + ) -> typing.MutableSequence[ + typing.MutableSequence[java.lang.annotation.Annotation] + ]: ... + def getParameterCount(self) -> int: ... + def getParameterTypes(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getTypeParameters( + self, + ) -> typing.MutableSequence[TypeVariable[Constructor[_Constructor__T]]]: ... + def hashCode(self) -> int: ... + def isSynthetic(self) -> bool: ... + def isVarArgs(self) -> bool: ... + def newInstance(self, *object: typing.Any) -> _Constructor__T: ... + @typing.overload + @staticmethod + def setAccessible( + accessibleObjectArray: list[AccessibleObject] | jpype.JArray, boolean: bool + ) -> None: ... + @typing.overload + def setAccessible(self, boolean: bool) -> None: ... + def toGenericString(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class Method(Executable): + def equals(self, object: typing.Any) -> bool: ... + def getAnnotatedReturnType(self) -> AnnotatedType: ... + _getAnnotation__T = typing.TypeVar( + "_getAnnotation__T", bound=java.lang.annotation.Annotation + ) # + def getAnnotation(self, class_: type[_getAnnotation__T]) -> _getAnnotation__T: ... + def getDeclaredAnnotations( + self, + ) -> typing.MutableSequence[java.lang.annotation.Annotation]: ... + def getDeclaringClass(self) -> type[typing.Any]: ... + def getDefaultValue(self) -> typing.Any: ... + def getExceptionTypes(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getGenericExceptionTypes(self) -> typing.MutableSequence[Type]: ... + def getGenericParameterTypes(self) -> typing.MutableSequence[Type]: ... + def getGenericReturnType(self) -> Type: ... + def getModifiers(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getParameterAnnotations( + self, + ) -> typing.MutableSequence[ + typing.MutableSequence[java.lang.annotation.Annotation] + ]: ... + def getParameterCount(self) -> int: ... + def getParameterTypes(self) -> typing.MutableSequence[type[typing.Any]]: ... + def getReturnType(self) -> type[typing.Any]: ... + def getTypeParameters(self) -> typing.MutableSequence[TypeVariable[Method]]: ... + def hashCode(self) -> int: ... + def invoke(self, object: typing.Any, *object2: typing.Any) -> typing.Any: ... + def isBridge(self) -> bool: ... + def isDefault(self) -> bool: ... + def isSynthetic(self) -> bool: ... + def isVarArgs(self) -> bool: ... + @typing.overload + @staticmethod + def setAccessible( + accessibleObjectArray: list[AccessibleObject] | jpype.JArray, boolean: bool + ) -> None: ... + @typing.overload + def setAccessible(self, boolean: bool) -> None: ... + def toGenericString(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.reflect")``. + + AccessFlag: type[AccessFlag] + AccessibleObject: type[AccessibleObject] + AnnotatedArrayType: type[AnnotatedArrayType] + AnnotatedElement: type[AnnotatedElement] + AnnotatedParameterizedType: type[AnnotatedParameterizedType] + AnnotatedType: type[AnnotatedType] + AnnotatedTypeVariable: type[AnnotatedTypeVariable] + AnnotatedWildcardType: type[AnnotatedWildcardType] + Array: type[Array] + ClassFileFormatVersion: type[ClassFileFormatVersion] + Constructor: type[Constructor] + Executable: type[Executable] + Field: type[Field] + GenericArrayType: type[GenericArrayType] + GenericDeclaration: type[GenericDeclaration] + GenericSignatureFormatError: type[GenericSignatureFormatError] + InaccessibleObjectException: type[InaccessibleObjectException] + InvocationHandler: type[InvocationHandler] + InvocationTargetException: type[InvocationTargetException] + MalformedParameterizedTypeException: type[MalformedParameterizedTypeException] + MalformedParametersException: type[MalformedParametersException] + Member: type[Member] + Method: type[Method] + Modifier: type[Modifier] + Parameter: type[Parameter] + ParameterizedType: type[ParameterizedType] + Proxy: type[Proxy] + RecordComponent: type[RecordComponent] + ReflectPermission: type[ReflectPermission] + Type: type[Type] + TypeVariable: type[TypeVariable] + UndeclaredThrowableException: type[UndeclaredThrowableException] + WildcardType: type[WildcardType] diff --git a/typings/java/lang/runtime/__init__.pyi b/typings/java/lang/runtime/__init__.pyi new file mode 100644 index 0000000..2c8be6f --- /dev/null +++ b/typings/java/lang/runtime/__init__.pyi @@ -0,0 +1,83 @@ +import typing +from typing import Protocol + +import java.lang +import java.lang.invoke + +class ExactConversionsSupport: + @staticmethod + def isDoubleToByteExact(double: float) -> bool: ... + @staticmethod + def isDoubleToCharExact(double: float) -> bool: ... + @staticmethod + def isDoubleToFloatExact(double: float) -> bool: ... + @staticmethod + def isDoubleToIntExact(double: float) -> bool: ... + @staticmethod + def isDoubleToLongExact(double: float) -> bool: ... + @staticmethod + def isDoubleToShortExact(double: float) -> bool: ... + @staticmethod + def isFloatToByteExact(float: float) -> bool: ... + @staticmethod + def isFloatToCharExact(float: float) -> bool: ... + @staticmethod + def isFloatToIntExact(float: float) -> bool: ... + @staticmethod + def isFloatToLongExact(float: float) -> bool: ... + @staticmethod + def isFloatToShortExact(float: float) -> bool: ... + @staticmethod + def isIntToByteExact(int: int) -> bool: ... + @staticmethod + def isIntToCharExact(int: int) -> bool: ... + @staticmethod + def isIntToFloatExact(int: int) -> bool: ... + @staticmethod + def isIntToShortExact(int: int) -> bool: ... + @staticmethod + def isLongToByteExact(long: int) -> bool: ... + @staticmethod + def isLongToCharExact(long: int) -> bool: ... + @staticmethod + def isLongToDoubleExact(long: int) -> bool: ... + @staticmethod + def isLongToFloatExact(long: int) -> bool: ... + @staticmethod + def isLongToIntExact(long: int) -> bool: ... + @staticmethod + def isLongToShortExact(long: int) -> bool: ... + +class ObjectMethods: + @staticmethod + def bootstrap( + lookup: java.lang.invoke.MethodHandles.Lookup, + string: java.lang.String | str, + typeDescriptor: java.lang.invoke.TypeDescriptor | typing.Callable, + class_: type[typing.Any], + string2: java.lang.String | str, + *methodHandle: java.lang.invoke.MethodHandle, + ) -> typing.Any: ... + +class SwitchBootstraps: + @staticmethod + def enumSwitch( + lookup: java.lang.invoke.MethodHandles.Lookup, + string: java.lang.String | str, + methodType: java.lang.invoke.MethodType, + *object: typing.Any, + ) -> java.lang.invoke.CallSite: ... + @staticmethod + def typeSwitch( + lookup: java.lang.invoke.MethodHandles.Lookup, + string: java.lang.String | str, + methodType: java.lang.invoke.MethodType, + *object: typing.Any, + ) -> java.lang.invoke.CallSite: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.lang.runtime")``. + + ExactConversionsSupport: type[ExactConversionsSupport] + ObjectMethods: type[ObjectMethods] + SwitchBootstraps: type[SwitchBootstraps] diff --git a/typings/java/math/__init__.pyi b/typings/java/math/__init__.pyi new file mode 100644 index 0000000..ddd0da4 --- /dev/null +++ b/typings/java/math/__init__.pyi @@ -0,0 +1,324 @@ +import decimal +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import jpype +from jpype.protocol import _JBigDecimal + +class BigDecimal(java.lang.Number, java.lang.Comparable["BigDecimal"], _JBigDecimal): + ZERO: typing.ClassVar[BigDecimal] = ... + ONE: typing.ClassVar[BigDecimal] = ... + TWO: typing.ClassVar[BigDecimal] = ... + TEN: typing.ClassVar[BigDecimal] = ... + ROUND_UP: typing.ClassVar[int] = ... + ROUND_DOWN: typing.ClassVar[int] = ... + ROUND_CEILING: typing.ClassVar[int] = ... + ROUND_FLOOR: typing.ClassVar[int] = ... + ROUND_HALF_UP: typing.ClassVar[int] = ... + ROUND_HALF_DOWN: typing.ClassVar[int] = ... + ROUND_HALF_EVEN: typing.ClassVar[int] = ... + ROUND_UNNECESSARY: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, charArray: list[str] | jpype.JArray): ... + @typing.overload + def __init__(self, charArray: list[str] | jpype.JArray, int: int, int2: int): ... + @typing.overload + def __init__( + self, + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + mathContext: MathContext, + ): ... + @typing.overload + def __init__( + self, charArray: list[str] | jpype.JArray, mathContext: MathContext + ): ... + @typing.overload + def __init__(self, double: float): ... + @typing.overload + def __init__(self, double: float, mathContext: MathContext): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, mathContext: MathContext): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, mathContext: MathContext): ... + @typing.overload + def __init__(self, bigInteger: BigInteger): ... + @typing.overload + def __init__(self, bigInteger: BigInteger, int: int): ... + @typing.overload + def __init__(self, bigInteger: BigInteger, int: int, mathContext: MathContext): ... + @typing.overload + def __init__(self, bigInteger: BigInteger, mathContext: MathContext): ... + @typing.overload + def __init__(self, long: int): ... + @typing.overload + def __init__(self, long: int, mathContext: MathContext): ... + @typing.overload + def abs(self) -> BigDecimal: ... + @typing.overload + def abs(self, mathContext: MathContext) -> BigDecimal: ... + @typing.overload + def add(self, bigDecimal: BigDecimal | decimal.Decimal) -> BigDecimal: ... + @typing.overload + def add( + self, bigDecimal: BigDecimal | decimal.Decimal, mathContext: MathContext + ) -> BigDecimal: ... + def byteValueExact(self) -> int: ... + def compareTo(self, bigDecimal: BigDecimal | decimal.Decimal) -> int: ... + @typing.overload + def divide(self, bigDecimal: BigDecimal | decimal.Decimal) -> BigDecimal: ... + @typing.overload + def divide( + self, bigDecimal: BigDecimal | decimal.Decimal, int: int + ) -> BigDecimal: ... + @typing.overload + def divide( + self, bigDecimal: BigDecimal | decimal.Decimal, int: int, int2: int + ) -> BigDecimal: ... + @typing.overload + def divide( + self, + bigDecimal: BigDecimal | decimal.Decimal, + int: int, + roundingMode: RoundingMode, + ) -> BigDecimal: ... + @typing.overload + def divide( + self, bigDecimal: BigDecimal | decimal.Decimal, mathContext: MathContext + ) -> BigDecimal: ... + @typing.overload + def divide( + self, bigDecimal: BigDecimal | decimal.Decimal, roundingMode: RoundingMode + ) -> BigDecimal: ... + @typing.overload + def divideAndRemainder( + self, bigDecimal: BigDecimal | decimal.Decimal + ) -> typing.MutableSequence[BigDecimal]: ... + @typing.overload + def divideAndRemainder( + self, bigDecimal: BigDecimal | decimal.Decimal, mathContext: MathContext + ) -> typing.MutableSequence[BigDecimal]: ... + @typing.overload + def divideToIntegralValue( + self, bigDecimal: BigDecimal | decimal.Decimal + ) -> BigDecimal: ... + @typing.overload + def divideToIntegralValue( + self, bigDecimal: BigDecimal | decimal.Decimal, mathContext: MathContext + ) -> BigDecimal: ... + def doubleValue(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def floatValue(self) -> float: ... + def hashCode(self) -> int: ... + def intValue(self) -> int: ... + def intValueExact(self) -> int: ... + def longValue(self) -> int: ... + def longValueExact(self) -> int: ... + def max(self, bigDecimal: BigDecimal | decimal.Decimal) -> BigDecimal: ... + def min(self, bigDecimal: BigDecimal | decimal.Decimal) -> BigDecimal: ... + def movePointLeft(self, int: int) -> BigDecimal: ... + def movePointRight(self, int: int) -> BigDecimal: ... + @typing.overload + def multiply(self, bigDecimal: BigDecimal | decimal.Decimal) -> BigDecimal: ... + @typing.overload + def multiply( + self, bigDecimal: BigDecimal | decimal.Decimal, mathContext: MathContext + ) -> BigDecimal: ... + @typing.overload + def negate(self) -> BigDecimal: ... + @typing.overload + def negate(self, mathContext: MathContext) -> BigDecimal: ... + @typing.overload + def plus(self) -> BigDecimal: ... + @typing.overload + def plus(self, mathContext: MathContext) -> BigDecimal: ... + @typing.overload + def pow(self, int: int) -> BigDecimal: ... + @typing.overload + def pow(self, int: int, mathContext: MathContext) -> BigDecimal: ... + def precision(self) -> int: ... + @typing.overload + def remainder(self, bigDecimal: BigDecimal | decimal.Decimal) -> BigDecimal: ... + @typing.overload + def remainder( + self, bigDecimal: BigDecimal | decimal.Decimal, mathContext: MathContext + ) -> BigDecimal: ... + def round(self, mathContext: MathContext) -> BigDecimal: ... + def scale(self) -> int: ... + def scaleByPowerOfTen(self, int: int) -> BigDecimal: ... + @typing.overload + def setScale(self, int: int) -> BigDecimal: ... + @typing.overload + def setScale(self, int: int, int2: int) -> BigDecimal: ... + @typing.overload + def setScale(self, int: int, roundingMode: RoundingMode) -> BigDecimal: ... + def shortValueExact(self) -> int: ... + def signum(self) -> int: ... + def sqrt(self, mathContext: MathContext) -> BigDecimal: ... + def stripTrailingZeros(self) -> BigDecimal: ... + @typing.overload + def subtract(self, bigDecimal: BigDecimal | decimal.Decimal) -> BigDecimal: ... + @typing.overload + def subtract( + self, bigDecimal: BigDecimal | decimal.Decimal, mathContext: MathContext + ) -> BigDecimal: ... + def toBigInteger(self) -> BigInteger: ... + def toBigIntegerExact(self) -> BigInteger: ... + def toEngineeringString(self) -> java.lang.String: ... + def toPlainString(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def ulp(self) -> BigDecimal: ... + def unscaledValue(self) -> BigInteger: ... + @typing.overload + @staticmethod + def valueOf(double: float) -> BigDecimal: ... + @typing.overload + @staticmethod + def valueOf(long: int) -> BigDecimal: ... + @typing.overload + @staticmethod + def valueOf(long: int, int: int) -> BigDecimal: ... + +class BigInteger(java.lang.Number, java.lang.Comparable["BigInteger"]): + ZERO: typing.ClassVar[BigInteger] = ... + ONE: typing.ClassVar[BigInteger] = ... + TWO: typing.ClassVar[BigInteger] = ... + TEN: typing.ClassVar[BigInteger] = ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ): ... + @typing.overload + def __init__(self, int: int, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ): ... + @typing.overload + def __init__(self, int: int, int2: int, random: java.util.Random): ... + @typing.overload + def __init__(self, int: int, random: java.util.Random): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + def abs(self) -> BigInteger: ... + def add(self, bigInteger: BigInteger) -> BigInteger: ... + def andNot(self, bigInteger: BigInteger) -> BigInteger: ... + def and_(self, bigInteger: BigInteger) -> BigInteger: ... + def bitCount(self) -> int: ... + def bitLength(self) -> int: ... + def byteValueExact(self) -> int: ... + def clearBit(self, int: int) -> BigInteger: ... + def compareTo(self, bigInteger: BigInteger) -> int: ... + def divide(self, bigInteger: BigInteger) -> BigInteger: ... + def divideAndRemainder( + self, bigInteger: BigInteger + ) -> typing.MutableSequence[BigInteger]: ... + def doubleValue(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def flipBit(self, int: int) -> BigInteger: ... + def floatValue(self) -> float: ... + def gcd(self, bigInteger: BigInteger) -> BigInteger: ... + def getLowestSetBit(self) -> int: ... + def hashCode(self) -> int: ... + def intValue(self) -> int: ... + def intValueExact(self) -> int: ... + def isProbablePrime(self, int: int) -> bool: ... + def longValue(self) -> int: ... + def longValueExact(self) -> int: ... + def max(self, bigInteger: BigInteger) -> BigInteger: ... + def min(self, bigInteger: BigInteger) -> BigInteger: ... + def mod(self, bigInteger: BigInteger) -> BigInteger: ... + def modInverse(self, bigInteger: BigInteger) -> BigInteger: ... + def modPow(self, bigInteger: BigInteger, bigInteger2: BigInteger) -> BigInteger: ... + def multiply(self, bigInteger: BigInteger) -> BigInteger: ... + def negate(self) -> BigInteger: ... + def nextProbablePrime(self) -> BigInteger: ... + def not_(self) -> BigInteger: ... + def or_(self, bigInteger: BigInteger) -> BigInteger: ... + def parallelMultiply(self, bigInteger: BigInteger) -> BigInteger: ... + def pow(self, int: int) -> BigInteger: ... + @staticmethod + def probablePrime(int: int, random: java.util.Random) -> BigInteger: ... + def remainder(self, bigInteger: BigInteger) -> BigInteger: ... + def setBit(self, int: int) -> BigInteger: ... + def shiftLeft(self, int: int) -> BigInteger: ... + def shiftRight(self, int: int) -> BigInteger: ... + def shortValueExact(self) -> int: ... + def signum(self) -> int: ... + def sqrt(self) -> BigInteger: ... + def sqrtAndRemainder(self) -> typing.MutableSequence[BigInteger]: ... + def subtract(self, bigInteger: BigInteger) -> BigInteger: ... + def testBit(self, int: int) -> bool: ... + def toByteArray(self) -> typing.MutableSequence[int]: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + def toString(self, int: int) -> java.lang.String: ... + @staticmethod + def valueOf(long: int) -> BigInteger: ... + def xor(self, bigInteger: BigInteger) -> BigInteger: ... + +class MathContext(java.io.Serializable): + UNLIMITED: typing.ClassVar[MathContext] = ... + DECIMAL32: typing.ClassVar[MathContext] = ... + DECIMAL64: typing.ClassVar[MathContext] = ... + DECIMAL128: typing.ClassVar[MathContext] = ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, roundingMode: RoundingMode): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def equals(self, object: typing.Any) -> bool: ... + def getPrecision(self) -> int: ... + def getRoundingMode(self) -> RoundingMode: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class RoundingMode(java.lang.Enum["RoundingMode"]): + UP: typing.ClassVar[RoundingMode] = ... + DOWN: typing.ClassVar[RoundingMode] = ... + CEILING: typing.ClassVar[RoundingMode] = ... + FLOOR: typing.ClassVar[RoundingMode] = ... + HALF_UP: typing.ClassVar[RoundingMode] = ... + HALF_DOWN: typing.ClassVar[RoundingMode] = ... + HALF_EVEN: typing.ClassVar[RoundingMode] = ... + UNNECESSARY: typing.ClassVar[RoundingMode] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(int: int) -> RoundingMode: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> RoundingMode: ... + @staticmethod + def values() -> typing.MutableSequence[RoundingMode]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.math")``. + + BigDecimal: type[BigDecimal] + BigInteger: type[BigInteger] + MathContext: type[MathContext] + RoundingMode: type[RoundingMode] diff --git a/typings/java/net/__init__.pyi b/typings/java/net/__init__.pyi new file mode 100644 index 0000000..9442241 --- /dev/null +++ b/typings/java/net/__init__.pyi @@ -0,0 +1,1443 @@ +import builtins +import typing +from typing import Protocol + +import java.io +import java.lang +import java.net.http +import java.net.spi +import java.nio.channels +import java.nio.charset +import java.nio.file +import java.security +import java.security.cert +import java.util +import java.util.jar +import java.util.stream +import javax.net.ssl +import jpype +import jpype.protocol + +class Authenticator: + def __init__(self): ... + @staticmethod + def getDefault() -> Authenticator: ... + @typing.overload + @staticmethod + def requestPasswordAuthentication( + string: java.lang.String | str, + inetAddress: InetAddress, + int: int, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + ) -> PasswordAuthentication: ... + @typing.overload + @staticmethod + def requestPasswordAuthentication( + string: java.lang.String | str, + inetAddress: InetAddress, + int: int, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + uRL: URL, + requestorType: Authenticator.RequestorType, + ) -> PasswordAuthentication: ... + @typing.overload + @staticmethod + def requestPasswordAuthentication( + authenticator: Authenticator, + string: java.lang.String | str, + inetAddress: InetAddress, + int: int, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + uRL: URL, + requestorType: Authenticator.RequestorType, + ) -> PasswordAuthentication: ... + @typing.overload + @staticmethod + def requestPasswordAuthentication( + inetAddress: InetAddress, + int: int, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> PasswordAuthentication: ... + def requestPasswordAuthenticationInstance( + self, + string: java.lang.String | str, + inetAddress: InetAddress, + int: int, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + uRL: URL, + requestorType: Authenticator.RequestorType, + ) -> PasswordAuthentication: ... + @staticmethod + def setDefault(authenticator: Authenticator) -> None: ... + class RequestorType(java.lang.Enum["Authenticator.RequestorType"]): + PROXY: typing.ClassVar[Authenticator.RequestorType] = ... + SERVER: typing.ClassVar[Authenticator.RequestorType] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Authenticator.RequestorType: ... + @staticmethod + def values() -> typing.MutableSequence[Authenticator.RequestorType]: ... + +class CacheRequest: + def __init__(self): ... + def abort(self) -> None: ... + def getBody(self) -> java.io.OutputStream: ... + +class CacheResponse: + def __init__(self): ... + def getBody(self) -> java.io.InputStream: ... + def getHeaders( + self, + ) -> java.util.Map[java.lang.String, java.util.List[java.lang.String]]: ... + +class ContentHandler: + def __init__(self): ... + @typing.overload + def getContent(self, uRLConnection: URLConnection) -> typing.Any: ... + @typing.overload + def getContent( + self, uRLConnection: URLConnection, classArray: list[type] | jpype.JArray + ) -> typing.Any: ... + +class ContentHandlerFactory: + def createContentHandler( + self, string: java.lang.String | str + ) -> ContentHandler: ... + +class CookieHandler: + def __init__(self): ... + def get( + self, + uRI: URI, + map: java.util.Map[ + java.lang.String | str, java.util.List[java.lang.String | str] + ] + | typing.Mapping[ + java.lang.String | str, java.util.List[java.lang.String | str] + ], + ) -> java.util.Map[java.lang.String, java.util.List[java.lang.String]]: ... + @staticmethod + def getDefault() -> CookieHandler: ... + def put( + self, + uRI: URI, + map: java.util.Map[ + java.lang.String | str, java.util.List[java.lang.String | str] + ] + | typing.Mapping[ + java.lang.String | str, java.util.List[java.lang.String | str] + ], + ) -> None: ... + @staticmethod + def setDefault(cookieHandler: CookieHandler) -> None: ... + +class CookiePolicy: + ACCEPT_ALL: typing.ClassVar[CookiePolicy] = ... + ACCEPT_NONE: typing.ClassVar[CookiePolicy] = ... + ACCEPT_ORIGINAL_SERVER: typing.ClassVar[CookiePolicy] = ... + def shouldAccept(self, uRI: URI, httpCookie: HttpCookie) -> bool: ... + +class CookieStore: + def add(self, uRI: URI, httpCookie: HttpCookie) -> None: ... + def get(self, uRI: URI) -> java.util.List[HttpCookie]: ... + def getCookies(self) -> java.util.List[HttpCookie]: ... + def getURIs(self) -> java.util.List[URI]: ... + def remove(self, uRI: URI, httpCookie: HttpCookie) -> bool: ... + def removeAll(self) -> bool: ... + +class DatagramPacket: + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes, int: int): ... + @typing.overload + def __init__( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + inetAddress: InetAddress, + int3: int, + ): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + socketAddress: SocketAddress, + ): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + inetAddress: InetAddress, + int2: int, + ): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + socketAddress: SocketAddress, + ): ... + def getAddress(self) -> InetAddress: ... + def getData(self) -> typing.MutableSequence[int]: ... + def getLength(self) -> int: ... + def getOffset(self) -> int: ... + def getPort(self) -> int: ... + def getSocketAddress(self) -> SocketAddress: ... + def setAddress(self, inetAddress: InetAddress) -> None: ... + @typing.overload + def setData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def setLength(self, int: int) -> None: ... + def setPort(self, int: int) -> None: ... + def setSocketAddress(self, socketAddress: SocketAddress) -> None: ... + +class DatagramSocket(java.io.Closeable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, inetAddress: InetAddress): ... + @typing.overload + def __init__(self, socketAddress: SocketAddress): ... + def bind(self, socketAddress: SocketAddress) -> None: ... + def close(self) -> None: ... + @typing.overload + def connect(self, inetAddress: InetAddress, int: int) -> None: ... + @typing.overload + def connect(self, socketAddress: SocketAddress) -> None: ... + def disconnect(self) -> None: ... + def getBroadcast(self) -> bool: ... + def getChannel(self) -> java.nio.channels.DatagramChannel: ... + def getInetAddress(self) -> InetAddress: ... + def getLocalAddress(self) -> InetAddress: ... + def getLocalPort(self) -> int: ... + def getLocalSocketAddress(self) -> SocketAddress: ... + _getOption__T = typing.TypeVar("_getOption__T") # + def getOption(self, socketOption: SocketOption[_getOption__T]) -> _getOption__T: ... + def getPort(self) -> int: ... + def getReceiveBufferSize(self) -> int: ... + def getRemoteSocketAddress(self) -> SocketAddress: ... + def getReuseAddress(self) -> bool: ... + def getSendBufferSize(self) -> int: ... + def getSoTimeout(self) -> int: ... + def getTrafficClass(self) -> int: ... + def isBound(self) -> bool: ... + def isClosed(self) -> bool: ... + def isConnected(self) -> bool: ... + def joinGroup( + self, socketAddress: SocketAddress, networkInterface: NetworkInterface + ) -> None: ... + def leaveGroup( + self, socketAddress: SocketAddress, networkInterface: NetworkInterface + ) -> None: ... + def receive(self, datagramPacket: DatagramPacket) -> None: ... + def send(self, datagramPacket: DatagramPacket) -> None: ... + def setBroadcast(self, boolean: bool) -> None: ... + @staticmethod + def setDatagramSocketImplFactory( + datagramSocketImplFactory: DatagramSocketImplFactory | typing.Callable, + ) -> None: ... + _setOption__T = typing.TypeVar("_setOption__T") # + def setOption( + self, socketOption: SocketOption[_setOption__T], t: _setOption__T + ) -> DatagramSocket: ... + def setReceiveBufferSize(self, int: int) -> None: ... + def setReuseAddress(self, boolean: bool) -> None: ... + def setSendBufferSize(self, int: int) -> None: ... + def setSoTimeout(self, int: int) -> None: ... + def setTrafficClass(self, int: int) -> None: ... + def supportedOptions(self) -> java.util.Set[SocketOption[typing.Any]]: ... + +class DatagramSocketImplFactory: + def createDatagramSocketImpl(self) -> DatagramSocketImpl: ... + +class FileNameMap: + def getContentTypeFor(self, string: java.lang.String | str) -> java.lang.String: ... + +class HttpCookie(java.lang.Cloneable): + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def clone(self) -> typing.Any: ... + @staticmethod + def domainMatches( + string: java.lang.String | str, string2: java.lang.String | str + ) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def getComment(self) -> java.lang.String: ... + def getCommentURL(self) -> java.lang.String: ... + def getDiscard(self) -> bool: ... + def getDomain(self) -> java.lang.String: ... + def getMaxAge(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getPath(self) -> java.lang.String: ... + def getPortlist(self) -> java.lang.String: ... + def getSecure(self) -> bool: ... + def getValue(self) -> java.lang.String: ... + def getVersion(self) -> int: ... + def hasExpired(self) -> bool: ... + def hashCode(self) -> int: ... + def isHttpOnly(self) -> bool: ... + @staticmethod + def parse(string: java.lang.String | str) -> java.util.List[HttpCookie]: ... + def setComment(self, string: java.lang.String | str) -> None: ... + def setCommentURL(self, string: java.lang.String | str) -> None: ... + def setDiscard(self, boolean: bool) -> None: ... + def setDomain(self, string: java.lang.String | str) -> None: ... + def setHttpOnly(self, boolean: bool) -> None: ... + def setMaxAge(self, long: int) -> None: ... + def setPath(self, string: java.lang.String | str) -> None: ... + def setPortlist(self, string: java.lang.String | str) -> None: ... + def setSecure(self, boolean: bool) -> None: ... + def setValue(self, string: java.lang.String | str) -> None: ... + def setVersion(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class HttpRetryException(java.io.IOException): + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, int: int, string2: java.lang.String | str + ): ... + def getLocation(self) -> java.lang.String: ... + def getReason(self) -> java.lang.String: ... + def responseCode(self) -> int: ... + +class IDN: + ALLOW_UNASSIGNED: typing.ClassVar[int] = ... + USE_STD3_ASCII_RULES: typing.ClassVar[int] = ... + @typing.overload + @staticmethod + def toASCII(string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + @staticmethod + def toASCII(string: java.lang.String | str, int: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def toUnicode(string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + @staticmethod + def toUnicode(string: java.lang.String | str, int: int) -> java.lang.String: ... + +class InetAddress(java.io.Serializable): + def equals(self, object: typing.Any) -> bool: ... + def getAddress(self) -> typing.MutableSequence[int]: ... + @staticmethod + def getAllByName( + string: java.lang.String | str, + ) -> typing.MutableSequence[InetAddress]: ... + @typing.overload + @staticmethod + def getByAddress(byteArray: list[int] | jpype.JArray | bytes) -> InetAddress: ... + @typing.overload + @staticmethod + def getByAddress( + string: java.lang.String | str, byteArray: list[int] | jpype.JArray | bytes + ) -> InetAddress: ... + @staticmethod + def getByName(string: java.lang.String | str) -> InetAddress: ... + def getCanonicalHostName(self) -> java.lang.String: ... + def getHostAddress(self) -> java.lang.String: ... + def getHostName(self) -> java.lang.String: ... + @staticmethod + def getLocalHost() -> InetAddress: ... + @staticmethod + def getLoopbackAddress() -> InetAddress: ... + def hashCode(self) -> int: ... + def isAnyLocalAddress(self) -> bool: ... + def isLinkLocalAddress(self) -> bool: ... + def isLoopbackAddress(self) -> bool: ... + def isMCGlobal(self) -> bool: ... + def isMCLinkLocal(self) -> bool: ... + def isMCNodeLocal(self) -> bool: ... + def isMCOrgLocal(self) -> bool: ... + def isMCSiteLocal(self) -> bool: ... + def isMulticastAddress(self) -> bool: ... + @typing.overload + def isReachable(self, int: int) -> bool: ... + @typing.overload + def isReachable( + self, networkInterface: NetworkInterface, int: int, int2: int + ) -> bool: ... + def isSiteLocalAddress(self) -> bool: ... + @staticmethod + def ofLiteral(string: java.lang.String | str) -> InetAddress: ... + def toString(self) -> java.lang.String: ... + +class InterfaceAddress: + def equals(self, object: typing.Any) -> bool: ... + def getAddress(self) -> InetAddress: ... + def getBroadcast(self) -> InetAddress: ... + def getNetworkPrefixLength(self) -> int: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class MalformedURLException(java.io.IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class NetPermission(java.security.BasicPermission): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class NetworkInterface: + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def getByIndex(int: int) -> NetworkInterface: ... + @staticmethod + def getByInetAddress(inetAddress: InetAddress) -> NetworkInterface: ... + @staticmethod + def getByName(string: java.lang.String | str) -> NetworkInterface: ... + def getDisplayName(self) -> java.lang.String: ... + def getHardwareAddress(self) -> typing.MutableSequence[int]: ... + def getIndex(self) -> int: ... + def getInetAddresses(self) -> java.util.Enumeration[InetAddress]: ... + def getInterfaceAddresses(self) -> java.util.List[InterfaceAddress]: ... + def getMTU(self) -> int: ... + def getName(self) -> java.lang.String: ... + @staticmethod + def getNetworkInterfaces() -> java.util.Enumeration[NetworkInterface]: ... + def getParent(self) -> NetworkInterface: ... + def getSubInterfaces(self) -> java.util.Enumeration[NetworkInterface]: ... + def hashCode(self) -> int: ... + def inetAddresses(self) -> java.util.stream.Stream[InetAddress]: ... + def isLoopback(self) -> bool: ... + def isPointToPoint(self) -> bool: ... + def isUp(self) -> bool: ... + def isVirtual(self) -> bool: ... + @staticmethod + def networkInterfaces() -> java.util.stream.Stream[NetworkInterface]: ... + def subInterfaces(self) -> java.util.stream.Stream[NetworkInterface]: ... + def supportsMulticast(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class PasswordAuthentication: + def __init__( + self, string: java.lang.String | str, charArray: list[str] | jpype.JArray + ): ... + def getPassword(self) -> typing.MutableSequence[str]: ... + def getUserName(self) -> java.lang.String: ... + +class ProtocolException(java.io.IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class ProtocolFamily: + def name(self) -> java.lang.String: ... + +class Proxy: + NO_PROXY: typing.ClassVar[Proxy] = ... + def __init__(self, type: Proxy.Type, socketAddress: SocketAddress): ... + def address(self) -> SocketAddress: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def type(self) -> Proxy.Type: ... + class Type(java.lang.Enum["Proxy.Type"]): + DIRECT: typing.ClassVar[Proxy.Type] = ... + HTTP: typing.ClassVar[Proxy.Type] = ... + SOCKS: typing.ClassVar[Proxy.Type] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Proxy.Type: ... + @staticmethod + def values() -> typing.MutableSequence[Proxy.Type]: ... + +class ProxySelector: + def __init__(self): ... + def connectFailed( + self, uRI: URI, socketAddress: SocketAddress, iOException: java.io.IOException + ) -> None: ... + @staticmethod + def getDefault() -> ProxySelector: ... + @staticmethod + def of(inetSocketAddress: InetSocketAddress) -> ProxySelector: ... + def select(self, uRI: URI) -> java.util.List[Proxy]: ... + @staticmethod + def setDefault(proxySelector: ProxySelector) -> None: ... + +class ResponseCache: + def __init__(self): ... + def get( + self, + uRI: URI, + string: java.lang.String | str, + map: java.util.Map[ + java.lang.String | str, java.util.List[java.lang.String | str] + ] + | typing.Mapping[ + java.lang.String | str, java.util.List[java.lang.String | str] + ], + ) -> CacheResponse: ... + @staticmethod + def getDefault() -> ResponseCache: ... + def put(self, uRI: URI, uRLConnection: URLConnection) -> CacheRequest: ... + @staticmethod + def setDefault(responseCache: ResponseCache) -> None: ... + +class ServerSocket(java.io.Closeable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, int: int, int2: int, inetAddress: InetAddress): ... + def accept(self) -> Socket: ... + @typing.overload + def bind(self, socketAddress: SocketAddress) -> None: ... + @typing.overload + def bind(self, socketAddress: SocketAddress, int: int) -> None: ... + def close(self) -> None: ... + def getChannel(self) -> java.nio.channels.ServerSocketChannel: ... + def getInetAddress(self) -> InetAddress: ... + def getLocalPort(self) -> int: ... + def getLocalSocketAddress(self) -> SocketAddress: ... + _getOption__T = typing.TypeVar("_getOption__T") # + def getOption(self, socketOption: SocketOption[_getOption__T]) -> _getOption__T: ... + def getReceiveBufferSize(self) -> int: ... + def getReuseAddress(self) -> bool: ... + def getSoTimeout(self) -> int: ... + def isBound(self) -> bool: ... + def isClosed(self) -> bool: ... + _setOption__T = typing.TypeVar("_setOption__T") # + def setOption( + self, socketOption: SocketOption[_setOption__T], t: _setOption__T + ) -> ServerSocket: ... + def setPerformancePreferences(self, int: int, int2: int, int3: int) -> None: ... + def setReceiveBufferSize(self, int: int) -> None: ... + def setReuseAddress(self, boolean: bool) -> None: ... + def setSoTimeout(self, int: int) -> None: ... + @staticmethod + def setSocketFactory( + socketImplFactory: SocketImplFactory | typing.Callable, + ) -> None: ... + def supportedOptions(self) -> java.util.Set[SocketOption[typing.Any]]: ... + def toString(self) -> java.lang.String: ... + +class Socket(java.io.Closeable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int, boolean: bool): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + int: int, + inetAddress: InetAddress, + int2: int, + ): ... + @typing.overload + def __init__(self, inetAddress: InetAddress, int: int): ... + @typing.overload + def __init__(self, inetAddress: InetAddress, int: int, boolean: bool): ... + @typing.overload + def __init__( + self, inetAddress: InetAddress, int: int, inetAddress2: InetAddress, int2: int + ): ... + @typing.overload + def __init__(self, proxy: Proxy): ... + def bind(self, socketAddress: SocketAddress) -> None: ... + def close(self) -> None: ... + @typing.overload + def connect(self, socketAddress: SocketAddress) -> None: ... + @typing.overload + def connect(self, socketAddress: SocketAddress, int: int) -> None: ... + def getChannel(self) -> java.nio.channels.SocketChannel: ... + def getInetAddress(self) -> InetAddress: ... + def getInputStream(self) -> java.io.InputStream: ... + def getKeepAlive(self) -> bool: ... + def getLocalAddress(self) -> InetAddress: ... + def getLocalPort(self) -> int: ... + def getLocalSocketAddress(self) -> SocketAddress: ... + def getOOBInline(self) -> bool: ... + _getOption__T = typing.TypeVar("_getOption__T") # + def getOption(self, socketOption: SocketOption[_getOption__T]) -> _getOption__T: ... + def getOutputStream(self) -> java.io.OutputStream: ... + def getPort(self) -> int: ... + def getReceiveBufferSize(self) -> int: ... + def getRemoteSocketAddress(self) -> SocketAddress: ... + def getReuseAddress(self) -> bool: ... + def getSendBufferSize(self) -> int: ... + def getSoLinger(self) -> int: ... + def getSoTimeout(self) -> int: ... + def getTcpNoDelay(self) -> bool: ... + def getTrafficClass(self) -> int: ... + def isBound(self) -> bool: ... + def isClosed(self) -> bool: ... + def isConnected(self) -> bool: ... + def isInputShutdown(self) -> bool: ... + def isOutputShutdown(self) -> bool: ... + def sendUrgentData(self, int: int) -> None: ... + def setKeepAlive(self, boolean: bool) -> None: ... + def setOOBInline(self, boolean: bool) -> None: ... + _setOption__T = typing.TypeVar("_setOption__T") # + def setOption( + self, socketOption: SocketOption[_setOption__T], t: _setOption__T + ) -> Socket: ... + def setPerformancePreferences(self, int: int, int2: int, int3: int) -> None: ... + def setReceiveBufferSize(self, int: int) -> None: ... + def setReuseAddress(self, boolean: bool) -> None: ... + def setSendBufferSize(self, int: int) -> None: ... + def setSoLinger(self, boolean: bool, int: int) -> None: ... + def setSoTimeout(self, int: int) -> None: ... + @staticmethod + def setSocketImplFactory( + socketImplFactory: SocketImplFactory | typing.Callable, + ) -> None: ... + def setTcpNoDelay(self, boolean: bool) -> None: ... + def setTrafficClass(self, int: int) -> None: ... + def shutdownInput(self) -> None: ... + def shutdownOutput(self) -> None: ... + def supportedOptions(self) -> java.util.Set[SocketOption[typing.Any]]: ... + def toString(self) -> java.lang.String: ... + +class SocketAddress(java.io.Serializable): + def __init__(self): ... + +class SocketException(java.io.IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SocketImplFactory: + def createSocketImpl(self) -> SocketImpl: ... + +_SocketOption__T = typing.TypeVar("_SocketOption__T") # + +class SocketOption(typing.Generic[_SocketOption__T]): + def name(self) -> java.lang.String: ... + def type(self) -> builtins.type[_SocketOption__T]: ... + +class SocketOptions: + TCP_NODELAY: typing.ClassVar[int] = ... + SO_BINDADDR: typing.ClassVar[int] = ... + SO_REUSEADDR: typing.ClassVar[int] = ... + SO_REUSEPORT: typing.ClassVar[int] = ... + SO_BROADCAST: typing.ClassVar[int] = ... + IP_MULTICAST_IF: typing.ClassVar[int] = ... + IP_MULTICAST_IF2: typing.ClassVar[int] = ... + IP_MULTICAST_LOOP: typing.ClassVar[int] = ... + IP_TOS: typing.ClassVar[int] = ... + SO_LINGER: typing.ClassVar[int] = ... + SO_TIMEOUT: typing.ClassVar[int] = ... + SO_SNDBUF: typing.ClassVar[int] = ... + SO_RCVBUF: typing.ClassVar[int] = ... + SO_KEEPALIVE: typing.ClassVar[int] = ... + SO_OOBINLINE: typing.ClassVar[int] = ... + def getOption(self, int: int) -> typing.Any: ... + def setOption(self, int: int, object: typing.Any) -> None: ... + +class SocketPermission(java.security.Permission, java.io.Serializable): + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getActions(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def implies(self, permission: java.security.Permission) -> bool: ... + def newPermissionCollection(self) -> java.security.PermissionCollection: ... + +class SocketTimeoutException(java.io.InterruptedIOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class StandardSocketOptions: + SO_BROADCAST: typing.ClassVar[SocketOption] = ... + SO_KEEPALIVE: typing.ClassVar[SocketOption] = ... + SO_SNDBUF: typing.ClassVar[SocketOption] = ... + SO_RCVBUF: typing.ClassVar[SocketOption] = ... + SO_REUSEADDR: typing.ClassVar[SocketOption] = ... + SO_REUSEPORT: typing.ClassVar[SocketOption] = ... + SO_LINGER: typing.ClassVar[SocketOption] = ... + IP_TOS: typing.ClassVar[SocketOption] = ... + IP_MULTICAST_IF: typing.ClassVar[SocketOption] = ... + IP_MULTICAST_TTL: typing.ClassVar[SocketOption] = ... + IP_MULTICAST_LOOP: typing.ClassVar[SocketOption] = ... + TCP_NODELAY: typing.ClassVar[SocketOption] = ... + +class URI(java.lang.Comparable["URI"], java.io.Serializable): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + int: int, + string4: java.lang.String | str, + string5: java.lang.String | str, + string6: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + string5: java.lang.String | str, + ): ... + def compareTo(self, uRI: URI) -> int: ... + @staticmethod + def create(string: java.lang.String | str) -> URI: ... + def equals(self, object: typing.Any) -> bool: ... + def getAuthority(self) -> java.lang.String: ... + def getFragment(self) -> java.lang.String: ... + def getHost(self) -> java.lang.String: ... + def getPath(self) -> java.lang.String: ... + def getPort(self) -> int: ... + def getQuery(self) -> java.lang.String: ... + def getRawAuthority(self) -> java.lang.String: ... + def getRawFragment(self) -> java.lang.String: ... + def getRawPath(self) -> java.lang.String: ... + def getRawQuery(self) -> java.lang.String: ... + def getRawSchemeSpecificPart(self) -> java.lang.String: ... + def getRawUserInfo(self) -> java.lang.String: ... + def getScheme(self) -> java.lang.String: ... + def getSchemeSpecificPart(self) -> java.lang.String: ... + def getUserInfo(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def isAbsolute(self) -> bool: ... + def isOpaque(self) -> bool: ... + def normalize(self) -> URI: ... + def parseServerAuthority(self) -> URI: ... + def relativize(self, uRI: URI) -> URI: ... + @typing.overload + def resolve(self, string: java.lang.String | str) -> URI: ... + @typing.overload + def resolve(self, uRI: URI) -> URI: ... + def toASCIIString(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def toURL(self) -> URL: ... + +class URISyntaxException(java.lang.Exception): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + def getIndex(self) -> int: ... + def getInput(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + def getReason(self) -> java.lang.String: ... + +class URL(java.io.Serializable): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + string3: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + string3: java.lang.String | str, + uRLStreamHandler: URLStreamHandler, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + @typing.overload + def __init__(self, uRL: URL, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + uRL: URL, + string: java.lang.String | str, + uRLStreamHandler: URLStreamHandler, + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getAuthority(self) -> java.lang.String: ... + @typing.overload + def getContent(self) -> typing.Any: ... + @typing.overload + def getContent( + self, classArray: list[type[typing.Any]] | jpype.JArray + ) -> typing.Any: ... + def getDefaultPort(self) -> int: ... + def getFile(self) -> java.lang.String: ... + def getHost(self) -> java.lang.String: ... + def getPath(self) -> java.lang.String: ... + def getPort(self) -> int: ... + def getProtocol(self) -> java.lang.String: ... + def getQuery(self) -> java.lang.String: ... + def getRef(self) -> java.lang.String: ... + def getUserInfo(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + @staticmethod + def of(uRI: URI, uRLStreamHandler: URLStreamHandler) -> URL: ... + @typing.overload + def openConnection(self) -> URLConnection: ... + @typing.overload + def openConnection(self, proxy: Proxy) -> URLConnection: ... + def openStream(self) -> java.io.InputStream: ... + def sameFile(self, uRL: URL) -> bool: ... + @staticmethod + def setURLStreamHandlerFactory( + uRLStreamHandlerFactory: URLStreamHandlerFactory | typing.Callable, + ) -> None: ... + def toExternalForm(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def toURI(self) -> URI: ... + +class URLClassLoader(java.security.SecureClassLoader, java.io.Closeable): + @typing.overload + def __init__( + self, + string: java.lang.String | str, + uRLArray: list[URL] | jpype.JArray, + classLoader: java.lang.ClassLoader, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + uRLArray: list[URL] | jpype.JArray, + classLoader: java.lang.ClassLoader, + uRLStreamHandlerFactory: URLStreamHandlerFactory | typing.Callable, + ): ... + @typing.overload + def __init__(self, uRLArray: list[URL] | jpype.JArray): ... + @typing.overload + def __init__( + self, uRLArray: list[URL] | jpype.JArray, classLoader: java.lang.ClassLoader + ): ... + @typing.overload + def __init__( + self, + uRLArray: list[URL] | jpype.JArray, + classLoader: java.lang.ClassLoader, + uRLStreamHandlerFactory: URLStreamHandlerFactory | typing.Callable, + ): ... + def close(self) -> None: ... + def findResource(self, string: java.lang.String | str) -> URL: ... + def findResources( + self, string: java.lang.String | str + ) -> java.util.Enumeration[URL]: ... + def getResourceAsStream( + self, string: java.lang.String | str + ) -> java.io.InputStream: ... + def getURLs(self) -> typing.MutableSequence[URL]: ... + @typing.overload + @staticmethod + def newInstance(uRLArray: list[URL] | jpype.JArray) -> URLClassLoader: ... + @typing.overload + @staticmethod + def newInstance( + uRLArray: list[URL] | jpype.JArray, classLoader: java.lang.ClassLoader + ) -> URLClassLoader: ... + +class URLConnection: + def addRequestProperty( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + def connect(self) -> None: ... + def getAllowUserInteraction(self) -> bool: ... + def getConnectTimeout(self) -> int: ... + @typing.overload + def getContent(self) -> typing.Any: ... + @typing.overload + def getContent( + self, classArray: list[type[typing.Any]] | jpype.JArray + ) -> typing.Any: ... + def getContentEncoding(self) -> java.lang.String: ... + def getContentLength(self) -> int: ... + def getContentLengthLong(self) -> int: ... + def getContentType(self) -> java.lang.String: ... + def getDate(self) -> int: ... + @staticmethod + def getDefaultAllowUserInteraction() -> bool: ... + @staticmethod + def getDefaultRequestProperty( + string: java.lang.String | str, + ) -> java.lang.String: ... + @typing.overload + def getDefaultUseCaches(self) -> bool: ... + @typing.overload + @staticmethod + def getDefaultUseCaches(string: java.lang.String | str) -> bool: ... + def getDoInput(self) -> bool: ... + def getDoOutput(self) -> bool: ... + def getExpiration(self) -> int: ... + @staticmethod + def getFileNameMap() -> FileNameMap: ... + @typing.overload + def getHeaderField(self, int: int) -> java.lang.String: ... + @typing.overload + def getHeaderField(self, string: java.lang.String | str) -> java.lang.String: ... + def getHeaderFieldDate(self, string: java.lang.String | str, long: int) -> int: ... + def getHeaderFieldInt(self, string: java.lang.String | str, int: int) -> int: ... + def getHeaderFieldKey(self, int: int) -> java.lang.String: ... + def getHeaderFieldLong(self, string: java.lang.String | str, long: int) -> int: ... + def getHeaderFields( + self, + ) -> java.util.Map[java.lang.String, java.util.List[java.lang.String]]: ... + def getIfModifiedSince(self) -> int: ... + def getInputStream(self) -> java.io.InputStream: ... + def getLastModified(self) -> int: ... + def getOutputStream(self) -> java.io.OutputStream: ... + def getPermission(self) -> java.security.Permission: ... + def getReadTimeout(self) -> int: ... + def getRequestProperties( + self, + ) -> java.util.Map[java.lang.String, java.util.List[java.lang.String]]: ... + def getRequestProperty( + self, string: java.lang.String | str + ) -> java.lang.String: ... + def getURL(self) -> URL: ... + def getUseCaches(self) -> bool: ... + @staticmethod + def guessContentTypeFromName( + string: java.lang.String | str, + ) -> java.lang.String: ... + @staticmethod + def guessContentTypeFromStream( + inputStream: java.io.InputStream, + ) -> java.lang.String: ... + def setAllowUserInteraction(self, boolean: bool) -> None: ... + def setConnectTimeout(self, int: int) -> None: ... + @staticmethod + def setContentHandlerFactory( + contentHandlerFactory: ContentHandlerFactory | typing.Callable, + ) -> None: ... + @staticmethod + def setDefaultAllowUserInteraction(boolean: bool) -> None: ... + @staticmethod + def setDefaultRequestProperty( + string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + @staticmethod + def setDefaultUseCaches(string: java.lang.String | str, boolean: bool) -> None: ... + @typing.overload + def setDefaultUseCaches(self, boolean: bool) -> None: ... + def setDoInput(self, boolean: bool) -> None: ... + def setDoOutput(self, boolean: bool) -> None: ... + @staticmethod + def setFileNameMap(fileNameMap: FileNameMap | typing.Callable) -> None: ... + def setIfModifiedSince(self, long: int) -> None: ... + def setReadTimeout(self, int: int) -> None: ... + def setRequestProperty( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + def setUseCaches(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class URLDecoder: + @typing.overload + @staticmethod + def decode(string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + @staticmethod + def decode( + string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def decode( + string: java.lang.String | str, charset: java.nio.charset.Charset + ) -> java.lang.String: ... + +class URLEncoder: + @typing.overload + @staticmethod + def encode(string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + @staticmethod + def encode( + string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def encode( + string: java.lang.String | str, charset: java.nio.charset.Charset + ) -> java.lang.String: ... + +class URLPermission(java.security.Permission): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getActions(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def implies(self, permission: java.security.Permission) -> bool: ... + +class URLStreamHandler: + def __init__(self): ... + +class URLStreamHandlerFactory: + def createURLStreamHandler( + self, string: java.lang.String | str + ) -> URLStreamHandler: ... + +class UnknownHostException(java.io.IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class UnknownServiceException(java.io.IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class BindException(SocketException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class ConnectException(SocketException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class CookieManager(CookieHandler): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, cookieStore: CookieStore, cookiePolicy: CookiePolicy | typing.Callable + ): ... + def get( + self, + uRI: URI, + map: java.util.Map[ + java.lang.String | str, java.util.List[java.lang.String | str] + ] + | typing.Mapping[ + java.lang.String | str, java.util.List[java.lang.String | str] + ], + ) -> java.util.Map[java.lang.String, java.util.List[java.lang.String]]: ... + def getCookieStore(self) -> CookieStore: ... + def put( + self, + uRI: URI, + map: java.util.Map[ + java.lang.String | str, java.util.List[java.lang.String | str] + ] + | typing.Mapping[ + java.lang.String | str, java.util.List[java.lang.String | str] + ], + ) -> None: ... + def setCookiePolicy(self, cookiePolicy: CookiePolicy | typing.Callable) -> None: ... + +class DatagramSocketImpl(SocketOptions): + def __init__(self): ... + +class HttpURLConnection(URLConnection): + HTTP_OK: typing.ClassVar[int] = ... + HTTP_CREATED: typing.ClassVar[int] = ... + HTTP_ACCEPTED: typing.ClassVar[int] = ... + HTTP_NOT_AUTHORITATIVE: typing.ClassVar[int] = ... + HTTP_NO_CONTENT: typing.ClassVar[int] = ... + HTTP_RESET: typing.ClassVar[int] = ... + HTTP_PARTIAL: typing.ClassVar[int] = ... + HTTP_MULT_CHOICE: typing.ClassVar[int] = ... + HTTP_MOVED_PERM: typing.ClassVar[int] = ... + HTTP_MOVED_TEMP: typing.ClassVar[int] = ... + HTTP_SEE_OTHER: typing.ClassVar[int] = ... + HTTP_NOT_MODIFIED: typing.ClassVar[int] = ... + HTTP_USE_PROXY: typing.ClassVar[int] = ... + HTTP_BAD_REQUEST: typing.ClassVar[int] = ... + HTTP_UNAUTHORIZED: typing.ClassVar[int] = ... + HTTP_PAYMENT_REQUIRED: typing.ClassVar[int] = ... + HTTP_FORBIDDEN: typing.ClassVar[int] = ... + HTTP_NOT_FOUND: typing.ClassVar[int] = ... + HTTP_BAD_METHOD: typing.ClassVar[int] = ... + HTTP_NOT_ACCEPTABLE: typing.ClassVar[int] = ... + HTTP_PROXY_AUTH: typing.ClassVar[int] = ... + HTTP_CLIENT_TIMEOUT: typing.ClassVar[int] = ... + HTTP_CONFLICT: typing.ClassVar[int] = ... + HTTP_GONE: typing.ClassVar[int] = ... + HTTP_LENGTH_REQUIRED: typing.ClassVar[int] = ... + HTTP_PRECON_FAILED: typing.ClassVar[int] = ... + HTTP_ENTITY_TOO_LARGE: typing.ClassVar[int] = ... + HTTP_REQ_TOO_LONG: typing.ClassVar[int] = ... + HTTP_UNSUPPORTED_TYPE: typing.ClassVar[int] = ... + HTTP_SERVER_ERROR: typing.ClassVar[int] = ... + HTTP_INTERNAL_ERROR: typing.ClassVar[int] = ... + HTTP_NOT_IMPLEMENTED: typing.ClassVar[int] = ... + HTTP_BAD_GATEWAY: typing.ClassVar[int] = ... + HTTP_UNAVAILABLE: typing.ClassVar[int] = ... + HTTP_GATEWAY_TIMEOUT: typing.ClassVar[int] = ... + HTTP_VERSION: typing.ClassVar[int] = ... + def disconnect(self) -> None: ... + def getErrorStream(self) -> java.io.InputStream: ... + @staticmethod + def getFollowRedirects() -> bool: ... + @typing.overload + def getHeaderField(self, int: int) -> java.lang.String: ... + @typing.overload + def getHeaderField(self, string: java.lang.String | str) -> java.lang.String: ... + def getHeaderFieldDate(self, string: java.lang.String | str, long: int) -> int: ... + def getHeaderFieldKey(self, int: int) -> java.lang.String: ... + def getInstanceFollowRedirects(self) -> bool: ... + def getPermission(self) -> java.security.Permission: ... + def getRequestMethod(self) -> java.lang.String: ... + def getResponseCode(self) -> int: ... + def getResponseMessage(self) -> java.lang.String: ... + def setAuthenticator(self, authenticator: Authenticator) -> None: ... + def setChunkedStreamingMode(self, int: int) -> None: ... + @typing.overload + def setFixedLengthStreamingMode(self, int: int) -> None: ... + @typing.overload + def setFixedLengthStreamingMode(self, long: int) -> None: ... + @staticmethod + def setFollowRedirects(boolean: bool) -> None: ... + def setInstanceFollowRedirects(self, boolean: bool) -> None: ... + def setRequestMethod(self, string: java.lang.String | str) -> None: ... + def usingProxy(self) -> bool: ... + +class Inet4Address(InetAddress): + def equals(self, object: typing.Any) -> bool: ... + def getAddress(self) -> typing.MutableSequence[int]: ... + def getHostAddress(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def isAnyLocalAddress(self) -> bool: ... + def isLinkLocalAddress(self) -> bool: ... + def isLoopbackAddress(self) -> bool: ... + def isMCGlobal(self) -> bool: ... + def isMCLinkLocal(self) -> bool: ... + def isMCNodeLocal(self) -> bool: ... + def isMCOrgLocal(self) -> bool: ... + def isMCSiteLocal(self) -> bool: ... + def isMulticastAddress(self) -> bool: ... + def isSiteLocalAddress(self) -> bool: ... + @typing.overload + @staticmethod + def ofLiteral(string: java.lang.String | str) -> Inet4Address: ... + @typing.overload + @staticmethod + def ofLiteral(string: java.lang.String | str) -> InetAddress: ... + @staticmethod + def ofPosixLiteral(string: java.lang.String | str) -> Inet4Address: ... + +class Inet6Address(InetAddress): + def equals(self, object: typing.Any) -> bool: ... + def getAddress(self) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def getByAddress( + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + ) -> Inet6Address: ... + @typing.overload + @staticmethod + def getByAddress( + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + networkInterface: NetworkInterface, + ) -> Inet6Address: ... + @typing.overload + @staticmethod + def getByAddress(byteArray: list[int] | jpype.JArray | bytes) -> InetAddress: ... + @typing.overload + @staticmethod + def getByAddress( + string: java.lang.String | str, byteArray: list[int] | jpype.JArray | bytes + ) -> InetAddress: ... + def getHostAddress(self) -> java.lang.String: ... + def getScopeId(self) -> int: ... + def getScopedInterface(self) -> NetworkInterface: ... + def hashCode(self) -> int: ... + def isAnyLocalAddress(self) -> bool: ... + def isIPv4CompatibleAddress(self) -> bool: ... + def isLinkLocalAddress(self) -> bool: ... + def isLoopbackAddress(self) -> bool: ... + def isMCGlobal(self) -> bool: ... + def isMCLinkLocal(self) -> bool: ... + def isMCNodeLocal(self) -> bool: ... + def isMCOrgLocal(self) -> bool: ... + def isMCSiteLocal(self) -> bool: ... + def isMulticastAddress(self) -> bool: ... + def isSiteLocalAddress(self) -> bool: ... + @staticmethod + def ofLiteral(string: java.lang.String | str) -> InetAddress: ... + +class InetSocketAddress(SocketAddress): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + @typing.overload + def __init__(self, inetAddress: InetAddress, int: int): ... + @staticmethod + def createUnresolved( + string: java.lang.String | str, int: int + ) -> InetSocketAddress: ... + def equals(self, object: typing.Any) -> bool: ... + def getAddress(self) -> InetAddress: ... + def getHostName(self) -> java.lang.String: ... + def getHostString(self) -> java.lang.String: ... + def getPort(self) -> int: ... + def hashCode(self) -> int: ... + def isUnresolved(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class JarURLConnection(URLConnection): + def getAttributes(self) -> java.util.jar.Attributes: ... + def getCertificates( + self, + ) -> typing.MutableSequence[java.security.cert.Certificate]: ... + def getEntryName(self) -> java.lang.String: ... + def getJarEntry(self) -> java.util.jar.JarEntry: ... + def getJarFile(self) -> java.util.jar.JarFile: ... + def getJarFileURL(self) -> URL: ... + def getMainAttributes(self) -> java.util.jar.Attributes: ... + def getManifest(self) -> java.util.jar.Manifest: ... + +class MulticastSocket(DatagramSocket): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, socketAddress: SocketAddress): ... + def getInterface(self) -> InetAddress: ... + def getLoopbackMode(self) -> bool: ... + def getNetworkInterface(self) -> NetworkInterface: ... + def getTTL(self) -> int: ... + def getTimeToLive(self) -> int: ... + @typing.overload + def joinGroup(self, inetAddress: InetAddress) -> None: ... + @typing.overload + def joinGroup( + self, socketAddress: SocketAddress, networkInterface: NetworkInterface + ) -> None: ... + @typing.overload + def leaveGroup(self, inetAddress: InetAddress) -> None: ... + @typing.overload + def leaveGroup( + self, socketAddress: SocketAddress, networkInterface: NetworkInterface + ) -> None: ... + @typing.overload + def send(self, datagramPacket: DatagramPacket) -> None: ... + @typing.overload + def send(self, datagramPacket: DatagramPacket, byte: int) -> None: ... + def setInterface(self, inetAddress: InetAddress) -> None: ... + def setLoopbackMode(self, boolean: bool) -> None: ... + def setNetworkInterface(self, networkInterface: NetworkInterface) -> None: ... + def setTTL(self, byte: int) -> None: ... + def setTimeToLive(self, int: int) -> None: ... + +class NoRouteToHostException(SocketException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class PortUnreachableException(SocketException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class SecureCacheResponse(CacheResponse): + def __init__(self): ... + def getCipherSuite(self) -> java.lang.String: ... + def getLocalCertificateChain( + self, + ) -> java.util.List[java.security.cert.Certificate]: ... + def getLocalPrincipal(self) -> java.security.Principal: ... + def getPeerPrincipal(self) -> java.security.Principal: ... + def getSSLSession(self) -> java.util.Optional[javax.net.ssl.SSLSession]: ... + def getServerCertificateChain( + self, + ) -> java.util.List[java.security.cert.Certificate]: ... + +class SocketImpl(SocketOptions): + def __init__(self): ... + def toString(self) -> java.lang.String: ... + +class StandardProtocolFamily(java.lang.Enum["StandardProtocolFamily"], ProtocolFamily): + INET: typing.ClassVar[StandardProtocolFamily] = ... + INET6: typing.ClassVar[StandardProtocolFamily] = ... + UNIX: typing.ClassVar[StandardProtocolFamily] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> StandardProtocolFamily: ... + @staticmethod + def values() -> typing.MutableSequence[StandardProtocolFamily]: ... + +class UnixDomainSocketAddress(SocketAddress): + def equals(self, object: typing.Any) -> bool: ... + def getPath(self) -> java.nio.file.Path: ... + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> UnixDomainSocketAddress: ... + @typing.overload + @staticmethod + def of( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + ) -> UnixDomainSocketAddress: ... + def toString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.net")``. + + Authenticator: type[Authenticator] + BindException: type[BindException] + CacheRequest: type[CacheRequest] + CacheResponse: type[CacheResponse] + ConnectException: type[ConnectException] + ContentHandler: type[ContentHandler] + ContentHandlerFactory: type[ContentHandlerFactory] + CookieHandler: type[CookieHandler] + CookieManager: type[CookieManager] + CookiePolicy: type[CookiePolicy] + CookieStore: type[CookieStore] + DatagramPacket: type[DatagramPacket] + DatagramSocket: type[DatagramSocket] + DatagramSocketImpl: type[DatagramSocketImpl] + DatagramSocketImplFactory: type[DatagramSocketImplFactory] + FileNameMap: type[FileNameMap] + HttpCookie: type[HttpCookie] + HttpRetryException: type[HttpRetryException] + HttpURLConnection: type[HttpURLConnection] + IDN: type[IDN] + Inet4Address: type[Inet4Address] + Inet6Address: type[Inet6Address] + InetAddress: type[InetAddress] + InetSocketAddress: type[InetSocketAddress] + InterfaceAddress: type[InterfaceAddress] + JarURLConnection: type[JarURLConnection] + MalformedURLException: type[MalformedURLException] + MulticastSocket: type[MulticastSocket] + NetPermission: type[NetPermission] + NetworkInterface: type[NetworkInterface] + NoRouteToHostException: type[NoRouteToHostException] + PasswordAuthentication: type[PasswordAuthentication] + PortUnreachableException: type[PortUnreachableException] + ProtocolException: type[ProtocolException] + ProtocolFamily: type[ProtocolFamily] + Proxy: type[Proxy] + ProxySelector: type[ProxySelector] + ResponseCache: type[ResponseCache] + SecureCacheResponse: type[SecureCacheResponse] + ServerSocket: type[ServerSocket] + Socket: type[Socket] + SocketAddress: type[SocketAddress] + SocketException: type[SocketException] + SocketImpl: type[SocketImpl] + SocketImplFactory: type[SocketImplFactory] + SocketOption: type[SocketOption] + SocketOptions: type[SocketOptions] + SocketPermission: type[SocketPermission] + SocketTimeoutException: type[SocketTimeoutException] + StandardProtocolFamily: type[StandardProtocolFamily] + StandardSocketOptions: type[StandardSocketOptions] + URI: type[URI] + URISyntaxException: type[URISyntaxException] + URL: type[URL] + URLClassLoader: type[URLClassLoader] + URLConnection: type[URLConnection] + URLDecoder: type[URLDecoder] + URLEncoder: type[URLEncoder] + URLPermission: type[URLPermission] + URLStreamHandler: type[URLStreamHandler] + URLStreamHandlerFactory: type[URLStreamHandlerFactory] + UnixDomainSocketAddress: type[UnixDomainSocketAddress] + UnknownHostException: type[UnknownHostException] + UnknownServiceException: type[UnknownServiceException] + http: java.net.http.__module_protocol__ + spi: java.net.spi.__module_protocol__ diff --git a/typings/java/net/http/__init__.pyi b/typings/java/net/http/__init__.pyi new file mode 100644 index 0000000..c99b88c --- /dev/null +++ b/typings/java/net/http/__init__.pyi @@ -0,0 +1,670 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.net +import java.nio +import java.nio.charset +import java.nio.file +import java.time +import java.util +import java.util.concurrent +import java.util.function +import java.util.stream +import javax.net.ssl +import jpype +import jpype.protocol + +class HttpClient(java.lang.AutoCloseable): + def authenticator(self) -> java.util.Optional[java.net.Authenticator]: ... + def awaitTermination(self, duration: java.time.Duration) -> bool: ... + def close(self) -> None: ... + def connectTimeout(self) -> java.util.Optional[java.time.Duration]: ... + def cookieHandler(self) -> java.util.Optional[java.net.CookieHandler]: ... + def executor(self) -> java.util.Optional[java.util.concurrent.Executor]: ... + def followRedirects(self) -> HttpClient.Redirect: ... + def isTerminated(self) -> bool: ... + @staticmethod + def newBuilder() -> HttpClient.Builder: ... + @staticmethod + def newHttpClient() -> HttpClient: ... + def newWebSocketBuilder(self) -> WebSocket.Builder: ... + def proxy(self) -> java.util.Optional[java.net.ProxySelector]: ... + _send__T = typing.TypeVar("_send__T") # + def send( + self, + httpRequest: HttpRequest, + bodyHandler: HttpResponse.BodyHandler[_send__T] + | typing.Callable[ + [HttpResponse.ResponseInfo], HttpResponse.BodySubscriber[typing.Any] + ], + ) -> HttpResponse[_send__T]: ... + _sendAsync_0__T = typing.TypeVar("_sendAsync_0__T") # + _sendAsync_1__T = typing.TypeVar("_sendAsync_1__T") # + @typing.overload + def sendAsync( + self, + httpRequest: HttpRequest, + bodyHandler: HttpResponse.BodyHandler[_sendAsync_0__T] + | typing.Callable[ + [HttpResponse.ResponseInfo], HttpResponse.BodySubscriber[typing.Any] + ], + ) -> java.util.concurrent.CompletableFuture[HttpResponse[_sendAsync_0__T]]: ... + @typing.overload + def sendAsync( + self, + httpRequest: HttpRequest, + bodyHandler: HttpResponse.BodyHandler[_sendAsync_1__T] + | typing.Callable[ + [HttpResponse.ResponseInfo], HttpResponse.BodySubscriber[typing.Any] + ], + pushPromiseHandler: HttpResponse.PushPromiseHandler[_sendAsync_1__T] + | typing.Callable[ + [ + HttpRequest, + HttpRequest, + java.util.function.Function[ + HttpResponse.BodyHandler[typing.Any], + java.util.concurrent.CompletableFuture[HttpResponse[typing.Any]], + ], + ], + None, + ], + ) -> java.util.concurrent.CompletableFuture[HttpResponse[_sendAsync_1__T]]: ... + def shutdown(self) -> None: ... + def shutdownNow(self) -> None: ... + def sslContext(self) -> javax.net.ssl.SSLContext: ... + def sslParameters(self) -> javax.net.ssl.SSLParameters: ... + def version(self) -> HttpClient.Version: ... + class Builder: + NO_PROXY: typing.ClassVar[java.net.ProxySelector] = ... + def authenticator( + self, authenticator: java.net.Authenticator + ) -> HttpClient.Builder: ... + def build(self) -> HttpClient: ... + def connectTimeout( + self, duration: java.time.Duration + ) -> HttpClient.Builder: ... + def cookieHandler( + self, cookieHandler: java.net.CookieHandler + ) -> HttpClient.Builder: ... + def executor( + self, executor: java.util.concurrent.Executor | typing.Callable + ) -> HttpClient.Builder: ... + def followRedirects( + self, redirect: HttpClient.Redirect + ) -> HttpClient.Builder: ... + def localAddress( + self, inetAddress: java.net.InetAddress + ) -> HttpClient.Builder: ... + def priority(self, int: int) -> HttpClient.Builder: ... + def proxy( + self, proxySelector: java.net.ProxySelector + ) -> HttpClient.Builder: ... + def sslContext( + self, sSLContext: javax.net.ssl.SSLContext + ) -> HttpClient.Builder: ... + def sslParameters( + self, sSLParameters: javax.net.ssl.SSLParameters + ) -> HttpClient.Builder: ... + def version(self, version: HttpClient.Version) -> HttpClient.Builder: ... + + class Redirect(java.lang.Enum["HttpClient.Redirect"]): + NEVER: typing.ClassVar[HttpClient.Redirect] = ... + ALWAYS: typing.ClassVar[HttpClient.Redirect] = ... + NORMAL: typing.ClassVar[HttpClient.Redirect] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> HttpClient.Redirect: ... + @staticmethod + def values() -> typing.MutableSequence[HttpClient.Redirect]: ... + + class Version(java.lang.Enum["HttpClient.Version"]): + HTTP_1_1: typing.ClassVar[HttpClient.Version] = ... + HTTP_2: typing.ClassVar[HttpClient.Version] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> HttpClient.Version: ... + @staticmethod + def values() -> typing.MutableSequence[HttpClient.Version]: ... + +class HttpHeaders: + def allValues( + self, string: java.lang.String | str + ) -> java.util.List[java.lang.String]: ... + def equals(self, object: typing.Any) -> bool: ... + def firstValue( + self, string: java.lang.String | str + ) -> java.util.Optional[java.lang.String]: ... + def firstValueAsLong( + self, string: java.lang.String | str + ) -> java.util.OptionalLong: ... + def hashCode(self) -> int: ... + def map( + self, + ) -> java.util.Map[java.lang.String, java.util.List[java.lang.String]]: ... + @staticmethod + def of( + map: java.util.Map[ + java.lang.String | str, java.util.List[java.lang.String | str] + ] + | typing.Mapping[ + java.lang.String | str, java.util.List[java.lang.String | str] + ], + biPredicate: java.util.function.BiPredicate[ + java.lang.String | str, java.lang.String | str + ] + | typing.Callable[[java.lang.String | str, java.lang.String | str], bool], + ) -> HttpHeaders: ... + def toString(self) -> java.lang.String: ... + +class HttpRequest: + def bodyPublisher(self) -> java.util.Optional[HttpRequest.BodyPublisher]: ... + def equals(self, object: typing.Any) -> bool: ... + def expectContinue(self) -> bool: ... + def hashCode(self) -> int: ... + def headers(self) -> HttpHeaders: ... + def method(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def newBuilder() -> HttpRequest.Builder: ... + @typing.overload + @staticmethod + def newBuilder(uRI: java.net.URI) -> HttpRequest.Builder: ... + @typing.overload + @staticmethod + def newBuilder( + httpRequest: HttpRequest, + biPredicate: java.util.function.BiPredicate[ + java.lang.String | str, java.lang.String | str + ] + | typing.Callable[[java.lang.String | str, java.lang.String | str], bool], + ) -> HttpRequest.Builder: ... + def timeout(self) -> java.util.Optional[java.time.Duration]: ... + def uri(self) -> java.net.URI: ... + def version(self) -> java.util.Optional[HttpClient.Version]: ... + class BodyPublisher(java.util.concurrent.Flow.Publisher[java.nio.ByteBuffer]): + def contentLength(self) -> int: ... + + class BodyPublishers: + @staticmethod + def concat( + *bodyPublisher: HttpRequest.BodyPublisher, + ) -> HttpRequest.BodyPublisher: ... + @typing.overload + @staticmethod + def fromPublisher( + publisher: java.util.concurrent.Flow.Publisher[java.nio.ByteBuffer] + | typing.Callable[[java.util.concurrent.Flow.Subscriber[typing.Any]], None], + ) -> HttpRequest.BodyPublisher: ... + @typing.overload + @staticmethod + def fromPublisher( + publisher: java.util.concurrent.Flow.Publisher[java.nio.ByteBuffer] + | typing.Callable[[java.util.concurrent.Flow.Subscriber[typing.Any]], None], + long: int, + ) -> HttpRequest.BodyPublisher: ... + @staticmethod + def noBody() -> HttpRequest.BodyPublisher: ... + @typing.overload + @staticmethod + def ofByteArray( + byteArray: list[int] | jpype.JArray | bytes, + ) -> HttpRequest.BodyPublisher: ... + @typing.overload + @staticmethod + def ofByteArray( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> HttpRequest.BodyPublisher: ... + @staticmethod + def ofByteArrays( + iterable: java.lang.Iterable[list[int] | jpype.JArray | bytes] + | typing.Sequence[list[int] | jpype.JArray | bytes] + | set[list[int] | jpype.JArray | bytes] + | typing.Callable[[], java.util.Iterator[typing.Any]], + ) -> HttpRequest.BodyPublisher: ... + @staticmethod + def ofFile( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + ) -> HttpRequest.BodyPublisher: ... + @staticmethod + def ofInputStream( + supplier: java.util.function.Supplier[java.io.InputStream] + | typing.Callable[[], java.io.InputStream], + ) -> HttpRequest.BodyPublisher: ... + @typing.overload + @staticmethod + def ofString(string: java.lang.String | str) -> HttpRequest.BodyPublisher: ... + @typing.overload + @staticmethod + def ofString( + string: java.lang.String | str, charset: java.nio.charset.Charset + ) -> HttpRequest.BodyPublisher: ... + + class Builder: + def DELETE(self) -> HttpRequest.Builder: ... + def GET(self) -> HttpRequest.Builder: ... + def HEAD(self) -> HttpRequest.Builder: ... + def POST( + self, bodyPublisher: HttpRequest.BodyPublisher + ) -> HttpRequest.Builder: ... + def PUT( + self, bodyPublisher: HttpRequest.BodyPublisher + ) -> HttpRequest.Builder: ... + def build(self) -> HttpRequest: ... + def copy(self) -> HttpRequest.Builder: ... + def expectContinue(self, boolean: bool) -> HttpRequest.Builder: ... + def header( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> HttpRequest.Builder: ... + def headers(self, *string: java.lang.String | str) -> HttpRequest.Builder: ... + def method( + self, + string: java.lang.String | str, + bodyPublisher: HttpRequest.BodyPublisher, + ) -> HttpRequest.Builder: ... + def setHeader( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> HttpRequest.Builder: ... + def timeout(self, duration: java.time.Duration) -> HttpRequest.Builder: ... + def uri(self, uRI: java.net.URI) -> HttpRequest.Builder: ... + def version(self, version: HttpClient.Version) -> HttpRequest.Builder: ... + +_HttpResponse__BodyHandler__T = typing.TypeVar("_HttpResponse__BodyHandler__T") # +_HttpResponse__BodySubscriber__T = typing.TypeVar( + "_HttpResponse__BodySubscriber__T" +) # +_HttpResponse__PushPromiseHandler__T = typing.TypeVar( + "_HttpResponse__PushPromiseHandler__T" +) # +_HttpResponse__T = typing.TypeVar("_HttpResponse__T") # + +class HttpResponse(typing.Generic[_HttpResponse__T]): + def body(self) -> _HttpResponse__T: ... + def connectionLabel(self) -> java.util.Optional[java.lang.String]: ... + def headers(self) -> HttpHeaders: ... + def previousResponse( + self, + ) -> java.util.Optional[HttpResponse[_HttpResponse__T]]: ... + def request(self) -> HttpRequest: ... + def sslSession(self) -> java.util.Optional[javax.net.ssl.SSLSession]: ... + def statusCode(self) -> int: ... + def uri(self) -> java.net.URI: ... + def version(self) -> HttpClient.Version: ... + class BodyHandler(typing.Generic[_HttpResponse__BodyHandler__T]): + def apply( + self, responseInfo: HttpResponse.ResponseInfo + ) -> HttpResponse.BodySubscriber[_HttpResponse__BodyHandler__T]: ... + + class BodyHandlers: + _buffering__T = typing.TypeVar("_buffering__T") # + @staticmethod + def buffering( + bodyHandler: HttpResponse.BodyHandler[_buffering__T] + | typing.Callable[ + [HttpResponse.ResponseInfo], HttpResponse.BodySubscriber[typing.Any] + ], + int: int, + ) -> HttpResponse.BodyHandler[_buffering__T]: ... + @staticmethod + def discarding() -> HttpResponse.BodyHandler[None]: ... + _fromLineSubscriber_1__S = typing.TypeVar( + "_fromLineSubscriber_1__S", bound=java.util.concurrent.Flow.Subscriber + ) # + _fromLineSubscriber_1__T = typing.TypeVar("_fromLineSubscriber_1__T") # + @typing.overload + @staticmethod + def fromLineSubscriber( + subscriber: java.util.concurrent.Flow.Subscriber[java.lang.String], + ) -> HttpResponse.BodyHandler[None]: ... + @typing.overload + @staticmethod + def fromLineSubscriber( + s: _fromLineSubscriber_1__S, + function: java.util.function.Function[ + _fromLineSubscriber_1__S, _fromLineSubscriber_1__T + ] + | typing.Callable[[_fromLineSubscriber_1__S], _fromLineSubscriber_1__T], + string: java.lang.String | str, + ) -> HttpResponse.BodyHandler[_fromLineSubscriber_1__T]: ... + _fromSubscriber_1__S = typing.TypeVar( + "_fromSubscriber_1__S", bound=java.util.concurrent.Flow.Subscriber + ) # + _fromSubscriber_1__T = typing.TypeVar("_fromSubscriber_1__T") # + @typing.overload + @staticmethod + def fromSubscriber( + subscriber: java.util.concurrent.Flow.Subscriber[ + java.util.List[java.nio.ByteBuffer] + ], + ) -> HttpResponse.BodyHandler[None]: ... + @typing.overload + @staticmethod + def fromSubscriber( + s: _fromSubscriber_1__S, + function: java.util.function.Function[ + _fromSubscriber_1__S, _fromSubscriber_1__T + ] + | typing.Callable[[_fromSubscriber_1__S], _fromSubscriber_1__T], + ) -> HttpResponse.BodyHandler[_fromSubscriber_1__T]: ... + _limiting__T = typing.TypeVar("_limiting__T") # + @staticmethod + def limiting( + bodyHandler: HttpResponse.BodyHandler[_limiting__T] + | typing.Callable[ + [HttpResponse.ResponseInfo], HttpResponse.BodySubscriber[typing.Any] + ], + long: int, + ) -> HttpResponse.BodyHandler[_limiting__T]: ... + @staticmethod + def ofByteArray() -> HttpResponse.BodyHandler[typing.MutableSequence[int]]: ... + @staticmethod + def ofByteArrayConsumer( + consumer: java.util.function.Consumer[ + java.util.Optional[list[int] | jpype.JArray | bytes] + ] + | typing.Callable[ + [java.util.Optional[list[int] | jpype.JArray | bytes]], None + ], + ) -> HttpResponse.BodyHandler[None]: ... + @typing.overload + @staticmethod + def ofFile( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + ) -> HttpResponse.BodyHandler[java.nio.file.Path]: ... + @typing.overload + @staticmethod + def ofFile( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *openOption: java.nio.file.OpenOption, + ) -> HttpResponse.BodyHandler[java.nio.file.Path]: ... + @staticmethod + def ofFileDownload( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *openOption: java.nio.file.OpenOption, + ) -> HttpResponse.BodyHandler[java.nio.file.Path]: ... + @staticmethod + def ofInputStream() -> HttpResponse.BodyHandler[java.io.InputStream]: ... + @staticmethod + def ofLines() -> HttpResponse.BodyHandler[ + java.util.stream.Stream[java.lang.String] + ]: ... + @staticmethod + def ofPublisher() -> HttpResponse.BodyHandler[ + java.util.concurrent.Flow.Publisher[java.util.List[java.nio.ByteBuffer]] + ]: ... + @typing.overload + @staticmethod + def ofString() -> HttpResponse.BodyHandler[java.lang.String]: ... + @typing.overload + @staticmethod + def ofString( + charset: java.nio.charset.Charset, + ) -> HttpResponse.BodyHandler[java.lang.String]: ... + _replacing__U = typing.TypeVar("_replacing__U") # + @staticmethod + def replacing(u: _replacing__U) -> HttpResponse.BodyHandler[_replacing__U]: ... + + class BodySubscriber( + java.util.concurrent.Flow.Subscriber[java.util.List[java.nio.ByteBuffer]], + typing.Generic[_HttpResponse__BodySubscriber__T], + ): + def getBody( + self, + ) -> java.util.concurrent.CompletionStage[_HttpResponse__BodySubscriber__T]: ... + + class BodySubscribers: + _buffering__T = typing.TypeVar("_buffering__T") # + @staticmethod + def buffering( + bodySubscriber: HttpResponse.BodySubscriber[_buffering__T], int: int + ) -> HttpResponse.BodySubscriber[_buffering__T]: ... + @staticmethod + def discarding() -> HttpResponse.BodySubscriber[None]: ... + _fromLineSubscriber_1__S = typing.TypeVar( + "_fromLineSubscriber_1__S", bound=java.util.concurrent.Flow.Subscriber + ) # + _fromLineSubscriber_1__T = typing.TypeVar("_fromLineSubscriber_1__T") # + @typing.overload + @staticmethod + def fromLineSubscriber( + subscriber: java.util.concurrent.Flow.Subscriber[java.lang.String], + ) -> HttpResponse.BodySubscriber[None]: ... + @typing.overload + @staticmethod + def fromLineSubscriber( + s: _fromLineSubscriber_1__S, + function: java.util.function.Function[ + _fromLineSubscriber_1__S, _fromLineSubscriber_1__T + ] + | typing.Callable[[_fromLineSubscriber_1__S], _fromLineSubscriber_1__T], + charset: java.nio.charset.Charset, + string: java.lang.String | str, + ) -> HttpResponse.BodySubscriber[_fromLineSubscriber_1__T]: ... + _fromSubscriber_1__S = typing.TypeVar( + "_fromSubscriber_1__S", bound=java.util.concurrent.Flow.Subscriber + ) # + _fromSubscriber_1__T = typing.TypeVar("_fromSubscriber_1__T") # + @typing.overload + @staticmethod + def fromSubscriber( + subscriber: java.util.concurrent.Flow.Subscriber[ + java.util.List[java.nio.ByteBuffer] + ], + ) -> HttpResponse.BodySubscriber[None]: ... + @typing.overload + @staticmethod + def fromSubscriber( + s: _fromSubscriber_1__S, + function: java.util.function.Function[ + _fromSubscriber_1__S, _fromSubscriber_1__T + ] + | typing.Callable[[_fromSubscriber_1__S], _fromSubscriber_1__T], + ) -> HttpResponse.BodySubscriber[_fromSubscriber_1__T]: ... + _limiting__T = typing.TypeVar("_limiting__T") # + @staticmethod + def limiting( + bodySubscriber: HttpResponse.BodySubscriber[_limiting__T], long: int + ) -> HttpResponse.BodySubscriber[_limiting__T]: ... + _mapping__T = typing.TypeVar("_mapping__T") # + _mapping__U = typing.TypeVar("_mapping__U") # + @staticmethod + def mapping( + bodySubscriber: HttpResponse.BodySubscriber[_mapping__T], + function: java.util.function.Function[_mapping__T, _mapping__U] + | typing.Callable[[_mapping__T], _mapping__U], + ) -> HttpResponse.BodySubscriber[_mapping__U]: ... + @staticmethod + def ofByteArray() -> HttpResponse.BodySubscriber[ + typing.MutableSequence[int] + ]: ... + @staticmethod + def ofByteArrayConsumer( + consumer: java.util.function.Consumer[ + java.util.Optional[list[int] | jpype.JArray | bytes] + ] + | typing.Callable[ + [java.util.Optional[list[int] | jpype.JArray | bytes]], None + ], + ) -> HttpResponse.BodySubscriber[None]: ... + @typing.overload + @staticmethod + def ofFile( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + ) -> HttpResponse.BodySubscriber[java.nio.file.Path]: ... + @typing.overload + @staticmethod + def ofFile( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *openOption: java.nio.file.OpenOption, + ) -> HttpResponse.BodySubscriber[java.nio.file.Path]: ... + @staticmethod + def ofInputStream() -> HttpResponse.BodySubscriber[java.io.InputStream]: ... + @staticmethod + def ofLines( + charset: java.nio.charset.Charset, + ) -> HttpResponse.BodySubscriber[java.util.stream.Stream[java.lang.String]]: ... + @staticmethod + def ofPublisher() -> HttpResponse.BodySubscriber[ + java.util.concurrent.Flow.Publisher[java.util.List[java.nio.ByteBuffer]] + ]: ... + @staticmethod + def ofString( + charset: java.nio.charset.Charset, + ) -> HttpResponse.BodySubscriber[java.lang.String]: ... + _replacing__U = typing.TypeVar("_replacing__U") # + @staticmethod + def replacing( + u: _replacing__U, + ) -> HttpResponse.BodySubscriber[_replacing__U]: ... + + class PushPromiseHandler(typing.Generic[_HttpResponse__PushPromiseHandler__T]): + def applyPushPromise( + self, + httpRequest: HttpRequest, + httpRequest2: HttpRequest, + function: java.util.function.Function[ + HttpResponse.BodyHandler[_HttpResponse__PushPromiseHandler__T] + | typing.Callable[ + [HttpResponse.ResponseInfo], HttpResponse.BodySubscriber[typing.Any] + ], + java.util.concurrent.CompletableFuture[ + HttpResponse[_HttpResponse__PushPromiseHandler__T] + ], + ] + | typing.Callable[ + [ + HttpResponse.BodyHandler[_HttpResponse__PushPromiseHandler__T] + | typing.Callable[ + [HttpResponse.ResponseInfo], + HttpResponse.BodySubscriber[typing.Any], + ] + ], + java.util.concurrent.CompletableFuture[ + HttpResponse[_HttpResponse__PushPromiseHandler__T] + ], + ], + ) -> None: ... + _of__T = typing.TypeVar("_of__T") # + @staticmethod + def of( + function: java.util.function.Function[ + HttpRequest, + HttpResponse.BodyHandler[_of__T] + | typing.Callable[ + [HttpResponse.ResponseInfo], HttpResponse.BodySubscriber[typing.Any] + ], + ] + | typing.Callable[ + [HttpRequest], + HttpResponse.BodyHandler[_of__T] + | typing.Callable[ + [HttpResponse.ResponseInfo], HttpResponse.BodySubscriber[typing.Any] + ], + ], + concurrentMap: java.util.concurrent.ConcurrentMap[ + HttpRequest, + java.util.concurrent.CompletableFuture[HttpResponse[_of__T]], + ], + ) -> HttpResponse.PushPromiseHandler[_of__T]: ... + + class ResponseInfo: + def headers(self) -> HttpHeaders: ... + def statusCode(self) -> int: ... + def version(self) -> HttpClient.Version: ... + +class HttpTimeoutException(java.io.IOException): + def __init__(self, string: java.lang.String | str): ... + +class WebSocket: + NORMAL_CLOSURE: typing.ClassVar[int] = ... + def abort(self) -> None: ... + def getSubprotocol(self) -> java.lang.String: ... + def isInputClosed(self) -> bool: ... + def isOutputClosed(self) -> bool: ... + def request(self, long: int) -> None: ... + def sendBinary( + self, byteBuffer: java.nio.ByteBuffer, boolean: bool + ) -> java.util.concurrent.CompletableFuture[WebSocket]: ... + def sendClose( + self, int: int, string: java.lang.String | str + ) -> java.util.concurrent.CompletableFuture[WebSocket]: ... + def sendPing( + self, byteBuffer: java.nio.ByteBuffer + ) -> java.util.concurrent.CompletableFuture[WebSocket]: ... + def sendPong( + self, byteBuffer: java.nio.ByteBuffer + ) -> java.util.concurrent.CompletableFuture[WebSocket]: ... + def sendText( + self, charSequence: java.lang.CharSequence | str, boolean: bool + ) -> java.util.concurrent.CompletableFuture[WebSocket]: ... + class Builder: + def buildAsync( + self, uRI: java.net.URI, listener: WebSocket.Listener + ) -> java.util.concurrent.CompletableFuture[WebSocket]: ... + def connectTimeout(self, duration: java.time.Duration) -> WebSocket.Builder: ... + def header( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> WebSocket.Builder: ... + def subprotocols( + self, string: java.lang.String | str, *string2: java.lang.String | str + ) -> WebSocket.Builder: ... + + class Listener: + def onBinary( + self, webSocket: WebSocket, byteBuffer: java.nio.ByteBuffer, boolean: bool + ) -> java.util.concurrent.CompletionStage[typing.Any]: ... + def onClose( + self, webSocket: WebSocket, int: int, string: java.lang.String | str + ) -> java.util.concurrent.CompletionStage[typing.Any]: ... + def onError( + self, webSocket: WebSocket, throwable: java.lang.Throwable + ) -> None: ... + def onOpen(self, webSocket: WebSocket) -> None: ... + def onPing( + self, webSocket: WebSocket, byteBuffer: java.nio.ByteBuffer + ) -> java.util.concurrent.CompletionStage[typing.Any]: ... + def onPong( + self, webSocket: WebSocket, byteBuffer: java.nio.ByteBuffer + ) -> java.util.concurrent.CompletionStage[typing.Any]: ... + def onText( + self, + webSocket: WebSocket, + charSequence: java.lang.CharSequence | str, + boolean: bool, + ) -> java.util.concurrent.CompletionStage[typing.Any]: ... + +class WebSocketHandshakeException(java.io.IOException): + def __init__(self, httpResponse: HttpResponse[typing.Any]): ... + def getResponse(self) -> HttpResponse[typing.Any]: ... + def initCause( + self, throwable: java.lang.Throwable + ) -> WebSocketHandshakeException: ... + +class HttpConnectTimeoutException(HttpTimeoutException): + def __init__(self, string: java.lang.String | str): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.net.http")``. + + HttpClient: type[HttpClient] + HttpConnectTimeoutException: type[HttpConnectTimeoutException] + HttpHeaders: type[HttpHeaders] + HttpRequest: type[HttpRequest] + HttpResponse: type[HttpResponse] + HttpTimeoutException: type[HttpTimeoutException] + WebSocket: type[WebSocket] + WebSocketHandshakeException: type[WebSocketHandshakeException] diff --git a/typings/java/net/spi/__init__.pyi b/typings/java/net/spi/__init__.pyi new file mode 100644 index 0000000..b6f3547 --- /dev/null +++ b/typings/java/net/spi/__init__.pyi @@ -0,0 +1,43 @@ +import typing +from typing import Protocol + +import java.lang +import java.net +import java.util.stream +import jpype + +class InetAddressResolver: + def lookupByAddress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> java.lang.String: ... + def lookupByName( + self, + string: java.lang.String | str, + lookupPolicy: InetAddressResolver.LookupPolicy, + ) -> java.util.stream.Stream[java.net.InetAddress]: ... + class LookupPolicy: + IPV4: typing.ClassVar[int] = ... + IPV6: typing.ClassVar[int] = ... + IPV4_FIRST: typing.ClassVar[int] = ... + IPV6_FIRST: typing.ClassVar[int] = ... + def characteristics(self) -> int: ... + @staticmethod + def of(int: int) -> InetAddressResolver.LookupPolicy: ... + +class InetAddressResolverProvider: + def get( + self, configuration: InetAddressResolverProvider.Configuration + ) -> InetAddressResolver: ... + def name(self) -> java.lang.String: ... + class Configuration: + def builtinResolver(self) -> InetAddressResolver: ... + def lookupLocalHostName(self) -> java.lang.String: ... + +class URLStreamHandlerProvider(java.net.URLStreamHandlerFactory): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.net.spi")``. + + InetAddressResolver: type[InetAddressResolver] + InetAddressResolverProvider: type[InetAddressResolverProvider] + URLStreamHandlerProvider: type[URLStreamHandlerProvider] diff --git a/typings/java/nio/__init__.pyi b/typings/java/nio/__init__.pyi new file mode 100644 index 0000000..5b86bad --- /dev/null +++ b/typings/java/nio/__init__.pyi @@ -0,0 +1,776 @@ +import typing +from typing import Protocol + +import java.lang +import java.nio.channels +import java.nio.charset +import java.nio.file +import java.util.stream +import jpype + +class Buffer: + def array(self) -> typing.Any: ... + def arrayOffset(self) -> int: ... + def capacity(self) -> int: ... + def clear(self) -> Buffer: ... + def duplicate(self) -> Buffer: ... + def flip(self) -> Buffer: ... + def hasArray(self) -> bool: ... + def hasRemaining(self) -> bool: ... + def isDirect(self) -> bool: ... + def isReadOnly(self) -> bool: ... + @typing.overload + def limit(self) -> int: ... + @typing.overload + def limit(self, int: int) -> Buffer: ... + def mark(self) -> Buffer: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def position(self, int: int) -> Buffer: ... + def remaining(self) -> int: ... + def reset(self) -> Buffer: ... + def rewind(self) -> Buffer: ... + @typing.overload + def slice(self) -> Buffer: ... + @typing.overload + def slice(self, int: int, int2: int) -> Buffer: ... + +class BufferOverflowException(java.lang.RuntimeException): + def __init__(self): ... + +class BufferUnderflowException(java.lang.RuntimeException): + def __init__(self): ... + +class ByteOrder: + BIG_ENDIAN: typing.ClassVar[ByteOrder] = ... + LITTLE_ENDIAN: typing.ClassVar[ByteOrder] = ... + @staticmethod + def nativeOrder() -> ByteOrder: ... + def toString(self) -> java.lang.String: ... + +class InvalidMarkException(java.lang.IllegalStateException): + def __init__(self): ... + +class ReadOnlyBufferException(java.lang.UnsupportedOperationException): + def __init__(self): ... + +class ByteBuffer(Buffer, java.lang.Comparable["ByteBuffer"]): + def alignedSlice(self, int: int) -> ByteBuffer: ... + def alignmentOffset(self, int: int, int2: int) -> int: ... + @staticmethod + def allocate(int: int) -> ByteBuffer: ... + @staticmethod + def allocateDirect(int: int) -> ByteBuffer: ... + def array(self) -> typing.MutableSequence[int]: ... + def arrayOffset(self) -> int: ... + def asCharBuffer(self) -> CharBuffer: ... + def asDoubleBuffer(self) -> DoubleBuffer: ... + def asFloatBuffer(self) -> FloatBuffer: ... + def asIntBuffer(self) -> IntBuffer: ... + def asLongBuffer(self) -> LongBuffer: ... + def asReadOnlyBuffer(self) -> ByteBuffer: ... + def asShortBuffer(self) -> ShortBuffer: ... + def clear(self) -> ByteBuffer: ... + def compact(self) -> ByteBuffer: ... + def compareTo(self, byteBuffer: ByteBuffer) -> int: ... + def duplicate(self) -> ByteBuffer: ... + def equals(self, object: typing.Any) -> bool: ... + def flip(self) -> ByteBuffer: ... + @typing.overload + def get(self) -> int: ... + @typing.overload + def get(self, int: int) -> int: ... + @typing.overload + def get(self, byteArray: list[int] | jpype.JArray | bytes) -> ByteBuffer: ... + @typing.overload + def get( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> ByteBuffer: ... + @typing.overload + def get( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> ByteBuffer: ... + @typing.overload + def get( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> ByteBuffer: ... + @typing.overload + def getChar(self) -> str: ... + @typing.overload + def getChar(self, int: int) -> str: ... + @typing.overload + def getDouble(self) -> float: ... + @typing.overload + def getDouble(self, int: int) -> float: ... + @typing.overload + def getFloat(self) -> float: ... + @typing.overload + def getFloat(self, int: int) -> float: ... + @typing.overload + def getInt(self) -> int: ... + @typing.overload + def getInt(self, int: int) -> int: ... + @typing.overload + def getLong(self) -> int: ... + @typing.overload + def getLong(self, int: int) -> int: ... + @typing.overload + def getShort(self) -> int: ... + @typing.overload + def getShort(self, int: int) -> int: ... + def hasArray(self) -> bool: ... + def hashCode(self) -> int: ... + def isDirect(self) -> bool: ... + @typing.overload + def limit(self) -> int: ... + @typing.overload + def limit(self, int: int) -> ByteBuffer: ... + def mark(self) -> ByteBuffer: ... + def mismatch(self, byteBuffer: ByteBuffer) -> int: ... + @typing.overload + def order(self, byteOrder: ByteOrder) -> ByteBuffer: ... + @typing.overload + def order(self) -> ByteOrder: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def position(self, int: int) -> ByteBuffer: ... + @typing.overload + def put(self, byte: int) -> ByteBuffer: ... + @typing.overload + def put(self, int: int, byte: int) -> ByteBuffer: ... + @typing.overload + def put(self, byteArray: list[int] | jpype.JArray | bytes) -> ByteBuffer: ... + @typing.overload + def put( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> ByteBuffer: ... + @typing.overload + def put( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> ByteBuffer: ... + @typing.overload + def put( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> ByteBuffer: ... + @typing.overload + def put( + self, int: int, byteBuffer: ByteBuffer, int2: int, int3: int + ) -> ByteBuffer: ... + @typing.overload + def put(self, byteBuffer: ByteBuffer) -> ByteBuffer: ... + @typing.overload + def putChar(self, char: str) -> ByteBuffer: ... + @typing.overload + def putChar(self, int: int, char: str) -> ByteBuffer: ... + @typing.overload + def putDouble(self, double: float) -> ByteBuffer: ... + @typing.overload + def putDouble(self, int: int, double: float) -> ByteBuffer: ... + @typing.overload + def putFloat(self, float: float) -> ByteBuffer: ... + @typing.overload + def putFloat(self, int: int, float: float) -> ByteBuffer: ... + @typing.overload + def putInt(self, int: int) -> ByteBuffer: ... + @typing.overload + def putInt(self, int: int, int2: int) -> ByteBuffer: ... + @typing.overload + def putLong(self, int: int, long: int) -> ByteBuffer: ... + @typing.overload + def putLong(self, long: int) -> ByteBuffer: ... + @typing.overload + def putShort(self, int: int, short: int) -> ByteBuffer: ... + @typing.overload + def putShort(self, short: int) -> ByteBuffer: ... + def reset(self) -> ByteBuffer: ... + def rewind(self) -> ByteBuffer: ... + @typing.overload + def slice(self) -> ByteBuffer: ... + @typing.overload + def slice(self, int: int, int2: int) -> ByteBuffer: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def wrap(byteArray: list[int] | jpype.JArray | bytes) -> ByteBuffer: ... + @typing.overload + @staticmethod + def wrap( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> ByteBuffer: ... + +class CharBuffer( + Buffer, + java.lang.Comparable["CharBuffer"], + java.lang.Appendable, + java.lang.CharSequence, + java.lang.Readable, +): + @staticmethod + def allocate(int: int) -> CharBuffer: ... + @typing.overload + def append(self, char: str) -> CharBuffer: ... + @typing.overload + def append(self, charSequence: java.lang.CharSequence | str) -> CharBuffer: ... + @typing.overload + def append( + self, charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> CharBuffer: ... + def array(self) -> typing.MutableSequence[str]: ... + def arrayOffset(self) -> int: ... + def asReadOnlyBuffer(self) -> CharBuffer: ... + def charAt(self, int: int) -> str: ... + def chars(self) -> java.util.stream.IntStream: ... + def clear(self) -> CharBuffer: ... + def compact(self) -> CharBuffer: ... + def compareTo(self, charBuffer: CharBuffer) -> int: ... + def duplicate(self) -> CharBuffer: ... + def equals(self, object: typing.Any) -> bool: ... + def flip(self) -> CharBuffer: ... + @typing.overload + def get(self) -> str: ... + @typing.overload + def get(self, int: int) -> str: ... + @typing.overload + def get(self, charArray: list[str] | jpype.JArray) -> CharBuffer: ... + @typing.overload + def get( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> CharBuffer: ... + @typing.overload + def get(self, int: int, charArray: list[str] | jpype.JArray) -> CharBuffer: ... + @typing.overload + def get( + self, int: int, charArray: list[str] | jpype.JArray, int2: int, int3: int + ) -> CharBuffer: ... + def getChars( + self, int: int, int2: int, charArray: list[str] | jpype.JArray, int3: int + ) -> None: ... + def hasArray(self) -> bool: ... + def hashCode(self) -> int: ... + def isDirect(self) -> bool: ... + def isEmpty(self) -> bool: ... + def length(self) -> int: ... + @typing.overload + def limit(self) -> int: ... + @typing.overload + def limit(self, int: int) -> CharBuffer: ... + def mark(self) -> CharBuffer: ... + def mismatch(self, charBuffer: CharBuffer) -> int: ... + def order(self) -> ByteOrder: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def position(self, int: int) -> CharBuffer: ... + @typing.overload + def put(self, char: str) -> CharBuffer: ... + @typing.overload + def put(self, int: int, char: str) -> CharBuffer: ... + @typing.overload + def put(self, charArray: list[str] | jpype.JArray) -> CharBuffer: ... + @typing.overload + def put(self, string: java.lang.String | str) -> CharBuffer: ... + @typing.overload + def put( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> CharBuffer: ... + @typing.overload + def put(self, int: int, charArray: list[str] | jpype.JArray) -> CharBuffer: ... + @typing.overload + def put( + self, int: int, charArray: list[str] | jpype.JArray, int2: int, int3: int + ) -> CharBuffer: ... + @typing.overload + def put( + self, int: int, charBuffer: CharBuffer, int2: int, int3: int + ) -> CharBuffer: ... + @typing.overload + def put( + self, string: java.lang.String | str, int: int, int2: int + ) -> CharBuffer: ... + @typing.overload + def put(self, charBuffer: CharBuffer) -> CharBuffer: ... + def read(self, charBuffer: CharBuffer) -> int: ... + def reset(self) -> CharBuffer: ... + def rewind(self) -> CharBuffer: ... + @typing.overload + def slice(self) -> CharBuffer: ... + @typing.overload + def slice(self, int: int, int2: int) -> CharBuffer: ... + def subSequence(self, int: int, int2: int) -> CharBuffer: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def wrap(charArray: list[str] | jpype.JArray) -> CharBuffer: ... + @typing.overload + @staticmethod + def wrap( + charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> CharBuffer: ... + @typing.overload + @staticmethod + def wrap(charSequence: java.lang.CharSequence | str) -> CharBuffer: ... + @typing.overload + @staticmethod + def wrap( + charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> CharBuffer: ... + +class DoubleBuffer(Buffer, java.lang.Comparable["DoubleBuffer"]): + @staticmethod + def allocate(int: int) -> DoubleBuffer: ... + def array(self) -> typing.MutableSequence[float]: ... + def arrayOffset(self) -> int: ... + def asReadOnlyBuffer(self) -> DoubleBuffer: ... + def clear(self) -> DoubleBuffer: ... + def compact(self) -> DoubleBuffer: ... + def compareTo(self, doubleBuffer: DoubleBuffer) -> int: ... + def duplicate(self) -> DoubleBuffer: ... + def equals(self, object: typing.Any) -> bool: ... + def flip(self) -> DoubleBuffer: ... + @typing.overload + def get(self) -> float: ... + @typing.overload + def get(self, int: int) -> float: ... + @typing.overload + def get(self, doubleArray: list[float] | jpype.JArray) -> DoubleBuffer: ... + @typing.overload + def get( + self, doubleArray: list[float] | jpype.JArray, int: int, int2: int + ) -> DoubleBuffer: ... + @typing.overload + def get( + self, int: int, doubleArray: list[float] | jpype.JArray + ) -> DoubleBuffer: ... + @typing.overload + def get( + self, int: int, doubleArray: list[float] | jpype.JArray, int2: int, int3: int + ) -> DoubleBuffer: ... + def hasArray(self) -> bool: ... + def hashCode(self) -> int: ... + def isDirect(self) -> bool: ... + @typing.overload + def limit(self) -> int: ... + @typing.overload + def limit(self, int: int) -> DoubleBuffer: ... + def mark(self) -> DoubleBuffer: ... + def mismatch(self, doubleBuffer: DoubleBuffer) -> int: ... + def order(self) -> ByteOrder: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def position(self, int: int) -> DoubleBuffer: ... + @typing.overload + def put(self, double: float) -> DoubleBuffer: ... + @typing.overload + def put(self, int: int, double: float) -> DoubleBuffer: ... + @typing.overload + def put(self, doubleArray: list[float] | jpype.JArray) -> DoubleBuffer: ... + @typing.overload + def put( + self, doubleArray: list[float] | jpype.JArray, int: int, int2: int + ) -> DoubleBuffer: ... + @typing.overload + def put( + self, int: int, doubleArray: list[float] | jpype.JArray + ) -> DoubleBuffer: ... + @typing.overload + def put( + self, int: int, doubleArray: list[float] | jpype.JArray, int2: int, int3: int + ) -> DoubleBuffer: ... + @typing.overload + def put( + self, int: int, doubleBuffer: DoubleBuffer, int2: int, int3: int + ) -> DoubleBuffer: ... + @typing.overload + def put(self, doubleBuffer: DoubleBuffer) -> DoubleBuffer: ... + def reset(self) -> DoubleBuffer: ... + def rewind(self) -> DoubleBuffer: ... + @typing.overload + def slice(self) -> DoubleBuffer: ... + @typing.overload + def slice(self, int: int, int2: int) -> DoubleBuffer: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def wrap(doubleArray: list[float] | jpype.JArray) -> DoubleBuffer: ... + @typing.overload + @staticmethod + def wrap( + doubleArray: list[float] | jpype.JArray, int: int, int2: int + ) -> DoubleBuffer: ... + +class FloatBuffer(Buffer, java.lang.Comparable["FloatBuffer"]): + @staticmethod + def allocate(int: int) -> FloatBuffer: ... + def array(self) -> typing.MutableSequence[float]: ... + def arrayOffset(self) -> int: ... + def asReadOnlyBuffer(self) -> FloatBuffer: ... + def clear(self) -> FloatBuffer: ... + def compact(self) -> FloatBuffer: ... + def compareTo(self, floatBuffer: FloatBuffer) -> int: ... + def duplicate(self) -> FloatBuffer: ... + def equals(self, object: typing.Any) -> bool: ... + def flip(self) -> FloatBuffer: ... + @typing.overload + def get(self) -> float: ... + @typing.overload + def get(self, int: int) -> float: ... + @typing.overload + def get(self, floatArray: list[float] | jpype.JArray) -> FloatBuffer: ... + @typing.overload + def get( + self, floatArray: list[float] | jpype.JArray, int: int, int2: int + ) -> FloatBuffer: ... + @typing.overload + def get(self, int: int, floatArray: list[float] | jpype.JArray) -> FloatBuffer: ... + @typing.overload + def get( + self, int: int, floatArray: list[float] | jpype.JArray, int2: int, int3: int + ) -> FloatBuffer: ... + def hasArray(self) -> bool: ... + def hashCode(self) -> int: ... + def isDirect(self) -> bool: ... + @typing.overload + def limit(self) -> int: ... + @typing.overload + def limit(self, int: int) -> FloatBuffer: ... + def mark(self) -> FloatBuffer: ... + def mismatch(self, floatBuffer: FloatBuffer) -> int: ... + def order(self) -> ByteOrder: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def position(self, int: int) -> FloatBuffer: ... + @typing.overload + def put(self, float: float) -> FloatBuffer: ... + @typing.overload + def put(self, int: int, float: float) -> FloatBuffer: ... + @typing.overload + def put(self, floatArray: list[float] | jpype.JArray) -> FloatBuffer: ... + @typing.overload + def put( + self, floatArray: list[float] | jpype.JArray, int: int, int2: int + ) -> FloatBuffer: ... + @typing.overload + def put(self, int: int, floatArray: list[float] | jpype.JArray) -> FloatBuffer: ... + @typing.overload + def put( + self, int: int, floatArray: list[float] | jpype.JArray, int2: int, int3: int + ) -> FloatBuffer: ... + @typing.overload + def put( + self, int: int, floatBuffer: FloatBuffer, int2: int, int3: int + ) -> FloatBuffer: ... + @typing.overload + def put(self, floatBuffer: FloatBuffer) -> FloatBuffer: ... + def reset(self) -> FloatBuffer: ... + def rewind(self) -> FloatBuffer: ... + @typing.overload + def slice(self) -> FloatBuffer: ... + @typing.overload + def slice(self, int: int, int2: int) -> FloatBuffer: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def wrap(floatArray: list[float] | jpype.JArray) -> FloatBuffer: ... + @typing.overload + @staticmethod + def wrap( + floatArray: list[float] | jpype.JArray, int: int, int2: int + ) -> FloatBuffer: ... + +class IntBuffer(Buffer, java.lang.Comparable["IntBuffer"]): + @staticmethod + def allocate(int: int) -> IntBuffer: ... + def array(self) -> typing.MutableSequence[int]: ... + def arrayOffset(self) -> int: ... + def asReadOnlyBuffer(self) -> IntBuffer: ... + def clear(self) -> IntBuffer: ... + def compact(self) -> IntBuffer: ... + def compareTo(self, intBuffer: IntBuffer) -> int: ... + def duplicate(self) -> IntBuffer: ... + def equals(self, object: typing.Any) -> bool: ... + def flip(self) -> IntBuffer: ... + @typing.overload + def get(self) -> int: ... + @typing.overload + def get(self, int: int) -> int: ... + @typing.overload + def get(self, int: int, intArray: list[int] | jpype.JArray) -> IntBuffer: ... + @typing.overload + def get( + self, int: int, intArray: list[int] | jpype.JArray, int3: int, int4: int + ) -> IntBuffer: ... + @typing.overload + def get(self, intArray: list[int] | jpype.JArray) -> IntBuffer: ... + @typing.overload + def get( + self, intArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> IntBuffer: ... + def hasArray(self) -> bool: ... + def hashCode(self) -> int: ... + def isDirect(self) -> bool: ... + @typing.overload + def limit(self) -> int: ... + @typing.overload + def limit(self, int: int) -> IntBuffer: ... + def mark(self) -> IntBuffer: ... + def mismatch(self, intBuffer: IntBuffer) -> int: ... + def order(self) -> ByteOrder: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def position(self, int: int) -> IntBuffer: ... + @typing.overload + def put(self, int: int) -> IntBuffer: ... + @typing.overload + def put(self, int: int, int2: int) -> IntBuffer: ... + @typing.overload + def put(self, intArray: list[int] | jpype.JArray) -> IntBuffer: ... + @typing.overload + def put(self, int: int, intArray: list[int] | jpype.JArray) -> IntBuffer: ... + @typing.overload + def put( + self, int: int, intArray: list[int] | jpype.JArray, int3: int, int4: int + ) -> IntBuffer: ... + @typing.overload + def put( + self, int: int, intBuffer: IntBuffer, int3: int, int4: int + ) -> IntBuffer: ... + @typing.overload + def put( + self, intArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> IntBuffer: ... + @typing.overload + def put(self, intBuffer: IntBuffer) -> IntBuffer: ... + def reset(self) -> IntBuffer: ... + def rewind(self) -> IntBuffer: ... + @typing.overload + def slice(self) -> IntBuffer: ... + @typing.overload + def slice(self, int: int, int2: int) -> IntBuffer: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def wrap(intArray: list[int] | jpype.JArray) -> IntBuffer: ... + @typing.overload + @staticmethod + def wrap(intArray: list[int] | jpype.JArray, int2: int, int3: int) -> IntBuffer: ... + +class LongBuffer(Buffer, java.lang.Comparable["LongBuffer"]): + @staticmethod + def allocate(int: int) -> LongBuffer: ... + def array(self) -> typing.MutableSequence[int]: ... + def arrayOffset(self) -> int: ... + def asReadOnlyBuffer(self) -> LongBuffer: ... + def clear(self) -> LongBuffer: ... + def compact(self) -> LongBuffer: ... + def compareTo(self, longBuffer: LongBuffer) -> int: ... + def duplicate(self) -> LongBuffer: ... + def equals(self, object: typing.Any) -> bool: ... + def flip(self) -> LongBuffer: ... + @typing.overload + def get(self) -> int: ... + @typing.overload + def get(self, int: int) -> int: ... + @typing.overload + def get(self, int: int, longArray: list[int] | jpype.JArray) -> LongBuffer: ... + @typing.overload + def get( + self, int: int, longArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> LongBuffer: ... + @typing.overload + def get(self, longArray: list[int] | jpype.JArray) -> LongBuffer: ... + @typing.overload + def get( + self, longArray: list[int] | jpype.JArray, int: int, int2: int + ) -> LongBuffer: ... + def hasArray(self) -> bool: ... + def hashCode(self) -> int: ... + def isDirect(self) -> bool: ... + @typing.overload + def limit(self) -> int: ... + @typing.overload + def limit(self, int: int) -> LongBuffer: ... + def mark(self) -> LongBuffer: ... + def mismatch(self, longBuffer: LongBuffer) -> int: ... + def order(self) -> ByteOrder: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def position(self, int: int) -> LongBuffer: ... + @typing.overload + def put(self, int: int, long: int) -> LongBuffer: ... + @typing.overload + def put(self, long: int) -> LongBuffer: ... + @typing.overload + def put(self, longArray: list[int] | jpype.JArray) -> LongBuffer: ... + @typing.overload + def put( + self, int: int, longBuffer: LongBuffer, int2: int, int3: int + ) -> LongBuffer: ... + @typing.overload + def put(self, int: int, longArray: list[int] | jpype.JArray) -> LongBuffer: ... + @typing.overload + def put( + self, int: int, longArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> LongBuffer: ... + @typing.overload + def put(self, longBuffer: LongBuffer) -> LongBuffer: ... + @typing.overload + def put( + self, longArray: list[int] | jpype.JArray, int: int, int2: int + ) -> LongBuffer: ... + def reset(self) -> LongBuffer: ... + def rewind(self) -> LongBuffer: ... + @typing.overload + def slice(self) -> LongBuffer: ... + @typing.overload + def slice(self, int: int, int2: int) -> LongBuffer: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def wrap(longArray: list[int] | jpype.JArray) -> LongBuffer: ... + @typing.overload + @staticmethod + def wrap( + longArray: list[int] | jpype.JArray, int: int, int2: int + ) -> LongBuffer: ... + +class ShortBuffer(Buffer, java.lang.Comparable["ShortBuffer"]): + @staticmethod + def allocate(int: int) -> ShortBuffer: ... + def array(self) -> typing.MutableSequence[int]: ... + def arrayOffset(self) -> int: ... + def asReadOnlyBuffer(self) -> ShortBuffer: ... + def clear(self) -> ShortBuffer: ... + def compact(self) -> ShortBuffer: ... + def compareTo(self, shortBuffer: ShortBuffer) -> int: ... + def duplicate(self) -> ShortBuffer: ... + def equals(self, object: typing.Any) -> bool: ... + def flip(self) -> ShortBuffer: ... + @typing.overload + def get(self) -> int: ... + @typing.overload + def get(self, int: int) -> int: ... + @typing.overload + def get(self, int: int, shortArray: list[int] | jpype.JArray) -> ShortBuffer: ... + @typing.overload + def get( + self, int: int, shortArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> ShortBuffer: ... + @typing.overload + def get(self, shortArray: list[int] | jpype.JArray) -> ShortBuffer: ... + @typing.overload + def get( + self, shortArray: list[int] | jpype.JArray, int: int, int2: int + ) -> ShortBuffer: ... + def hasArray(self) -> bool: ... + def hashCode(self) -> int: ... + def isDirect(self) -> bool: ... + @typing.overload + def limit(self) -> int: ... + @typing.overload + def limit(self, int: int) -> ShortBuffer: ... + def mark(self) -> ShortBuffer: ... + def mismatch(self, shortBuffer: ShortBuffer) -> int: ... + def order(self) -> ByteOrder: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def position(self, int: int) -> ShortBuffer: ... + @typing.overload + def put(self, int: int, short: int) -> ShortBuffer: ... + @typing.overload + def put(self, short: int) -> ShortBuffer: ... + @typing.overload + def put(self, shortArray: list[int] | jpype.JArray) -> ShortBuffer: ... + @typing.overload + def put( + self, int: int, shortBuffer: ShortBuffer, int2: int, int3: int + ) -> ShortBuffer: ... + @typing.overload + def put(self, int: int, shortArray: list[int] | jpype.JArray) -> ShortBuffer: ... + @typing.overload + def put( + self, int: int, shortArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> ShortBuffer: ... + @typing.overload + def put(self, shortBuffer: ShortBuffer) -> ShortBuffer: ... + @typing.overload + def put( + self, shortArray: list[int] | jpype.JArray, int: int, int2: int + ) -> ShortBuffer: ... + def reset(self) -> ShortBuffer: ... + def rewind(self) -> ShortBuffer: ... + @typing.overload + def slice(self) -> ShortBuffer: ... + @typing.overload + def slice(self, int: int, int2: int) -> ShortBuffer: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def wrap(shortArray: list[int] | jpype.JArray) -> ShortBuffer: ... + @typing.overload + @staticmethod + def wrap( + shortArray: list[int] | jpype.JArray, int: int, int2: int + ) -> ShortBuffer: ... + +class MappedByteBuffer(ByteBuffer): + def clear(self) -> MappedByteBuffer: ... + def compact(self) -> MappedByteBuffer: ... + def duplicate(self) -> MappedByteBuffer: ... + def flip(self) -> MappedByteBuffer: ... + @typing.overload + def force(self) -> MappedByteBuffer: ... + @typing.overload + def force(self, int: int, int2: int) -> MappedByteBuffer: ... + def isLoaded(self) -> bool: ... + @typing.overload + def limit(self) -> int: ... + @typing.overload + def limit(self, int: int) -> MappedByteBuffer: ... + def load(self) -> MappedByteBuffer: ... + def mark(self) -> MappedByteBuffer: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def position(self, int: int) -> MappedByteBuffer: ... + def reset(self) -> MappedByteBuffer: ... + def rewind(self) -> MappedByteBuffer: ... + @typing.overload + def slice(self) -> MappedByteBuffer: ... + @typing.overload + def slice(self, int: int, int2: int) -> MappedByteBuffer: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.nio")``. + + Buffer: type[Buffer] + BufferOverflowException: type[BufferOverflowException] + BufferUnderflowException: type[BufferUnderflowException] + ByteBuffer: type[ByteBuffer] + ByteOrder: type[ByteOrder] + CharBuffer: type[CharBuffer] + DoubleBuffer: type[DoubleBuffer] + FloatBuffer: type[FloatBuffer] + IntBuffer: type[IntBuffer] + InvalidMarkException: type[InvalidMarkException] + LongBuffer: type[LongBuffer] + MappedByteBuffer: type[MappedByteBuffer] + ReadOnlyBufferException: type[ReadOnlyBufferException] + ShortBuffer: type[ShortBuffer] + channels: java.nio.channels.__module_protocol__ + charset: java.nio.charset.__module_protocol__ + file: java.nio.file.__module_protocol__ diff --git a/typings/java/nio/channels/__init__.pyi b/typings/java/nio/channels/__init__.pyi new file mode 100644 index 0000000..0612248 --- /dev/null +++ b/typings/java/nio/channels/__init__.pyi @@ -0,0 +1,907 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.lang.foreign +import java.net +import java.nio +import java.nio.channels.spi +import java.nio.charset +import java.nio.file +import java.nio.file.attribute +import java.util +import java.util.concurrent +import java.util.function +import jpype +import jpype.protocol + +class AcceptPendingException(java.lang.IllegalStateException): + def __init__(self): ... + +class AlreadyBoundException(java.lang.IllegalStateException): + def __init__(self): ... + +class AlreadyConnectedException(java.lang.IllegalStateException): + def __init__(self): ... + +class AsynchronousChannelGroup: + def awaitTermination( + self, long: int, timeUnit: java.util.concurrent.TimeUnit + ) -> bool: ... + def isShutdown(self) -> bool: ... + def isTerminated(self) -> bool: ... + def provider(self) -> java.nio.channels.spi.AsynchronousChannelProvider: ... + def shutdown(self) -> None: ... + def shutdownNow(self) -> None: ... + @staticmethod + def withCachedThreadPool( + executorService: java.util.concurrent.ExecutorService, int: int + ) -> AsynchronousChannelGroup: ... + @staticmethod + def withFixedThreadPool( + int: int, threadFactory: java.util.concurrent.ThreadFactory | typing.Callable + ) -> AsynchronousChannelGroup: ... + @staticmethod + def withThreadPool( + executorService: java.util.concurrent.ExecutorService, + ) -> AsynchronousChannelGroup: ... + +class CancelledKeyException(java.lang.IllegalStateException): + def __init__(self): ... + +class Channel(java.io.Closeable): + def close(self) -> None: ... + def isOpen(self) -> bool: ... + +class Channels: + @typing.overload + @staticmethod + def newChannel(inputStream: java.io.InputStream) -> ReadableByteChannel: ... + @typing.overload + @staticmethod + def newChannel(outputStream: java.io.OutputStream) -> WritableByteChannel: ... + @typing.overload + @staticmethod + def newInputStream( + asynchronousByteChannel: AsynchronousByteChannel, + ) -> java.io.InputStream: ... + @typing.overload + @staticmethod + def newInputStream( + readableByteChannel: ReadableByteChannel, + ) -> java.io.InputStream: ... + @typing.overload + @staticmethod + def newOutputStream( + asynchronousByteChannel: AsynchronousByteChannel, + ) -> java.io.OutputStream: ... + @typing.overload + @staticmethod + def newOutputStream( + writableByteChannel: WritableByteChannel, + ) -> java.io.OutputStream: ... + @typing.overload + @staticmethod + def newReader( + readableByteChannel: ReadableByteChannel, string: java.lang.String | str + ) -> java.io.Reader: ... + @typing.overload + @staticmethod + def newReader( + readableByteChannel: ReadableByteChannel, charset: java.nio.charset.Charset + ) -> java.io.Reader: ... + @typing.overload + @staticmethod + def newReader( + readableByteChannel: ReadableByteChannel, + charsetDecoder: java.nio.charset.CharsetDecoder, + int: int, + ) -> java.io.Reader: ... + @typing.overload + @staticmethod + def newWriter( + writableByteChannel: WritableByteChannel, string: java.lang.String | str + ) -> java.io.Writer: ... + @typing.overload + @staticmethod + def newWriter( + writableByteChannel: WritableByteChannel, charset: java.nio.charset.Charset + ) -> java.io.Writer: ... + @typing.overload + @staticmethod + def newWriter( + writableByteChannel: WritableByteChannel, + charsetEncoder: java.nio.charset.CharsetEncoder, + int: int, + ) -> java.io.Writer: ... + +class ClosedChannelException(java.io.IOException): + def __init__(self): ... + +class ClosedSelectorException(java.lang.IllegalStateException): + def __init__(self): ... + +_CompletionHandler__V = typing.TypeVar("_CompletionHandler__V") # +_CompletionHandler__A = typing.TypeVar("_CompletionHandler__A") # + +class CompletionHandler(typing.Generic[_CompletionHandler__V, _CompletionHandler__A]): + def completed(self, v: _CompletionHandler__V, a: _CompletionHandler__A) -> None: ... + def failed( + self, throwable: java.lang.Throwable, a: _CompletionHandler__A + ) -> None: ... + +class ConnectionPendingException(java.lang.IllegalStateException): + def __init__(self): ... + +class FileLock(java.lang.AutoCloseable): + def acquiredBy(self) -> Channel: ... + def channel(self) -> FileChannel: ... + def close(self) -> None: ... + def isShared(self) -> bool: ... + def isValid(self) -> bool: ... + def overlaps(self, long: int, long2: int) -> bool: ... + def position(self) -> int: ... + def release(self) -> None: ... + def size(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class FileLockInterruptionException(java.io.IOException): + def __init__(self): ... + +class IllegalBlockingModeException(java.lang.IllegalStateException): + def __init__(self): ... + +class IllegalChannelGroupException(java.lang.IllegalArgumentException): + def __init__(self): ... + +class IllegalSelectorException(java.lang.IllegalArgumentException): + def __init__(self): ... + +class InterruptedByTimeoutException(java.io.IOException): + def __init__(self): ... + +class MembershipKey: + def block(self, inetAddress: java.net.InetAddress) -> MembershipKey: ... + def channel(self) -> MulticastChannel: ... + def drop(self) -> None: ... + def group(self) -> java.net.InetAddress: ... + def isValid(self) -> bool: ... + def networkInterface(self) -> java.net.NetworkInterface: ... + def sourceAddress(self) -> java.net.InetAddress: ... + def unblock(self, inetAddress: java.net.InetAddress) -> MembershipKey: ... + +class NoConnectionPendingException(java.lang.IllegalStateException): + def __init__(self): ... + +class NonReadableChannelException(java.lang.IllegalStateException): + def __init__(self): ... + +class NonWritableChannelException(java.lang.IllegalStateException): + def __init__(self): ... + +class NotYetBoundException(java.lang.IllegalStateException): + def __init__(self): ... + +class NotYetConnectedException(java.lang.IllegalStateException): + def __init__(self): ... + +class OverlappingFileLockException(java.lang.IllegalStateException): + def __init__(self): ... + +class ReadPendingException(java.lang.IllegalStateException): + def __init__(self): ... + +class SelectionKey: + OP_READ: typing.ClassVar[int] = ... + OP_WRITE: typing.ClassVar[int] = ... + OP_CONNECT: typing.ClassVar[int] = ... + OP_ACCEPT: typing.ClassVar[int] = ... + def attach(self, object: typing.Any) -> typing.Any: ... + def attachment(self) -> typing.Any: ... + def cancel(self) -> None: ... + def channel(self) -> SelectableChannel: ... + @typing.overload + def interestOps(self) -> int: ... + @typing.overload + def interestOps(self, int: int) -> SelectionKey: ... + def interestOpsAnd(self, int: int) -> int: ... + def interestOpsOr(self, int: int) -> int: ... + def isAcceptable(self) -> bool: ... + def isConnectable(self) -> bool: ... + def isReadable(self) -> bool: ... + def isValid(self) -> bool: ... + def isWritable(self) -> bool: ... + def readyOps(self) -> int: ... + def selector(self) -> Selector: ... + +class Selector(java.io.Closeable): + def close(self) -> None: ... + def isOpen(self) -> bool: ... + def keys(self) -> java.util.Set[SelectionKey]: ... + @staticmethod + def open() -> Selector: ... + def provider(self) -> java.nio.channels.spi.SelectorProvider: ... + @typing.overload + def select(self) -> int: ... + @typing.overload + def select(self, long: int) -> int: ... + @typing.overload + def select( + self, + consumer: java.util.function.Consumer[SelectionKey] + | typing.Callable[[SelectionKey], None], + ) -> int: ... + @typing.overload + def select( + self, + consumer: java.util.function.Consumer[SelectionKey] + | typing.Callable[[SelectionKey], None], + long: int, + ) -> int: ... + @typing.overload + def selectNow(self) -> int: ... + @typing.overload + def selectNow( + self, + consumer: java.util.function.Consumer[SelectionKey] + | typing.Callable[[SelectionKey], None], + ) -> int: ... + def selectedKeys(self) -> java.util.Set[SelectionKey]: ... + def wakeup(self) -> Selector: ... + +class ShutdownChannelGroupException(java.lang.IllegalStateException): + def __init__(self): ... + +class UnresolvedAddressException(java.lang.IllegalArgumentException): + def __init__(self): ... + +class UnsupportedAddressTypeException(java.lang.IllegalArgumentException): + def __init__(self): ... + +class WritePendingException(java.lang.IllegalStateException): + def __init__(self): ... + +class AsynchronousChannel(Channel): + def close(self) -> None: ... + +class AsynchronousCloseException(ClosedChannelException): + def __init__(self): ... + +class InterruptibleChannel(Channel): + def close(self) -> None: ... + +class NetworkChannel(Channel): + def bind(self, socketAddress: java.net.SocketAddress) -> NetworkChannel: ... + def getLocalAddress(self) -> java.net.SocketAddress: ... + _getOption__T = typing.TypeVar("_getOption__T") # + def getOption( + self, socketOption: java.net.SocketOption[_getOption__T] + ) -> _getOption__T: ... + _setOption__T = typing.TypeVar("_setOption__T") # + def setOption( + self, socketOption: java.net.SocketOption[_setOption__T], t: _setOption__T + ) -> NetworkChannel: ... + def supportedOptions(self) -> java.util.Set[java.net.SocketOption[typing.Any]]: ... + +class ReadableByteChannel(Channel): + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + +class SelectableChannel(java.nio.channels.spi.AbstractInterruptibleChannel, Channel): + def blockingLock(self) -> typing.Any: ... + def configureBlocking(self, boolean: bool) -> SelectableChannel: ... + def isBlocking(self) -> bool: ... + def isRegistered(self) -> bool: ... + def keyFor(self, selector: Selector) -> SelectionKey: ... + def provider(self) -> java.nio.channels.spi.SelectorProvider: ... + @typing.overload + def register( + self, selector: Selector, int: int, object: typing.Any + ) -> SelectionKey: ... + @typing.overload + def register(self, selector: Selector, int: int) -> SelectionKey: ... + def validOps(self) -> int: ... + +class WritableByteChannel(Channel): + def write(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + +class AsynchronousByteChannel(AsynchronousChannel): + _read_1__A = typing.TypeVar("_read_1__A") # + @typing.overload + def read( + self, byteBuffer: java.nio.ByteBuffer + ) -> java.util.concurrent.Future[int]: ... + @typing.overload + def read( + self, + byteBuffer: java.nio.ByteBuffer, + a: _read_1__A, + completionHandler: CompletionHandler[int, _read_1__A], + ) -> None: ... + _write_1__A = typing.TypeVar("_write_1__A") # + @typing.overload + def write( + self, byteBuffer: java.nio.ByteBuffer + ) -> java.util.concurrent.Future[int]: ... + @typing.overload + def write( + self, + byteBuffer: java.nio.ByteBuffer, + a: _write_1__A, + completionHandler: CompletionHandler[int, _write_1__A], + ) -> None: ... + +class AsynchronousFileChannel(AsynchronousChannel): + def force(self, boolean: bool) -> None: ... + _lock_1__A = typing.TypeVar("_lock_1__A") # + _lock_3__A = typing.TypeVar("_lock_3__A") # + @typing.overload + def lock( + self, long: int, long2: int, boolean: bool + ) -> java.util.concurrent.Future[FileLock]: ... + @typing.overload + def lock( + self, + long: int, + long2: int, + boolean: bool, + a: _lock_1__A, + completionHandler: CompletionHandler[FileLock, _lock_1__A], + ) -> None: ... + @typing.overload + def lock(self) -> java.util.concurrent.Future[FileLock]: ... + @typing.overload + def lock( + self, a: _lock_3__A, completionHandler: CompletionHandler[FileLock, _lock_3__A] + ) -> None: ... + @typing.overload + @staticmethod + def open( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *openOption: java.nio.file.OpenOption, + ) -> AsynchronousFileChannel: ... + @typing.overload + @staticmethod + def open( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + set: java.util.Set[java.nio.file.OpenOption], + executorService: java.util.concurrent.ExecutorService, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> AsynchronousFileChannel: ... + _read_1__A = typing.TypeVar("_read_1__A") # + @typing.overload + def read( + self, byteBuffer: java.nio.ByteBuffer, long: int + ) -> java.util.concurrent.Future[int]: ... + @typing.overload + def read( + self, + byteBuffer: java.nio.ByteBuffer, + long: int, + a: _read_1__A, + completionHandler: CompletionHandler[int, _read_1__A], + ) -> None: ... + def size(self) -> int: ... + def truncate(self, long: int) -> AsynchronousFileChannel: ... + @typing.overload + def tryLock(self, long: int, long2: int, boolean: bool) -> FileLock: ... + @typing.overload + def tryLock(self) -> FileLock: ... + _write_1__A = typing.TypeVar("_write_1__A") # + @typing.overload + def write( + self, byteBuffer: java.nio.ByteBuffer, long: int + ) -> java.util.concurrent.Future[int]: ... + @typing.overload + def write( + self, + byteBuffer: java.nio.ByteBuffer, + long: int, + a: _write_1__A, + completionHandler: CompletionHandler[int, _write_1__A], + ) -> None: ... + +class AsynchronousServerSocketChannel(AsynchronousChannel, NetworkChannel): + _accept_1__A = typing.TypeVar("_accept_1__A") # + @typing.overload + def accept(self) -> java.util.concurrent.Future[AsynchronousSocketChannel]: ... + @typing.overload + def accept( + self, + a: _accept_1__A, + completionHandler: CompletionHandler[AsynchronousSocketChannel, _accept_1__A], + ) -> None: ... + @typing.overload + def bind( + self, socketAddress: java.net.SocketAddress, int: int + ) -> AsynchronousServerSocketChannel: ... + @typing.overload + def bind( + self, socketAddress: java.net.SocketAddress + ) -> AsynchronousServerSocketChannel: ... + def getLocalAddress(self) -> java.net.SocketAddress: ... + @typing.overload + @staticmethod + def open() -> AsynchronousServerSocketChannel: ... + @typing.overload + @staticmethod + def open( + asynchronousChannelGroup: AsynchronousChannelGroup, + ) -> AsynchronousServerSocketChannel: ... + def provider(self) -> java.nio.channels.spi.AsynchronousChannelProvider: ... + _setOption__T = typing.TypeVar("_setOption__T") # + def setOption( + self, socketOption: java.net.SocketOption[_setOption__T], t: _setOption__T + ) -> AsynchronousServerSocketChannel: ... + +class ByteChannel(ReadableByteChannel, WritableByteChannel): ... + +class ClosedByInterruptException(AsynchronousCloseException): + def __init__(self): ... + +class GatheringByteChannel(WritableByteChannel): + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def write( + self, byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray + ) -> int: ... + @typing.overload + def write( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + ) -> int: ... + +class MulticastChannel(NetworkChannel): + def close(self) -> None: ... + @typing.overload + def join( + self, + inetAddress: java.net.InetAddress, + networkInterface: java.net.NetworkInterface, + ) -> MembershipKey: ... + @typing.overload + def join( + self, + inetAddress: java.net.InetAddress, + networkInterface: java.net.NetworkInterface, + inetAddress2: java.net.InetAddress, + ) -> MembershipKey: ... + +class ScatteringByteChannel(ReadableByteChannel): + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read( + self, byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray + ) -> int: ... + @typing.overload + def read( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + ) -> int: ... + +class ServerSocketChannel( + java.nio.channels.spi.AbstractSelectableChannel, NetworkChannel +): + def accept(self) -> SocketChannel: ... + @typing.overload + def bind( + self, socketAddress: java.net.SocketAddress, int: int + ) -> ServerSocketChannel: ... + @typing.overload + def bind(self, socketAddress: java.net.SocketAddress) -> ServerSocketChannel: ... + def getLocalAddress(self) -> java.net.SocketAddress: ... + @typing.overload + @staticmethod + def open() -> ServerSocketChannel: ... + @typing.overload + @staticmethod + def open( + protocolFamily: java.net.ProtocolFamily | typing.Callable, + ) -> ServerSocketChannel: ... + _setOption__T = typing.TypeVar("_setOption__T") # + def setOption( + self, socketOption: java.net.SocketOption[_setOption__T], t: _setOption__T + ) -> ServerSocketChannel: ... + def socket(self) -> java.net.ServerSocket: ... + def validOps(self) -> int: ... + +class AsynchronousSocketChannel(AsynchronousByteChannel, NetworkChannel): + def bind( + self, socketAddress: java.net.SocketAddress + ) -> AsynchronousSocketChannel: ... + _connect_1__A = typing.TypeVar("_connect_1__A") # + @typing.overload + def connect( + self, socketAddress: java.net.SocketAddress + ) -> java.util.concurrent.Future[None]: ... + @typing.overload + def connect( + self, + socketAddress: java.net.SocketAddress, + a: _connect_1__A, + completionHandler: CompletionHandler[None, _connect_1__A], + ) -> None: ... + def getLocalAddress(self) -> java.net.SocketAddress: ... + def getRemoteAddress(self) -> java.net.SocketAddress: ... + @typing.overload + @staticmethod + def open() -> AsynchronousSocketChannel: ... + @typing.overload + @staticmethod + def open( + asynchronousChannelGroup: AsynchronousChannelGroup, + ) -> AsynchronousSocketChannel: ... + def provider(self) -> java.nio.channels.spi.AsynchronousChannelProvider: ... + _read_1__A = typing.TypeVar("_read_1__A") # + _read_2__A = typing.TypeVar("_read_2__A") # + _read_3__A = typing.TypeVar("_read_3__A") # + @typing.overload + def read( + self, byteBuffer: java.nio.ByteBuffer + ) -> java.util.concurrent.Future[int]: ... + @typing.overload + def read( + self, + byteBuffer: java.nio.ByteBuffer, + long: int, + timeUnit: java.util.concurrent.TimeUnit, + a: _read_1__A, + completionHandler: CompletionHandler[int, _read_1__A], + ) -> None: ... + @typing.overload + def read( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + long: int, + timeUnit: java.util.concurrent.TimeUnit, + a: _read_2__A, + completionHandler: CompletionHandler[int, _read_2__A], + ) -> None: ... + @typing.overload + def read( + self, + byteBuffer: java.nio.ByteBuffer, + a: _read_3__A, + completionHandler: CompletionHandler[int, _read_3__A], + ) -> None: ... + _setOption__T = typing.TypeVar("_setOption__T") # + def setOption( + self, socketOption: java.net.SocketOption[_setOption__T], t: _setOption__T + ) -> AsynchronousSocketChannel: ... + def shutdownInput(self) -> AsynchronousSocketChannel: ... + def shutdownOutput(self) -> AsynchronousSocketChannel: ... + _write_1__A = typing.TypeVar("_write_1__A") # + _write_2__A = typing.TypeVar("_write_2__A") # + _write_3__A = typing.TypeVar("_write_3__A") # + @typing.overload + def write( + self, byteBuffer: java.nio.ByteBuffer + ) -> java.util.concurrent.Future[int]: ... + @typing.overload + def write( + self, + byteBuffer: java.nio.ByteBuffer, + long: int, + timeUnit: java.util.concurrent.TimeUnit, + a: _write_1__A, + completionHandler: CompletionHandler[int, _write_1__A], + ) -> None: ... + @typing.overload + def write( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + long: int, + timeUnit: java.util.concurrent.TimeUnit, + a: _write_2__A, + completionHandler: CompletionHandler[int, _write_2__A], + ) -> None: ... + @typing.overload + def write( + self, + byteBuffer: java.nio.ByteBuffer, + a: _write_3__A, + completionHandler: CompletionHandler[int, _write_3__A], + ) -> None: ... + +class DatagramChannel( + java.nio.channels.spi.AbstractSelectableChannel, + ByteChannel, + ScatteringByteChannel, + GatheringByteChannel, + MulticastChannel, +): + def bind(self, socketAddress: java.net.SocketAddress) -> DatagramChannel: ... + def connect(self, socketAddress: java.net.SocketAddress) -> DatagramChannel: ... + def disconnect(self) -> DatagramChannel: ... + def getLocalAddress(self) -> java.net.SocketAddress: ... + def getRemoteAddress(self) -> java.net.SocketAddress: ... + def isConnected(self) -> bool: ... + @typing.overload + @staticmethod + def open() -> DatagramChannel: ... + @typing.overload + @staticmethod + def open( + protocolFamily: java.net.ProtocolFamily | typing.Callable, + ) -> DatagramChannel: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + ) -> int: ... + @typing.overload + def read( + self, byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray + ) -> int: ... + def receive(self, byteBuffer: java.nio.ByteBuffer) -> java.net.SocketAddress: ... + def send( + self, byteBuffer: java.nio.ByteBuffer, socketAddress: java.net.SocketAddress + ) -> int: ... + _setOption__T = typing.TypeVar("_setOption__T") # + def setOption( + self, socketOption: java.net.SocketOption[_setOption__T], t: _setOption__T + ) -> DatagramChannel: ... + def socket(self) -> java.net.DatagramSocket: ... + def validOps(self) -> int: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def write( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + ) -> int: ... + @typing.overload + def write( + self, byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray + ) -> int: ... + +class Pipe: + @staticmethod + def open() -> Pipe: ... + def sink(self) -> Pipe.SinkChannel: ... + def source(self) -> Pipe.SourceChannel: ... + class SinkChannel( + java.nio.channels.spi.AbstractSelectableChannel, + WritableByteChannel, + GatheringByteChannel, + ): + def validOps(self) -> int: ... + + class SourceChannel( + java.nio.channels.spi.AbstractSelectableChannel, + ReadableByteChannel, + ScatteringByteChannel, + ): + def validOps(self) -> int: ... + +class SeekableByteChannel(ByteChannel): + @typing.overload + def position(self, long: int) -> SeekableByteChannel: ... + @typing.overload + def position(self) -> int: ... + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + def size(self) -> int: ... + def truncate(self, long: int) -> SeekableByteChannel: ... + def write(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + +class SocketChannel( + java.nio.channels.spi.AbstractSelectableChannel, + ByteChannel, + ScatteringByteChannel, + GatheringByteChannel, + NetworkChannel, +): + def bind(self, socketAddress: java.net.SocketAddress) -> SocketChannel: ... + def connect(self, socketAddress: java.net.SocketAddress) -> bool: ... + def finishConnect(self) -> bool: ... + def getLocalAddress(self) -> java.net.SocketAddress: ... + def getRemoteAddress(self) -> java.net.SocketAddress: ... + def isConnected(self) -> bool: ... + def isConnectionPending(self) -> bool: ... + @typing.overload + @staticmethod + def open() -> SocketChannel: ... + @typing.overload + @staticmethod + def open( + protocolFamily: java.net.ProtocolFamily | typing.Callable, + ) -> SocketChannel: ... + @typing.overload + @staticmethod + def open(socketAddress: java.net.SocketAddress) -> SocketChannel: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + ) -> int: ... + @typing.overload + def read( + self, byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray + ) -> int: ... + _setOption__T = typing.TypeVar("_setOption__T") # + def setOption( + self, socketOption: java.net.SocketOption[_setOption__T], t: _setOption__T + ) -> SocketChannel: ... + def shutdownInput(self) -> SocketChannel: ... + def shutdownOutput(self) -> SocketChannel: ... + def socket(self) -> java.net.Socket: ... + def validOps(self) -> int: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def write( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + ) -> int: ... + @typing.overload + def write( + self, byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray + ) -> int: ... + +class FileChannel( + java.nio.channels.spi.AbstractInterruptibleChannel, + SeekableByteChannel, + GatheringByteChannel, + ScatteringByteChannel, +): + def force(self, boolean: bool) -> None: ... + @typing.overload + def lock(self, long: int, long2: int, boolean: bool) -> FileLock: ... + @typing.overload + def lock(self) -> FileLock: ... + @typing.overload + def map( + self, mapMode: FileChannel.MapMode, long: int, long2: int + ) -> java.nio.MappedByteBuffer: ... + @typing.overload + def map( + self, + mapMode: FileChannel.MapMode, + long: int, + long2: int, + arena: java.lang.foreign.Arena, + ) -> java.lang.foreign.MemorySegment: ... + @typing.overload + @staticmethod + def open( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *openOption: java.nio.file.OpenOption, + ) -> FileChannel: ... + @typing.overload + @staticmethod + def open( + path: java.nio.file.Path | jpype.protocol.SupportsPath, + set: java.util.Set[java.nio.file.OpenOption], + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> FileChannel: ... + @typing.overload + def position(self, long: int) -> FileChannel: ... + @typing.overload + def position(self) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer, long: int) -> int: ... + @typing.overload + def read( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + ) -> int: ... + @typing.overload + def read( + self, byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray + ) -> int: ... + def size(self) -> int: ... + def transferFrom( + self, readableByteChannel: ReadableByteChannel, long: int, long2: int + ) -> int: ... + def transferTo( + self, long: int, long2: int, writableByteChannel: WritableByteChannel + ) -> int: ... + def truncate(self, long: int) -> FileChannel: ... + @typing.overload + def tryLock(self, long: int, long2: int, boolean: bool) -> FileLock: ... + @typing.overload + def tryLock(self) -> FileLock: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer, long: int) -> int: ... + @typing.overload + def write( + self, + byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray, + int: int, + int2: int, + ) -> int: ... + @typing.overload + def write( + self, byteBufferArray: list[java.nio.ByteBuffer] | jpype.JArray + ) -> int: ... + class MapMode: + READ_ONLY: typing.ClassVar[FileChannel.MapMode] = ... + READ_WRITE: typing.ClassVar[FileChannel.MapMode] = ... + PRIVATE: typing.ClassVar[FileChannel.MapMode] = ... + def toString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.nio.channels")``. + + AcceptPendingException: type[AcceptPendingException] + AlreadyBoundException: type[AlreadyBoundException] + AlreadyConnectedException: type[AlreadyConnectedException] + AsynchronousByteChannel: type[AsynchronousByteChannel] + AsynchronousChannel: type[AsynchronousChannel] + AsynchronousChannelGroup: type[AsynchronousChannelGroup] + AsynchronousCloseException: type[AsynchronousCloseException] + AsynchronousFileChannel: type[AsynchronousFileChannel] + AsynchronousServerSocketChannel: type[AsynchronousServerSocketChannel] + AsynchronousSocketChannel: type[AsynchronousSocketChannel] + ByteChannel: type[ByteChannel] + CancelledKeyException: type[CancelledKeyException] + Channel: type[Channel] + Channels: type[Channels] + ClosedByInterruptException: type[ClosedByInterruptException] + ClosedChannelException: type[ClosedChannelException] + ClosedSelectorException: type[ClosedSelectorException] + CompletionHandler: type[CompletionHandler] + ConnectionPendingException: type[ConnectionPendingException] + DatagramChannel: type[DatagramChannel] + FileChannel: type[FileChannel] + FileLock: type[FileLock] + FileLockInterruptionException: type[FileLockInterruptionException] + GatheringByteChannel: type[GatheringByteChannel] + IllegalBlockingModeException: type[IllegalBlockingModeException] + IllegalChannelGroupException: type[IllegalChannelGroupException] + IllegalSelectorException: type[IllegalSelectorException] + InterruptedByTimeoutException: type[InterruptedByTimeoutException] + InterruptibleChannel: type[InterruptibleChannel] + MembershipKey: type[MembershipKey] + MulticastChannel: type[MulticastChannel] + NetworkChannel: type[NetworkChannel] + NoConnectionPendingException: type[NoConnectionPendingException] + NonReadableChannelException: type[NonReadableChannelException] + NonWritableChannelException: type[NonWritableChannelException] + NotYetBoundException: type[NotYetBoundException] + NotYetConnectedException: type[NotYetConnectedException] + OverlappingFileLockException: type[OverlappingFileLockException] + Pipe: type[Pipe] + ReadPendingException: type[ReadPendingException] + ReadableByteChannel: type[ReadableByteChannel] + ScatteringByteChannel: type[ScatteringByteChannel] + SeekableByteChannel: type[SeekableByteChannel] + SelectableChannel: type[SelectableChannel] + SelectionKey: type[SelectionKey] + Selector: type[Selector] + ServerSocketChannel: type[ServerSocketChannel] + ShutdownChannelGroupException: type[ShutdownChannelGroupException] + SocketChannel: type[SocketChannel] + UnresolvedAddressException: type[UnresolvedAddressException] + UnsupportedAddressTypeException: type[UnsupportedAddressTypeException] + WritableByteChannel: type[WritableByteChannel] + WritePendingException: type[WritePendingException] + spi: java.nio.channels.spi.__module_protocol__ diff --git a/typings/java/nio/channels/spi/__init__.pyi b/typings/java/nio/channels/spi/__init__.pyi new file mode 100644 index 0000000..7c7724e --- /dev/null +++ b/typings/java/nio/channels/spi/__init__.pyi @@ -0,0 +1,96 @@ +import typing +from typing import Protocol + +import java.net +import java.nio.channels +import java.util.concurrent + +class AbstractInterruptibleChannel( + java.nio.channels.Channel, java.nio.channels.InterruptibleChannel +): + def close(self) -> None: ... + def isOpen(self) -> bool: ... + +class AbstractSelectableChannel(java.nio.channels.SelectableChannel): + def blockingLock(self) -> typing.Any: ... + def configureBlocking( + self, boolean: bool + ) -> java.nio.channels.SelectableChannel: ... + def isBlocking(self) -> bool: ... + def isRegistered(self) -> bool: ... + def keyFor( + self, selector: java.nio.channels.Selector + ) -> java.nio.channels.SelectionKey: ... + def provider(self) -> SelectorProvider: ... + @typing.overload + def register( + self, selector: java.nio.channels.Selector, int: int + ) -> java.nio.channels.SelectionKey: ... + @typing.overload + def register( + self, selector: java.nio.channels.Selector, int: int, object: typing.Any + ) -> java.nio.channels.SelectionKey: ... + +class AbstractSelectionKey(java.nio.channels.SelectionKey): + def cancel(self) -> None: ... + def isValid(self) -> bool: ... + +class AbstractSelector(java.nio.channels.Selector): + def close(self) -> None: ... + def isOpen(self) -> bool: ... + def provider(self) -> SelectorProvider: ... + +class AsynchronousChannelProvider: + @typing.overload + def openAsynchronousChannelGroup( + self, + int: int, + threadFactory: java.util.concurrent.ThreadFactory | typing.Callable, + ) -> java.nio.channels.AsynchronousChannelGroup: ... + @typing.overload + def openAsynchronousChannelGroup( + self, executorService: java.util.concurrent.ExecutorService, int: int + ) -> java.nio.channels.AsynchronousChannelGroup: ... + def openAsynchronousServerSocketChannel( + self, asynchronousChannelGroup: java.nio.channels.AsynchronousChannelGroup + ) -> java.nio.channels.AsynchronousServerSocketChannel: ... + def openAsynchronousSocketChannel( + self, asynchronousChannelGroup: java.nio.channels.AsynchronousChannelGroup + ) -> java.nio.channels.AsynchronousSocketChannel: ... + @staticmethod + def provider() -> AsynchronousChannelProvider: ... + +class SelectorProvider: + def inheritedChannel(self) -> java.nio.channels.Channel: ... + @typing.overload + def openDatagramChannel(self) -> java.nio.channels.DatagramChannel: ... + @typing.overload + def openDatagramChannel( + self, protocolFamily: java.net.ProtocolFamily | typing.Callable + ) -> java.nio.channels.DatagramChannel: ... + def openPipe(self) -> java.nio.channels.Pipe: ... + def openSelector(self) -> AbstractSelector: ... + @typing.overload + def openServerSocketChannel(self) -> java.nio.channels.ServerSocketChannel: ... + @typing.overload + def openServerSocketChannel( + self, protocolFamily: java.net.ProtocolFamily | typing.Callable + ) -> java.nio.channels.ServerSocketChannel: ... + @typing.overload + def openSocketChannel(self) -> java.nio.channels.SocketChannel: ... + @typing.overload + def openSocketChannel( + self, protocolFamily: java.net.ProtocolFamily | typing.Callable + ) -> java.nio.channels.SocketChannel: ... + @staticmethod + def provider() -> SelectorProvider: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.nio.channels.spi")``. + + AbstractInterruptibleChannel: type[AbstractInterruptibleChannel] + AbstractSelectableChannel: type[AbstractSelectableChannel] + AbstractSelectionKey: type[AbstractSelectionKey] + AbstractSelector: type[AbstractSelector] + AsynchronousChannelProvider: type[AsynchronousChannelProvider] + SelectorProvider: type[SelectorProvider] diff --git a/typings/java/nio/charset/__init__.pyi b/typings/java/nio/charset/__init__.pyi new file mode 100644 index 0000000..27d7ca7 --- /dev/null +++ b/typings/java/nio/charset/__init__.pyi @@ -0,0 +1,181 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.nio +import java.nio.charset.spi +import java.util +import jpype + +class CharacterCodingException(java.io.IOException): + def __init__(self): ... + +class Charset(java.lang.Comparable["Charset"]): + def aliases(self) -> java.util.Set[java.lang.String]: ... + @staticmethod + def availableCharsets() -> java.util.SortedMap[java.lang.String, Charset]: ... + def canEncode(self) -> bool: ... + def compareTo(self, charset: Charset) -> int: ... + def contains(self, charset: Charset) -> bool: ... + def decode(self, byteBuffer: java.nio.ByteBuffer) -> java.nio.CharBuffer: ... + @staticmethod + def defaultCharset() -> Charset: ... + @typing.overload + def displayName(self) -> java.lang.String: ... + @typing.overload + def displayName(self, locale: java.util.Locale) -> java.lang.String: ... + @typing.overload + def encode(self, string: java.lang.String | str) -> java.nio.ByteBuffer: ... + @typing.overload + def encode(self, charBuffer: java.nio.CharBuffer) -> java.nio.ByteBuffer: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + @staticmethod + def forName(string: java.lang.String | str) -> Charset: ... + @typing.overload + @staticmethod + def forName(string: java.lang.String | str, charset: Charset) -> Charset: ... + def hashCode(self) -> int: ... + def isRegistered(self) -> bool: ... + @staticmethod + def isSupported(string: java.lang.String | str) -> bool: ... + def name(self) -> java.lang.String: ... + def newDecoder(self) -> CharsetDecoder: ... + def newEncoder(self) -> CharsetEncoder: ... + def toString(self) -> java.lang.String: ... + +class CharsetDecoder: + def averageCharsPerByte(self) -> float: ... + def charset(self) -> Charset: ... + @typing.overload + def decode(self, byteBuffer: java.nio.ByteBuffer) -> java.nio.CharBuffer: ... + @typing.overload + def decode( + self, + byteBuffer: java.nio.ByteBuffer, + charBuffer: java.nio.CharBuffer, + boolean: bool, + ) -> CoderResult: ... + def detectedCharset(self) -> Charset: ... + def flush(self, charBuffer: java.nio.CharBuffer) -> CoderResult: ... + def isAutoDetecting(self) -> bool: ... + def isCharsetDetected(self) -> bool: ... + def malformedInputAction(self) -> CodingErrorAction: ... + def maxCharsPerByte(self) -> float: ... + def onMalformedInput( + self, codingErrorAction: CodingErrorAction + ) -> CharsetDecoder: ... + def onUnmappableCharacter( + self, codingErrorAction: CodingErrorAction + ) -> CharsetDecoder: ... + def replaceWith(self, string: java.lang.String | str) -> CharsetDecoder: ... + def replacement(self) -> java.lang.String: ... + def reset(self) -> CharsetDecoder: ... + def unmappableCharacterAction(self) -> CodingErrorAction: ... + +class CharsetEncoder: + def averageBytesPerChar(self) -> float: ... + @typing.overload + def canEncode(self, char: str) -> bool: ... + @typing.overload + def canEncode(self, charSequence: java.lang.CharSequence | str) -> bool: ... + def charset(self) -> Charset: ... + @typing.overload + def encode(self, charBuffer: java.nio.CharBuffer) -> java.nio.ByteBuffer: ... + @typing.overload + def encode( + self, + charBuffer: java.nio.CharBuffer, + byteBuffer: java.nio.ByteBuffer, + boolean: bool, + ) -> CoderResult: ... + def flush(self, byteBuffer: java.nio.ByteBuffer) -> CoderResult: ... + def isLegalReplacement( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> bool: ... + def malformedInputAction(self) -> CodingErrorAction: ... + def maxBytesPerChar(self) -> float: ... + def onMalformedInput( + self, codingErrorAction: CodingErrorAction + ) -> CharsetEncoder: ... + def onUnmappableCharacter( + self, codingErrorAction: CodingErrorAction + ) -> CharsetEncoder: ... + def replaceWith( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> CharsetEncoder: ... + def replacement(self) -> typing.MutableSequence[int]: ... + def reset(self) -> CharsetEncoder: ... + def unmappableCharacterAction(self) -> CodingErrorAction: ... + +class CoderMalfunctionError(java.lang.Error): + def __init__(self, exception: java.lang.Exception): ... + +class CoderResult: + UNDERFLOW: typing.ClassVar[CoderResult] = ... + OVERFLOW: typing.ClassVar[CoderResult] = ... + def isError(self) -> bool: ... + def isMalformed(self) -> bool: ... + def isOverflow(self) -> bool: ... + def isUnderflow(self) -> bool: ... + def isUnmappable(self) -> bool: ... + def length(self) -> int: ... + @staticmethod + def malformedForLength(int: int) -> CoderResult: ... + def throwException(self) -> None: ... + def toString(self) -> java.lang.String: ... + @staticmethod + def unmappableForLength(int: int) -> CoderResult: ... + +class CodingErrorAction: + IGNORE: typing.ClassVar[CodingErrorAction] = ... + REPLACE: typing.ClassVar[CodingErrorAction] = ... + REPORT: typing.ClassVar[CodingErrorAction] = ... + def toString(self) -> java.lang.String: ... + +class IllegalCharsetNameException(java.lang.IllegalArgumentException): + def __init__(self, string: java.lang.String | str): ... + def getCharsetName(self) -> java.lang.String: ... + +class StandardCharsets: + US_ASCII: typing.ClassVar[Charset] = ... + ISO_8859_1: typing.ClassVar[Charset] = ... + UTF_8: typing.ClassVar[Charset] = ... + UTF_16BE: typing.ClassVar[Charset] = ... + UTF_16LE: typing.ClassVar[Charset] = ... + UTF_16: typing.ClassVar[Charset] = ... + UTF_32BE: typing.ClassVar[Charset] = ... + UTF_32LE: typing.ClassVar[Charset] = ... + UTF_32: typing.ClassVar[Charset] = ... + +class UnsupportedCharsetException(java.lang.IllegalArgumentException): + def __init__(self, string: java.lang.String | str): ... + def getCharsetName(self) -> java.lang.String: ... + +class MalformedInputException(CharacterCodingException): + def __init__(self, int: int): ... + def getInputLength(self) -> int: ... + def getMessage(self) -> java.lang.String: ... + +class UnmappableCharacterException(CharacterCodingException): + def __init__(self, int: int): ... + def getInputLength(self) -> int: ... + def getMessage(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.nio.charset")``. + + CharacterCodingException: type[CharacterCodingException] + Charset: type[Charset] + CharsetDecoder: type[CharsetDecoder] + CharsetEncoder: type[CharsetEncoder] + CoderMalfunctionError: type[CoderMalfunctionError] + CoderResult: type[CoderResult] + CodingErrorAction: type[CodingErrorAction] + IllegalCharsetNameException: type[IllegalCharsetNameException] + MalformedInputException: type[MalformedInputException] + StandardCharsets: type[StandardCharsets] + UnmappableCharacterException: type[UnmappableCharacterException] + UnsupportedCharsetException: type[UnsupportedCharsetException] + spi: java.nio.charset.spi.__module_protocol__ diff --git a/typings/java/nio/charset/spi/__init__.pyi b/typings/java/nio/charset/spi/__init__.pyi new file mode 100644 index 0000000..935ccec --- /dev/null +++ b/typings/java/nio/charset/spi/__init__.pyi @@ -0,0 +1,16 @@ +from typing import Protocol + +import java.lang +import java.nio.charset +import java.util + +class CharsetProvider: + def charsetForName( + self, string: java.lang.String | str + ) -> java.nio.charset.Charset: ... + def charsets(self) -> java.util.Iterator[java.nio.charset.Charset]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.nio.charset.spi")``. + + CharsetProvider: type[CharsetProvider] diff --git a/typings/java/nio/file/__init__.pyi b/typings/java/nio/file/__init__.pyi new file mode 100644 index 0000000..079d8d2 --- /dev/null +++ b/typings/java/nio/file/__init__.pyi @@ -0,0 +1,993 @@ +import builtins +import typing +from typing import Protocol + +import java.io +import java.lang +import java.net +import java.nio.channels +import java.nio.charset +import java.nio.file.attribute +import java.nio.file.spi +import java.security +import java.util +import java.util.concurrent +import java.util.function +import java.util.stream +import jpype +import jpype.protocol + +class AccessMode(java.lang.Enum["AccessMode"]): + READ: typing.ClassVar[AccessMode] = ... + WRITE: typing.ClassVar[AccessMode] = ... + EXECUTE: typing.ClassVar[AccessMode] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> AccessMode: ... + @staticmethod + def values() -> typing.MutableSequence[AccessMode]: ... + +class ClosedDirectoryStreamException(java.lang.IllegalStateException): + def __init__(self): ... + +class ClosedFileSystemException(java.lang.IllegalStateException): + def __init__(self): ... + +class ClosedWatchServiceException(java.lang.IllegalStateException): + def __init__(self): ... + +class CopyOption: ... + +class DirectoryIteratorException(java.util.ConcurrentModificationException): + def __init__(self, iOException: java.io.IOException): ... + def getCause(self) -> java.io.IOException: ... + +_DirectoryStream__Filter__T = typing.TypeVar("_DirectoryStream__Filter__T") # +_DirectoryStream__T = typing.TypeVar("_DirectoryStream__T") # + +class DirectoryStream( + java.io.Closeable, + java.lang.Iterable[_DirectoryStream__T], + typing.Generic[_DirectoryStream__T], +): + def iterator(self) -> java.util.Iterator[_DirectoryStream__T]: ... + class Filter(typing.Generic[_DirectoryStream__Filter__T]): + def accept(self, t: _DirectoryStream__Filter__T) -> bool: ... + +class FileStore: + def getAttribute(self, string: java.lang.String | str) -> typing.Any: ... + def getBlockSize(self) -> int: ... + _getFileStoreAttributeView__V = typing.TypeVar( + "_getFileStoreAttributeView__V", + bound=java.nio.file.attribute.FileStoreAttributeView, + ) # + def getFileStoreAttributeView( + self, class_: builtins.type[_getFileStoreAttributeView__V] + ) -> _getFileStoreAttributeView__V: ... + def getTotalSpace(self) -> int: ... + def getUnallocatedSpace(self) -> int: ... + def getUsableSpace(self) -> int: ... + def isReadOnly(self) -> bool: ... + def name(self) -> java.lang.String: ... + @typing.overload + def supportsFileAttributeView( + self, class_: builtins.type[java.nio.file.attribute.FileAttributeView] + ) -> bool: ... + @typing.overload + def supportsFileAttributeView(self, string: java.lang.String | str) -> bool: ... + def type(self) -> java.lang.String: ... + +class FileSystem(java.io.Closeable): + def close(self) -> None: ... + def getFileStores(self) -> java.lang.Iterable[FileStore]: ... + def getPath( + self, string: java.lang.String | str, *string2: java.lang.String | str + ) -> Path: ... + def getPathMatcher(self, string: java.lang.String | str) -> PathMatcher: ... + def getRootDirectories(self) -> java.lang.Iterable[Path]: ... + def getSeparator(self) -> java.lang.String: ... + def getUserPrincipalLookupService( + self, + ) -> java.nio.file.attribute.UserPrincipalLookupService: ... + def isOpen(self) -> bool: ... + def isReadOnly(self) -> bool: ... + def newWatchService(self) -> WatchService: ... + def provider(self) -> java.nio.file.spi.FileSystemProvider: ... + def supportedFileAttributeViews(self) -> java.util.Set[java.lang.String]: ... + +class FileSystemAlreadyExistsException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class FileSystemException(java.io.IOException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + def getFile(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + def getOtherFile(self) -> java.lang.String: ... + def getReason(self) -> java.lang.String: ... + +class FileSystemNotFoundException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class FileSystems: + @staticmethod + def getDefault() -> FileSystem: ... + @staticmethod + def getFileSystem(uRI: java.net.URI) -> FileSystem: ... + @typing.overload + @staticmethod + def newFileSystem( + uRI: java.net.URI, + map: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + ) -> FileSystem: ... + @typing.overload + @staticmethod + def newFileSystem( + uRI: java.net.URI, + map: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + classLoader: java.lang.ClassLoader, + ) -> FileSystem: ... + @typing.overload + @staticmethod + def newFileSystem(path: Path | jpype.protocol.SupportsPath) -> FileSystem: ... + @typing.overload + @staticmethod + def newFileSystem( + path: Path | jpype.protocol.SupportsPath, classLoader: java.lang.ClassLoader + ) -> FileSystem: ... + @typing.overload + @staticmethod + def newFileSystem( + path: Path | jpype.protocol.SupportsPath, + map: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + ) -> FileSystem: ... + @typing.overload + @staticmethod + def newFileSystem( + path: Path | jpype.protocol.SupportsPath, + map: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + classLoader: java.lang.ClassLoader, + ) -> FileSystem: ... + +class FileVisitOption(java.lang.Enum["FileVisitOption"]): + FOLLOW_LINKS: typing.ClassVar[FileVisitOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> FileVisitOption: ... + @staticmethod + def values() -> typing.MutableSequence[FileVisitOption]: ... + +class FileVisitResult(java.lang.Enum["FileVisitResult"]): + CONTINUE: typing.ClassVar[FileVisitResult] = ... + TERMINATE: typing.ClassVar[FileVisitResult] = ... + SKIP_SUBTREE: typing.ClassVar[FileVisitResult] = ... + SKIP_SIBLINGS: typing.ClassVar[FileVisitResult] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> FileVisitResult: ... + @staticmethod + def values() -> typing.MutableSequence[FileVisitResult]: ... + +_FileVisitor__T = typing.TypeVar("_FileVisitor__T") # + +class FileVisitor(typing.Generic[_FileVisitor__T]): + def postVisitDirectory( + self, t: _FileVisitor__T, iOException: java.io.IOException + ) -> FileVisitResult: ... + def preVisitDirectory( + self, + t: _FileVisitor__T, + basicFileAttributes: java.nio.file.attribute.BasicFileAttributes, + ) -> FileVisitResult: ... + def visitFile( + self, + t: _FileVisitor__T, + basicFileAttributes: java.nio.file.attribute.BasicFileAttributes, + ) -> FileVisitResult: ... + def visitFileFailed( + self, t: _FileVisitor__T, iOException: java.io.IOException + ) -> FileVisitResult: ... + +class Files: + @typing.overload + @staticmethod + def copy( + path: Path | jpype.protocol.SupportsPath, + path2: Path | jpype.protocol.SupportsPath, + *copyOption: CopyOption, + ) -> Path: ... + @typing.overload + @staticmethod + def copy( + inputStream: java.io.InputStream, + path: Path | jpype.protocol.SupportsPath, + *copyOption: CopyOption, + ) -> int: ... + @typing.overload + @staticmethod + def copy( + path: Path | jpype.protocol.SupportsPath, outputStream: java.io.OutputStream + ) -> int: ... + @staticmethod + def createDirectories( + path: Path | jpype.protocol.SupportsPath, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> Path: ... + @staticmethod + def createDirectory( + path: Path | jpype.protocol.SupportsPath, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> Path: ... + @staticmethod + def createFile( + path: Path | jpype.protocol.SupportsPath, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> Path: ... + @staticmethod + def createLink( + path: Path | jpype.protocol.SupportsPath, + path2: Path | jpype.protocol.SupportsPath, + ) -> Path: ... + @staticmethod + def createSymbolicLink( + path: Path | jpype.protocol.SupportsPath, + path2: Path | jpype.protocol.SupportsPath, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> Path: ... + @typing.overload + @staticmethod + def createTempDirectory( + string: java.lang.String | str, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> Path: ... + @typing.overload + @staticmethod + def createTempDirectory( + path: Path | jpype.protocol.SupportsPath, + string: java.lang.String | str, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> Path: ... + @typing.overload + @staticmethod + def createTempFile( + string: java.lang.String | str, + string2: java.lang.String | str, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> Path: ... + @typing.overload + @staticmethod + def createTempFile( + path: Path | jpype.protocol.SupportsPath, + string: java.lang.String | str, + string2: java.lang.String | str, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> Path: ... + @staticmethod + def delete(path: Path | jpype.protocol.SupportsPath) -> None: ... + @staticmethod + def deleteIfExists(path: Path | jpype.protocol.SupportsPath) -> bool: ... + @staticmethod + def exists( + path: Path | jpype.protocol.SupportsPath, *linkOption: LinkOption + ) -> bool: ... + @staticmethod + def find( + path: Path | jpype.protocol.SupportsPath, + int: int, + biPredicate: java.util.function.BiPredicate[ + Path | jpype.protocol.SupportsPath, + java.nio.file.attribute.BasicFileAttributes, + ] + | typing.Callable[ + [ + Path | jpype.protocol.SupportsPath, + java.nio.file.attribute.BasicFileAttributes, + ], + bool, + ], + *fileVisitOption: FileVisitOption, + ) -> java.util.stream.Stream[Path]: ... + @staticmethod + def getAttribute( + path: Path | jpype.protocol.SupportsPath, + string: java.lang.String | str, + *linkOption: LinkOption, + ) -> typing.Any: ... + _getFileAttributeView__V = typing.TypeVar( + "_getFileAttributeView__V", bound=java.nio.file.attribute.FileAttributeView + ) # + @staticmethod + def getFileAttributeView( + path: Path | jpype.protocol.SupportsPath, + class_: type[_getFileAttributeView__V], + *linkOption: LinkOption, + ) -> _getFileAttributeView__V: ... + @staticmethod + def getFileStore(path: Path | jpype.protocol.SupportsPath) -> FileStore: ... + @staticmethod + def getLastModifiedTime( + path: Path | jpype.protocol.SupportsPath, *linkOption: LinkOption + ) -> java.nio.file.attribute.FileTime: ... + @staticmethod + def getOwner( + path: Path | jpype.protocol.SupportsPath, *linkOption: LinkOption + ) -> java.nio.file.attribute.UserPrincipal: ... + @staticmethod + def getPosixFilePermissions( + path: Path | jpype.protocol.SupportsPath, *linkOption: LinkOption + ) -> java.util.Set[java.nio.file.attribute.PosixFilePermission]: ... + @staticmethod + def isDirectory( + path: Path | jpype.protocol.SupportsPath, *linkOption: LinkOption + ) -> bool: ... + @staticmethod + def isExecutable(path: Path | jpype.protocol.SupportsPath) -> bool: ... + @staticmethod + def isHidden(path: Path | jpype.protocol.SupportsPath) -> bool: ... + @staticmethod + def isReadable(path: Path | jpype.protocol.SupportsPath) -> bool: ... + @staticmethod + def isRegularFile( + path: Path | jpype.protocol.SupportsPath, *linkOption: LinkOption + ) -> bool: ... + @staticmethod + def isSameFile( + path: Path | jpype.protocol.SupportsPath, + path2: Path | jpype.protocol.SupportsPath, + ) -> bool: ... + @staticmethod + def isSymbolicLink(path: Path | jpype.protocol.SupportsPath) -> bool: ... + @staticmethod + def isWritable(path: Path | jpype.protocol.SupportsPath) -> bool: ... + @typing.overload + @staticmethod + def lines( + path: Path | jpype.protocol.SupportsPath, + ) -> java.util.stream.Stream[java.lang.String]: ... + @typing.overload + @staticmethod + def lines( + path: Path | jpype.protocol.SupportsPath, charset: java.nio.charset.Charset + ) -> java.util.stream.Stream[java.lang.String]: ... + @staticmethod + def list( + path: Path | jpype.protocol.SupportsPath, + ) -> java.util.stream.Stream[Path]: ... + @staticmethod + def mismatch( + path: Path | jpype.protocol.SupportsPath, + path2: Path | jpype.protocol.SupportsPath, + ) -> int: ... + @staticmethod + def move( + path: Path | jpype.protocol.SupportsPath, + path2: Path | jpype.protocol.SupportsPath, + *copyOption: CopyOption, + ) -> Path: ... + @typing.overload + @staticmethod + def newBufferedReader( + path: Path | jpype.protocol.SupportsPath, + ) -> java.io.BufferedReader: ... + @typing.overload + @staticmethod + def newBufferedReader( + path: Path | jpype.protocol.SupportsPath, charset: java.nio.charset.Charset + ) -> java.io.BufferedReader: ... + @typing.overload + @staticmethod + def newBufferedWriter( + path: Path | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + *openOption: OpenOption, + ) -> java.io.BufferedWriter: ... + @typing.overload + @staticmethod + def newBufferedWriter( + path: Path | jpype.protocol.SupportsPath, *openOption: OpenOption + ) -> java.io.BufferedWriter: ... + @typing.overload + @staticmethod + def newByteChannel( + path: Path | jpype.protocol.SupportsPath, *openOption: OpenOption + ) -> java.nio.channels.SeekableByteChannel: ... + @typing.overload + @staticmethod + def newByteChannel( + path: Path | jpype.protocol.SupportsPath, + set: java.util.Set[OpenOption], + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> java.nio.channels.SeekableByteChannel: ... + @typing.overload + @staticmethod + def newDirectoryStream( + path: Path | jpype.protocol.SupportsPath, + ) -> DirectoryStream[Path]: ... + @typing.overload + @staticmethod + def newDirectoryStream( + path: Path | jpype.protocol.SupportsPath, string: java.lang.String | str + ) -> DirectoryStream[Path]: ... + @typing.overload + @staticmethod + def newDirectoryStream( + path: Path | jpype.protocol.SupportsPath, + filter: DirectoryStream.Filter[Path] | typing.Callable[[Path], bool], + ) -> DirectoryStream[Path]: ... + @staticmethod + def newInputStream( + path: Path | jpype.protocol.SupportsPath, *openOption: OpenOption + ) -> java.io.InputStream: ... + @staticmethod + def newOutputStream( + path: Path | jpype.protocol.SupportsPath, *openOption: OpenOption + ) -> java.io.OutputStream: ... + @staticmethod + def notExists( + path: Path | jpype.protocol.SupportsPath, *linkOption: LinkOption + ) -> bool: ... + @staticmethod + def probeContentType( + path: Path | jpype.protocol.SupportsPath, + ) -> java.lang.String: ... + @staticmethod + def readAllBytes( + path: Path | jpype.protocol.SupportsPath, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def readAllLines( + path: Path | jpype.protocol.SupportsPath, + ) -> java.util.List[java.lang.String]: ... + @typing.overload + @staticmethod + def readAllLines( + path: Path | jpype.protocol.SupportsPath, charset: java.nio.charset.Charset + ) -> java.util.List[java.lang.String]: ... + _readAttributes_0__A = typing.TypeVar( + "_readAttributes_0__A", bound=java.nio.file.attribute.BasicFileAttributes + ) # + @typing.overload + @staticmethod + def readAttributes( + path: Path | jpype.protocol.SupportsPath, + class_: type[_readAttributes_0__A], + *linkOption: LinkOption, + ) -> _readAttributes_0__A: ... + @typing.overload + @staticmethod + def readAttributes( + path: Path | jpype.protocol.SupportsPath, + string: java.lang.String | str, + *linkOption: LinkOption, + ) -> java.util.Map[java.lang.String, typing.Any]: ... + @typing.overload + @staticmethod + def readString(path: Path | jpype.protocol.SupportsPath) -> java.lang.String: ... + @typing.overload + @staticmethod + def readString( + path: Path | jpype.protocol.SupportsPath, charset: java.nio.charset.Charset + ) -> java.lang.String: ... + @staticmethod + def readSymbolicLink(path: Path | jpype.protocol.SupportsPath) -> Path: ... + @staticmethod + def setAttribute( + path: Path | jpype.protocol.SupportsPath, + string: java.lang.String | str, + object: typing.Any, + *linkOption: LinkOption, + ) -> Path: ... + @staticmethod + def setLastModifiedTime( + path: Path | jpype.protocol.SupportsPath, + fileTime: java.nio.file.attribute.FileTime, + ) -> Path: ... + @staticmethod + def setOwner( + path: Path | jpype.protocol.SupportsPath, + userPrincipal: java.nio.file.attribute.UserPrincipal | typing.Callable, + ) -> Path: ... + @staticmethod + def setPosixFilePermissions( + path: Path | jpype.protocol.SupportsPath, + set: java.util.Set[java.nio.file.attribute.PosixFilePermission], + ) -> Path: ... + @staticmethod + def size(path: Path | jpype.protocol.SupportsPath) -> int: ... + @typing.overload + @staticmethod + def walk( + path: Path | jpype.protocol.SupportsPath, + int: int, + *fileVisitOption: FileVisitOption, + ) -> java.util.stream.Stream[Path]: ... + @typing.overload + @staticmethod + def walk( + path: Path | jpype.protocol.SupportsPath, *fileVisitOption: FileVisitOption + ) -> java.util.stream.Stream[Path]: ... + @typing.overload + @staticmethod + def walkFileTree( + path: Path | jpype.protocol.SupportsPath, fileVisitor: FileVisitor[Path] + ) -> Path: ... + @typing.overload + @staticmethod + def walkFileTree( + path: Path | jpype.protocol.SupportsPath, + set: java.util.Set[FileVisitOption], + int: int, + fileVisitor: FileVisitor[Path], + ) -> Path: ... + @typing.overload + @staticmethod + def write( + path: Path | jpype.protocol.SupportsPath, + byteArray: builtins.list[int] | jpype.JArray | bytes, + *openOption: OpenOption, + ) -> Path: ... + @typing.overload + @staticmethod + def write( + path: Path | jpype.protocol.SupportsPath, + iterable: java.lang.Iterable[java.lang.CharSequence] + | typing.Sequence[java.lang.CharSequence] + | set[java.lang.CharSequence] + | typing.Callable[[], java.util.Iterator[typing.Any]], + charset: java.nio.charset.Charset, + *openOption: OpenOption, + ) -> Path: ... + @typing.overload + @staticmethod + def write( + path: Path | jpype.protocol.SupportsPath, + iterable: java.lang.Iterable[java.lang.CharSequence] + | typing.Sequence[java.lang.CharSequence] + | set[java.lang.CharSequence] + | typing.Callable[[], java.util.Iterator[typing.Any]], + *openOption: OpenOption, + ) -> Path: ... + @typing.overload + @staticmethod + def writeString( + path: Path | jpype.protocol.SupportsPath, + charSequence: java.lang.CharSequence | str, + charset: java.nio.charset.Charset, + *openOption: OpenOption, + ) -> Path: ... + @typing.overload + @staticmethod + def writeString( + path: Path | jpype.protocol.SupportsPath, + charSequence: java.lang.CharSequence | str, + *openOption: OpenOption, + ) -> Path: ... + +class InvalidPathException(java.lang.IllegalArgumentException): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + def getIndex(self) -> int: ... + def getInput(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + def getReason(self) -> java.lang.String: ... + +class LinkPermission(java.security.BasicPermission): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class OpenOption: ... + +class PathMatcher: + def matches(self, path: Path | jpype.protocol.SupportsPath) -> bool: ... + +class Paths: + @typing.overload + @staticmethod + def get( + string: java.lang.String | str, *string2: java.lang.String | str + ) -> Path: ... + @typing.overload + @staticmethod + def get(uRI: java.net.URI) -> Path: ... + +class ProviderMismatchException(java.lang.IllegalArgumentException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class ProviderNotFoundException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class ReadOnlyFileSystemException(java.lang.UnsupportedOperationException): + def __init__(self): ... + +class StandardWatchEventKinds: + OVERFLOW: typing.ClassVar[WatchEvent.Kind] = ... + ENTRY_CREATE: typing.ClassVar[WatchEvent.Kind] = ... + ENTRY_DELETE: typing.ClassVar[WatchEvent.Kind] = ... + ENTRY_MODIFY: typing.ClassVar[WatchEvent.Kind] = ... + +_WatchEvent__Kind__T = typing.TypeVar("_WatchEvent__Kind__T") # +_WatchEvent__T = typing.TypeVar("_WatchEvent__T") # + +class WatchEvent(typing.Generic[_WatchEvent__T]): + def context(self) -> _WatchEvent__T: ... + def count(self) -> int: ... + def kind(self) -> WatchEvent.Kind[_WatchEvent__T]: ... + class Kind(typing.Generic[_WatchEvent__Kind__T]): + def name(self) -> java.lang.String: ... + def type(self) -> builtins.type[_WatchEvent__Kind__T]: ... + + class Modifier: + def name(self) -> java.lang.String: ... + +class WatchKey: + def cancel(self) -> None: ... + def isValid(self) -> bool: ... + def pollEvents(self) -> java.util.List[WatchEvent[typing.Any]]: ... + def reset(self) -> bool: ... + def watchable(self) -> Watchable: ... + +class WatchService(java.io.Closeable): + def close(self) -> None: ... + @typing.overload + def poll(self) -> WatchKey: ... + @typing.overload + def poll(self, long: int, timeUnit: java.util.concurrent.TimeUnit) -> WatchKey: ... + def take(self) -> WatchKey: ... + +class Watchable: + @typing.overload + def register( + self, watchService: WatchService, *kind: WatchEvent.Kind[typing.Any] + ) -> WatchKey: ... + @typing.overload + def register( + self, + watchService: WatchService, + kindArray: list[WatchEvent.Kind[typing.Any]] | jpype.JArray, + *modifier: WatchEvent.Modifier | typing.Callable, + ) -> WatchKey: ... + +class AccessDeniedException(FileSystemException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + +class AtomicMoveNotSupportedException(FileSystemException): + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + +class DirectoryNotEmptyException(FileSystemException): + def __init__(self, string: java.lang.String | str): ... + +class FileAlreadyExistsException(FileSystemException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + +class FileSystemLoopException(FileSystemException): + def __init__(self, string: java.lang.String | str): ... + +class LinkOption(java.lang.Enum["LinkOption"], OpenOption, CopyOption): + NOFOLLOW_LINKS: typing.ClassVar[LinkOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> LinkOption: ... + @staticmethod + def values() -> typing.MutableSequence[LinkOption]: ... + +class NoSuchFileException(FileSystemException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + +class NotDirectoryException(FileSystemException): + def __init__(self, string: java.lang.String | str): ... + +class NotLinkException(FileSystemException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + +class Path(java.lang.Comparable["Path"], java.lang.Iterable["Path"], Watchable): + def compareTo(self, path: Path | jpype.protocol.SupportsPath) -> int: ... + @typing.overload + def endsWith(self, path: Path | jpype.protocol.SupportsPath) -> bool: ... + @typing.overload + def endsWith(self, string: java.lang.String | str) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def getFileName(self) -> Path: ... + def getFileSystem(self) -> FileSystem: ... + def getName(self, int: int) -> Path: ... + def getNameCount(self) -> int: ... + def getParent(self) -> Path: ... + def getRoot(self) -> Path: ... + def hashCode(self) -> int: ... + def isAbsolute(self) -> bool: ... + def iterator(self) -> java.util.Iterator[Path]: ... + def normalize(self) -> Path: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, *string2: java.lang.String | str + ) -> Path: ... + @typing.overload + @staticmethod + def of(uRI: java.net.URI) -> Path: ... + @typing.overload + def register( + self, + watchService: WatchService, + kindArray: list[WatchEvent.Kind[typing.Any]] | jpype.JArray, + *modifier: WatchEvent.Modifier | typing.Callable, + ) -> WatchKey: ... + @typing.overload + def register( + self, watchService: WatchService, *kind: WatchEvent.Kind[typing.Any] + ) -> WatchKey: ... + def relativize(self, path: Path | jpype.protocol.SupportsPath) -> Path: ... + @typing.overload + def resolve(self, path: Path | jpype.protocol.SupportsPath) -> Path: ... + @typing.overload + def resolve(self, string: java.lang.String | str) -> Path: ... + @typing.overload + def resolve( + self, string: java.lang.String | str, *string2: java.lang.String | str + ) -> Path: ... + @typing.overload + def resolve( + self, + path: Path | jpype.protocol.SupportsPath, + *path2: Path | jpype.protocol.SupportsPath, + ) -> Path: ... + @typing.overload + def resolveSibling(self, string: java.lang.String | str) -> Path: ... + @typing.overload + def resolveSibling(self, path: Path | jpype.protocol.SupportsPath) -> Path: ... + @typing.overload + def startsWith(self, path: Path | jpype.protocol.SupportsPath) -> bool: ... + @typing.overload + def startsWith(self, string: java.lang.String | str) -> bool: ... + def subpath(self, int: int, int2: int) -> Path: ... + def toAbsolutePath(self) -> Path: ... + def toFile(self) -> java.io.File: ... + def toRealPath(self, *linkOption: LinkOption) -> Path: ... + def toString(self) -> java.lang.String: ... + def toUri(self) -> java.net.URI: ... + +_SecureDirectoryStream__T = typing.TypeVar("_SecureDirectoryStream__T") # + +class SecureDirectoryStream( + DirectoryStream[_SecureDirectoryStream__T], + typing.Generic[_SecureDirectoryStream__T], +): + def deleteDirectory(self, t: _SecureDirectoryStream__T) -> None: ... + def deleteFile(self, t: _SecureDirectoryStream__T) -> None: ... + _getFileAttributeView_0__V = typing.TypeVar( + "_getFileAttributeView_0__V", bound=java.nio.file.attribute.FileAttributeView + ) # + _getFileAttributeView_1__V = typing.TypeVar( + "_getFileAttributeView_1__V", bound=java.nio.file.attribute.FileAttributeView + ) # + @typing.overload + def getFileAttributeView( + self, class_: type[_getFileAttributeView_0__V] + ) -> _getFileAttributeView_0__V: ... + @typing.overload + def getFileAttributeView( + self, + t: _SecureDirectoryStream__T, + class_: type[_getFileAttributeView_1__V], + *linkOption: LinkOption, + ) -> _getFileAttributeView_1__V: ... + def move( + self, + t: _SecureDirectoryStream__T, + secureDirectoryStream: SecureDirectoryStream[_SecureDirectoryStream__T], + t2: _SecureDirectoryStream__T, + ) -> None: ... + def newByteChannel( + self, + t: _SecureDirectoryStream__T, + set: java.util.Set[OpenOption], + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> java.nio.channels.SeekableByteChannel: ... + def newDirectoryStream( + self, t: _SecureDirectoryStream__T, *linkOption: LinkOption + ) -> SecureDirectoryStream[_SecureDirectoryStream__T]: ... + +_SimpleFileVisitor__T = typing.TypeVar("_SimpleFileVisitor__T") # + +class SimpleFileVisitor( + FileVisitor[_SimpleFileVisitor__T], typing.Generic[_SimpleFileVisitor__T] +): + def postVisitDirectory( + self, t: _SimpleFileVisitor__T, iOException: java.io.IOException + ) -> FileVisitResult: ... + def preVisitDirectory( + self, + t: _SimpleFileVisitor__T, + basicFileAttributes: java.nio.file.attribute.BasicFileAttributes, + ) -> FileVisitResult: ... + def visitFile( + self, + t: _SimpleFileVisitor__T, + basicFileAttributes: java.nio.file.attribute.BasicFileAttributes, + ) -> FileVisitResult: ... + def visitFileFailed( + self, t: _SimpleFileVisitor__T, iOException: java.io.IOException + ) -> FileVisitResult: ... + +class StandardCopyOption(java.lang.Enum["StandardCopyOption"], CopyOption): + REPLACE_EXISTING: typing.ClassVar[StandardCopyOption] = ... + COPY_ATTRIBUTES: typing.ClassVar[StandardCopyOption] = ... + ATOMIC_MOVE: typing.ClassVar[StandardCopyOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> StandardCopyOption: ... + @staticmethod + def values() -> typing.MutableSequence[StandardCopyOption]: ... + +class StandardOpenOption(java.lang.Enum["StandardOpenOption"], OpenOption): + READ: typing.ClassVar[StandardOpenOption] = ... + WRITE: typing.ClassVar[StandardOpenOption] = ... + APPEND: typing.ClassVar[StandardOpenOption] = ... + TRUNCATE_EXISTING: typing.ClassVar[StandardOpenOption] = ... + CREATE: typing.ClassVar[StandardOpenOption] = ... + CREATE_NEW: typing.ClassVar[StandardOpenOption] = ... + DELETE_ON_CLOSE: typing.ClassVar[StandardOpenOption] = ... + SPARSE: typing.ClassVar[StandardOpenOption] = ... + SYNC: typing.ClassVar[StandardOpenOption] = ... + DSYNC: typing.ClassVar[StandardOpenOption] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> StandardOpenOption: ... + @staticmethod + def values() -> typing.MutableSequence[StandardOpenOption]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.nio.file")``. + + AccessDeniedException: type[AccessDeniedException] + AccessMode: type[AccessMode] + AtomicMoveNotSupportedException: type[AtomicMoveNotSupportedException] + ClosedDirectoryStreamException: type[ClosedDirectoryStreamException] + ClosedFileSystemException: type[ClosedFileSystemException] + ClosedWatchServiceException: type[ClosedWatchServiceException] + CopyOption: type[CopyOption] + DirectoryIteratorException: type[DirectoryIteratorException] + DirectoryNotEmptyException: type[DirectoryNotEmptyException] + DirectoryStream: type[DirectoryStream] + FileAlreadyExistsException: type[FileAlreadyExistsException] + FileStore: type[FileStore] + FileSystem: type[FileSystem] + FileSystemAlreadyExistsException: type[FileSystemAlreadyExistsException] + FileSystemException: type[FileSystemException] + FileSystemLoopException: type[FileSystemLoopException] + FileSystemNotFoundException: type[FileSystemNotFoundException] + FileSystems: type[FileSystems] + FileVisitOption: type[FileVisitOption] + FileVisitResult: type[FileVisitResult] + FileVisitor: type[FileVisitor] + Files: type[Files] + InvalidPathException: type[InvalidPathException] + LinkOption: type[LinkOption] + LinkPermission: type[LinkPermission] + NoSuchFileException: type[NoSuchFileException] + NotDirectoryException: type[NotDirectoryException] + NotLinkException: type[NotLinkException] + OpenOption: type[OpenOption] + Path: type[Path] + PathMatcher: type[PathMatcher] + Paths: type[Paths] + ProviderMismatchException: type[ProviderMismatchException] + ProviderNotFoundException: type[ProviderNotFoundException] + ReadOnlyFileSystemException: type[ReadOnlyFileSystemException] + SecureDirectoryStream: type[SecureDirectoryStream] + SimpleFileVisitor: type[SimpleFileVisitor] + StandardCopyOption: type[StandardCopyOption] + StandardOpenOption: type[StandardOpenOption] + StandardWatchEventKinds: type[StandardWatchEventKinds] + WatchEvent: type[WatchEvent] + WatchKey: type[WatchKey] + WatchService: type[WatchService] + Watchable: type[Watchable] + attribute: java.nio.file.attribute.__module_protocol__ + spi: java.nio.file.spi.__module_protocol__ diff --git a/typings/java/nio/file/attribute/__init__.pyi b/typings/java/nio/file/attribute/__init__.pyi new file mode 100644 index 0000000..7793b02 --- /dev/null +++ b/typings/java/nio/file/attribute/__init__.pyi @@ -0,0 +1,289 @@ +import datetime +import typing +from typing import Protocol + +import java.io +import java.lang +import java.nio +import java.security +import java.time +import java.util +import java.util.concurrent + +class AclEntry: + def equals(self, object: typing.Any) -> bool: ... + def flags(self) -> java.util.Set[AclEntryFlag]: ... + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def newBuilder() -> AclEntry.Builder: ... + @typing.overload + @staticmethod + def newBuilder(aclEntry: AclEntry) -> AclEntry.Builder: ... + def permissions(self) -> java.util.Set[AclEntryPermission]: ... + def principal(self) -> UserPrincipal: ... + def toString(self) -> java.lang.String: ... + def type(self) -> AclEntryType: ... + class Builder: + def build(self) -> AclEntry: ... + @typing.overload + def setFlags(self, *aclEntryFlag: AclEntryFlag) -> AclEntry.Builder: ... + @typing.overload + def setFlags(self, set: java.util.Set[AclEntryFlag]) -> AclEntry.Builder: ... + @typing.overload + def setPermissions( + self, *aclEntryPermission: AclEntryPermission + ) -> AclEntry.Builder: ... + @typing.overload + def setPermissions( + self, set: java.util.Set[AclEntryPermission] + ) -> AclEntry.Builder: ... + def setPrincipal( + self, userPrincipal: UserPrincipal | typing.Callable + ) -> AclEntry.Builder: ... + def setType(self, aclEntryType: AclEntryType) -> AclEntry.Builder: ... + +class AclEntryFlag(java.lang.Enum["AclEntryFlag"]): + FILE_INHERIT: typing.ClassVar[AclEntryFlag] = ... + DIRECTORY_INHERIT: typing.ClassVar[AclEntryFlag] = ... + NO_PROPAGATE_INHERIT: typing.ClassVar[AclEntryFlag] = ... + INHERIT_ONLY: typing.ClassVar[AclEntryFlag] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> AclEntryFlag: ... + @staticmethod + def values() -> typing.MutableSequence[AclEntryFlag]: ... + +class AclEntryPermission(java.lang.Enum["AclEntryPermission"]): + READ_DATA: typing.ClassVar[AclEntryPermission] = ... + WRITE_DATA: typing.ClassVar[AclEntryPermission] = ... + APPEND_DATA: typing.ClassVar[AclEntryPermission] = ... + READ_NAMED_ATTRS: typing.ClassVar[AclEntryPermission] = ... + WRITE_NAMED_ATTRS: typing.ClassVar[AclEntryPermission] = ... + EXECUTE: typing.ClassVar[AclEntryPermission] = ... + DELETE_CHILD: typing.ClassVar[AclEntryPermission] = ... + READ_ATTRIBUTES: typing.ClassVar[AclEntryPermission] = ... + WRITE_ATTRIBUTES: typing.ClassVar[AclEntryPermission] = ... + DELETE: typing.ClassVar[AclEntryPermission] = ... + READ_ACL: typing.ClassVar[AclEntryPermission] = ... + WRITE_ACL: typing.ClassVar[AclEntryPermission] = ... + WRITE_OWNER: typing.ClassVar[AclEntryPermission] = ... + SYNCHRONIZE: typing.ClassVar[AclEntryPermission] = ... + LIST_DIRECTORY: typing.ClassVar[AclEntryPermission] = ... + ADD_FILE: typing.ClassVar[AclEntryPermission] = ... + ADD_SUBDIRECTORY: typing.ClassVar[AclEntryPermission] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> AclEntryPermission: ... + @staticmethod + def values() -> typing.MutableSequence[AclEntryPermission]: ... + +class AclEntryType(java.lang.Enum["AclEntryType"]): + ALLOW: typing.ClassVar[AclEntryType] = ... + DENY: typing.ClassVar[AclEntryType] = ... + AUDIT: typing.ClassVar[AclEntryType] = ... + ALARM: typing.ClassVar[AclEntryType] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> AclEntryType: ... + @staticmethod + def values() -> typing.MutableSequence[AclEntryType]: ... + +class AttributeView: + def name(self) -> java.lang.String: ... + +class BasicFileAttributes: + def creationTime(self) -> FileTime: ... + def fileKey(self) -> typing.Any: ... + def isDirectory(self) -> bool: ... + def isOther(self) -> bool: ... + def isRegularFile(self) -> bool: ... + def isSymbolicLink(self) -> bool: ... + def lastAccessTime(self) -> FileTime: ... + def lastModifiedTime(self) -> FileTime: ... + def size(self) -> int: ... + +_FileAttribute__T = typing.TypeVar("_FileAttribute__T") # + +class FileAttribute(typing.Generic[_FileAttribute__T]): + def name(self) -> java.lang.String: ... + def value(self) -> _FileAttribute__T: ... + +class FileTime(java.lang.Comparable["FileTime"]): + def compareTo(self, fileTime: FileTime) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def fromMillis(long: int) -> FileTime: ... + @typing.overload + @staticmethod + def from_(instant: java.time.Instant | datetime.datetime) -> FileTime: ... + @typing.overload + @staticmethod + def from_(long: int, timeUnit: java.util.concurrent.TimeUnit) -> FileTime: ... + def hashCode(self) -> int: ... + def to(self, timeUnit: java.util.concurrent.TimeUnit) -> int: ... + def toInstant(self) -> java.time.Instant: ... + def toMillis(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class PosixFilePermission(java.lang.Enum["PosixFilePermission"]): + OWNER_READ: typing.ClassVar[PosixFilePermission] = ... + OWNER_WRITE: typing.ClassVar[PosixFilePermission] = ... + OWNER_EXECUTE: typing.ClassVar[PosixFilePermission] = ... + GROUP_READ: typing.ClassVar[PosixFilePermission] = ... + GROUP_WRITE: typing.ClassVar[PosixFilePermission] = ... + GROUP_EXECUTE: typing.ClassVar[PosixFilePermission] = ... + OTHERS_READ: typing.ClassVar[PosixFilePermission] = ... + OTHERS_WRITE: typing.ClassVar[PosixFilePermission] = ... + OTHERS_EXECUTE: typing.ClassVar[PosixFilePermission] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> PosixFilePermission: ... + @staticmethod + def values() -> typing.MutableSequence[PosixFilePermission]: ... + +class PosixFilePermissions: + @staticmethod + def asFileAttribute( + set: java.util.Set[PosixFilePermission], + ) -> FileAttribute[java.util.Set[PosixFilePermission]]: ... + @staticmethod + def fromString( + string: java.lang.String | str, + ) -> java.util.Set[PosixFilePermission]: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(set: java.util.Set[PosixFilePermission]) -> java.lang.String: ... + +class UserPrincipal(java.security.Principal): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class UserPrincipalLookupService: + def lookupPrincipalByGroupName( + self, string: java.lang.String | str + ) -> GroupPrincipal: ... + def lookupPrincipalByName( + self, string: java.lang.String | str + ) -> UserPrincipal: ... + +class UserPrincipalNotFoundException(java.io.IOException): + def __init__(self, string: java.lang.String | str): ... + def getName(self) -> java.lang.String: ... + +class DosFileAttributes(BasicFileAttributes): + def isArchive(self) -> bool: ... + def isHidden(self) -> bool: ... + def isReadOnly(self) -> bool: ... + def isSystem(self) -> bool: ... + +class FileAttributeView(AttributeView): ... +class FileStoreAttributeView(AttributeView): ... + +class GroupPrincipal(UserPrincipal): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class PosixFileAttributes(BasicFileAttributes): + def group(self) -> GroupPrincipal: ... + def owner(self) -> UserPrincipal: ... + def permissions(self) -> java.util.Set[PosixFilePermission]: ... + +class BasicFileAttributeView(FileAttributeView): + def name(self) -> java.lang.String: ... + def readAttributes(self) -> BasicFileAttributes: ... + def setTimes( + self, fileTime: FileTime, fileTime2: FileTime, fileTime3: FileTime + ) -> None: ... + +class FileOwnerAttributeView(FileAttributeView): + def getOwner(self) -> UserPrincipal: ... + def name(self) -> java.lang.String: ... + def setOwner(self, userPrincipal: UserPrincipal | typing.Callable) -> None: ... + +class UserDefinedFileAttributeView(FileAttributeView): + def delete(self, string: java.lang.String | str) -> None: ... + def list(self) -> java.util.List[java.lang.String]: ... + def name(self) -> java.lang.String: ... + def read( + self, string: java.lang.String | str, byteBuffer: java.nio.ByteBuffer + ) -> int: ... + def size(self, string: java.lang.String | str) -> int: ... + def write( + self, string: java.lang.String | str, byteBuffer: java.nio.ByteBuffer + ) -> int: ... + +class AclFileAttributeView(FileOwnerAttributeView): + def getAcl(self) -> java.util.List[AclEntry]: ... + def name(self) -> java.lang.String: ... + def setAcl(self, list: java.util.List[AclEntry]) -> None: ... + +class DosFileAttributeView(BasicFileAttributeView): + def name(self) -> java.lang.String: ... + def readAttributes(self) -> DosFileAttributes: ... + def setArchive(self, boolean: bool) -> None: ... + def setHidden(self, boolean: bool) -> None: ... + def setReadOnly(self, boolean: bool) -> None: ... + def setSystem(self, boolean: bool) -> None: ... + +class PosixFileAttributeView(BasicFileAttributeView, FileOwnerAttributeView): + def name(self) -> java.lang.String: ... + def readAttributes(self) -> PosixFileAttributes: ... + def setGroup(self, groupPrincipal: GroupPrincipal | typing.Callable) -> None: ... + def setPermissions(self, set: java.util.Set[PosixFilePermission]) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.nio.file.attribute")``. + + AclEntry: type[AclEntry] + AclEntryFlag: type[AclEntryFlag] + AclEntryPermission: type[AclEntryPermission] + AclEntryType: type[AclEntryType] + AclFileAttributeView: type[AclFileAttributeView] + AttributeView: type[AttributeView] + BasicFileAttributeView: type[BasicFileAttributeView] + BasicFileAttributes: type[BasicFileAttributes] + DosFileAttributeView: type[DosFileAttributeView] + DosFileAttributes: type[DosFileAttributes] + FileAttribute: type[FileAttribute] + FileAttributeView: type[FileAttributeView] + FileOwnerAttributeView: type[FileOwnerAttributeView] + FileStoreAttributeView: type[FileStoreAttributeView] + FileTime: type[FileTime] + GroupPrincipal: type[GroupPrincipal] + PosixFileAttributeView: type[PosixFileAttributeView] + PosixFileAttributes: type[PosixFileAttributes] + PosixFilePermission: type[PosixFilePermission] + PosixFilePermissions: type[PosixFilePermissions] + UserDefinedFileAttributeView: type[UserDefinedFileAttributeView] + UserPrincipal: type[UserPrincipal] + UserPrincipalLookupService: type[UserPrincipalLookupService] + UserPrincipalNotFoundException: type[UserPrincipalNotFoundException] diff --git a/typings/java/nio/file/spi/__init__.pyi b/typings/java/nio/file/spi/__init__.pyi new file mode 100644 index 0000000..5089310 --- /dev/null +++ b/typings/java/nio/file/spi/__init__.pyi @@ -0,0 +1,179 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.net +import java.nio.channels +import java.nio.file +import java.nio.file.attribute +import java.util +import java.util.concurrent +import jpype.protocol + +class FileSystemProvider: + def checkAccess( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *accessMode: java.nio.file.AccessMode, + ) -> None: ... + def copy( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + path2: java.nio.file.Path | jpype.protocol.SupportsPath, + *copyOption: java.nio.file.CopyOption, + ) -> None: ... + def createDirectory( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> None: ... + def createLink( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + path2: java.nio.file.Path | jpype.protocol.SupportsPath, + ) -> None: ... + def createSymbolicLink( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + path2: java.nio.file.Path | jpype.protocol.SupportsPath, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> None: ... + def delete( + self, path: java.nio.file.Path | jpype.protocol.SupportsPath + ) -> None: ... + def deleteIfExists( + self, path: java.nio.file.Path | jpype.protocol.SupportsPath + ) -> bool: ... + def exists( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *linkOption: java.nio.file.LinkOption, + ) -> bool: ... + _getFileAttributeView__V = typing.TypeVar( + "_getFileAttributeView__V", bound=java.nio.file.attribute.FileAttributeView + ) # + def getFileAttributeView( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + class_: type[_getFileAttributeView__V], + *linkOption: java.nio.file.LinkOption, + ) -> _getFileAttributeView__V: ... + def getFileStore( + self, path: java.nio.file.Path | jpype.protocol.SupportsPath + ) -> java.nio.file.FileStore: ... + def getFileSystem(self, uRI: java.net.URI) -> java.nio.file.FileSystem: ... + def getPath(self, uRI: java.net.URI) -> java.nio.file.Path: ... + def getScheme(self) -> java.lang.String: ... + @staticmethod + def installedProviders() -> java.util.List[FileSystemProvider]: ... + def isHidden( + self, path: java.nio.file.Path | jpype.protocol.SupportsPath + ) -> bool: ... + def isSameFile( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + path2: java.nio.file.Path | jpype.protocol.SupportsPath, + ) -> bool: ... + def move( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + path2: java.nio.file.Path | jpype.protocol.SupportsPath, + *copyOption: java.nio.file.CopyOption, + ) -> None: ... + def newAsynchronousFileChannel( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + set: java.util.Set[java.nio.file.OpenOption], + executorService: java.util.concurrent.ExecutorService, + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> java.nio.channels.AsynchronousFileChannel: ... + def newByteChannel( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + set: java.util.Set[java.nio.file.OpenOption], + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> java.nio.channels.SeekableByteChannel: ... + def newDirectoryStream( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + filter: java.nio.file.DirectoryStream.Filter[java.nio.file.Path] + | typing.Callable[[java.nio.file.Path], bool], + ) -> java.nio.file.DirectoryStream[java.nio.file.Path]: ... + def newFileChannel( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + set: java.util.Set[java.nio.file.OpenOption], + *fileAttribute: java.nio.file.attribute.FileAttribute[typing.Any], + ) -> java.nio.channels.FileChannel: ... + @typing.overload + def newFileSystem( + self, + uRI: java.net.URI, + map: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + ) -> java.nio.file.FileSystem: ... + @typing.overload + def newFileSystem( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + map: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + ) -> java.nio.file.FileSystem: ... + def newInputStream( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *openOption: java.nio.file.OpenOption, + ) -> java.io.InputStream: ... + def newOutputStream( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + *openOption: java.nio.file.OpenOption, + ) -> java.io.OutputStream: ... + _readAttributes_0__A = typing.TypeVar( + "_readAttributes_0__A", bound=java.nio.file.attribute.BasicFileAttributes + ) # + @typing.overload + def readAttributes( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + class_: type[_readAttributes_0__A], + *linkOption: java.nio.file.LinkOption, + ) -> _readAttributes_0__A: ... + @typing.overload + def readAttributes( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + string: java.lang.String | str, + *linkOption: java.nio.file.LinkOption, + ) -> java.util.Map[java.lang.String, typing.Any]: ... + _readAttributesIfExists__A = typing.TypeVar( + "_readAttributesIfExists__A", bound=java.nio.file.attribute.BasicFileAttributes + ) # + def readAttributesIfExists( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + class_: type[_readAttributesIfExists__A], + *linkOption: java.nio.file.LinkOption, + ) -> _readAttributesIfExists__A: ... + def readSymbolicLink( + self, path: java.nio.file.Path | jpype.protocol.SupportsPath + ) -> java.nio.file.Path: ... + def setAttribute( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + string: java.lang.String | str, + object: typing.Any, + *linkOption: java.nio.file.LinkOption, + ) -> None: ... + +class FileTypeDetector: + def probeContentType( + self, path: java.nio.file.Path | jpype.protocol.SupportsPath + ) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.nio.file.spi")``. + + FileSystemProvider: type[FileSystemProvider] + FileTypeDetector: type[FileTypeDetector] diff --git a/typings/java/rmi/__init__.pyi b/typings/java/rmi/__init__.pyi new file mode 100644 index 0000000..aae9271 --- /dev/null +++ b/typings/java/rmi/__init__.pyi @@ -0,0 +1,178 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.rmi.dgc +import java.rmi.registry +import java.rmi.server + +class AlreadyBoundException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +_MarshalledObject__T = typing.TypeVar("_MarshalledObject__T") # + +class MarshalledObject(java.io.Serializable, typing.Generic[_MarshalledObject__T]): + def __init__(self, t: _MarshalledObject__T): ... + def equals(self, object: typing.Any) -> bool: ... + def get(self) -> _MarshalledObject__T: ... + def hashCode(self) -> int: ... + +class Naming: + @staticmethod + def bind(string: java.lang.String | str, remote: Remote) -> None: ... + @staticmethod + def list( + string: java.lang.String | str, + ) -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def lookup(string: java.lang.String | str) -> Remote: ... + @staticmethod + def rebind(string: java.lang.String | str, remote: Remote) -> None: ... + @staticmethod + def unbind(string: java.lang.String | str) -> None: ... + +class NotBoundException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class RMISecurityException(java.lang.SecurityException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class RMISecurityManager(java.lang.SecurityManager): + def __init__(self): ... + +class Remote: ... + +class RemoteException(java.io.IOException): + detail: java.lang.Throwable = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + def getCause(self) -> java.lang.Throwable: ... + def getMessage(self) -> java.lang.String: ... + +class AccessException(RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class ConnectException(RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class ConnectIOException(RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class MarshalException(RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class NoSuchObjectException(RemoteException): + def __init__(self, string: java.lang.String | str): ... + +class ServerError(RemoteException): + def __init__(self, string: java.lang.String | str, error: java.lang.Error): ... + +class ServerException(RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class ServerRuntimeException(RemoteException): + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class StubNotFoundException(RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class UnexpectedException(RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class UnknownHostException(RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class UnmarshalException(RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.rmi")``. + + AccessException: type[AccessException] + AlreadyBoundException: type[AlreadyBoundException] + ConnectException: type[ConnectException] + ConnectIOException: type[ConnectIOException] + MarshalException: type[MarshalException] + MarshalledObject: type[MarshalledObject] + Naming: type[Naming] + NoSuchObjectException: type[NoSuchObjectException] + NotBoundException: type[NotBoundException] + RMISecurityException: type[RMISecurityException] + RMISecurityManager: type[RMISecurityManager] + Remote: type[Remote] + RemoteException: type[RemoteException] + ServerError: type[ServerError] + ServerException: type[ServerException] + ServerRuntimeException: type[ServerRuntimeException] + StubNotFoundException: type[StubNotFoundException] + UnexpectedException: type[UnexpectedException] + UnknownHostException: type[UnknownHostException] + UnmarshalException: type[UnmarshalException] + dgc: java.rmi.dgc.__module_protocol__ + registry: java.rmi.registry.__module_protocol__ + server: java.rmi.server.__module_protocol__ diff --git a/typings/java/rmi/dgc/__init__.pyi b/typings/java/rmi/dgc/__init__.pyi new file mode 100644 index 0000000..8721ec3 --- /dev/null +++ b/typings/java/rmi/dgc/__init__.pyi @@ -0,0 +1,43 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.rmi +import java.rmi.server +import jpype + +class DGC(java.rmi.Remote): + def clean( + self, + objIDArray: list[java.rmi.server.ObjID] | jpype.JArray, + long: int, + vMID: VMID, + boolean: bool, + ) -> None: ... + def dirty( + self, + objIDArray: list[java.rmi.server.ObjID] | jpype.JArray, + long: int, + lease: Lease, + ) -> Lease: ... + +class Lease(java.io.Serializable): + def __init__(self, vMID: VMID, long: int): ... + def getVMID(self) -> VMID: ... + def getValue(self) -> int: ... + +class VMID(java.io.Serializable): + def __init__(self): ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + @staticmethod + def isUnique() -> bool: ... + def toString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.rmi.dgc")``. + + DGC: type[DGC] + Lease: type[Lease] + VMID: type[VMID] diff --git a/typings/java/rmi/registry/__init__.pyi b/typings/java/rmi/registry/__init__.pyi new file mode 100644 index 0000000..b24b466 --- /dev/null +++ b/typings/java/rmi/registry/__init__.pyi @@ -0,0 +1,61 @@ +import typing +from typing import Protocol + +import java.lang +import java.rmi +import java.rmi.server + +class LocateRegistry: + @typing.overload + @staticmethod + def createRegistry(int: int) -> Registry: ... + @typing.overload + @staticmethod + def createRegistry( + int: int, + rMIClientSocketFactory: java.rmi.server.RMIClientSocketFactory + | typing.Callable, + rMIServerSocketFactory: java.rmi.server.RMIServerSocketFactory + | typing.Callable, + ) -> Registry: ... + @typing.overload + @staticmethod + def getRegistry() -> Registry: ... + @typing.overload + @staticmethod + def getRegistry(int: int) -> Registry: ... + @typing.overload + @staticmethod + def getRegistry(string: java.lang.String | str) -> Registry: ... + @typing.overload + @staticmethod + def getRegistry(string: java.lang.String | str, int: int) -> Registry: ... + @typing.overload + @staticmethod + def getRegistry( + string: java.lang.String | str, + int: int, + rMIClientSocketFactory: java.rmi.server.RMIClientSocketFactory + | typing.Callable, + ) -> Registry: ... + +class Registry(java.rmi.Remote): + REGISTRY_PORT: typing.ClassVar[int] = ... + def bind(self, string: java.lang.String | str, remote: java.rmi.Remote) -> None: ... + def list(self) -> typing.MutableSequence[java.lang.String]: ... + def lookup(self, string: java.lang.String | str) -> java.rmi.Remote: ... + def rebind( + self, string: java.lang.String | str, remote: java.rmi.Remote + ) -> None: ... + def unbind(self, string: java.lang.String | str) -> None: ... + +class RegistryHandler: + def registryImpl(self, int: int) -> Registry: ... + def registryStub(self, string: java.lang.String | str, int: int) -> Registry: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.rmi.registry")``. + + LocateRegistry: type[LocateRegistry] + Registry: type[Registry] + RegistryHandler: type[RegistryHandler] diff --git a/typings/java/rmi/server/__init__.pyi b/typings/java/rmi/server/__init__.pyi new file mode 100644 index 0000000..2506a15 --- /dev/null +++ b/typings/java/rmi/server/__init__.pyi @@ -0,0 +1,348 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.lang.reflect +import java.net +import java.rmi +import jpype + +class ExportException(java.rmi.RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class LoaderHandler: + packagePrefix: typing.ClassVar[java.lang.String] = ... + def getSecurityContext(self, classLoader: java.lang.ClassLoader) -> typing.Any: ... + @typing.overload + def loadClass(self, string: java.lang.String | str) -> type[typing.Any]: ... + @typing.overload + def loadClass( + self, uRL: java.net.URL, string: java.lang.String | str + ) -> type[typing.Any]: ... + +class LogStream(java.io.PrintStream): + SILENT: typing.ClassVar[int] = ... + BRIEF: typing.ClassVar[int] = ... + VERBOSE: typing.ClassVar[int] = ... + @staticmethod + def getDefaultStream() -> java.io.PrintStream: ... + def getOutputStream(self) -> java.io.OutputStream: ... + @staticmethod + def log(string: java.lang.String | str) -> LogStream: ... + @staticmethod + def parseLevel(string: java.lang.String | str) -> int: ... + @staticmethod + def setDefaultStream(printStream: java.io.PrintStream) -> None: ... + def setOutputStream(self, outputStream: java.io.OutputStream) -> None: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class ObjID(java.io.Serializable): + REGISTRY_ID: typing.ClassVar[int] = ... + ACTIVATOR_ID: typing.ClassVar[int] = ... + DGC_ID: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + @staticmethod + def read(objectInput: java.io.ObjectInput) -> ObjID: ... + def toString(self) -> java.lang.String: ... + def write(self, objectOutput: java.io.ObjectOutput) -> None: ... + +class Operation: + def __init__(self, string: java.lang.String | str): ... + def getOperation(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class RMIClassLoader: + @staticmethod + def getClassAnnotation(class_: type[typing.Any]) -> java.lang.String: ... + @staticmethod + def getClassLoader(string: java.lang.String | str) -> java.lang.ClassLoader: ... + @staticmethod + def getDefaultProviderInstance() -> RMIClassLoaderSpi: ... + @staticmethod + def getSecurityContext(classLoader: java.lang.ClassLoader) -> typing.Any: ... + @typing.overload + @staticmethod + def loadClass(string: java.lang.String | str) -> type[typing.Any]: ... + @typing.overload + @staticmethod + def loadClass( + string: java.lang.String | str, string2: java.lang.String | str + ) -> type[typing.Any]: ... + @typing.overload + @staticmethod + def loadClass( + string: java.lang.String | str, + string2: java.lang.String | str, + classLoader: java.lang.ClassLoader, + ) -> type[typing.Any]: ... + @typing.overload + @staticmethod + def loadClass( + uRL: java.net.URL, string: java.lang.String | str + ) -> type[typing.Any]: ... + @staticmethod + def loadProxyClass( + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + classLoader: java.lang.ClassLoader, + ) -> type[typing.Any]: ... + +class RMIClassLoaderSpi: + def __init__(self): ... + def getClassAnnotation(self, class_: type[typing.Any]) -> java.lang.String: ... + def getClassLoader( + self, string: java.lang.String | str + ) -> java.lang.ClassLoader: ... + def loadClass( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + classLoader: java.lang.ClassLoader, + ) -> type[typing.Any]: ... + def loadProxyClass( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + classLoader: java.lang.ClassLoader, + ) -> type[typing.Any]: ... + +class RMIClientSocketFactory: + def createSocket( + self, string: java.lang.String | str, int: int + ) -> java.net.Socket: ... + +class RMIFailureHandler: + def failure(self, exception: java.lang.Exception) -> bool: ... + +class RMIServerSocketFactory: + def createServerSocket(self, int: int) -> java.net.ServerSocket: ... + +class RemoteCall: + def done(self) -> None: ... + def executeCall(self) -> None: ... + def getInputStream(self) -> java.io.ObjectInput: ... + def getOutputStream(self) -> java.io.ObjectOutput: ... + def getResultStream(self, boolean: bool) -> java.io.ObjectOutput: ... + def releaseInputStream(self) -> None: ... + def releaseOutputStream(self) -> None: ... + +class RemoteObject(java.rmi.Remote, java.io.Serializable): + def equals(self, object: typing.Any) -> bool: ... + def getRef(self) -> RemoteRef: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + @staticmethod + def toStub(remote: java.rmi.Remote) -> java.rmi.Remote: ... + +class RemoteRef(java.io.Externalizable): + serialVersionUID: typing.ClassVar[int] = ... + packagePrefix: typing.ClassVar[java.lang.String] = ... + def done(self, remoteCall: RemoteCall) -> None: ... + def getRefClass(self, objectOutput: java.io.ObjectOutput) -> java.lang.String: ... + @typing.overload + def invoke( + self, + remote: java.rmi.Remote, + method: java.lang.reflect.Method, + objectArray: list[typing.Any] | jpype.JArray, + long: int, + ) -> typing.Any: ... + @typing.overload + def invoke(self, remoteCall: RemoteCall) -> None: ... + def newCall( + self, + remoteObject: RemoteObject, + operationArray: list[Operation] | jpype.JArray, + int: int, + long: int, + ) -> RemoteCall: ... + def remoteEquals(self, remoteRef: RemoteRef) -> bool: ... + def remoteHashCode(self) -> int: ... + def remoteToString(self) -> java.lang.String: ... + +class ServerCloneException(java.lang.CloneNotSupportedException): + detail: java.lang.Exception = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + def getCause(self) -> java.lang.Throwable: ... + def getMessage(self) -> java.lang.String: ... + +class ServerNotActiveException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Skeleton: + def dispatch( + self, remote: java.rmi.Remote, remoteCall: RemoteCall, int: int, long: int + ) -> None: ... + def getOperations(self) -> typing.MutableSequence[Operation]: ... + +class SkeletonMismatchException(java.rmi.RemoteException): + def __init__(self, string: java.lang.String | str): ... + +class SkeletonNotFoundException(java.rmi.RemoteException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class UID(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, short: int): ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + @staticmethod + def read(dataInput: java.io.DataInput) -> UID: ... + def toString(self) -> java.lang.String: ... + def write(self, dataOutput: java.io.DataOutput) -> None: ... + +class Unreferenced: + def unreferenced(self) -> None: ... + +class RMISocketFactory(RMIClientSocketFactory, RMIServerSocketFactory): + def __init__(self): ... + def createServerSocket(self, int: int) -> java.net.ServerSocket: ... + def createSocket( + self, string: java.lang.String | str, int: int + ) -> java.net.Socket: ... + @staticmethod + def getDefaultSocketFactory() -> RMISocketFactory: ... + @staticmethod + def getFailureHandler() -> RMIFailureHandler: ... + @staticmethod + def getSocketFactory() -> RMISocketFactory: ... + @staticmethod + def setFailureHandler( + rMIFailureHandler: RMIFailureHandler | typing.Callable, + ) -> None: ... + @staticmethod + def setSocketFactory(rMISocketFactory: RMISocketFactory) -> None: ... + +class RemoteObjectInvocationHandler(RemoteObject, java.lang.reflect.InvocationHandler): + def __init__(self, remoteRef: RemoteRef): ... + def invoke( + self, + object: typing.Any, + method: java.lang.reflect.Method, + objectArray: list[typing.Any] | jpype.JArray, + ) -> typing.Any: ... + +class RemoteServer(RemoteObject): + @staticmethod + def getClientHost() -> java.lang.String: ... + @staticmethod + def getLog() -> java.io.PrintStream: ... + @staticmethod + def setLog(outputStream: java.io.OutputStream) -> None: ... + +class RemoteStub(RemoteObject): ... + +class ServerRef(RemoteRef): + serialVersionUID: typing.ClassVar[int] = ... + def exportObject( + self, remote: java.rmi.Remote, object: typing.Any + ) -> RemoteStub: ... + def getClientHost(self) -> java.lang.String: ... + +class SocketSecurityException(ExportException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, exception: java.lang.Exception + ): ... + +class UnicastRemoteObject(RemoteServer): + def clone(self) -> typing.Any: ... + @typing.overload + @staticmethod + def exportObject(remote: java.rmi.Remote, int: int) -> java.rmi.Remote: ... + @typing.overload + @staticmethod + def exportObject( + remote: java.rmi.Remote, + int: int, + objectInputFilter: java.io.ObjectInputFilter | typing.Callable, + ) -> java.rmi.Remote: ... + @typing.overload + @staticmethod + def exportObject( + remote: java.rmi.Remote, + int: int, + rMIClientSocketFactory: RMIClientSocketFactory | typing.Callable, + rMIServerSocketFactory: RMIServerSocketFactory | typing.Callable, + ) -> java.rmi.Remote: ... + @typing.overload + @staticmethod + def exportObject( + remote: java.rmi.Remote, + int: int, + rMIClientSocketFactory: RMIClientSocketFactory | typing.Callable, + rMIServerSocketFactory: RMIServerSocketFactory | typing.Callable, + objectInputFilter: java.io.ObjectInputFilter | typing.Callable, + ) -> java.rmi.Remote: ... + @typing.overload + @staticmethod + def exportObject(remote: java.rmi.Remote) -> RemoteStub: ... + @staticmethod + def unexportObject(remote: java.rmi.Remote, boolean: bool) -> bool: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.rmi.server")``. + + ExportException: type[ExportException] + LoaderHandler: type[LoaderHandler] + LogStream: type[LogStream] + ObjID: type[ObjID] + Operation: type[Operation] + RMIClassLoader: type[RMIClassLoader] + RMIClassLoaderSpi: type[RMIClassLoaderSpi] + RMIClientSocketFactory: type[RMIClientSocketFactory] + RMIFailureHandler: type[RMIFailureHandler] + RMIServerSocketFactory: type[RMIServerSocketFactory] + RMISocketFactory: type[RMISocketFactory] + RemoteCall: type[RemoteCall] + RemoteObject: type[RemoteObject] + RemoteObjectInvocationHandler: type[RemoteObjectInvocationHandler] + RemoteRef: type[RemoteRef] + RemoteServer: type[RemoteServer] + RemoteStub: type[RemoteStub] + ServerCloneException: type[ServerCloneException] + ServerNotActiveException: type[ServerNotActiveException] + ServerRef: type[ServerRef] + Skeleton: type[Skeleton] + SkeletonMismatchException: type[SkeletonMismatchException] + SkeletonNotFoundException: type[SkeletonNotFoundException] + SocketSecurityException: type[SocketSecurityException] + UID: type[UID] + UnicastRemoteObject: type[UnicastRemoteObject] + Unreferenced: type[Unreferenced] diff --git a/typings/java/security/__init__.pyi b/typings/java/security/__init__.pyi new file mode 100644 index 0000000..110e978 --- /dev/null +++ b/typings/java/security/__init__.pyi @@ -0,0 +1,1720 @@ +import typing +from typing import Protocol + +import java +import java.io +import java.lang +import java.net +import java.nio +import java.security.cert +import java.security.interfaces +import java.security.spec +import java.util +import java.util.function +import java.util.stream +import javax.crypto +import javax.security.auth +import javax.security.auth.callback +import javax.security.auth.login +import jpype +import jpype.protocol + +class AccessControlContext: + @typing.overload + def __init__( + self, + accessControlContext: AccessControlContext, + domainCombiner: DomainCombiner | typing.Callable, + ): ... + @typing.overload + def __init__( + self, protectionDomainArray: list[ProtectionDomain] | jpype.JArray + ): ... + def checkPermission(self, permission: Permission) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getDomainCombiner(self) -> DomainCombiner: ... + def hashCode(self) -> int: ... + +class AccessControlException(java.lang.SecurityException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, permission: Permission): ... + def getPermission(self) -> Permission: ... + +class AccessController: + @staticmethod + def checkPermission(permission: Permission) -> None: ... + _doPrivileged_0__T = typing.TypeVar("_doPrivileged_0__T") # + _doPrivileged_1__T = typing.TypeVar("_doPrivileged_1__T") # + _doPrivileged_2__T = typing.TypeVar("_doPrivileged_2__T") # + _doPrivileged_3__T = typing.TypeVar("_doPrivileged_3__T") # + _doPrivileged_4__T = typing.TypeVar("_doPrivileged_4__T") # + _doPrivileged_5__T = typing.TypeVar("_doPrivileged_5__T") # + @typing.overload + @staticmethod + def doPrivileged( + privilegedAction: PrivilegedAction[_doPrivileged_0__T] + | typing.Callable[[], _doPrivileged_0__T], + ) -> _doPrivileged_0__T: ... + @typing.overload + @staticmethod + def doPrivileged( + privilegedAction: PrivilegedAction[_doPrivileged_1__T] + | typing.Callable[[], _doPrivileged_1__T], + accessControlContext: AccessControlContext, + ) -> _doPrivileged_1__T: ... + @typing.overload + @staticmethod + def doPrivileged( + privilegedAction: PrivilegedAction[_doPrivileged_2__T] + | typing.Callable[[], _doPrivileged_2__T], + accessControlContext: AccessControlContext, + *permission: Permission, + ) -> _doPrivileged_2__T: ... + @typing.overload + @staticmethod + def doPrivileged( + privilegedExceptionAction: PrivilegedExceptionAction[_doPrivileged_3__T] + | typing.Callable[[], _doPrivileged_3__T], + ) -> _doPrivileged_3__T: ... + @typing.overload + @staticmethod + def doPrivileged( + privilegedExceptionAction: PrivilegedExceptionAction[_doPrivileged_4__T] + | typing.Callable[[], _doPrivileged_4__T], + accessControlContext: AccessControlContext, + ) -> _doPrivileged_4__T: ... + @typing.overload + @staticmethod + def doPrivileged( + privilegedExceptionAction: PrivilegedExceptionAction[_doPrivileged_5__T] + | typing.Callable[[], _doPrivileged_5__T], + accessControlContext: AccessControlContext, + *permission: Permission, + ) -> _doPrivileged_5__T: ... + _doPrivilegedWithCombiner_0__T = typing.TypeVar( + "_doPrivilegedWithCombiner_0__T" + ) # + _doPrivilegedWithCombiner_1__T = typing.TypeVar( + "_doPrivilegedWithCombiner_1__T" + ) # + _doPrivilegedWithCombiner_2__T = typing.TypeVar( + "_doPrivilegedWithCombiner_2__T" + ) # + _doPrivilegedWithCombiner_3__T = typing.TypeVar( + "_doPrivilegedWithCombiner_3__T" + ) # + @typing.overload + @staticmethod + def doPrivilegedWithCombiner( + privilegedAction: PrivilegedAction[_doPrivilegedWithCombiner_0__T] + | typing.Callable[[], _doPrivilegedWithCombiner_0__T], + ) -> _doPrivilegedWithCombiner_0__T: ... + @typing.overload + @staticmethod + def doPrivilegedWithCombiner( + privilegedAction: PrivilegedAction[_doPrivilegedWithCombiner_1__T] + | typing.Callable[[], _doPrivilegedWithCombiner_1__T], + accessControlContext: AccessControlContext, + *permission: Permission, + ) -> _doPrivilegedWithCombiner_1__T: ... + @typing.overload + @staticmethod + def doPrivilegedWithCombiner( + privilegedExceptionAction: PrivilegedExceptionAction[ + _doPrivilegedWithCombiner_2__T + ] + | typing.Callable[[], _doPrivilegedWithCombiner_2__T], + ) -> _doPrivilegedWithCombiner_2__T: ... + @typing.overload + @staticmethod + def doPrivilegedWithCombiner( + privilegedExceptionAction: PrivilegedExceptionAction[ + _doPrivilegedWithCombiner_3__T + ] + | typing.Callable[[], _doPrivilegedWithCombiner_3__T], + accessControlContext: AccessControlContext, + *permission: Permission, + ) -> _doPrivilegedWithCombiner_3__T: ... + @staticmethod + def getContext() -> AccessControlContext: ... + +class AlgorithmConstraints: + @typing.overload + def permits( + self, + set: java.util.Set[CryptoPrimitive], + string: java.lang.String | str, + algorithmParameters: AlgorithmParameters, + ) -> bool: ... + @typing.overload + def permits( + self, + set: java.util.Set[CryptoPrimitive], + string: java.lang.String | str, + key: Key, + algorithmParameters: AlgorithmParameters, + ) -> bool: ... + @typing.overload + def permits(self, set: java.util.Set[CryptoPrimitive], key: Key) -> bool: ... + +class AlgorithmParameterGenerator: + def generateParameters(self) -> AlgorithmParameters: ... + def getAlgorithm(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> AlgorithmParameterGenerator: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> AlgorithmParameterGenerator: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: Provider + ) -> AlgorithmParameterGenerator: ... + def getProvider(self) -> Provider: ... + @typing.overload + def init(self, int: int) -> None: ... + @typing.overload + def init(self, int: int, secureRandom: SecureRandom) -> None: ... + @typing.overload + def init( + self, algorithmParameterSpec: java.security.spec.AlgorithmParameterSpec + ) -> None: ... + @typing.overload + def init( + self, + algorithmParameterSpec: java.security.spec.AlgorithmParameterSpec, + secureRandom: SecureRandom, + ) -> None: ... + +class AlgorithmParameterGeneratorSpi: + def __init__(self): ... + +class AlgorithmParameters: + def getAlgorithm(self) -> java.lang.String: ... + @typing.overload + def getEncoded(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getEncoded( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> AlgorithmParameters: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> AlgorithmParameters: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: Provider + ) -> AlgorithmParameters: ... + _getParameterSpec__T = typing.TypeVar( + "_getParameterSpec__T", bound=java.security.spec.AlgorithmParameterSpec + ) # + def getParameterSpec( + self, class_: type[_getParameterSpec__T] + ) -> _getParameterSpec__T: ... + def getProvider(self) -> Provider: ... + @typing.overload + def init(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def init( + self, + byteArray: list[int] | jpype.JArray | bytes, + string: java.lang.String | str, + ) -> None: ... + @typing.overload + def init( + self, algorithmParameterSpec: java.security.spec.AlgorithmParameterSpec + ) -> None: ... + def toString(self) -> java.lang.String: ... + +class AlgorithmParametersSpi: + def __init__(self): ... + +class Certificate: + def decode(self, inputStream: java.io.InputStream) -> None: ... + def encode(self, outputStream: java.io.OutputStream) -> None: ... + def getFormat(self) -> java.lang.String: ... + def getGuarantor(self) -> Principal: ... + def getPrincipal(self) -> Principal: ... + def getPublicKey(self) -> PublicKey: ... + def toString(self, boolean: bool) -> java.lang.String: ... + +class CodeSigner(java.io.Serializable): + def __init__(self, certPath: java.security.cert.CertPath, timestamp: Timestamp): ... + def equals(self, object: typing.Any) -> bool: ... + def getSignerCertPath(self) -> java.security.cert.CertPath: ... + def getTimestamp(self) -> Timestamp: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class CodeSource(java.io.Serializable): + @typing.overload + def __init__( + self, uRL: java.net.URL, codeSignerArray: list[CodeSigner] | jpype.JArray + ): ... + @typing.overload + def __init__( + self, + uRL: java.net.URL, + certificateArray: list[java.security.cert.Certificate] | jpype.JArray, + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getCertificates( + self, + ) -> typing.MutableSequence[java.security.cert.Certificate]: ... + def getCodeSigners(self) -> typing.MutableSequence[CodeSigner]: ... + def getLocation(self) -> java.net.URL: ... + def hashCode(self) -> int: ... + def implies(self, codeSource: CodeSource) -> bool: ... + def toString(self) -> java.lang.String: ... + +class CryptoPrimitive(java.lang.Enum["CryptoPrimitive"]): + MESSAGE_DIGEST: typing.ClassVar[CryptoPrimitive] = ... + SECURE_RANDOM: typing.ClassVar[CryptoPrimitive] = ... + BLOCK_CIPHER: typing.ClassVar[CryptoPrimitive] = ... + STREAM_CIPHER: typing.ClassVar[CryptoPrimitive] = ... + MAC: typing.ClassVar[CryptoPrimitive] = ... + KEY_WRAP: typing.ClassVar[CryptoPrimitive] = ... + PUBLIC_KEY_ENCRYPTION: typing.ClassVar[CryptoPrimitive] = ... + SIGNATURE: typing.ClassVar[CryptoPrimitive] = ... + KEY_ENCAPSULATION: typing.ClassVar[CryptoPrimitive] = ... + KEY_AGREEMENT: typing.ClassVar[CryptoPrimitive] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> CryptoPrimitive: ... + @staticmethod + def values() -> typing.MutableSequence[CryptoPrimitive]: ... + +class DEREncodable: ... + +class DigestInputStream(java.io.FilterInputStream): + def __init__( + self, inputStream: java.io.InputStream, messageDigest: MessageDigest + ): ... + def getMessageDigest(self) -> MessageDigest: ... + def on(self, boolean: bool) -> None: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def setMessageDigest(self, messageDigest: MessageDigest) -> None: ... + def toString(self) -> java.lang.String: ... + +class DigestOutputStream(java.io.FilterOutputStream): + def __init__( + self, outputStream: java.io.OutputStream, messageDigest: MessageDigest + ): ... + def getMessageDigest(self) -> MessageDigest: ... + def on(self, boolean: bool) -> None: ... + def setMessageDigest(self, messageDigest: MessageDigest) -> None: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class DomainCombiner: + def combine( + self, + protectionDomainArray: list[ProtectionDomain] | jpype.JArray, + protectionDomainArray2: list[ProtectionDomain] | jpype.JArray, + ) -> typing.MutableSequence[ProtectionDomain]: ... + +class GeneralSecurityException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class Guard: + def checkGuard(self, object: typing.Any) -> None: ... + +class GuardedObject(java.io.Serializable): + def __init__(self, object: typing.Any, guard: Guard | typing.Callable): ... + def getObject(self) -> typing.Any: ... + +class InvalidParameterException(java.lang.IllegalArgumentException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class Key(java.io.Serializable): + serialVersionUID: typing.ClassVar[int] = ... + def getAlgorithm(self) -> java.lang.String: ... + def getEncoded(self) -> typing.MutableSequence[int]: ... + def getFormat(self) -> java.lang.String: ... + +class KeyFactory: + def generatePrivate(self, keySpec: java.security.spec.KeySpec) -> PrivateKey: ... + def generatePublic(self, keySpec: java.security.spec.KeySpec) -> PublicKey: ... + def getAlgorithm(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> KeyFactory: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> KeyFactory: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: Provider + ) -> KeyFactory: ... + _getKeySpec__T = typing.TypeVar( + "_getKeySpec__T", bound=java.security.spec.KeySpec + ) # + def getKeySpec(self, key: Key, class_: type[_getKeySpec__T]) -> _getKeySpec__T: ... + def getProvider(self) -> Provider: ... + def translateKey(self, key: Key) -> Key: ... + +class KeyFactorySpi: + def __init__(self): ... + +class KeyPairGeneratorSpi: + def __init__(self): ... + def generateKeyPair(self) -> KeyPair: ... + @typing.overload + def initialize(self, int: int, secureRandom: SecureRandom) -> None: ... + @typing.overload + def initialize( + self, + algorithmParameterSpec: java.security.spec.AlgorithmParameterSpec, + secureRandom: SecureRandom, + ) -> None: ... + +class KeyRep(java.io.Serializable): + def __init__( + self, + type: KeyRep.Type, + string: java.lang.String | str, + string2: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + ): ... + class Type(java.lang.Enum["KeyRep.Type"]): + SECRET: typing.ClassVar[KeyRep.Type] = ... + PUBLIC: typing.ClassVar[KeyRep.Type] = ... + PRIVATE: typing.ClassVar[KeyRep.Type] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> KeyRep.Type: ... + @staticmethod + def values() -> typing.MutableSequence[KeyRep.Type]: ... + +class KeyStoreSpi: + def __init__(self): ... + def engineAliases(self) -> java.util.Enumeration[java.lang.String]: ... + def engineContainsAlias(self, string: java.lang.String | str) -> bool: ... + def engineDeleteEntry(self, string: java.lang.String | str) -> None: ... + def engineEntryInstanceOf( + self, string: java.lang.String | str, class_: type[KeyStore.Entry] + ) -> bool: ... + def engineGetAttributes( + self, string: java.lang.String | str + ) -> java.util.Set[KeyStore.Entry.Attribute]: ... + def engineGetCertificate( + self, string: java.lang.String | str + ) -> java.security.cert.Certificate: ... + def engineGetCertificateAlias( + self, certificate: java.security.cert.Certificate + ) -> java.lang.String: ... + def engineGetCertificateChain( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.security.cert.Certificate]: ... + def engineGetCreationDate( + self, string: java.lang.String | str + ) -> java.util.Date: ... + def engineGetEntry( + self, + string: java.lang.String | str, + protectionParameter: KeyStore.ProtectionParameter, + ) -> KeyStore.Entry: ... + def engineGetKey( + self, string: java.lang.String | str, charArray: list[str] | jpype.JArray + ) -> Key: ... + def engineIsCertificateEntry(self, string: java.lang.String | str) -> bool: ... + def engineIsKeyEntry(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def engineLoad( + self, inputStream: java.io.InputStream, charArray: list[str] | jpype.JArray + ) -> None: ... + @typing.overload + def engineLoad( + self, loadStoreParameter: KeyStore.LoadStoreParameter | typing.Callable + ) -> None: ... + def engineProbe(self, inputStream: java.io.InputStream) -> bool: ... + def engineSetCertificateEntry( + self, + string: java.lang.String | str, + certificate: java.security.cert.Certificate, + ) -> None: ... + def engineSetEntry( + self, + string: java.lang.String | str, + entry: KeyStore.Entry, + protectionParameter: KeyStore.ProtectionParameter, + ) -> None: ... + @typing.overload + def engineSetKeyEntry( + self, + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + certificateArray: list[java.security.cert.Certificate] | jpype.JArray, + ) -> None: ... + @typing.overload + def engineSetKeyEntry( + self, + string: java.lang.String | str, + key: Key, + charArray: list[str] | jpype.JArray, + certificateArray: list[java.security.cert.Certificate] | jpype.JArray, + ) -> None: ... + def engineSize(self) -> int: ... + @typing.overload + def engineStore( + self, outputStream: java.io.OutputStream, charArray: list[str] | jpype.JArray + ) -> None: ... + @typing.overload + def engineStore( + self, loadStoreParameter: KeyStore.LoadStoreParameter | typing.Callable + ) -> None: ... + +class MessageDigestSpi: + def __init__(self): ... + def clone(self) -> typing.Any: ... + +class PEMDecoder: + _decode_1__S = typing.TypeVar("_decode_1__S", bound=DEREncodable) # + _decode_3__S = typing.TypeVar("_decode_3__S", bound=DEREncodable) # + @typing.overload + def decode(self, inputStream: java.io.InputStream) -> DEREncodable: ... + @typing.overload + def decode( + self, inputStream: java.io.InputStream, class_: type[_decode_1__S] + ) -> _decode_1__S: ... + @typing.overload + def decode(self, string: java.lang.String | str) -> DEREncodable: ... + @typing.overload + def decode( + self, string: java.lang.String | str, class_: type[_decode_3__S] + ) -> _decode_3__S: ... + @staticmethod + def of() -> PEMDecoder: ... + def withDecryption(self, charArray: list[str] | jpype.JArray) -> PEMDecoder: ... + def withFactory(self, provider: Provider) -> PEMDecoder: ... + +class PEMEncoder: + def encode(self, dEREncodable: DEREncodable) -> typing.MutableSequence[int]: ... + def encodeToString(self, dEREncodable: DEREncodable) -> java.lang.String: ... + @staticmethod + def of() -> PEMEncoder: ... + def withEncryption(self, charArray: list[str] | jpype.JArray) -> PEMEncoder: ... + +class PermissionCollection(java.io.Serializable): + def __init__(self): ... + def add(self, permission: Permission) -> None: ... + def elements(self) -> java.util.Enumeration[Permission]: ... + def elementsAsStream(self) -> java.util.stream.Stream[Permission]: ... + def implies(self, permission: Permission) -> bool: ... + def isReadOnly(self) -> bool: ... + def setReadOnly(self) -> None: ... + def toString(self) -> java.lang.String: ... + +class Policy: + UNSUPPORTED_EMPTY_COLLECTION: typing.ClassVar[PermissionCollection] = ... + def __init__(self): ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, parameters: Policy.Parameters + ) -> Policy: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, + parameters: Policy.Parameters, + string2: java.lang.String | str, + ) -> Policy: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, + parameters: Policy.Parameters, + provider: Provider, + ) -> Policy: ... + def getParameters(self) -> Policy.Parameters: ... + @typing.overload + def getPermissions(self, codeSource: CodeSource) -> PermissionCollection: ... + @typing.overload + def getPermissions( + self, protectionDomain: ProtectionDomain + ) -> PermissionCollection: ... + @staticmethod + def getPolicy() -> Policy: ... + def getProvider(self) -> Provider: ... + def getType(self) -> java.lang.String: ... + def implies( + self, protectionDomain: ProtectionDomain, permission: Permission + ) -> bool: ... + def refresh(self) -> None: ... + @staticmethod + def setPolicy(policy: Policy) -> None: ... + class Parameters: ... + +class PolicySpi: + def __init__(self): ... + +class Principal: + def equals(self, object: typing.Any) -> bool: ... + def getName(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def implies(self, subject: javax.security.auth.Subject) -> bool: ... + def toString(self) -> java.lang.String: ... + +_PrivilegedAction__T = typing.TypeVar("_PrivilegedAction__T") # + +class PrivilegedAction(typing.Generic[_PrivilegedAction__T]): + def run(self) -> _PrivilegedAction__T: ... + +class PrivilegedActionException(java.lang.Exception): + def __init__(self, exception: java.lang.Exception): ... + def getException(self) -> java.lang.Exception: ... + def toString(self) -> java.lang.String: ... + +_PrivilegedExceptionAction__T = typing.TypeVar("_PrivilegedExceptionAction__T") # + +class PrivilegedExceptionAction(typing.Generic[_PrivilegedExceptionAction__T]): + def run(self) -> _PrivilegedExceptionAction__T: ... + +class ProtectionDomain: + @typing.overload + def __init__( + self, codeSource: CodeSource, permissionCollection: PermissionCollection + ): ... + @typing.overload + def __init__( + self, + codeSource: CodeSource, + permissionCollection: PermissionCollection, + classLoader: java.lang.ClassLoader, + principalArray: list[Principal] | jpype.JArray, + ): ... + def getClassLoader(self) -> java.lang.ClassLoader: ... + def getCodeSource(self) -> CodeSource: ... + def getPermissions(self) -> PermissionCollection: ... + def getPrincipals(self) -> typing.MutableSequence[Principal]: ... + def implies(self, permission: Permission) -> bool: ... + def staticPermissionsOnly(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class Provider(java.util.Properties): + def clear(self) -> None: ... + def compute( + self, + object: typing.Any, + biFunction: java.util.function.BiFunction[typing.Any, typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], typing.Any], + ) -> typing.Any: ... + def computeIfAbsent( + self, + object: typing.Any, + function: java.util.function.Function[typing.Any, typing.Any] + | typing.Callable[[typing.Any], typing.Any], + ) -> typing.Any: ... + def computeIfPresent( + self, + object: typing.Any, + biFunction: java.util.function.BiFunction[typing.Any, typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], typing.Any], + ) -> typing.Any: ... + def configure(self, string: java.lang.String | str) -> Provider: ... + def elements(self) -> java.util.Enumeration[typing.Any]: ... + def entrySet( + self, + ) -> java.util.Set[java.util.Map.Entry[typing.Any, typing.Any]]: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], None], + ) -> None: ... + def get(self, object: typing.Any) -> typing.Any: ... + def getInfo(self) -> java.lang.String: ... + def getName(self) -> java.lang.String: ... + def getOrDefault(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + @typing.overload + def getProperty(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def getProperty( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + def getService( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> Provider.Service: ... + def getServices(self) -> java.util.Set[Provider.Service]: ... + def getVersion(self) -> float: ... + def getVersionStr(self) -> java.lang.String: ... + def isConfigured(self) -> bool: ... + def keySet(self) -> java.util.Set[typing.Any]: ... + def keys(self) -> java.util.Enumeration[typing.Any]: ... + @typing.overload + def load(self, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def load(self, reader: java.io.Reader) -> None: ... + def merge( + self, + object: typing.Any, + object2: typing.Any, + biFunction: java.util.function.BiFunction[typing.Any, typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], typing.Any], + ) -> typing.Any: ... + def put(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + def putAll( + self, + map: java.util.Map[typing.Any, typing.Any] + | typing.Mapping[typing.Any, typing.Any], + ) -> None: ... + def putIfAbsent(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> typing.Any: ... + @typing.overload + def replace( + self, object: typing.Any, object2: typing.Any, object3: typing.Any + ) -> bool: ... + @typing.overload + def replace(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[typing.Any, typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], typing.Any], + ) -> None: ... + def toString(self) -> java.lang.String: ... + def values(self) -> java.util.Collection[typing.Any]: ... + class Service: + def __init__( + self, + provider: Provider, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + list: java.util.List[java.lang.String | str], + map: java.util.Map[java.lang.String | str, java.lang.String | str] + | typing.Mapping[java.lang.String | str, java.lang.String | str], + ): ... + def getAlgorithm(self) -> java.lang.String: ... + def getAttribute(self, string: java.lang.String | str) -> java.lang.String: ... + def getClassName(self) -> java.lang.String: ... + def getProvider(self) -> Provider: ... + def getType(self) -> java.lang.String: ... + def newInstance(self, object: typing.Any) -> typing.Any: ... + def supportsParameter(self, object: typing.Any) -> bool: ... + def toString(self) -> java.lang.String: ... + +class ProviderException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SecureClassLoader(java.lang.ClassLoader): ... + +class SecureRandom(java.util.Random): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + def generateSeed(self, int: int) -> typing.MutableSequence[int]: ... + def getAlgorithm(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> SecureRandom: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> SecureRandom: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: Provider + ) -> SecureRandom: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, secureRandomParameters: SecureRandomParameters + ) -> SecureRandom: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, + secureRandomParameters: SecureRandomParameters, + string2: java.lang.String | str, + ) -> SecureRandom: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, + secureRandomParameters: SecureRandomParameters, + provider: Provider, + ) -> SecureRandom: ... + @staticmethod + def getInstanceStrong() -> SecureRandom: ... + def getParameters(self) -> SecureRandomParameters: ... + def getProvider(self) -> Provider: ... + @staticmethod + def getSeed(int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def nextBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def nextBytes( + self, + byteArray: list[int] | jpype.JArray | bytes, + secureRandomParameters: SecureRandomParameters, + ) -> None: ... + @typing.overload + def reseed(self) -> None: ... + @typing.overload + def reseed(self, secureRandomParameters: SecureRandomParameters) -> None: ... + @typing.overload + def setSeed(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setSeed(self, long: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class SecureRandomParameters: ... + +class SecureRandomSpi(java.io.Serializable): + def __init__(self): ... + def toString(self) -> java.lang.String: ... + +class Security: + @staticmethod + def addProvider(provider: Provider) -> int: ... + @staticmethod + def getAlgorithmProperty( + string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @staticmethod + def getAlgorithms( + string: java.lang.String | str, + ) -> java.util.Set[java.lang.String]: ... + @staticmethod + def getProperty(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def getProvider(string: java.lang.String | str) -> Provider: ... + @typing.overload + @staticmethod + def getProviders() -> typing.MutableSequence[Provider]: ... + @typing.overload + @staticmethod + def getProviders( + string: java.lang.String | str, + ) -> typing.MutableSequence[Provider]: ... + @typing.overload + @staticmethod + def getProviders( + map: java.util.Map[java.lang.String | str, java.lang.String | str] + | typing.Mapping[java.lang.String | str, java.lang.String | str], + ) -> typing.MutableSequence[Provider]: ... + @staticmethod + def insertProviderAt(provider: Provider, int: int) -> int: ... + @staticmethod + def removeProvider(string: java.lang.String | str) -> None: ... + @staticmethod + def setProperty( + string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + +class SignatureSpi: + def __init__(self): ... + def clone(self) -> typing.Any: ... + +class SignedObject(java.io.Serializable): + def __init__( + self, + serializable: java.io.Serializable, + privateKey: PrivateKey, + signature: Signature, + ): ... + def getAlgorithm(self) -> java.lang.String: ... + def getObject(self) -> typing.Any: ... + def getSignature(self) -> typing.MutableSequence[int]: ... + def verify(self, publicKey: PublicKey, signature: Signature) -> bool: ... + +class Timestamp(java.io.Serializable): + def __init__(self, date: java.util.Date, certPath: java.security.cert.CertPath): ... + def equals(self, object: typing.Any) -> bool: ... + def getSignerCertPath(self) -> java.security.cert.CertPath: ... + def getTimestamp(self) -> java.util.Date: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class AsymmetricKey(Key, DEREncodable): + def getParams(self) -> java.security.spec.AlgorithmParameterSpec: ... + +class AuthProvider(Provider): + def login( + self, + subject: javax.security.auth.Subject, + callbackHandler: javax.security.auth.callback.CallbackHandler | typing.Callable, + ) -> None: ... + def logout(self) -> None: ... + def setCallbackHandler( + self, + callbackHandler: javax.security.auth.callback.CallbackHandler | typing.Callable, + ) -> None: ... + +class DigestException(GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class DrbgParameters: + @staticmethod + def instantiation( + int: int, + capability: DrbgParameters.Capability, + byteArray: list[int] | jpype.JArray | bytes, + ) -> DrbgParameters.Instantiation: ... + @staticmethod + def nextBytes( + int: int, boolean: bool, byteArray: list[int] | jpype.JArray | bytes + ) -> DrbgParameters.NextBytes: ... + @staticmethod + def reseed( + boolean: bool, byteArray: list[int] | jpype.JArray | bytes + ) -> DrbgParameters.Reseed: ... + class Capability(java.lang.Enum["DrbgParameters.Capability"]): + PR_AND_RESEED: typing.ClassVar[DrbgParameters.Capability] = ... + RESEED_ONLY: typing.ClassVar[DrbgParameters.Capability] = ... + NONE: typing.ClassVar[DrbgParameters.Capability] = ... + def supportsPredictionResistance(self) -> bool: ... + def supportsReseeding(self) -> bool: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> DrbgParameters.Capability: ... + @staticmethod + def values() -> typing.MutableSequence[DrbgParameters.Capability]: ... + + class Instantiation(SecureRandomParameters): + def getCapability(self) -> DrbgParameters.Capability: ... + def getPersonalizationString(self) -> typing.MutableSequence[int]: ... + def getStrength(self) -> int: ... + def toString(self) -> java.lang.String: ... + + class NextBytes(SecureRandomParameters): + def getAdditionalInput(self) -> typing.MutableSequence[int]: ... + def getPredictionResistance(self) -> bool: ... + def getStrength(self) -> int: ... + + class Reseed(SecureRandomParameters): + def getAdditionalInput(self) -> typing.MutableSequence[int]: ... + def getPredictionResistance(self) -> bool: ... + +class Identity(Principal, java.io.Serializable): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, identityScope: IdentityScope + ): ... + def addCertificate(self, certificate: Certificate) -> None: ... + def certificates(self) -> typing.MutableSequence[Certificate]: ... + def equals(self, object: typing.Any) -> bool: ... + def getInfo(self) -> java.lang.String: ... + def getName(self) -> java.lang.String: ... + def getPublicKey(self) -> PublicKey: ... + def getScope(self) -> IdentityScope: ... + def hashCode(self) -> int: ... + def removeCertificate(self, certificate: Certificate) -> None: ... + def setInfo(self, string: java.lang.String | str) -> None: ... + def setPublicKey(self, publicKey: PublicKey) -> None: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + def toString(self, boolean: bool) -> java.lang.String: ... + +class InvalidAlgorithmParameterException(GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class KeyException(GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class KeyPair(java.io.Serializable, DEREncodable): + def __init__(self, publicKey: PublicKey, privateKey: PrivateKey): ... + def getPrivate(self) -> PrivateKey: ... + def getPublic(self) -> PublicKey: ... + +class KeyPairGenerator(KeyPairGeneratorSpi): + def genKeyPair(self) -> KeyPair: ... + def generateKeyPair(self) -> KeyPair: ... + def getAlgorithm(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> KeyPairGenerator: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> KeyPairGenerator: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: Provider + ) -> KeyPairGenerator: ... + def getProvider(self) -> Provider: ... + @typing.overload + def initialize(self, int: int) -> None: ... + @typing.overload + def initialize(self, int: int, secureRandom: SecureRandom) -> None: ... + @typing.overload + def initialize( + self, algorithmParameterSpec: java.security.spec.AlgorithmParameterSpec + ) -> None: ... + @typing.overload + def initialize( + self, + algorithmParameterSpec: java.security.spec.AlgorithmParameterSpec, + secureRandom: SecureRandom, + ) -> None: ... + +class KeyStoreException(GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class MessageDigest(MessageDigestSpi): + def clone(self) -> typing.Any: ... + @typing.overload + def digest(self) -> typing.MutableSequence[int]: ... + @typing.overload + def digest( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def digest( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def getAlgorithm(self) -> java.lang.String: ... + def getDigestLength(self) -> int: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> MessageDigest: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> MessageDigest: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: Provider + ) -> MessageDigest: ... + def getProvider(self) -> Provider: ... + @staticmethod + def isEqual( + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> bool: ... + def reset(self) -> None: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def update(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def update(self, byte: int) -> None: ... + @typing.overload + def update(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def update( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + +class NoSuchAlgorithmException(GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class NoSuchProviderException(GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class PEMRecord(java.lang.Record, DEREncodable): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + type: java.lang.String | str, + content: java.lang.String | str, + leadingData: list[int] | jpype.JArray | bytes, + ): ... + def content(self) -> java.lang.String: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def leadingData(self) -> typing.MutableSequence[int]: ... + def toString(self) -> java.lang.String: ... + def type(self) -> java.lang.String: ... + +class Permission(Guard, java.io.Serializable): + def __init__(self, string: java.lang.String | str): ... + def checkGuard(self, object: typing.Any) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getActions(self) -> java.lang.String: ... + def getName(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def implies(self, permission: Permission) -> bool: ... + def newPermissionCollection(self) -> PermissionCollection: ... + def toString(self) -> java.lang.String: ... + +class Permissions(PermissionCollection, java.io.Serializable): + def __init__(self): ... + def add(self, permission: Permission) -> None: ... + def elements(self) -> java.util.Enumeration[Permission]: ... + def implies(self, permission: Permission) -> bool: ... + +class Signature(SignatureSpi): + def clone(self) -> typing.Any: ... + def getAlgorithm(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> Signature: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> Signature: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: Provider + ) -> Signature: ... + def getParameter(self, string: java.lang.String | str) -> typing.Any: ... + def getParameters(self) -> AlgorithmParameters: ... + def getProvider(self) -> Provider: ... + @typing.overload + def initSign(self, privateKey: PrivateKey) -> None: ... + @typing.overload + def initSign(self, privateKey: PrivateKey, secureRandom: SecureRandom) -> None: ... + @typing.overload + def initVerify(self, publicKey: PublicKey) -> None: ... + @typing.overload + def initVerify(self, certificate: java.security.cert.Certificate) -> None: ... + @typing.overload + def setParameter( + self, string: java.lang.String | str, object: typing.Any + ) -> None: ... + @typing.overload + def setParameter( + self, algorithmParameterSpec: java.security.spec.AlgorithmParameterSpec + ) -> None: ... + @typing.overload + def sign(self) -> typing.MutableSequence[int]: ... + @typing.overload + def sign( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def update(self, byte: int) -> None: ... + @typing.overload + def update(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def update( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def update(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def verify(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def verify( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> bool: ... + +class SignatureException(GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class URIParameter( + Policy.Parameters, javax.security.auth.login.Configuration.Parameters +): + def __init__(self, uRI: java.net.URI): ... + def getURI(self) -> java.net.URI: ... + +class UnrecoverableEntryException(GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class AllPermission(Permission): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getActions(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def implies(self, permission: Permission) -> bool: ... + def newPermissionCollection(self) -> PermissionCollection: ... + +class BasicPermission(Permission, java.io.Serializable): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getActions(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def implies(self, permission: Permission) -> bool: ... + def newPermissionCollection(self) -> PermissionCollection: ... + +class IdentityScope(Identity): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, identityScope: IdentityScope + ): ... + def addIdentity(self, identity: Identity) -> None: ... + @typing.overload + def getIdentity(self, string: java.lang.String | str) -> Identity: ... + @typing.overload + def getIdentity(self, publicKey: PublicKey) -> Identity: ... + @typing.overload + def getIdentity(self, principal: Principal | typing.Callable) -> Identity: ... + @staticmethod + def getSystemScope() -> IdentityScope: ... + def identities(self) -> java.util.Enumeration[Identity]: ... + def removeIdentity(self, identity: Identity) -> None: ... + def size(self) -> int: ... + @typing.overload + def toString(self, boolean: bool) -> java.lang.String: ... + @typing.overload + def toString(self) -> java.lang.String: ... + +class InvalidKeyException(KeyException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class KeyManagementException(KeyException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class PrivateKey(AsymmetricKey, javax.security.auth.Destroyable): + serialVersionUID: typing.ClassVar[int] = ... + +class PublicKey(AsymmetricKey): + serialVersionUID: typing.ClassVar[int] = ... + +class Signer(Identity): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, identityScope: IdentityScope + ): ... + def getPrivateKey(self) -> PrivateKey: ... + def setKeyPair(self, keyPair: KeyPair) -> None: ... + @typing.overload + def toString(self, boolean: bool) -> java.lang.String: ... + @typing.overload + def toString(self) -> java.lang.String: ... + +class UnrecoverableKeyException(UnrecoverableEntryException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class UnresolvedPermission(Permission, java.io.Serializable): + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + certificateArray: list[java.security.cert.Certificate] | jpype.JArray, + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getActions(self) -> java.lang.String: ... + def getUnresolvedActions(self) -> java.lang.String: ... + def getUnresolvedCerts( + self, + ) -> typing.MutableSequence[java.security.cert.Certificate]: ... + def getUnresolvedName(self) -> java.lang.String: ... + def getUnresolvedType(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def implies(self, permission: Permission) -> bool: ... + def newPermissionCollection(self) -> PermissionCollection: ... + def toString(self) -> java.lang.String: ... + +class SecurityPermission(BasicPermission): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class DomainLoadStoreParameter(java.security.KeyStore.LoadStoreParameter): + def __init__( + self, + uRI: java.net.URI, + map: java.util.Map[java.lang.String | str, KeyStore.ProtectionParameter] + | typing.Mapping[java.lang.String | str, KeyStore.ProtectionParameter], + ): ... + def getConfiguration(self) -> java.net.URI: ... + def getProtectionParameter(self) -> KeyStore.ProtectionParameter: ... + def getProtectionParams( + self, + ) -> java.util.Map[java.lang.String, KeyStore.ProtectionParameter]: ... + +class KeyStore: + def aliases(self) -> java.util.Enumeration[java.lang.String]: ... + def containsAlias(self, string: java.lang.String | str) -> bool: ... + def deleteEntry(self, string: java.lang.String | str) -> None: ... + def entryInstanceOf( + self, string: java.lang.String | str, class_: type[KeyStore.Entry] + ) -> bool: ... + def getAttributes( + self, string: java.lang.String | str + ) -> java.util.Set[KeyStore.Entry.Attribute]: ... + def getCertificate( + self, string: java.lang.String | str + ) -> java.security.cert.Certificate: ... + def getCertificateAlias( + self, certificate: java.security.cert.Certificate + ) -> java.lang.String: ... + def getCertificateChain( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.security.cert.Certificate]: ... + def getCreationDate(self, string: java.lang.String | str) -> java.util.Date: ... + @staticmethod + def getDefaultType() -> java.lang.String: ... + def getEntry( + self, + string: java.lang.String | str, + protectionParameter: KeyStore.ProtectionParameter, + ) -> KeyStore.Entry: ... + @typing.overload + @staticmethod + def getInstance( + file: java.io.File | jpype.protocol.SupportsPath, + charArray: list[str] | jpype.JArray, + ) -> KeyStore: ... + @typing.overload + @staticmethod + def getInstance( + file: java.io.File | jpype.protocol.SupportsPath, + loadStoreParameter: KeyStore.LoadStoreParameter | typing.Callable, + ) -> KeyStore: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> KeyStore: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> KeyStore: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str, provider: Provider) -> KeyStore: ... + def getKey( + self, string: java.lang.String | str, charArray: list[str] | jpype.JArray + ) -> Key: ... + def getProvider(self) -> Provider: ... + def getType(self) -> java.lang.String: ... + def isCertificateEntry(self, string: java.lang.String | str) -> bool: ... + def isKeyEntry(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def load( + self, inputStream: java.io.InputStream, charArray: list[str] | jpype.JArray + ) -> None: ... + @typing.overload + def load( + self, loadStoreParameter: KeyStore.LoadStoreParameter | typing.Callable + ) -> None: ... + def setCertificateEntry( + self, + string: java.lang.String | str, + certificate: java.security.cert.Certificate, + ) -> None: ... + def setEntry( + self, + string: java.lang.String | str, + entry: KeyStore.Entry, + protectionParameter: KeyStore.ProtectionParameter, + ) -> None: ... + @typing.overload + def setKeyEntry( + self, + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + certificateArray: list[java.security.cert.Certificate] | jpype.JArray, + ) -> None: ... + @typing.overload + def setKeyEntry( + self, + string: java.lang.String | str, + key: Key, + charArray: list[str] | jpype.JArray, + certificateArray: list[java.security.cert.Certificate] | jpype.JArray, + ) -> None: ... + def size(self) -> int: ... + @typing.overload + def store( + self, outputStream: java.io.OutputStream, charArray: list[str] | jpype.JArray + ) -> None: ... + @typing.overload + def store( + self, loadStoreParameter: KeyStore.LoadStoreParameter | typing.Callable + ) -> None: ... + class Builder: + def getKeyStore(self) -> KeyStore: ... + def getProtectionParameter( + self, string: java.lang.String | str + ) -> KeyStore.ProtectionParameter: ... + @typing.overload + @staticmethod + def newInstance( + file: java.io.File | jpype.protocol.SupportsPath, + protectionParameter: KeyStore.ProtectionParameter, + ) -> KeyStore.Builder: ... + @typing.overload + @staticmethod + def newInstance( + string: java.lang.String | str, + provider: Provider, + file: java.io.File | jpype.protocol.SupportsPath, + protectionParameter: KeyStore.ProtectionParameter, + ) -> KeyStore.Builder: ... + @typing.overload + @staticmethod + def newInstance( + string: java.lang.String | str, + provider: Provider, + protectionParameter: KeyStore.ProtectionParameter, + ) -> KeyStore.Builder: ... + @typing.overload + @staticmethod + def newInstance( + keyStore: KeyStore, protectionParameter: KeyStore.ProtectionParameter + ) -> KeyStore.Builder: ... + + class CallbackHandlerProtection(java.security.KeyStore.ProtectionParameter): + def __init__( + self, + callbackHandler: javax.security.auth.callback.CallbackHandler + | typing.Callable, + ): ... + def getCallbackHandler( + self, + ) -> javax.security.auth.callback.CallbackHandler: ... + + class Entry: + def getAttributes(self) -> java.util.Set[KeyStore.Entry.Attribute]: ... + class Attribute: + def getName(self) -> java.lang.String: ... + def getValue(self) -> java.lang.String: ... + + class LoadStoreParameter: + def getProtectionParameter(self) -> KeyStore.ProtectionParameter: ... + + class PasswordProtection( + java.security.KeyStore.ProtectionParameter, javax.security.auth.Destroyable + ): + @typing.overload + def __init__(self, charArray: list[str] | jpype.JArray): ... + @typing.overload + def __init__( + self, + charArray: list[str] | jpype.JArray, + string: java.lang.String | str, + algorithmParameterSpec: java.security.spec.AlgorithmParameterSpec, + ): ... + def destroy(self) -> None: ... + def getPassword(self) -> typing.MutableSequence[str]: ... + def getProtectionAlgorithm(self) -> java.lang.String: ... + def getProtectionParameters( + self, + ) -> java.security.spec.AlgorithmParameterSpec: ... + def isDestroyed(self) -> bool: ... + + class PrivateKeyEntry(java.security.KeyStore.Entry): + @typing.overload + def __init__( + self, + privateKey: PrivateKey, + certificateArray: list[java.security.cert.Certificate] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + privateKey: PrivateKey, + certificateArray: list[java.security.cert.Certificate] | jpype.JArray, + set: java.util.Set[KeyStore.Entry.Attribute], + ): ... + def getAttributes(self) -> java.util.Set[KeyStore.Entry.Attribute]: ... + def getCertificate(self) -> java.security.cert.Certificate: ... + def getCertificateChain( + self, + ) -> typing.MutableSequence[java.security.cert.Certificate]: ... + def getPrivateKey(self) -> PrivateKey: ... + def toString(self) -> java.lang.String: ... + + class ProtectionParameter: ... + + class SecretKeyEntry(java.security.KeyStore.Entry): + @typing.overload + def __init__(self, secretKey: javax.crypto.SecretKey): ... + @typing.overload + def __init__( + self, + secretKey: javax.crypto.SecretKey, + set: java.util.Set[KeyStore.Entry.Attribute], + ): ... + def getAttributes(self) -> java.util.Set[KeyStore.Entry.Attribute]: ... + def getSecretKey(self) -> javax.crypto.SecretKey: ... + def toString(self) -> java.lang.String: ... + + class TrustedCertificateEntry(java.security.KeyStore.Entry): + @typing.overload + def __init__(self, certificate: java.security.cert.Certificate): ... + @typing.overload + def __init__( + self, + certificate: java.security.cert.Certificate, + set: java.util.Set[KeyStore.Entry.Attribute], + ): ... + def getAttributes(self) -> java.util.Set[KeyStore.Entry.Attribute]: ... + def getTrustedCertificate(self) -> java.security.cert.Certificate: ... + def toString(self) -> java.lang.String: ... + +class PKCS12Attribute(KeyStore.Entry.Attribute): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getEncoded(self) -> typing.MutableSequence[int]: ... + def getName(self) -> java.lang.String: ... + def getValue(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.security")``. + + AccessControlContext: type[AccessControlContext] + AccessControlException: type[AccessControlException] + AccessController: type[AccessController] + AlgorithmConstraints: type[AlgorithmConstraints] + AlgorithmParameterGenerator: type[AlgorithmParameterGenerator] + AlgorithmParameterGeneratorSpi: type[AlgorithmParameterGeneratorSpi] + AlgorithmParameters: type[AlgorithmParameters] + AlgorithmParametersSpi: type[AlgorithmParametersSpi] + AllPermission: type[AllPermission] + AsymmetricKey: type[AsymmetricKey] + AuthProvider: type[AuthProvider] + BasicPermission: type[BasicPermission] + Certificate: type[Certificate] + CodeSigner: type[CodeSigner] + CodeSource: type[CodeSource] + CryptoPrimitive: type[CryptoPrimitive] + DEREncodable: type[DEREncodable] + DigestException: type[DigestException] + DigestInputStream: type[DigestInputStream] + DigestOutputStream: type[DigestOutputStream] + DomainCombiner: type[DomainCombiner] + DomainLoadStoreParameter: type[DomainLoadStoreParameter] + DrbgParameters: type[DrbgParameters] + GeneralSecurityException: type[GeneralSecurityException] + Guard: type[Guard] + GuardedObject: type[GuardedObject] + Identity: type[Identity] + IdentityScope: type[IdentityScope] + InvalidAlgorithmParameterException: type[InvalidAlgorithmParameterException] + InvalidKeyException: type[InvalidKeyException] + InvalidParameterException: type[InvalidParameterException] + Key: type[Key] + KeyException: type[KeyException] + KeyFactory: type[KeyFactory] + KeyFactorySpi: type[KeyFactorySpi] + KeyManagementException: type[KeyManagementException] + KeyPair: type[KeyPair] + KeyPairGenerator: type[KeyPairGenerator] + KeyPairGeneratorSpi: type[KeyPairGeneratorSpi] + KeyRep: type[KeyRep] + KeyStore: type[KeyStore] + KeyStoreException: type[KeyStoreException] + KeyStoreSpi: type[KeyStoreSpi] + MessageDigest: type[MessageDigest] + MessageDigestSpi: type[MessageDigestSpi] + NoSuchAlgorithmException: type[NoSuchAlgorithmException] + NoSuchProviderException: type[NoSuchProviderException] + PEMDecoder: type[PEMDecoder] + PEMEncoder: type[PEMEncoder] + PEMRecord: type[PEMRecord] + PKCS12Attribute: type[PKCS12Attribute] + Permission: type[Permission] + PermissionCollection: type[PermissionCollection] + Permissions: type[Permissions] + Policy: type[Policy] + PolicySpi: type[PolicySpi] + Principal: type[Principal] + PrivateKey: type[PrivateKey] + PrivilegedAction: type[PrivilegedAction] + PrivilegedActionException: type[PrivilegedActionException] + PrivilegedExceptionAction: type[PrivilegedExceptionAction] + ProtectionDomain: type[ProtectionDomain] + Provider: type[Provider] + ProviderException: type[ProviderException] + PublicKey: type[PublicKey] + SecureClassLoader: type[SecureClassLoader] + SecureRandom: type[SecureRandom] + SecureRandomParameters: type[SecureRandomParameters] + SecureRandomSpi: type[SecureRandomSpi] + Security: type[Security] + SecurityPermission: type[SecurityPermission] + Signature: type[Signature] + SignatureException: type[SignatureException] + SignatureSpi: type[SignatureSpi] + SignedObject: type[SignedObject] + Signer: type[Signer] + Timestamp: type[Timestamp] + URIParameter: type[URIParameter] + UnrecoverableEntryException: type[UnrecoverableEntryException] + UnrecoverableKeyException: type[UnrecoverableKeyException] + UnresolvedPermission: type[UnresolvedPermission] + cert: java.security.cert.__module_protocol__ + interfaces: java.security.interfaces.__module_protocol__ + spec: java.security.spec.__module_protocol__ diff --git a/typings/java/security/cert/__init__.pyi b/typings/java/security/cert/__init__.pyi new file mode 100644 index 0000000..20750bf --- /dev/null +++ b/typings/java/security/cert/__init__.pyi @@ -0,0 +1,934 @@ +import typing +from typing import Protocol + +import java +import java.io +import java.lang +import java.math +import java.net +import java.security +import java.util +import javax.security.auth.x500 +import jpype + +class CRL: + def getType(self) -> java.lang.String: ... + def isRevoked(self, certificate: Certificate) -> bool: ... + def toString(self) -> java.lang.String: ... + +class CRLException(java.security.GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class CRLReason(java.lang.Enum["CRLReason"]): + UNSPECIFIED: typing.ClassVar[CRLReason] = ... + KEY_COMPROMISE: typing.ClassVar[CRLReason] = ... + CA_COMPROMISE: typing.ClassVar[CRLReason] = ... + AFFILIATION_CHANGED: typing.ClassVar[CRLReason] = ... + SUPERSEDED: typing.ClassVar[CRLReason] = ... + CESSATION_OF_OPERATION: typing.ClassVar[CRLReason] = ... + CERTIFICATE_HOLD: typing.ClassVar[CRLReason] = ... + UNUSED: typing.ClassVar[CRLReason] = ... + REMOVE_FROM_CRL: typing.ClassVar[CRLReason] = ... + PRIVILEGE_WITHDRAWN: typing.ClassVar[CRLReason] = ... + AA_COMPROMISE: typing.ClassVar[CRLReason] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> CRLReason: ... + @staticmethod + def values() -> typing.MutableSequence[CRLReason]: ... + +class CRLSelector(java.lang.Cloneable): + def clone(self) -> typing.Any: ... + def match(self, cRL: CRL) -> bool: ... + +class CertPath(java.io.Serializable): + def equals(self, object: typing.Any) -> bool: ... + def getCertificates(self) -> java.util.List[Certificate]: ... + @typing.overload + def getEncoded(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getEncoded( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def getEncodings(self) -> java.util.Iterator[java.lang.String]: ... + def getType(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class CertPathBuilder: + def build( + self, certPathParameters: CertPathParameters | typing.Callable + ) -> CertPathBuilderResult: ... + def getAlgorithm(self) -> java.lang.String: ... + @staticmethod + def getDefaultType() -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> CertPathBuilder: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> CertPathBuilder: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: java.security.Provider + ) -> CertPathBuilder: ... + def getProvider(self) -> java.security.Provider: ... + def getRevocationChecker(self) -> CertPathChecker: ... + +class CertPathBuilderException(java.security.GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class CertPathBuilderResult(java.lang.Cloneable): + def clone(self) -> typing.Any: ... + def getCertPath(self) -> CertPath: ... + +class CertPathBuilderSpi: + def __init__(self): ... + def engineBuild( + self, certPathParameters: CertPathParameters | typing.Callable + ) -> CertPathBuilderResult: ... + def engineGetRevocationChecker(self) -> CertPathChecker: ... + +class CertPathChecker: + def check(self, certificate: Certificate) -> None: ... + def init(self, boolean: bool) -> None: ... + def isForwardCheckingSupported(self) -> bool: ... + +class CertPathParameters(java.lang.Cloneable): + def clone(self) -> typing.Any: ... + +class CertPathValidator: + def getAlgorithm(self) -> java.lang.String: ... + @staticmethod + def getDefaultType() -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> CertPathValidator: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> CertPathValidator: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: java.security.Provider + ) -> CertPathValidator: ... + def getProvider(self) -> java.security.Provider: ... + def getRevocationChecker(self) -> CertPathChecker: ... + def validate( + self, + certPath: CertPath, + certPathParameters: CertPathParameters | typing.Callable, + ) -> CertPathValidatorResult: ... + +class CertPathValidatorResult(java.lang.Cloneable): + def clone(self) -> typing.Any: ... + +class CertPathValidatorSpi: + def __init__(self): ... + def engineGetRevocationChecker(self) -> CertPathChecker: ... + def engineValidate( + self, + certPath: CertPath, + certPathParameters: CertPathParameters | typing.Callable, + ) -> CertPathValidatorResult: ... + +class CertSelector(java.lang.Cloneable): + def clone(self) -> typing.Any: ... + def match(self, certificate: Certificate) -> bool: ... + +class CertStore: + def getCRLs(self, cRLSelector: CRLSelector) -> java.util.Collection[CRL]: ... + def getCertStoreParameters(self) -> CertStoreParameters: ... + def getCertificates( + self, certSelector: CertSelector + ) -> java.util.Collection[Certificate]: ... + @staticmethod + def getDefaultType() -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, + certStoreParameters: CertStoreParameters | typing.Callable, + ) -> CertStore: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, + certStoreParameters: CertStoreParameters | typing.Callable, + string2: java.lang.String | str, + ) -> CertStore: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, + certStoreParameters: CertStoreParameters | typing.Callable, + provider: java.security.Provider, + ) -> CertStore: ... + def getProvider(self) -> java.security.Provider: ... + def getType(self) -> java.lang.String: ... + +class CertStoreException(java.security.GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class CertStoreParameters(java.lang.Cloneable): + def clone(self) -> typing.Any: ... + +class CertStoreSpi: + def __init__(self, certStoreParameters: CertStoreParameters | typing.Callable): ... + def engineGetCRLs(self, cRLSelector: CRLSelector) -> java.util.Collection[CRL]: ... + def engineGetCertificates( + self, certSelector: CertSelector + ) -> java.util.Collection[Certificate]: ... + +class Certificate(java.io.Serializable): + def equals(self, object: typing.Any) -> bool: ... + def getEncoded(self) -> typing.MutableSequence[int]: ... + def getPublicKey(self) -> java.security.PublicKey: ... + def getType(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def verify(self, publicKey: java.security.PublicKey) -> None: ... + @typing.overload + def verify( + self, publicKey: java.security.PublicKey, string: java.lang.String | str + ) -> None: ... + @typing.overload + def verify( + self, publicKey: java.security.PublicKey, provider: java.security.Provider + ) -> None: ... + +class CertificateException(java.security.GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class CertificateFactory: + def generateCRL(self, inputStream: java.io.InputStream) -> CRL: ... + def generateCRLs( + self, inputStream: java.io.InputStream + ) -> java.util.Collection[CRL]: ... + @typing.overload + def generateCertPath(self, inputStream: java.io.InputStream) -> CertPath: ... + @typing.overload + def generateCertPath( + self, inputStream: java.io.InputStream, string: java.lang.String | str + ) -> CertPath: ... + @typing.overload + def generateCertPath(self, list: java.util.List[Certificate]) -> CertPath: ... + def generateCertificate(self, inputStream: java.io.InputStream) -> Certificate: ... + def generateCertificates( + self, inputStream: java.io.InputStream + ) -> java.util.Collection[Certificate]: ... + def getCertPathEncodings(self) -> java.util.Iterator[java.lang.String]: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> CertificateFactory: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, string2: java.lang.String | str + ) -> CertificateFactory: ... + @typing.overload + @staticmethod + def getInstance( + string: java.lang.String | str, provider: java.security.Provider + ) -> CertificateFactory: ... + def getProvider(self) -> java.security.Provider: ... + def getType(self) -> java.lang.String: ... + +class CertificateFactorySpi: + def __init__(self): ... + def engineGenerateCRL(self, inputStream: java.io.InputStream) -> CRL: ... + def engineGenerateCRLs( + self, inputStream: java.io.InputStream + ) -> java.util.Collection[CRL]: ... + @typing.overload + def engineGenerateCertPath(self, inputStream: java.io.InputStream) -> CertPath: ... + @typing.overload + def engineGenerateCertPath( + self, inputStream: java.io.InputStream, string: java.lang.String | str + ) -> CertPath: ... + @typing.overload + def engineGenerateCertPath(self, list: java.util.List[Certificate]) -> CertPath: ... + def engineGenerateCertificate( + self, inputStream: java.io.InputStream + ) -> Certificate: ... + def engineGenerateCertificates( + self, inputStream: java.io.InputStream + ) -> java.util.Collection[Certificate]: ... + def engineGetCertPathEncodings(self) -> java.util.Iterator[java.lang.String]: ... + +class Extension: + def encode(self, outputStream: java.io.OutputStream) -> None: ... + def getId(self) -> java.lang.String: ... + def getValue(self) -> typing.MutableSequence[int]: ... + def isCritical(self) -> bool: ... + +class PolicyNode: + def getChildren(self) -> java.util.Iterator[PolicyNode]: ... + def getDepth(self) -> int: ... + def getExpectedPolicies(self) -> java.util.Set[java.lang.String]: ... + def getParent(self) -> PolicyNode: ... + def getPolicyQualifiers(self) -> java.util.Set[PolicyQualifierInfo]: ... + def getValidPolicy(self) -> java.lang.String: ... + def isCritical(self) -> bool: ... + +class PolicyQualifierInfo: + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + def getEncoded(self) -> typing.MutableSequence[int]: ... + def getPolicyQualifier(self) -> typing.MutableSequence[int]: ... + def getPolicyQualifierId(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class TrustAnchor: + @typing.overload + def __init__( + self, + string: java.lang.String | str, + publicKey: java.security.PublicKey, + byteArray: list[int] | jpype.JArray | bytes, + ): ... + @typing.overload + def __init__( + self, + x509Certificate: X509Certificate, + byteArray: list[int] | jpype.JArray | bytes, + ): ... + @typing.overload + def __init__( + self, + x500Principal: javax.security.auth.x500.X500Principal, + publicKey: java.security.PublicKey, + byteArray: list[int] | jpype.JArray | bytes, + ): ... + def getCA(self) -> javax.security.auth.x500.X500Principal: ... + def getCAName(self) -> java.lang.String: ... + def getCAPublicKey(self) -> java.security.PublicKey: ... + def getNameConstraints(self) -> typing.MutableSequence[int]: ... + def getTrustedCert(self) -> X509Certificate: ... + def toString(self) -> java.lang.String: ... + +class X509Extension: + def getCriticalExtensionOIDs(self) -> java.util.Set[java.lang.String]: ... + def getExtensionValue( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def getNonCriticalExtensionOIDs(self) -> java.util.Set[java.lang.String]: ... + def hasUnsupportedCriticalExtension(self) -> bool: ... + +class CertificateEncodingException(CertificateException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class CertificateExpiredException(CertificateException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class CertificateNotYetValidException(CertificateException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class CertificateParsingException(CertificateException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class CertificateRevokedException(CertificateException): + def __init__( + self, + date: java.util.Date, + cRLReason: CRLReason, + x500Principal: javax.security.auth.x500.X500Principal, + map: java.util.Map[java.lang.String | str, Extension] + | typing.Mapping[java.lang.String | str, Extension], + ): ... + def getAuthorityName(self) -> javax.security.auth.x500.X500Principal: ... + def getExtensions(self) -> java.util.Map[java.lang.String, Extension]: ... + def getInvalidityDate(self) -> java.util.Date: ... + def getMessage(self) -> java.lang.String: ... + def getRevocationDate(self) -> java.util.Date: ... + def getRevocationReason(self) -> CRLReason: ... + +class CollectionCertStoreParameters(CertStoreParameters): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ): ... + def clone(self) -> typing.Any: ... + def getCollection(self) -> java.util.Collection[typing.Any]: ... + def toString(self) -> java.lang.String: ... + +class LDAPCertStoreParameters(CertStoreParameters): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + def clone(self) -> typing.Any: ... + def getPort(self) -> int: ... + def getServerName(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class PKIXCertPathChecker(CertPathChecker, java.lang.Cloneable): + @typing.overload + def check( + self, + certificate: Certificate, + collection: java.util.Collection[java.lang.String | str] + | typing.Sequence[java.lang.String | str] + | set[java.lang.String | str], + ) -> None: ... + @typing.overload + def check(self, certificate: Certificate) -> None: ... + def clone(self) -> typing.Any: ... + def getSupportedExtensions(self) -> java.util.Set[java.lang.String]: ... + def init(self, boolean: bool) -> None: ... + def isForwardCheckingSupported(self) -> bool: ... + +class PKIXCertPathValidatorResult(CertPathValidatorResult): + def __init__( + self, + trustAnchor: TrustAnchor, + policyNode: PolicyNode, + publicKey: java.security.PublicKey, + ): ... + def clone(self) -> typing.Any: ... + def getPolicyTree(self) -> PolicyNode: ... + def getPublicKey(self) -> java.security.PublicKey: ... + def getTrustAnchor(self) -> TrustAnchor: ... + def toString(self) -> java.lang.String: ... + +class PKIXParameters(CertPathParameters): + @typing.overload + def __init__(self, keyStore: java.security.KeyStore): ... + @typing.overload + def __init__(self, set: java.util.Set[TrustAnchor]): ... + def addCertPathChecker(self, pKIXCertPathChecker: PKIXCertPathChecker) -> None: ... + def addCertStore(self, certStore: CertStore) -> None: ... + def clone(self) -> typing.Any: ... + def getCertPathCheckers(self) -> java.util.List[PKIXCertPathChecker]: ... + def getCertStores(self) -> java.util.List[CertStore]: ... + def getDate(self) -> java.util.Date: ... + def getInitialPolicies(self) -> java.util.Set[java.lang.String]: ... + def getPolicyQualifiersRejected(self) -> bool: ... + def getSigProvider(self) -> java.lang.String: ... + def getTargetCertConstraints(self) -> CertSelector: ... + def getTrustAnchors(self) -> java.util.Set[TrustAnchor]: ... + def isAnyPolicyInhibited(self) -> bool: ... + def isExplicitPolicyRequired(self) -> bool: ... + def isPolicyMappingInhibited(self) -> bool: ... + def isRevocationEnabled(self) -> bool: ... + def setAnyPolicyInhibited(self, boolean: bool) -> None: ... + def setCertPathCheckers( + self, list: java.util.List[PKIXCertPathChecker] + ) -> None: ... + def setCertStores(self, list: java.util.List[CertStore]) -> None: ... + def setDate(self, date: java.util.Date) -> None: ... + def setExplicitPolicyRequired(self, boolean: bool) -> None: ... + def setInitialPolicies( + self, set: java.util.Set[java.lang.String | str] + ) -> None: ... + def setPolicyMappingInhibited(self, boolean: bool) -> None: ... + def setPolicyQualifiersRejected(self, boolean: bool) -> None: ... + def setRevocationEnabled(self, boolean: bool) -> None: ... + def setSigProvider(self, string: java.lang.String | str) -> None: ... + def setTargetCertConstraints(self, certSelector: CertSelector) -> None: ... + def setTrustAnchors(self, set: java.util.Set[TrustAnchor]) -> None: ... + def toString(self) -> java.lang.String: ... + +class URICertStoreParameters(CertStoreParameters): + def __init__(self, uRI: java.net.URI): ... + def clone(self) -> URICertStoreParameters: ... + def equals(self, object: typing.Any) -> bool: ... + def getURI(self) -> java.net.URI: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class X509CRL(CRL, X509Extension, java.security.DEREncodable): + def equals(self, object: typing.Any) -> bool: ... + def getEncoded(self) -> typing.MutableSequence[int]: ... + def getIssuerDN(self) -> java.security.Principal: ... + def getIssuerX500Principal(self) -> javax.security.auth.x500.X500Principal: ... + def getNextUpdate(self) -> java.util.Date: ... + @typing.overload + def getRevokedCertificate( + self, bigInteger: java.math.BigInteger + ) -> X509CRLEntry: ... + @typing.overload + def getRevokedCertificate( + self, x509Certificate: X509Certificate + ) -> X509CRLEntry: ... + def getRevokedCertificates(self) -> java.util.Set[X509CRLEntry]: ... + def getSigAlgName(self) -> java.lang.String: ... + def getSigAlgOID(self) -> java.lang.String: ... + def getSigAlgParams(self) -> typing.MutableSequence[int]: ... + def getSignature(self) -> typing.MutableSequence[int]: ... + def getTBSCertList(self) -> typing.MutableSequence[int]: ... + def getThisUpdate(self) -> java.util.Date: ... + def getVersion(self) -> int: ... + def hashCode(self) -> int: ... + @typing.overload + def verify(self, publicKey: java.security.PublicKey) -> None: ... + @typing.overload + def verify( + self, publicKey: java.security.PublicKey, string: java.lang.String | str + ) -> None: ... + @typing.overload + def verify( + self, publicKey: java.security.PublicKey, provider: java.security.Provider + ) -> None: ... + +class X509CRLEntry(X509Extension): + def __init__(self): ... + def equals(self, object: typing.Any) -> bool: ... + def getCertificateIssuer(self) -> javax.security.auth.x500.X500Principal: ... + def getEncoded(self) -> typing.MutableSequence[int]: ... + def getRevocationDate(self) -> java.util.Date: ... + def getRevocationReason(self) -> CRLReason: ... + def getSerialNumber(self) -> java.math.BigInteger: ... + def hasExtensions(self) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class X509CRLSelector(CRLSelector): + def __init__(self): ... + def addIssuer( + self, x500Principal: javax.security.auth.x500.X500Principal + ) -> None: ... + @typing.overload + def addIssuerName(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def addIssuerName(self, string: java.lang.String | str) -> None: ... + def clone(self) -> typing.Any: ... + def getCertificateChecking(self) -> X509Certificate: ... + def getDateAndTime(self) -> java.util.Date: ... + def getIssuerNames(self) -> java.util.Collection[typing.Any]: ... + def getIssuers( + self, + ) -> java.util.Collection[javax.security.auth.x500.X500Principal]: ... + def getMaxCRL(self) -> java.math.BigInteger: ... + def getMinCRL(self) -> java.math.BigInteger: ... + def match(self, cRL: CRL) -> bool: ... + def setCertificateChecking(self, x509Certificate: X509Certificate) -> None: ... + def setDateAndTime(self, date: java.util.Date) -> None: ... + def setIssuerNames( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> None: ... + def setIssuers( + self, + collection: java.util.Collection[javax.security.auth.x500.X500Principal] + | typing.Sequence[javax.security.auth.x500.X500Principal] + | set[javax.security.auth.x500.X500Principal], + ) -> None: ... + def setMaxCRLNumber(self, bigInteger: java.math.BigInteger) -> None: ... + def setMinCRLNumber(self, bigInteger: java.math.BigInteger) -> None: ... + def toString(self) -> java.lang.String: ... + +class X509CertSelector(CertSelector): + def __init__(self): ... + @typing.overload + def addPathToName( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def addPathToName(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def addSubjectAlternativeName( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def addSubjectAlternativeName( + self, int: int, string: java.lang.String | str + ) -> None: ... + def clone(self) -> typing.Any: ... + def getAuthorityKeyIdentifier(self) -> typing.MutableSequence[int]: ... + def getBasicConstraints(self) -> int: ... + def getCertificate(self) -> X509Certificate: ... + def getCertificateValid(self) -> java.util.Date: ... + def getExtendedKeyUsage(self) -> java.util.Set[java.lang.String]: ... + def getIssuer(self) -> javax.security.auth.x500.X500Principal: ... + def getIssuerAsBytes(self) -> typing.MutableSequence[int]: ... + def getIssuerAsString(self) -> java.lang.String: ... + def getKeyUsage(self) -> typing.MutableSequence[bool]: ... + def getMatchAllSubjectAltNames(self) -> bool: ... + def getNameConstraints(self) -> typing.MutableSequence[int]: ... + def getPathToNames(self) -> java.util.Collection[java.util.List[typing.Any]]: ... + def getPolicy(self) -> java.util.Set[java.lang.String]: ... + def getPrivateKeyValid(self) -> java.util.Date: ... + def getSerialNumber(self) -> java.math.BigInteger: ... + def getSubject(self) -> javax.security.auth.x500.X500Principal: ... + def getSubjectAlternativeNames( + self, + ) -> java.util.Collection[java.util.List[typing.Any]]: ... + def getSubjectAsBytes(self) -> typing.MutableSequence[int]: ... + def getSubjectAsString(self) -> java.lang.String: ... + def getSubjectKeyIdentifier(self) -> typing.MutableSequence[int]: ... + def getSubjectPublicKey(self) -> java.security.PublicKey: ... + def getSubjectPublicKeyAlgID(self) -> java.lang.String: ... + def match(self, certificate: Certificate) -> bool: ... + def setAuthorityKeyIdentifier( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + def setBasicConstraints(self, int: int) -> None: ... + def setCertificate(self, x509Certificate: X509Certificate) -> None: ... + def setCertificateValid(self, date: java.util.Date) -> None: ... + def setExtendedKeyUsage( + self, set: java.util.Set[java.lang.String | str] + ) -> None: ... + @typing.overload + def setIssuer(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setIssuer(self, string: java.lang.String | str) -> None: ... + @typing.overload + def setIssuer( + self, x500Principal: javax.security.auth.x500.X500Principal + ) -> None: ... + def setKeyUsage(self, booleanArray: list[bool] | jpype.JArray) -> None: ... + def setMatchAllSubjectAltNames(self, boolean: bool) -> None: ... + def setNameConstraints( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + def setPathToNames( + self, + collection: java.util.Collection[java.util.List[typing.Any]] + | typing.Sequence[java.util.List[typing.Any]] + | set[java.util.List[typing.Any]], + ) -> None: ... + def setPolicy(self, set: java.util.Set[java.lang.String | str]) -> None: ... + def setPrivateKeyValid(self, date: java.util.Date) -> None: ... + def setSerialNumber(self, bigInteger: java.math.BigInteger) -> None: ... + @typing.overload + def setSubject(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setSubject(self, string: java.lang.String | str) -> None: ... + @typing.overload + def setSubject( + self, x500Principal: javax.security.auth.x500.X500Principal + ) -> None: ... + def setSubjectAlternativeNames( + self, + collection: java.util.Collection[java.util.List[typing.Any]] + | typing.Sequence[java.util.List[typing.Any]] + | set[java.util.List[typing.Any]], + ) -> None: ... + def setSubjectKeyIdentifier( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def setSubjectPublicKey( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def setSubjectPublicKey(self, publicKey: java.security.PublicKey) -> None: ... + def setSubjectPublicKeyAlgID(self, string: java.lang.String | str) -> None: ... + def toString(self) -> java.lang.String: ... + +class X509Certificate(Certificate, X509Extension, java.security.DEREncodable): + @typing.overload + def checkValidity(self) -> None: ... + @typing.overload + def checkValidity(self, date: java.util.Date) -> None: ... + def getBasicConstraints(self) -> int: ... + def getExtendedKeyUsage(self) -> java.util.List[java.lang.String]: ... + def getIssuerAlternativeNames( + self, + ) -> java.util.Collection[java.util.List[typing.Any]]: ... + def getIssuerDN(self) -> java.security.Principal: ... + def getIssuerUniqueID(self) -> typing.MutableSequence[bool]: ... + def getIssuerX500Principal(self) -> javax.security.auth.x500.X500Principal: ... + def getKeyUsage(self) -> typing.MutableSequence[bool]: ... + def getNotAfter(self) -> java.util.Date: ... + def getNotBefore(self) -> java.util.Date: ... + def getSerialNumber(self) -> java.math.BigInteger: ... + def getSigAlgName(self) -> java.lang.String: ... + def getSigAlgOID(self) -> java.lang.String: ... + def getSigAlgParams(self) -> typing.MutableSequence[int]: ... + def getSignature(self) -> typing.MutableSequence[int]: ... + def getSubjectAlternativeNames( + self, + ) -> java.util.Collection[java.util.List[typing.Any]]: ... + def getSubjectDN(self) -> java.security.Principal: ... + def getSubjectUniqueID(self) -> typing.MutableSequence[bool]: ... + def getSubjectX500Principal(self) -> javax.security.auth.x500.X500Principal: ... + def getTBSCertificate(self) -> typing.MutableSequence[int]: ... + def getVersion(self) -> int: ... + @typing.overload + def verify(self, publicKey: java.security.PublicKey) -> None: ... + @typing.overload + def verify( + self, publicKey: java.security.PublicKey, string: java.lang.String | str + ) -> None: ... + @typing.overload + def verify( + self, publicKey: java.security.PublicKey, provider: java.security.Provider + ) -> None: ... + +class PKIXBuilderParameters(PKIXParameters): + @typing.overload + def __init__( + self, keyStore: java.security.KeyStore, certSelector: CertSelector + ): ... + @typing.overload + def __init__(self, set: java.util.Set[TrustAnchor], certSelector: CertSelector): ... + def getMaxPathLength(self) -> int: ... + def setMaxPathLength(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class PKIXCertPathBuilderResult(PKIXCertPathValidatorResult, CertPathBuilderResult): + def __init__( + self, + certPath: CertPath, + trustAnchor: TrustAnchor, + policyNode: PolicyNode, + publicKey: java.security.PublicKey, + ): ... + def getCertPath(self) -> CertPath: ... + def toString(self) -> java.lang.String: ... + +class PKIXRevocationChecker(PKIXCertPathChecker): + def clone(self) -> PKIXRevocationChecker: ... + def getOcspExtensions(self) -> java.util.List[Extension]: ... + def getOcspResponder(self) -> java.net.URI: ... + def getOcspResponderCert(self) -> X509Certificate: ... + def getOcspResponses( + self, + ) -> java.util.Map[X509Certificate, typing.MutableSequence[int]]: ... + def getOptions(self) -> java.util.Set[PKIXRevocationChecker.Option]: ... + def getSoftFailExceptions(self) -> java.util.List[CertPathValidatorException]: ... + def setOcspExtensions(self, list: java.util.List[Extension]) -> None: ... + def setOcspResponder(self, uRI: java.net.URI) -> None: ... + def setOcspResponderCert(self, x509Certificate: X509Certificate) -> None: ... + def setOcspResponses( + self, + map: java.util.Map[X509Certificate, list[int] | jpype.JArray | bytes] + | typing.Mapping[X509Certificate, list[int] | jpype.JArray | bytes], + ) -> None: ... + def setOptions(self, set: java.util.Set[PKIXRevocationChecker.Option]) -> None: ... + class Option(java.lang.Enum["PKIXRevocationChecker.Option"]): + ONLY_END_ENTITY: typing.ClassVar[PKIXRevocationChecker.Option] = ... + PREFER_CRLS: typing.ClassVar[PKIXRevocationChecker.Option] = ... + NO_FALLBACK: typing.ClassVar[PKIXRevocationChecker.Option] = ... + SOFT_FAIL: typing.ClassVar[PKIXRevocationChecker.Option] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> PKIXRevocationChecker.Option: ... + @staticmethod + def values() -> typing.MutableSequence[PKIXRevocationChecker.Option]: ... + +class CertPathValidatorException(java.security.GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + throwable: java.lang.Throwable, + certPath: CertPath, + int: int, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + throwable: java.lang.Throwable, + certPath: CertPath, + int: int, + reason: CertPathValidatorException.Reason, + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + def getCertPath(self) -> CertPath: ... + def getIndex(self) -> int: ... + def getReason(self) -> CertPathValidatorException.Reason: ... + class BasicReason( + java.lang.Enum["CertPathValidatorException.BasicReason"], + java.security.cert.CertPathValidatorException.Reason, + ): + UNSPECIFIED: typing.ClassVar[CertPathValidatorException.BasicReason] = ... + EXPIRED: typing.ClassVar[CertPathValidatorException.BasicReason] = ... + NOT_YET_VALID: typing.ClassVar[CertPathValidatorException.BasicReason] = ... + REVOKED: typing.ClassVar[CertPathValidatorException.BasicReason] = ... + UNDETERMINED_REVOCATION_STATUS: typing.ClassVar[ + CertPathValidatorException.BasicReason + ] = ... + INVALID_SIGNATURE: typing.ClassVar[CertPathValidatorException.BasicReason] = ... + ALGORITHM_CONSTRAINED: typing.ClassVar[ + CertPathValidatorException.BasicReason + ] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> CertPathValidatorException.BasicReason: ... + @staticmethod + def values() -> typing.MutableSequence[ + CertPathValidatorException.BasicReason + ]: ... + + class Reason(java.io.Serializable): ... + +class PKIXReason(java.lang.Enum["PKIXReason"], CertPathValidatorException.Reason): + NAME_CHAINING: typing.ClassVar[PKIXReason] = ... + INVALID_KEY_USAGE: typing.ClassVar[PKIXReason] = ... + INVALID_POLICY: typing.ClassVar[PKIXReason] = ... + NO_TRUST_ANCHOR: typing.ClassVar[PKIXReason] = ... + UNRECOGNIZED_CRIT_EXT: typing.ClassVar[PKIXReason] = ... + NOT_CA_CERT: typing.ClassVar[PKIXReason] = ... + PATH_TOO_LONG: typing.ClassVar[PKIXReason] = ... + INVALID_NAME: typing.ClassVar[PKIXReason] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> PKIXReason: ... + @staticmethod + def values() -> typing.MutableSequence[PKIXReason]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.security.cert")``. + + CRL: type[CRL] + CRLException: type[CRLException] + CRLReason: type[CRLReason] + CRLSelector: type[CRLSelector] + CertPath: type[CertPath] + CertPathBuilder: type[CertPathBuilder] + CertPathBuilderException: type[CertPathBuilderException] + CertPathBuilderResult: type[CertPathBuilderResult] + CertPathBuilderSpi: type[CertPathBuilderSpi] + CertPathChecker: type[CertPathChecker] + CertPathParameters: type[CertPathParameters] + CertPathValidator: type[CertPathValidator] + CertPathValidatorException: type[CertPathValidatorException] + CertPathValidatorResult: type[CertPathValidatorResult] + CertPathValidatorSpi: type[CertPathValidatorSpi] + CertSelector: type[CertSelector] + CertStore: type[CertStore] + CertStoreException: type[CertStoreException] + CertStoreParameters: type[CertStoreParameters] + CertStoreSpi: type[CertStoreSpi] + Certificate: type[Certificate] + CertificateEncodingException: type[CertificateEncodingException] + CertificateException: type[CertificateException] + CertificateExpiredException: type[CertificateExpiredException] + CertificateFactory: type[CertificateFactory] + CertificateFactorySpi: type[CertificateFactorySpi] + CertificateNotYetValidException: type[CertificateNotYetValidException] + CertificateParsingException: type[CertificateParsingException] + CertificateRevokedException: type[CertificateRevokedException] + CollectionCertStoreParameters: type[CollectionCertStoreParameters] + Extension: type[Extension] + LDAPCertStoreParameters: type[LDAPCertStoreParameters] + PKIXBuilderParameters: type[PKIXBuilderParameters] + PKIXCertPathBuilderResult: type[PKIXCertPathBuilderResult] + PKIXCertPathChecker: type[PKIXCertPathChecker] + PKIXCertPathValidatorResult: type[PKIXCertPathValidatorResult] + PKIXParameters: type[PKIXParameters] + PKIXReason: type[PKIXReason] + PKIXRevocationChecker: type[PKIXRevocationChecker] + PolicyNode: type[PolicyNode] + PolicyQualifierInfo: type[PolicyQualifierInfo] + TrustAnchor: type[TrustAnchor] + URICertStoreParameters: type[URICertStoreParameters] + X509CRL: type[X509CRL] + X509CRLEntry: type[X509CRLEntry] + X509CRLSelector: type[X509CRLSelector] + X509CertSelector: type[X509CertSelector] + X509Certificate: type[X509Certificate] + X509Extension: type[X509Extension] diff --git a/typings/java/security/interfaces/__init__.pyi b/typings/java/security/interfaces/__init__.pyi new file mode 100644 index 0000000..24a2711 --- /dev/null +++ b/typings/java/security/interfaces/__init__.pyi @@ -0,0 +1,128 @@ +import typing +from typing import Protocol + +import java.math +import java.security +import java.security.spec +import java.util + +class DSAKey: + def getParams(self) -> DSAParams: ... + +class DSAKeyPairGenerator: + @typing.overload + def initialize( + self, int: int, boolean: bool, secureRandom: java.security.SecureRandom + ) -> None: ... + @typing.overload + def initialize( + self, dSAParams: DSAParams, secureRandom: java.security.SecureRandom + ) -> None: ... + +class DSAParams(java.security.spec.AlgorithmParameterSpec): + def getG(self) -> java.math.BigInteger: ... + def getP(self) -> java.math.BigInteger: ... + def getQ(self) -> java.math.BigInteger: ... + +class ECKey: + def getParams(self) -> java.security.spec.ECParameterSpec: ... + +class EdECKey: + def getParams(self) -> java.security.spec.NamedParameterSpec: ... + +class RSAKey: + def getModulus(self) -> java.math.BigInteger: ... + def getParams(self) -> java.security.spec.AlgorithmParameterSpec: ... + +class XECKey: + def getParams(self) -> java.security.spec.AlgorithmParameterSpec: ... + +class DSAPrivateKey(DSAKey, java.security.PrivateKey): + serialVersionUID: typing.ClassVar[int] = ... + def getParams(self) -> DSAParams: ... + def getX(self) -> java.math.BigInteger: ... + +class DSAPublicKey(DSAKey, java.security.PublicKey): + serialVersionUID: typing.ClassVar[int] = ... + def getParams(self) -> DSAParams: ... + def getY(self) -> java.math.BigInteger: ... + +class ECPrivateKey(java.security.PrivateKey, ECKey): + serialVersionUID: typing.ClassVar[int] = ... + def getParams(self) -> java.security.spec.ECParameterSpec: ... + def getS(self) -> java.math.BigInteger: ... + +class ECPublicKey(java.security.PublicKey, ECKey): + serialVersionUID: typing.ClassVar[int] = ... + def getParams(self) -> java.security.spec.ECParameterSpec: ... + def getW(self) -> java.security.spec.ECPoint: ... + +class EdECPrivateKey(EdECKey, java.security.PrivateKey): + def getBytes(self) -> java.util.Optional[typing.MutableSequence[int]]: ... + def getParams(self) -> java.security.spec.NamedParameterSpec: ... + +class EdECPublicKey(EdECKey, java.security.PublicKey): + def getParams(self) -> java.security.spec.NamedParameterSpec: ... + def getPoint(self) -> java.security.spec.EdECPoint: ... + +class RSAPrivateKey(java.security.PrivateKey, RSAKey): + serialVersionUID: typing.ClassVar[int] = ... + def getParams(self) -> java.security.spec.AlgorithmParameterSpec: ... + def getPrivateExponent(self) -> java.math.BigInteger: ... + +class RSAPublicKey(java.security.PublicKey, RSAKey): + serialVersionUID: typing.ClassVar[int] = ... + def getParams(self) -> java.security.spec.AlgorithmParameterSpec: ... + def getPublicExponent(self) -> java.math.BigInteger: ... + +class XECPrivateKey(XECKey, java.security.PrivateKey): + def getParams(self) -> java.security.spec.AlgorithmParameterSpec: ... + def getScalar(self) -> java.util.Optional[typing.MutableSequence[int]]: ... + +class XECPublicKey(XECKey, java.security.PublicKey): + def getParams(self) -> java.security.spec.AlgorithmParameterSpec: ... + def getU(self) -> java.math.BigInteger: ... + +class RSAMultiPrimePrivateCrtKey(RSAPrivateKey): + serialVersionUID: typing.ClassVar[int] = ... + def getCrtCoefficient(self) -> java.math.BigInteger: ... + def getOtherPrimeInfo( + self, + ) -> typing.MutableSequence[java.security.spec.RSAOtherPrimeInfo]: ... + def getPrimeExponentP(self) -> java.math.BigInteger: ... + def getPrimeExponentQ(self) -> java.math.BigInteger: ... + def getPrimeP(self) -> java.math.BigInteger: ... + def getPrimeQ(self) -> java.math.BigInteger: ... + def getPublicExponent(self) -> java.math.BigInteger: ... + +class RSAPrivateCrtKey(RSAPrivateKey): + serialVersionUID: typing.ClassVar[int] = ... + def getCrtCoefficient(self) -> java.math.BigInteger: ... + def getPrimeExponentP(self) -> java.math.BigInteger: ... + def getPrimeExponentQ(self) -> java.math.BigInteger: ... + def getPrimeP(self) -> java.math.BigInteger: ... + def getPrimeQ(self) -> java.math.BigInteger: ... + def getPublicExponent(self) -> java.math.BigInteger: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.security.interfaces")``. + + DSAKey: type[DSAKey] + DSAKeyPairGenerator: type[DSAKeyPairGenerator] + DSAParams: type[DSAParams] + DSAPrivateKey: type[DSAPrivateKey] + DSAPublicKey: type[DSAPublicKey] + ECKey: type[ECKey] + ECPrivateKey: type[ECPrivateKey] + ECPublicKey: type[ECPublicKey] + EdECKey: type[EdECKey] + EdECPrivateKey: type[EdECPrivateKey] + EdECPublicKey: type[EdECPublicKey] + RSAKey: type[RSAKey] + RSAMultiPrimePrivateCrtKey: type[RSAMultiPrimePrivateCrtKey] + RSAPrivateCrtKey: type[RSAPrivateCrtKey] + RSAPrivateKey: type[RSAPrivateKey] + RSAPublicKey: type[RSAPublicKey] + XECKey: type[XECKey] + XECPrivateKey: type[XECPrivateKey] + XECPublicKey: type[XECPublicKey] diff --git a/typings/java/security/spec/__init__.pyi b/typings/java/security/spec/__init__.pyi new file mode 100644 index 0000000..5af36a0 --- /dev/null +++ b/typings/java/security/spec/__init__.pyi @@ -0,0 +1,457 @@ +import typing +from typing import Protocol + +import java.lang +import java.math +import java.security +import java.security.interfaces +import java.util +import jpype + +class AlgorithmParameterSpec: ... + +class ECField: + def getFieldSize(self) -> int: ... + +class ECPoint: + POINT_INFINITY: typing.ClassVar[ECPoint] = ... + def __init__( + self, bigInteger: java.math.BigInteger, bigInteger2: java.math.BigInteger + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getAffineX(self) -> java.math.BigInteger: ... + def getAffineY(self) -> java.math.BigInteger: ... + def hashCode(self) -> int: ... + +class EdECPoint: + def __init__(self, boolean: bool, bigInteger: java.math.BigInteger): ... + def getY(self) -> java.math.BigInteger: ... + def isXOdd(self) -> bool: ... + +class EllipticCurve: + @typing.overload + def __init__( + self, + eCField: ECField | typing.Callable, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + ): ... + @typing.overload + def __init__( + self, + eCField: ECField | typing.Callable, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + byteArray: list[int] | jpype.JArray | bytes, + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getA(self) -> java.math.BigInteger: ... + def getB(self) -> java.math.BigInteger: ... + def getField(self) -> ECField: ... + def getSeed(self) -> typing.MutableSequence[int]: ... + def hashCode(self) -> int: ... + +class InvalidKeySpecException(java.security.GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class InvalidParameterSpecException(java.security.GeneralSecurityException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class KeySpec: ... + +class RSAOtherPrimeInfo: + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + bigInteger3: java.math.BigInteger, + ): ... + def getCrtCoefficient(self) -> java.math.BigInteger: ... + def getExponent(self) -> java.math.BigInteger: ... + def getPrime(self) -> java.math.BigInteger: ... + +class DSAGenParameterSpec(AlgorithmParameterSpec): + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int): ... + def getPrimePLength(self) -> int: ... + def getSeedLength(self) -> int: ... + def getSubprimeQLength(self) -> int: ... + +class DSAParameterSpec(AlgorithmParameterSpec, java.security.interfaces.DSAParams): + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + bigInteger3: java.math.BigInteger, + ): ... + def getG(self) -> java.math.BigInteger: ... + def getP(self) -> java.math.BigInteger: ... + def getQ(self) -> java.math.BigInteger: ... + +class DSAPrivateKeySpec(KeySpec): + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + bigInteger3: java.math.BigInteger, + bigInteger4: java.math.BigInteger, + ): ... + def getG(self) -> java.math.BigInteger: ... + def getP(self) -> java.math.BigInteger: ... + def getQ(self) -> java.math.BigInteger: ... + def getX(self) -> java.math.BigInteger: ... + +class DSAPublicKeySpec(KeySpec): + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + bigInteger3: java.math.BigInteger, + bigInteger4: java.math.BigInteger, + ): ... + def getG(self) -> java.math.BigInteger: ... + def getP(self) -> java.math.BigInteger: ... + def getQ(self) -> java.math.BigInteger: ... + def getY(self) -> java.math.BigInteger: ... + +class ECFieldF2m(ECField): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, intArray: list[int] | jpype.JArray): ... + @typing.overload + def __init__(self, int: int, bigInteger: java.math.BigInteger): ... + def equals(self, object: typing.Any) -> bool: ... + def getFieldSize(self) -> int: ... + def getM(self) -> int: ... + def getMidTermsOfReductionPolynomial(self) -> typing.MutableSequence[int]: ... + def getReductionPolynomial(self) -> java.math.BigInteger: ... + def hashCode(self) -> int: ... + +class ECFieldFp(ECField): + def __init__(self, bigInteger: java.math.BigInteger): ... + def equals(self, object: typing.Any) -> bool: ... + def getFieldSize(self) -> int: ... + def getP(self) -> java.math.BigInteger: ... + def hashCode(self) -> int: ... + +class ECParameterSpec(AlgorithmParameterSpec): + def __init__( + self, + ellipticCurve: EllipticCurve, + eCPoint: ECPoint, + bigInteger: java.math.BigInteger, + int: int, + ): ... + def getCofactor(self) -> int: ... + def getCurve(self) -> EllipticCurve: ... + def getGenerator(self) -> ECPoint: ... + def getOrder(self) -> java.math.BigInteger: ... + +class ECPrivateKeySpec(KeySpec): + def __init__( + self, bigInteger: java.math.BigInteger, eCParameterSpec: ECParameterSpec + ): ... + def getParams(self) -> ECParameterSpec: ... + def getS(self) -> java.math.BigInteger: ... + +class ECPublicKeySpec(KeySpec): + def __init__(self, eCPoint: ECPoint, eCParameterSpec: ECParameterSpec): ... + def getParams(self) -> ECParameterSpec: ... + def getW(self) -> ECPoint: ... + +class EdDSAParameterSpec(AlgorithmParameterSpec): + @typing.overload + def __init__(self, boolean: bool): ... + @typing.overload + def __init__(self, boolean: bool, byteArray: list[int] | jpype.JArray | bytes): ... + def getContext(self) -> java.util.Optional[typing.MutableSequence[int]]: ... + def isPrehash(self) -> bool: ... + +class EdECPrivateKeySpec(KeySpec): + def __init__( + self, + namedParameterSpec: NamedParameterSpec, + byteArray: list[int] | jpype.JArray | bytes, + ): ... + def getBytes(self) -> typing.MutableSequence[int]: ... + def getParams(self) -> NamedParameterSpec: ... + +class EdECPublicKeySpec(KeySpec): + def __init__( + self, namedParameterSpec: NamedParameterSpec, edECPoint: EdECPoint + ): ... + def getParams(self) -> NamedParameterSpec: ... + def getPoint(self) -> EdECPoint: ... + +class EncodedKeySpec(KeySpec): + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + def getAlgorithm(self) -> java.lang.String: ... + def getEncoded(self) -> typing.MutableSequence[int]: ... + def getFormat(self) -> java.lang.String: ... + +class MGF1ParameterSpec(AlgorithmParameterSpec): + SHA1: typing.ClassVar[MGF1ParameterSpec] = ... + SHA224: typing.ClassVar[MGF1ParameterSpec] = ... + SHA256: typing.ClassVar[MGF1ParameterSpec] = ... + SHA384: typing.ClassVar[MGF1ParameterSpec] = ... + SHA512: typing.ClassVar[MGF1ParameterSpec] = ... + SHA512_224: typing.ClassVar[MGF1ParameterSpec] = ... + SHA512_256: typing.ClassVar[MGF1ParameterSpec] = ... + SHA3_224: typing.ClassVar[MGF1ParameterSpec] = ... + SHA3_256: typing.ClassVar[MGF1ParameterSpec] = ... + SHA3_384: typing.ClassVar[MGF1ParameterSpec] = ... + SHA3_512: typing.ClassVar[MGF1ParameterSpec] = ... + def __init__(self, string: java.lang.String | str): ... + def getDigestAlgorithm(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class NamedParameterSpec(AlgorithmParameterSpec): + X25519: typing.ClassVar[NamedParameterSpec] = ... + X448: typing.ClassVar[NamedParameterSpec] = ... + ED25519: typing.ClassVar[NamedParameterSpec] = ... + ED448: typing.ClassVar[NamedParameterSpec] = ... + ML_DSA_44: typing.ClassVar[NamedParameterSpec] = ... + ML_DSA_65: typing.ClassVar[NamedParameterSpec] = ... + ML_DSA_87: typing.ClassVar[NamedParameterSpec] = ... + ML_KEM_512: typing.ClassVar[NamedParameterSpec] = ... + ML_KEM_768: typing.ClassVar[NamedParameterSpec] = ... + ML_KEM_1024: typing.ClassVar[NamedParameterSpec] = ... + def __init__(self, string: java.lang.String | str): ... + def getName(self) -> java.lang.String: ... + +class PSSParameterSpec(AlgorithmParameterSpec): + TRAILER_FIELD_BC: typing.ClassVar[int] = ... + DEFAULT: typing.ClassVar[PSSParameterSpec] = ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + algorithmParameterSpec: AlgorithmParameterSpec, + int: int, + int2: int, + ): ... + def getDigestAlgorithm(self) -> java.lang.String: ... + def getMGFAlgorithm(self) -> java.lang.String: ... + def getMGFParameters(self) -> AlgorithmParameterSpec: ... + def getSaltLength(self) -> int: ... + def getTrailerField(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class RSAKeyGenParameterSpec(AlgorithmParameterSpec): + F0: typing.ClassVar[java.math.BigInteger] = ... + F4: typing.ClassVar[java.math.BigInteger] = ... + @typing.overload + def __init__(self, int: int, bigInteger: java.math.BigInteger): ... + @typing.overload + def __init__( + self, + int: int, + bigInteger: java.math.BigInteger, + algorithmParameterSpec: AlgorithmParameterSpec, + ): ... + def getKeyParams(self) -> AlgorithmParameterSpec: ... + def getKeysize(self) -> int: ... + def getPublicExponent(self) -> java.math.BigInteger: ... + +class RSAPrivateKeySpec(KeySpec): + @typing.overload + def __init__( + self, bigInteger: java.math.BigInteger, bigInteger2: java.math.BigInteger + ): ... + @typing.overload + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + algorithmParameterSpec: AlgorithmParameterSpec, + ): ... + def getModulus(self) -> java.math.BigInteger: ... + def getParams(self) -> AlgorithmParameterSpec: ... + def getPrivateExponent(self) -> java.math.BigInteger: ... + +class RSAPublicKeySpec(KeySpec): + @typing.overload + def __init__( + self, bigInteger: java.math.BigInteger, bigInteger2: java.math.BigInteger + ): ... + @typing.overload + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + algorithmParameterSpec: AlgorithmParameterSpec, + ): ... + def getModulus(self) -> java.math.BigInteger: ... + def getParams(self) -> AlgorithmParameterSpec: ... + def getPublicExponent(self) -> java.math.BigInteger: ... + +class XECPrivateKeySpec(KeySpec): + def __init__( + self, + algorithmParameterSpec: AlgorithmParameterSpec, + byteArray: list[int] | jpype.JArray | bytes, + ): ... + def getParams(self) -> AlgorithmParameterSpec: ... + def getScalar(self) -> typing.MutableSequence[int]: ... + +class XECPublicKeySpec(KeySpec): + def __init__( + self, + algorithmParameterSpec: AlgorithmParameterSpec, + bigInteger: java.math.BigInteger, + ): ... + def getParams(self) -> AlgorithmParameterSpec: ... + def getU(self) -> java.math.BigInteger: ... + +class ECGenParameterSpec(NamedParameterSpec): + def __init__(self, string: java.lang.String | str): ... + +class PKCS8EncodedKeySpec(EncodedKeySpec, java.security.DEREncodable): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + string: java.lang.String | str, + ): ... + def getEncoded(self) -> typing.MutableSequence[int]: ... + def getFormat(self) -> java.lang.String: ... + +class RSAMultiPrimePrivateCrtKeySpec(RSAPrivateKeySpec): + @typing.overload + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + bigInteger3: java.math.BigInteger, + bigInteger4: java.math.BigInteger, + bigInteger5: java.math.BigInteger, + bigInteger6: java.math.BigInteger, + bigInteger7: java.math.BigInteger, + bigInteger8: java.math.BigInteger, + rSAOtherPrimeInfoArray: list[RSAOtherPrimeInfo] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + bigInteger3: java.math.BigInteger, + bigInteger4: java.math.BigInteger, + bigInteger5: java.math.BigInteger, + bigInteger6: java.math.BigInteger, + bigInteger7: java.math.BigInteger, + bigInteger8: java.math.BigInteger, + rSAOtherPrimeInfoArray: list[RSAOtherPrimeInfo] | jpype.JArray, + algorithmParameterSpec: AlgorithmParameterSpec, + ): ... + def getCrtCoefficient(self) -> java.math.BigInteger: ... + def getOtherPrimeInfo(self) -> typing.MutableSequence[RSAOtherPrimeInfo]: ... + def getPrimeExponentP(self) -> java.math.BigInteger: ... + def getPrimeExponentQ(self) -> java.math.BigInteger: ... + def getPrimeP(self) -> java.math.BigInteger: ... + def getPrimeQ(self) -> java.math.BigInteger: ... + def getPublicExponent(self) -> java.math.BigInteger: ... + +class RSAPrivateCrtKeySpec(RSAPrivateKeySpec): + @typing.overload + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + bigInteger3: java.math.BigInteger, + bigInteger4: java.math.BigInteger, + bigInteger5: java.math.BigInteger, + bigInteger6: java.math.BigInteger, + bigInteger7: java.math.BigInteger, + bigInteger8: java.math.BigInteger, + ): ... + @typing.overload + def __init__( + self, + bigInteger: java.math.BigInteger, + bigInteger2: java.math.BigInteger, + bigInteger3: java.math.BigInteger, + bigInteger4: java.math.BigInteger, + bigInteger5: java.math.BigInteger, + bigInteger6: java.math.BigInteger, + bigInteger7: java.math.BigInteger, + bigInteger8: java.math.BigInteger, + algorithmParameterSpec: AlgorithmParameterSpec, + ): ... + def getCrtCoefficient(self) -> java.math.BigInteger: ... + def getPrimeExponentP(self) -> java.math.BigInteger: ... + def getPrimeExponentQ(self) -> java.math.BigInteger: ... + def getPrimeP(self) -> java.math.BigInteger: ... + def getPrimeQ(self) -> java.math.BigInteger: ... + def getPublicExponent(self) -> java.math.BigInteger: ... + +class X509EncodedKeySpec(EncodedKeySpec, java.security.DEREncodable): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__( + self, + byteArray: list[int] | jpype.JArray | bytes, + string: java.lang.String | str, + ): ... + def getEncoded(self) -> typing.MutableSequence[int]: ... + def getFormat(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.security.spec")``. + + AlgorithmParameterSpec: type[AlgorithmParameterSpec] + DSAGenParameterSpec: type[DSAGenParameterSpec] + DSAParameterSpec: type[DSAParameterSpec] + DSAPrivateKeySpec: type[DSAPrivateKeySpec] + DSAPublicKeySpec: type[DSAPublicKeySpec] + ECField: type[ECField] + ECFieldF2m: type[ECFieldF2m] + ECFieldFp: type[ECFieldFp] + ECGenParameterSpec: type[ECGenParameterSpec] + ECParameterSpec: type[ECParameterSpec] + ECPoint: type[ECPoint] + ECPrivateKeySpec: type[ECPrivateKeySpec] + ECPublicKeySpec: type[ECPublicKeySpec] + EdDSAParameterSpec: type[EdDSAParameterSpec] + EdECPoint: type[EdECPoint] + EdECPrivateKeySpec: type[EdECPrivateKeySpec] + EdECPublicKeySpec: type[EdECPublicKeySpec] + EllipticCurve: type[EllipticCurve] + EncodedKeySpec: type[EncodedKeySpec] + InvalidKeySpecException: type[InvalidKeySpecException] + InvalidParameterSpecException: type[InvalidParameterSpecException] + KeySpec: type[KeySpec] + MGF1ParameterSpec: type[MGF1ParameterSpec] + NamedParameterSpec: type[NamedParameterSpec] + PKCS8EncodedKeySpec: type[PKCS8EncodedKeySpec] + PSSParameterSpec: type[PSSParameterSpec] + RSAKeyGenParameterSpec: type[RSAKeyGenParameterSpec] + RSAMultiPrimePrivateCrtKeySpec: type[RSAMultiPrimePrivateCrtKeySpec] + RSAOtherPrimeInfo: type[RSAOtherPrimeInfo] + RSAPrivateCrtKeySpec: type[RSAPrivateCrtKeySpec] + RSAPrivateKeySpec: type[RSAPrivateKeySpec] + RSAPublicKeySpec: type[RSAPublicKeySpec] + X509EncodedKeySpec: type[X509EncodedKeySpec] + XECPrivateKeySpec: type[XECPrivateKeySpec] + XECPublicKeySpec: type[XECPublicKeySpec] diff --git a/typings/java/sql/__init__.pyi b/typings/java/sql/__init__.pyi new file mode 100644 index 0000000..9d85f25 --- /dev/null +++ b/typings/java/sql/__init__.pyi @@ -0,0 +1,3096 @@ +import datetime +import decimal +import typing +from typing import Protocol + +import java.io +import java.lang +import java.math +import java.net +import java.security +import java.time +import java.util +import java.util.concurrent +import java.util.logging +import java.util.stream +import javax.xml.transform +import jpype +from jpype.protocol import _JDate, _JSQLDate, _JSQLTime + +class Array: + def free(self) -> None: ... + @typing.overload + def getArray(self) -> typing.Any: ... + @typing.overload + def getArray( + self, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> typing.Any: ... + @typing.overload + def getArray(self, long: int, int: int) -> typing.Any: ... + @typing.overload + def getArray( + self, + long: int, + int: int, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> typing.Any: ... + def getBaseType(self) -> int: ... + def getBaseTypeName(self) -> java.lang.String: ... + @typing.overload + def getResultSet(self) -> ResultSet: ... + @typing.overload + def getResultSet( + self, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> ResultSet: ... + @typing.overload + def getResultSet(self, long: int, int: int) -> ResultSet: ... + @typing.overload + def getResultSet( + self, + long: int, + int: int, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> ResultSet: ... + +class Blob: + def free(self) -> None: ... + @typing.overload + def getBinaryStream(self) -> java.io.InputStream: ... + @typing.overload + def getBinaryStream(self, long: int, long2: int) -> java.io.InputStream: ... + def getBytes(self, long: int, int: int) -> typing.MutableSequence[int]: ... + def length(self) -> int: ... + @typing.overload + def position( + self, byteArray: list[int] | jpype.JArray | bytes, long: int + ) -> int: ... + @typing.overload + def position(self, blob: Blob, long: int) -> int: ... + def setBinaryStream(self, long: int) -> java.io.OutputStream: ... + @typing.overload + def setBytes( + self, long: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + @typing.overload + def setBytes( + self, + long: int, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + ) -> int: ... + def truncate(self, long: int) -> None: ... + +class ClientInfoStatus(java.lang.Enum["ClientInfoStatus"]): + REASON_UNKNOWN: typing.ClassVar[ClientInfoStatus] = ... + REASON_UNKNOWN_PROPERTY: typing.ClassVar[ClientInfoStatus] = ... + REASON_VALUE_INVALID: typing.ClassVar[ClientInfoStatus] = ... + REASON_VALUE_TRUNCATED: typing.ClassVar[ClientInfoStatus] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ClientInfoStatus: ... + @staticmethod + def values() -> typing.MutableSequence[ClientInfoStatus]: ... + +class Clob: + def free(self) -> None: ... + def getAsciiStream(self) -> java.io.InputStream: ... + @typing.overload + def getCharacterStream(self) -> java.io.Reader: ... + @typing.overload + def getCharacterStream(self, long: int, long2: int) -> java.io.Reader: ... + def getSubString(self, long: int, int: int) -> java.lang.String: ... + def length(self) -> int: ... + @typing.overload + def position(self, string: java.lang.String | str, long: int) -> int: ... + @typing.overload + def position(self, clob: Clob, long: int) -> int: ... + def setAsciiStream(self, long: int) -> java.io.OutputStream: ... + def setCharacterStream(self, long: int) -> java.io.Writer: ... + @typing.overload + def setString(self, long: int, string: java.lang.String | str) -> int: ... + @typing.overload + def setString( + self, long: int, string: java.lang.String | str, int: int, int2: int + ) -> int: ... + def truncate(self, long: int) -> None: ... + +class ConnectionBuilder: + def build(self) -> Connection: ... + def password(self, string: java.lang.String | str) -> ConnectionBuilder: ... + def shardingKey(self, shardingKey: ShardingKey) -> ConnectionBuilder: ... + def superShardingKey(self, shardingKey: ShardingKey) -> ConnectionBuilder: ... + def user(self, string: java.lang.String | str) -> ConnectionBuilder: ... + +class Date(java.util.Date, _JSQLDate): + @typing.overload + def __init__(self, int: int, int2: int, int3: int): ... + @typing.overload + def __init__(self, long: int): ... + def getHours(self) -> int: ... + def getMinutes(self) -> int: ... + def getSeconds(self) -> int: ... + def setHours(self, int: int) -> None: ... + def setMinutes(self, int: int) -> None: ... + def setSeconds(self, int: int) -> None: ... + def setTime(self, long: int) -> None: ... + def toInstant(self) -> java.time.Instant: ... + def toLocalDate(self) -> java.time.LocalDate: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Date: ... + @typing.overload + @staticmethod + def valueOf(localDate: java.time.LocalDate) -> Date: ... + +class Driver: + def acceptsURL(self, string: java.lang.String | str) -> bool: ... + def connect( + self, string: java.lang.String | str, properties: java.util.Properties + ) -> Connection: ... + def getMajorVersion(self) -> int: ... + def getMinorVersion(self) -> int: ... + def getParentLogger(self) -> java.util.logging.Logger: ... + def getPropertyInfo( + self, string: java.lang.String | str, properties: java.util.Properties + ) -> typing.MutableSequence[DriverPropertyInfo]: ... + def jdbcCompliant(self) -> bool: ... + +class DriverAction: + def deregister(self) -> None: ... + +class DriverManager: + @staticmethod + def deregisterDriver(driver: Driver) -> None: ... + @staticmethod + def drivers() -> java.util.stream.Stream[Driver]: ... + @typing.overload + @staticmethod + def getConnection(string: java.lang.String | str) -> Connection: ... + @typing.overload + @staticmethod + def getConnection( + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> Connection: ... + @typing.overload + @staticmethod + def getConnection( + string: java.lang.String | str, properties: java.util.Properties + ) -> Connection: ... + @staticmethod + def getDriver(string: java.lang.String | str) -> Driver: ... + @staticmethod + def getDrivers() -> java.util.Enumeration[Driver]: ... + @staticmethod + def getLogStream() -> java.io.PrintStream: ... + @staticmethod + def getLogWriter() -> java.io.PrintWriter: ... + @staticmethod + def getLoginTimeout() -> int: ... + @staticmethod + def println(string: java.lang.String | str) -> None: ... + @typing.overload + @staticmethod + def registerDriver(driver: Driver) -> None: ... + @typing.overload + @staticmethod + def registerDriver( + driver: Driver, driverAction: DriverAction | typing.Callable + ) -> None: ... + @staticmethod + def setLogStream(printStream: java.io.PrintStream) -> None: ... + @staticmethod + def setLogWriter(printWriter: java.io.PrintWriter) -> None: ... + @staticmethod + def setLoginTimeout(int: int) -> None: ... + +class DriverPropertyInfo: + name: java.lang.String = ... + description: java.lang.String = ... + required: bool = ... + value: java.lang.String = ... + choices: typing.MutableSequence[java.lang.String] = ... + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class PseudoColumnUsage(java.lang.Enum["PseudoColumnUsage"]): + SELECT_LIST_ONLY: typing.ClassVar[PseudoColumnUsage] = ... + WHERE_CLAUSE_ONLY: typing.ClassVar[PseudoColumnUsage] = ... + NO_USAGE_RESTRICTIONS: typing.ClassVar[PseudoColumnUsage] = ... + USAGE_UNKNOWN: typing.ClassVar[PseudoColumnUsage] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> PseudoColumnUsage: ... + @staticmethod + def values() -> typing.MutableSequence[PseudoColumnUsage]: ... + +class Ref: + def getBaseTypeName(self) -> java.lang.String: ... + @typing.overload + def getObject(self) -> typing.Any: ... + @typing.overload + def getObject( + self, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> typing.Any: ... + def setObject(self, object: typing.Any) -> None: ... + +class RowId: + def equals(self, object: typing.Any) -> bool: ... + def getBytes(self) -> typing.MutableSequence[int]: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class RowIdLifetime(java.lang.Enum["RowIdLifetime"]): + ROWID_UNSUPPORTED: typing.ClassVar[RowIdLifetime] = ... + ROWID_VALID_OTHER: typing.ClassVar[RowIdLifetime] = ... + ROWID_VALID_SESSION: typing.ClassVar[RowIdLifetime] = ... + ROWID_VALID_TRANSACTION: typing.ClassVar[RowIdLifetime] = ... + ROWID_VALID_FOREVER: typing.ClassVar[RowIdLifetime] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> RowIdLifetime: ... + @staticmethod + def values() -> typing.MutableSequence[RowIdLifetime]: ... + +class SQLData: + def getSQLTypeName(self) -> java.lang.String: ... + def readSQL(self, sQLInput: SQLInput, string: java.lang.String | str) -> None: ... + def writeSQL(self, sQLOutput: SQLOutput) -> None: ... + +class SQLException(java.lang.Exception, java.lang.Iterable[java.lang.Throwable]): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + def getErrorCode(self) -> int: ... + def getNextException(self) -> SQLException: ... + def getSQLState(self) -> java.lang.String: ... + def iterator(self) -> java.util.Iterator[java.lang.Throwable]: ... + def setNextException(self, sQLException: SQLException) -> None: ... + +class SQLInput: + def readArray(self) -> Array: ... + def readAsciiStream(self) -> java.io.InputStream: ... + def readBigDecimal(self) -> java.math.BigDecimal: ... + def readBinaryStream(self) -> java.io.InputStream: ... + def readBlob(self) -> Blob: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readBytes(self) -> typing.MutableSequence[int]: ... + def readCharacterStream(self) -> java.io.Reader: ... + def readClob(self) -> Clob: ... + def readDate(self) -> Date: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + def readInt(self) -> int: ... + def readLong(self) -> int: ... + def readNClob(self) -> NClob: ... + def readNString(self) -> java.lang.String: ... + _readObject_1__T = typing.TypeVar("_readObject_1__T") # + @typing.overload + def readObject(self) -> typing.Any: ... + @typing.overload + def readObject(self, class_: type[_readObject_1__T]) -> _readObject_1__T: ... + def readRef(self) -> Ref: ... + def readRowId(self) -> RowId: ... + def readSQLXML(self) -> SQLXML: ... + def readShort(self) -> int: ... + def readString(self) -> java.lang.String: ... + def readTime(self) -> Time: ... + def readTimestamp(self) -> Timestamp: ... + def readURL(self) -> java.net.URL: ... + def wasNull(self) -> bool: ... + +class SQLOutput: + def writeArray(self, array: Array) -> None: ... + def writeAsciiStream(self, inputStream: java.io.InputStream) -> None: ... + def writeBigDecimal( + self, bigDecimal: java.math.BigDecimal | decimal.Decimal + ) -> None: ... + def writeBinaryStream(self, inputStream: java.io.InputStream) -> None: ... + def writeBlob(self, blob: Blob) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, byte: int) -> None: ... + def writeBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def writeCharacterStream(self, reader: java.io.Reader) -> None: ... + def writeClob(self, clob: Clob) -> None: ... + def writeDate(self, date: Date | datetime.date) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeNClob(self, nClob: NClob) -> None: ... + def writeNString(self, string: java.lang.String | str) -> None: ... + @typing.overload + def writeObject(self, sQLData: SQLData) -> None: ... + @typing.overload + def writeObject(self, object: typing.Any, sQLType: SQLType) -> None: ... + def writeRef(self, ref: Ref) -> None: ... + def writeRowId(self, rowId: RowId | typing.Callable) -> None: ... + def writeSQLXML(self, sQLXML: SQLXML) -> None: ... + def writeShort(self, short: int) -> None: ... + def writeString(self, string: java.lang.String | str) -> None: ... + def writeStruct(self, struct: Struct) -> None: ... + def writeTime(self, time: Time | datetime.time) -> None: ... + def writeTimestamp(self, timestamp: Timestamp | datetime.datetime) -> None: ... + def writeURL(self, uRL: java.net.URL) -> None: ... + +class SQLPermission(java.security.BasicPermission): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class SQLType: + def getName(self) -> java.lang.String: ... + def getVendor(self) -> java.lang.String: ... + def getVendorTypeNumber(self) -> int: ... + +class SQLXML: + def free(self) -> None: ... + def getBinaryStream(self) -> java.io.InputStream: ... + def getCharacterStream(self) -> java.io.Reader: ... + _getSource__T = typing.TypeVar( + "_getSource__T", bound=javax.xml.transform.Source + ) # + def getSource(self, class_: type[_getSource__T]) -> _getSource__T: ... + def getString(self) -> java.lang.String: ... + def setBinaryStream(self) -> java.io.OutputStream: ... + def setCharacterStream(self) -> java.io.Writer: ... + _setResult__T = typing.TypeVar( + "_setResult__T", bound=javax.xml.transform.Result + ) # + def setResult(self, class_: type[_setResult__T]) -> _setResult__T: ... + def setString(self, string: java.lang.String | str) -> None: ... + +class Savepoint: + def getSavepointId(self) -> int: ... + def getSavepointName(self) -> java.lang.String: ... + +class ShardingKey: ... + +class ShardingKeyBuilder: + def build(self) -> ShardingKey: ... + def subkey(self, object: typing.Any, sQLType: SQLType) -> ShardingKeyBuilder: ... + +class Struct: + @typing.overload + def getAttributes(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def getAttributes( + self, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> typing.MutableSequence[typing.Any]: ... + def getSQLTypeName(self) -> java.lang.String: ... + +class Time(java.util.Date, _JSQLTime): + @typing.overload + def __init__(self, int: int, int2: int, int3: int): ... + @typing.overload + def __init__(self, long: int): ... + def getDate(self) -> int: ... + def getDay(self) -> int: ... + def getMonth(self) -> int: ... + def getYear(self) -> int: ... + def setDate(self, int: int) -> None: ... + def setMonth(self, int: int) -> None: ... + def setTime(self, long: int) -> None: ... + def setYear(self, int: int) -> None: ... + def toInstant(self) -> java.time.Instant: ... + def toLocalTime(self) -> java.time.LocalTime: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Time: ... + @typing.overload + @staticmethod + def valueOf(localTime: java.time.LocalTime) -> Time: ... + +class Timestamp(java.util.Date, _JDate): + @typing.overload + def __init__( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int, int7: int + ): ... + @typing.overload + def __init__(self, long: int): ... + @typing.overload + def after(self, timestamp: Timestamp | datetime.datetime) -> bool: ... + @typing.overload + def after(self, date: java.util.Date) -> bool: ... + @typing.overload + def before(self, timestamp: Timestamp | datetime.datetime) -> bool: ... + @typing.overload + def before(self, date: java.util.Date) -> bool: ... + @typing.overload + def compareTo(self, timestamp: Timestamp | datetime.datetime) -> int: ... + @typing.overload + def compareTo(self, date: java.util.Date) -> int: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def equals(self, timestamp: Timestamp | datetime.datetime) -> bool: ... + @typing.overload + @staticmethod + def from_(instant: java.time.Instant | datetime.datetime) -> Timestamp: ... + @typing.overload + @staticmethod + def from_(instant: java.time.Instant | datetime.datetime) -> java.util.Date: ... + def getNanos(self) -> int: ... + def getTime(self) -> int: ... + def hashCode(self) -> int: ... + def setNanos(self, int: int) -> None: ... + def setTime(self, long: int) -> None: ... + def toInstant(self) -> java.time.Instant: ... + def toLocalDateTime(self) -> java.time.LocalDateTime: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Timestamp: ... + @typing.overload + @staticmethod + def valueOf(localDateTime: java.time.LocalDateTime) -> Timestamp: ... + +class Types: + BIT: typing.ClassVar[int] = ... + TINYINT: typing.ClassVar[int] = ... + SMALLINT: typing.ClassVar[int] = ... + INTEGER: typing.ClassVar[int] = ... + BIGINT: typing.ClassVar[int] = ... + FLOAT: typing.ClassVar[int] = ... + REAL: typing.ClassVar[int] = ... + DOUBLE: typing.ClassVar[int] = ... + NUMERIC: typing.ClassVar[int] = ... + DECIMAL: typing.ClassVar[int] = ... + CHAR: typing.ClassVar[int] = ... + VARCHAR: typing.ClassVar[int] = ... + LONGVARCHAR: typing.ClassVar[int] = ... + DATE: typing.ClassVar[int] = ... + TIME: typing.ClassVar[int] = ... + TIMESTAMP: typing.ClassVar[int] = ... + BINARY: typing.ClassVar[int] = ... + VARBINARY: typing.ClassVar[int] = ... + LONGVARBINARY: typing.ClassVar[int] = ... + NULL: typing.ClassVar[int] = ... + OTHER: typing.ClassVar[int] = ... + JAVA_OBJECT: typing.ClassVar[int] = ... + DISTINCT: typing.ClassVar[int] = ... + STRUCT: typing.ClassVar[int] = ... + ARRAY: typing.ClassVar[int] = ... + BLOB: typing.ClassVar[int] = ... + CLOB: typing.ClassVar[int] = ... + REF: typing.ClassVar[int] = ... + DATALINK: typing.ClassVar[int] = ... + BOOLEAN: typing.ClassVar[int] = ... + ROWID: typing.ClassVar[int] = ... + NCHAR: typing.ClassVar[int] = ... + NVARCHAR: typing.ClassVar[int] = ... + LONGNVARCHAR: typing.ClassVar[int] = ... + NCLOB: typing.ClassVar[int] = ... + SQLXML: typing.ClassVar[int] = ... + REF_CURSOR: typing.ClassVar[int] = ... + TIME_WITH_TIMEZONE: typing.ClassVar[int] = ... + TIMESTAMP_WITH_TIMEZONE: typing.ClassVar[int] = ... + +class Wrapper: + def isWrapperFor(self, class_: type[typing.Any]) -> bool: ... + _unwrap__T = typing.TypeVar("_unwrap__T") # + def unwrap(self, class_: type[_unwrap__T]) -> _unwrap__T: ... + +class BatchUpdateException(SQLException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, intArray: list[int] | jpype.JArray): ... + @typing.overload + def __init__( + self, intArray: list[int] | jpype.JArray, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, intArray: list[int] | jpype.JArray + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + intArray: list[int] | jpype.JArray, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + intArray: list[int] | jpype.JArray, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + longArray: list[int] | jpype.JArray, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + intArray: list[int] | jpype.JArray, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + def getLargeUpdateCounts(self) -> typing.MutableSequence[int]: ... + def getUpdateCounts(self) -> typing.MutableSequence[int]: ... + +class Connection(Wrapper, java.lang.AutoCloseable): + TRANSACTION_NONE: typing.ClassVar[int] = ... + TRANSACTION_READ_UNCOMMITTED: typing.ClassVar[int] = ... + TRANSACTION_READ_COMMITTED: typing.ClassVar[int] = ... + TRANSACTION_REPEATABLE_READ: typing.ClassVar[int] = ... + TRANSACTION_SERIALIZABLE: typing.ClassVar[int] = ... + def abort( + self, executor: java.util.concurrent.Executor | typing.Callable + ) -> None: ... + def beginRequest(self) -> None: ... + def clearWarnings(self) -> None: ... + def close(self) -> None: ... + def commit(self) -> None: ... + def createArrayOf( + self, + string: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ) -> Array: ... + def createBlob(self) -> Blob: ... + def createClob(self) -> Clob: ... + def createNClob(self) -> NClob: ... + def createSQLXML(self) -> SQLXML: ... + @typing.overload + def createStatement(self) -> Statement: ... + @typing.overload + def createStatement(self, int: int, int2: int) -> Statement: ... + @typing.overload + def createStatement(self, int: int, int2: int, int3: int) -> Statement: ... + def createStruct( + self, + string: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ) -> Struct: ... + def endRequest(self) -> None: ... + def getAutoCommit(self) -> bool: ... + def getCatalog(self) -> java.lang.String: ... + @typing.overload + def getClientInfo(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def getClientInfo(self) -> java.util.Properties: ... + def getHoldability(self) -> int: ... + def getMetaData(self) -> DatabaseMetaData: ... + def getNetworkTimeout(self) -> int: ... + def getSchema(self) -> java.lang.String: ... + def getTransactionIsolation(self) -> int: ... + def getTypeMap(self) -> java.util.Map[java.lang.String, type[typing.Any]]: ... + def getWarnings(self) -> SQLWarning: ... + def isClosed(self) -> bool: ... + def isReadOnly(self) -> bool: ... + def isValid(self, int: int) -> bool: ... + def nativeSQL(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def prepareCall(self, string: java.lang.String | str) -> CallableStatement: ... + @typing.overload + def prepareCall( + self, string: java.lang.String | str, int: int, int2: int + ) -> CallableStatement: ... + @typing.overload + def prepareCall( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> CallableStatement: ... + @typing.overload + def prepareStatement(self, string: java.lang.String | str) -> PreparedStatement: ... + @typing.overload + def prepareStatement( + self, string: java.lang.String | str, int: int + ) -> PreparedStatement: ... + @typing.overload + def prepareStatement( + self, string: java.lang.String | str, int: int, int2: int + ) -> PreparedStatement: ... + @typing.overload + def prepareStatement( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> PreparedStatement: ... + @typing.overload + def prepareStatement( + self, string: java.lang.String | str, intArray: list[int] | jpype.JArray + ) -> PreparedStatement: ... + @typing.overload + def prepareStatement( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> PreparedStatement: ... + def releaseSavepoint(self, savepoint: Savepoint) -> None: ... + @typing.overload + def rollback(self) -> None: ... + @typing.overload + def rollback(self, savepoint: Savepoint) -> None: ... + def setAutoCommit(self, boolean: bool) -> None: ... + def setCatalog(self, string: java.lang.String | str) -> None: ... + @typing.overload + def setClientInfo( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def setClientInfo(self, properties: java.util.Properties) -> None: ... + def setHoldability(self, int: int) -> None: ... + def setNetworkTimeout( + self, executor: java.util.concurrent.Executor | typing.Callable, int: int + ) -> None: ... + def setReadOnly(self, boolean: bool) -> None: ... + @typing.overload + def setSavepoint(self) -> Savepoint: ... + @typing.overload + def setSavepoint(self, string: java.lang.String | str) -> Savepoint: ... + def setSchema(self, string: java.lang.String | str) -> None: ... + @typing.overload + def setShardingKey(self, shardingKey: ShardingKey) -> None: ... + @typing.overload + def setShardingKey( + self, shardingKey: ShardingKey, shardingKey2: ShardingKey + ) -> None: ... + @typing.overload + def setShardingKeyIfValid(self, shardingKey: ShardingKey, int: int) -> bool: ... + @typing.overload + def setShardingKeyIfValid( + self, shardingKey: ShardingKey, shardingKey2: ShardingKey, int: int + ) -> bool: ... + def setTransactionIsolation(self, int: int) -> None: ... + def setTypeMap( + self, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> None: ... + +class DatabaseMetaData(Wrapper): + procedureResultUnknown: typing.ClassVar[int] = ... + procedureNoResult: typing.ClassVar[int] = ... + procedureReturnsResult: typing.ClassVar[int] = ... + procedureColumnUnknown: typing.ClassVar[int] = ... + procedureColumnIn: typing.ClassVar[int] = ... + procedureColumnInOut: typing.ClassVar[int] = ... + procedureColumnOut: typing.ClassVar[int] = ... + procedureColumnReturn: typing.ClassVar[int] = ... + procedureColumnResult: typing.ClassVar[int] = ... + procedureNoNulls: typing.ClassVar[int] = ... + procedureNullable: typing.ClassVar[int] = ... + procedureNullableUnknown: typing.ClassVar[int] = ... + columnNoNulls: typing.ClassVar[int] = ... + columnNullable: typing.ClassVar[int] = ... + columnNullableUnknown: typing.ClassVar[int] = ... + bestRowTemporary: typing.ClassVar[int] = ... + bestRowTransaction: typing.ClassVar[int] = ... + bestRowSession: typing.ClassVar[int] = ... + bestRowUnknown: typing.ClassVar[int] = ... + bestRowNotPseudo: typing.ClassVar[int] = ... + bestRowPseudo: typing.ClassVar[int] = ... + versionColumnUnknown: typing.ClassVar[int] = ... + versionColumnNotPseudo: typing.ClassVar[int] = ... + versionColumnPseudo: typing.ClassVar[int] = ... + importedKeyCascade: typing.ClassVar[int] = ... + importedKeyRestrict: typing.ClassVar[int] = ... + importedKeySetNull: typing.ClassVar[int] = ... + importedKeyNoAction: typing.ClassVar[int] = ... + importedKeySetDefault: typing.ClassVar[int] = ... + importedKeyInitiallyDeferred: typing.ClassVar[int] = ... + importedKeyInitiallyImmediate: typing.ClassVar[int] = ... + importedKeyNotDeferrable: typing.ClassVar[int] = ... + typeNoNulls: typing.ClassVar[int] = ... + typeNullable: typing.ClassVar[int] = ... + typeNullableUnknown: typing.ClassVar[int] = ... + typePredNone: typing.ClassVar[int] = ... + typePredChar: typing.ClassVar[int] = ... + typePredBasic: typing.ClassVar[int] = ... + typeSearchable: typing.ClassVar[int] = ... + tableIndexStatistic: typing.ClassVar[int] = ... + tableIndexClustered: typing.ClassVar[int] = ... + tableIndexHashed: typing.ClassVar[int] = ... + tableIndexOther: typing.ClassVar[int] = ... + attributeNoNulls: typing.ClassVar[int] = ... + attributeNullable: typing.ClassVar[int] = ... + attributeNullableUnknown: typing.ClassVar[int] = ... + sqlStateXOpen: typing.ClassVar[int] = ... + sqlStateSQL: typing.ClassVar[int] = ... + sqlStateSQL99: typing.ClassVar[int] = ... + functionColumnUnknown: typing.ClassVar[int] = ... + functionColumnIn: typing.ClassVar[int] = ... + functionColumnInOut: typing.ClassVar[int] = ... + functionColumnOut: typing.ClassVar[int] = ... + functionReturn: typing.ClassVar[int] = ... + functionColumnResult: typing.ClassVar[int] = ... + functionNoNulls: typing.ClassVar[int] = ... + functionNullable: typing.ClassVar[int] = ... + functionNullableUnknown: typing.ClassVar[int] = ... + functionResultUnknown: typing.ClassVar[int] = ... + functionNoTable: typing.ClassVar[int] = ... + functionReturnsTable: typing.ClassVar[int] = ... + def allProceduresAreCallable(self) -> bool: ... + def allTablesAreSelectable(self) -> bool: ... + def autoCommitFailureClosesAllResultSets(self) -> bool: ... + def dataDefinitionCausesTransactionCommit(self) -> bool: ... + def dataDefinitionIgnoredInTransactions(self) -> bool: ... + def deletesAreDetected(self, int: int) -> bool: ... + def doesMaxRowSizeIncludeBlobs(self) -> bool: ... + def generatedKeyAlwaysReturned(self) -> bool: ... + def getAttributes( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + ) -> ResultSet: ... + def getBestRowIdentifier( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + int: int, + boolean: bool, + ) -> ResultSet: ... + def getCatalogSeparator(self) -> java.lang.String: ... + def getCatalogTerm(self) -> java.lang.String: ... + def getCatalogs(self) -> ResultSet: ... + def getClientInfoProperties(self) -> ResultSet: ... + def getColumnPrivileges( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + ) -> ResultSet: ... + def getColumns( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + ) -> ResultSet: ... + def getConnection(self) -> Connection: ... + def getCrossReference( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + string5: java.lang.String | str, + string6: java.lang.String | str, + ) -> ResultSet: ... + def getDatabaseMajorVersion(self) -> int: ... + def getDatabaseMinorVersion(self) -> int: ... + def getDatabaseProductName(self) -> java.lang.String: ... + def getDatabaseProductVersion(self) -> java.lang.String: ... + def getDefaultTransactionIsolation(self) -> int: ... + def getDriverMajorVersion(self) -> int: ... + def getDriverMinorVersion(self) -> int: ... + def getDriverName(self) -> java.lang.String: ... + def getDriverVersion(self) -> java.lang.String: ... + def getExportedKeys( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> ResultSet: ... + def getExtraNameCharacters(self) -> java.lang.String: ... + def getFunctionColumns( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + ) -> ResultSet: ... + def getFunctions( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> ResultSet: ... + def getIdentifierQuoteString(self) -> java.lang.String: ... + def getImportedKeys( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> ResultSet: ... + def getIndexInfo( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + boolean: bool, + boolean2: bool, + ) -> ResultSet: ... + def getJDBCMajorVersion(self) -> int: ... + def getJDBCMinorVersion(self) -> int: ... + def getMaxBinaryLiteralLength(self) -> int: ... + def getMaxCatalogNameLength(self) -> int: ... + def getMaxCharLiteralLength(self) -> int: ... + def getMaxColumnNameLength(self) -> int: ... + def getMaxColumnsInGroupBy(self) -> int: ... + def getMaxColumnsInIndex(self) -> int: ... + def getMaxColumnsInOrderBy(self) -> int: ... + def getMaxColumnsInSelect(self) -> int: ... + def getMaxColumnsInTable(self) -> int: ... + def getMaxConnections(self) -> int: ... + def getMaxCursorNameLength(self) -> int: ... + def getMaxIndexLength(self) -> int: ... + def getMaxLogicalLobSize(self) -> int: ... + def getMaxProcedureNameLength(self) -> int: ... + def getMaxRowSize(self) -> int: ... + def getMaxSchemaNameLength(self) -> int: ... + def getMaxStatementLength(self) -> int: ... + def getMaxStatements(self) -> int: ... + def getMaxTableNameLength(self) -> int: ... + def getMaxTablesInSelect(self) -> int: ... + def getMaxUserNameLength(self) -> int: ... + def getNumericFunctions(self) -> java.lang.String: ... + def getPrimaryKeys( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> ResultSet: ... + def getProcedureColumns( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + ) -> ResultSet: ... + def getProcedureTerm(self) -> java.lang.String: ... + def getProcedures( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> ResultSet: ... + def getPseudoColumns( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + ) -> ResultSet: ... + def getResultSetHoldability(self) -> int: ... + def getRowIdLifetime(self) -> RowIdLifetime: ... + def getSQLKeywords(self) -> java.lang.String: ... + def getSQLStateType(self) -> int: ... + def getSchemaTerm(self) -> java.lang.String: ... + @typing.overload + def getSchemas(self) -> ResultSet: ... + @typing.overload + def getSchemas( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> ResultSet: ... + def getSearchStringEscape(self) -> java.lang.String: ... + def getStringFunctions(self) -> java.lang.String: ... + def getSuperTables( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> ResultSet: ... + def getSuperTypes( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> ResultSet: ... + def getSystemFunctions(self) -> java.lang.String: ... + def getTablePrivileges( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> ResultSet: ... + def getTableTypes(self) -> ResultSet: ... + def getTables( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> ResultSet: ... + def getTimeDateFunctions(self) -> java.lang.String: ... + def getTypeInfo(self) -> ResultSet: ... + def getUDTs( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + intArray: list[int] | jpype.JArray, + ) -> ResultSet: ... + def getURL(self) -> java.lang.String: ... + def getUserName(self) -> java.lang.String: ... + def getVersionColumns( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> ResultSet: ... + def insertsAreDetected(self, int: int) -> bool: ... + def isCatalogAtStart(self) -> bool: ... + def isReadOnly(self) -> bool: ... + def locatorsUpdateCopy(self) -> bool: ... + def nullPlusNonNullIsNull(self) -> bool: ... + def nullsAreSortedAtEnd(self) -> bool: ... + def nullsAreSortedAtStart(self) -> bool: ... + def nullsAreSortedHigh(self) -> bool: ... + def nullsAreSortedLow(self) -> bool: ... + def othersDeletesAreVisible(self, int: int) -> bool: ... + def othersInsertsAreVisible(self, int: int) -> bool: ... + def othersUpdatesAreVisible(self, int: int) -> bool: ... + def ownDeletesAreVisible(self, int: int) -> bool: ... + def ownInsertsAreVisible(self, int: int) -> bool: ... + def ownUpdatesAreVisible(self, int: int) -> bool: ... + def storesLowerCaseIdentifiers(self) -> bool: ... + def storesLowerCaseQuotedIdentifiers(self) -> bool: ... + def storesMixedCaseIdentifiers(self) -> bool: ... + def storesMixedCaseQuotedIdentifiers(self) -> bool: ... + def storesUpperCaseIdentifiers(self) -> bool: ... + def storesUpperCaseQuotedIdentifiers(self) -> bool: ... + def supportsANSI92EntryLevelSQL(self) -> bool: ... + def supportsANSI92FullSQL(self) -> bool: ... + def supportsANSI92IntermediateSQL(self) -> bool: ... + def supportsAlterTableWithAddColumn(self) -> bool: ... + def supportsAlterTableWithDropColumn(self) -> bool: ... + def supportsBatchUpdates(self) -> bool: ... + def supportsCatalogsInDataManipulation(self) -> bool: ... + def supportsCatalogsInIndexDefinitions(self) -> bool: ... + def supportsCatalogsInPrivilegeDefinitions(self) -> bool: ... + def supportsCatalogsInProcedureCalls(self) -> bool: ... + def supportsCatalogsInTableDefinitions(self) -> bool: ... + def supportsColumnAliasing(self) -> bool: ... + @typing.overload + def supportsConvert(self) -> bool: ... + @typing.overload + def supportsConvert(self, int: int, int2: int) -> bool: ... + def supportsCoreSQLGrammar(self) -> bool: ... + def supportsCorrelatedSubqueries(self) -> bool: ... + def supportsDataDefinitionAndDataManipulationTransactions(self) -> bool: ... + def supportsDataManipulationTransactionsOnly(self) -> bool: ... + def supportsDifferentTableCorrelationNames(self) -> bool: ... + def supportsExpressionsInOrderBy(self) -> bool: ... + def supportsExtendedSQLGrammar(self) -> bool: ... + def supportsFullOuterJoins(self) -> bool: ... + def supportsGetGeneratedKeys(self) -> bool: ... + def supportsGroupBy(self) -> bool: ... + def supportsGroupByBeyondSelect(self) -> bool: ... + def supportsGroupByUnrelated(self) -> bool: ... + def supportsIntegrityEnhancementFacility(self) -> bool: ... + def supportsLikeEscapeClause(self) -> bool: ... + def supportsLimitedOuterJoins(self) -> bool: ... + def supportsMinimumSQLGrammar(self) -> bool: ... + def supportsMixedCaseIdentifiers(self) -> bool: ... + def supportsMixedCaseQuotedIdentifiers(self) -> bool: ... + def supportsMultipleOpenResults(self) -> bool: ... + def supportsMultipleResultSets(self) -> bool: ... + def supportsMultipleTransactions(self) -> bool: ... + def supportsNamedParameters(self) -> bool: ... + def supportsNonNullableColumns(self) -> bool: ... + def supportsOpenCursorsAcrossCommit(self) -> bool: ... + def supportsOpenCursorsAcrossRollback(self) -> bool: ... + def supportsOpenStatementsAcrossCommit(self) -> bool: ... + def supportsOpenStatementsAcrossRollback(self) -> bool: ... + def supportsOrderByUnrelated(self) -> bool: ... + def supportsOuterJoins(self) -> bool: ... + def supportsPositionedDelete(self) -> bool: ... + def supportsPositionedUpdate(self) -> bool: ... + def supportsRefCursors(self) -> bool: ... + def supportsResultSetConcurrency(self, int: int, int2: int) -> bool: ... + def supportsResultSetHoldability(self, int: int) -> bool: ... + def supportsResultSetType(self, int: int) -> bool: ... + def supportsSavepoints(self) -> bool: ... + def supportsSchemasInDataManipulation(self) -> bool: ... + def supportsSchemasInIndexDefinitions(self) -> bool: ... + def supportsSchemasInPrivilegeDefinitions(self) -> bool: ... + def supportsSchemasInProcedureCalls(self) -> bool: ... + def supportsSchemasInTableDefinitions(self) -> bool: ... + def supportsSelectForUpdate(self) -> bool: ... + def supportsSharding(self) -> bool: ... + def supportsStatementPooling(self) -> bool: ... + def supportsStoredFunctionsUsingCallSyntax(self) -> bool: ... + def supportsStoredProcedures(self) -> bool: ... + def supportsSubqueriesInComparisons(self) -> bool: ... + def supportsSubqueriesInExists(self) -> bool: ... + def supportsSubqueriesInIns(self) -> bool: ... + def supportsSubqueriesInQuantifieds(self) -> bool: ... + def supportsTableCorrelationNames(self) -> bool: ... + def supportsTransactionIsolationLevel(self, int: int) -> bool: ... + def supportsTransactions(self) -> bool: ... + def supportsUnion(self) -> bool: ... + def supportsUnionAll(self) -> bool: ... + def updatesAreDetected(self, int: int) -> bool: ... + def usesLocalFilePerTable(self) -> bool: ... + def usesLocalFiles(self) -> bool: ... + +class JDBCType(java.lang.Enum["JDBCType"], SQLType): + BIT: typing.ClassVar[JDBCType] = ... + TINYINT: typing.ClassVar[JDBCType] = ... + SMALLINT: typing.ClassVar[JDBCType] = ... + INTEGER: typing.ClassVar[JDBCType] = ... + BIGINT: typing.ClassVar[JDBCType] = ... + FLOAT: typing.ClassVar[JDBCType] = ... + REAL: typing.ClassVar[JDBCType] = ... + DOUBLE: typing.ClassVar[JDBCType] = ... + NUMERIC: typing.ClassVar[JDBCType] = ... + DECIMAL: typing.ClassVar[JDBCType] = ... + CHAR: typing.ClassVar[JDBCType] = ... + VARCHAR: typing.ClassVar[JDBCType] = ... + LONGVARCHAR: typing.ClassVar[JDBCType] = ... + DATE: typing.ClassVar[JDBCType] = ... + TIME: typing.ClassVar[JDBCType] = ... + TIMESTAMP: typing.ClassVar[JDBCType] = ... + BINARY: typing.ClassVar[JDBCType] = ... + VARBINARY: typing.ClassVar[JDBCType] = ... + LONGVARBINARY: typing.ClassVar[JDBCType] = ... + NULL: typing.ClassVar[JDBCType] = ... + OTHER: typing.ClassVar[JDBCType] = ... + JAVA_OBJECT: typing.ClassVar[JDBCType] = ... + DISTINCT: typing.ClassVar[JDBCType] = ... + STRUCT: typing.ClassVar[JDBCType] = ... + ARRAY: typing.ClassVar[JDBCType] = ... + BLOB: typing.ClassVar[JDBCType] = ... + CLOB: typing.ClassVar[JDBCType] = ... + REF: typing.ClassVar[JDBCType] = ... + DATALINK: typing.ClassVar[JDBCType] = ... + BOOLEAN: typing.ClassVar[JDBCType] = ... + ROWID: typing.ClassVar[JDBCType] = ... + NCHAR: typing.ClassVar[JDBCType] = ... + NVARCHAR: typing.ClassVar[JDBCType] = ... + LONGNVARCHAR: typing.ClassVar[JDBCType] = ... + NCLOB: typing.ClassVar[JDBCType] = ... + SQLXML: typing.ClassVar[JDBCType] = ... + REF_CURSOR: typing.ClassVar[JDBCType] = ... + TIME_WITH_TIMEZONE: typing.ClassVar[JDBCType] = ... + TIMESTAMP_WITH_TIMEZONE: typing.ClassVar[JDBCType] = ... + def getName(self) -> java.lang.String: ... + def getVendor(self) -> java.lang.String: ... + def getVendorTypeNumber(self) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(int: int) -> JDBCType: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> JDBCType: ... + @staticmethod + def values() -> typing.MutableSequence[JDBCType]: ... + +class NClob(Clob): ... + +class ParameterMetaData(Wrapper): + parameterNoNulls: typing.ClassVar[int] = ... + parameterNullable: typing.ClassVar[int] = ... + parameterNullableUnknown: typing.ClassVar[int] = ... + parameterModeUnknown: typing.ClassVar[int] = ... + parameterModeIn: typing.ClassVar[int] = ... + parameterModeInOut: typing.ClassVar[int] = ... + parameterModeOut: typing.ClassVar[int] = ... + def getParameterClassName(self, int: int) -> java.lang.String: ... + def getParameterCount(self) -> int: ... + def getParameterMode(self, int: int) -> int: ... + def getParameterType(self, int: int) -> int: ... + def getParameterTypeName(self, int: int) -> java.lang.String: ... + def getPrecision(self, int: int) -> int: ... + def getScale(self, int: int) -> int: ... + def isNullable(self, int: int) -> int: ... + def isSigned(self, int: int) -> bool: ... + +class ResultSet(Wrapper, java.lang.AutoCloseable): + FETCH_FORWARD: typing.ClassVar[int] = ... + FETCH_REVERSE: typing.ClassVar[int] = ... + FETCH_UNKNOWN: typing.ClassVar[int] = ... + TYPE_FORWARD_ONLY: typing.ClassVar[int] = ... + TYPE_SCROLL_INSENSITIVE: typing.ClassVar[int] = ... + TYPE_SCROLL_SENSITIVE: typing.ClassVar[int] = ... + CONCUR_READ_ONLY: typing.ClassVar[int] = ... + CONCUR_UPDATABLE: typing.ClassVar[int] = ... + HOLD_CURSORS_OVER_COMMIT: typing.ClassVar[int] = ... + CLOSE_CURSORS_AT_COMMIT: typing.ClassVar[int] = ... + def absolute(self, int: int) -> bool: ... + def afterLast(self) -> None: ... + def beforeFirst(self) -> None: ... + def cancelRowUpdates(self) -> None: ... + def clearWarnings(self) -> None: ... + def close(self) -> None: ... + def deleteRow(self) -> None: ... + def findColumn(self, string: java.lang.String | str) -> int: ... + def first(self) -> bool: ... + @typing.overload + def getArray(self, int: int) -> Array: ... + @typing.overload + def getArray(self, string: java.lang.String | str) -> Array: ... + @typing.overload + def getAsciiStream(self, int: int) -> java.io.InputStream: ... + @typing.overload + def getAsciiStream(self, string: java.lang.String | str) -> java.io.InputStream: ... + @typing.overload + def getBigDecimal(self, int: int) -> java.math.BigDecimal: ... + @typing.overload + def getBigDecimal(self, int: int, int2: int) -> java.math.BigDecimal: ... + @typing.overload + def getBigDecimal(self, string: java.lang.String | str) -> java.math.BigDecimal: ... + @typing.overload + def getBigDecimal( + self, string: java.lang.String | str, int: int + ) -> java.math.BigDecimal: ... + @typing.overload + def getBinaryStream(self, int: int) -> java.io.InputStream: ... + @typing.overload + def getBinaryStream( + self, string: java.lang.String | str + ) -> java.io.InputStream: ... + @typing.overload + def getBlob(self, int: int) -> Blob: ... + @typing.overload + def getBlob(self, string: java.lang.String | str) -> Blob: ... + @typing.overload + def getBoolean(self, int: int) -> bool: ... + @typing.overload + def getBoolean(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def getByte(self, int: int) -> int: ... + @typing.overload + def getByte(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getBytes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getCharacterStream(self, int: int) -> java.io.Reader: ... + @typing.overload + def getCharacterStream(self, string: java.lang.String | str) -> java.io.Reader: ... + @typing.overload + def getClob(self, int: int) -> Clob: ... + @typing.overload + def getClob(self, string: java.lang.String | str) -> Clob: ... + def getConcurrency(self) -> int: ... + def getCursorName(self) -> java.lang.String: ... + @typing.overload + def getDate(self, int: int) -> Date: ... + @typing.overload + def getDate(self, int: int, calendar: java.util.Calendar) -> Date: ... + @typing.overload + def getDate(self, string: java.lang.String | str) -> Date: ... + @typing.overload + def getDate( + self, string: java.lang.String | str, calendar: java.util.Calendar + ) -> Date: ... + @typing.overload + def getDouble(self, int: int) -> float: ... + @typing.overload + def getDouble(self, string: java.lang.String | str) -> float: ... + def getFetchDirection(self) -> int: ... + def getFetchSize(self) -> int: ... + @typing.overload + def getFloat(self, int: int) -> float: ... + @typing.overload + def getFloat(self, string: java.lang.String | str) -> float: ... + def getHoldability(self) -> int: ... + @typing.overload + def getInt(self, int: int) -> int: ... + @typing.overload + def getInt(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getLong(self, int: int) -> int: ... + @typing.overload + def getLong(self, string: java.lang.String | str) -> int: ... + def getMetaData(self) -> ResultSetMetaData: ... + @typing.overload + def getNCharacterStream(self, int: int) -> java.io.Reader: ... + @typing.overload + def getNCharacterStream(self, string: java.lang.String | str) -> java.io.Reader: ... + @typing.overload + def getNClob(self, int: int) -> NClob: ... + @typing.overload + def getNClob(self, string: java.lang.String | str) -> NClob: ... + @typing.overload + def getNString(self, int: int) -> java.lang.String: ... + @typing.overload + def getNString(self, string: java.lang.String | str) -> java.lang.String: ... + _getObject_1__T = typing.TypeVar("_getObject_1__T") # + _getObject_4__T = typing.TypeVar("_getObject_4__T") # + @typing.overload + def getObject(self, int: int) -> typing.Any: ... + @typing.overload + def getObject(self, int: int, class_: type[_getObject_1__T]) -> _getObject_1__T: ... + @typing.overload + def getObject( + self, + int: int, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> typing.Any: ... + @typing.overload + def getObject(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def getObject( + self, string: java.lang.String | str, class_: type[_getObject_4__T] + ) -> _getObject_4__T: ... + @typing.overload + def getObject( + self, + string: java.lang.String | str, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> typing.Any: ... + @typing.overload + def getRef(self, int: int) -> Ref: ... + @typing.overload + def getRef(self, string: java.lang.String | str) -> Ref: ... + def getRow(self) -> int: ... + @typing.overload + def getRowId(self, int: int) -> RowId: ... + @typing.overload + def getRowId(self, string: java.lang.String | str) -> RowId: ... + @typing.overload + def getSQLXML(self, int: int) -> SQLXML: ... + @typing.overload + def getSQLXML(self, string: java.lang.String | str) -> SQLXML: ... + @typing.overload + def getShort(self, int: int) -> int: ... + @typing.overload + def getShort(self, string: java.lang.String | str) -> int: ... + def getStatement(self) -> Statement: ... + @typing.overload + def getString(self, int: int) -> java.lang.String: ... + @typing.overload + def getString(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def getTime(self, int: int) -> Time: ... + @typing.overload + def getTime(self, int: int, calendar: java.util.Calendar) -> Time: ... + @typing.overload + def getTime(self, string: java.lang.String | str) -> Time: ... + @typing.overload + def getTime( + self, string: java.lang.String | str, calendar: java.util.Calendar + ) -> Time: ... + @typing.overload + def getTimestamp(self, int: int) -> Timestamp: ... + @typing.overload + def getTimestamp(self, int: int, calendar: java.util.Calendar) -> Timestamp: ... + @typing.overload + def getTimestamp(self, string: java.lang.String | str) -> Timestamp: ... + @typing.overload + def getTimestamp( + self, string: java.lang.String | str, calendar: java.util.Calendar + ) -> Timestamp: ... + def getType(self) -> int: ... + @typing.overload + def getURL(self, int: int) -> java.net.URL: ... + @typing.overload + def getURL(self, string: java.lang.String | str) -> java.net.URL: ... + @typing.overload + def getUnicodeStream(self, int: int) -> java.io.InputStream: ... + @typing.overload + def getUnicodeStream( + self, string: java.lang.String | str + ) -> java.io.InputStream: ... + def getWarnings(self) -> SQLWarning: ... + def insertRow(self) -> None: ... + def isAfterLast(self) -> bool: ... + def isBeforeFirst(self) -> bool: ... + def isClosed(self) -> bool: ... + def isFirst(self) -> bool: ... + def isLast(self) -> bool: ... + def last(self) -> bool: ... + def moveToCurrentRow(self) -> None: ... + def moveToInsertRow(self) -> None: ... + def next(self) -> bool: ... + def previous(self) -> bool: ... + def refreshRow(self) -> None: ... + def relative(self, int: int) -> bool: ... + def rowDeleted(self) -> bool: ... + def rowInserted(self) -> bool: ... + def rowUpdated(self) -> bool: ... + def setFetchDirection(self, int: int) -> None: ... + def setFetchSize(self, int: int) -> None: ... + @typing.overload + def updateArray(self, int: int, array: Array) -> None: ... + @typing.overload + def updateArray(self, string: java.lang.String | str, array: Array) -> None: ... + @typing.overload + def updateAsciiStream(self, int: int, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def updateAsciiStream( + self, int: int, inputStream: java.io.InputStream, int2: int + ) -> None: ... + @typing.overload + def updateAsciiStream( + self, int: int, inputStream: java.io.InputStream, long: int + ) -> None: ... + @typing.overload + def updateAsciiStream( + self, string: java.lang.String | str, inputStream: java.io.InputStream + ) -> None: ... + @typing.overload + def updateAsciiStream( + self, string: java.lang.String | str, inputStream: java.io.InputStream, int: int + ) -> None: ... + @typing.overload + def updateAsciiStream( + self, + string: java.lang.String | str, + inputStream: java.io.InputStream, + long: int, + ) -> None: ... + @typing.overload + def updateBigDecimal( + self, int: int, bigDecimal: java.math.BigDecimal | decimal.Decimal + ) -> None: ... + @typing.overload + def updateBigDecimal( + self, + string: java.lang.String | str, + bigDecimal: java.math.BigDecimal | decimal.Decimal, + ) -> None: ... + @typing.overload + def updateBinaryStream( + self, int: int, inputStream: java.io.InputStream + ) -> None: ... + @typing.overload + def updateBinaryStream( + self, int: int, inputStream: java.io.InputStream, int2: int + ) -> None: ... + @typing.overload + def updateBinaryStream( + self, int: int, inputStream: java.io.InputStream, long: int + ) -> None: ... + @typing.overload + def updateBinaryStream( + self, string: java.lang.String | str, inputStream: java.io.InputStream + ) -> None: ... + @typing.overload + def updateBinaryStream( + self, string: java.lang.String | str, inputStream: java.io.InputStream, int: int + ) -> None: ... + @typing.overload + def updateBinaryStream( + self, + string: java.lang.String | str, + inputStream: java.io.InputStream, + long: int, + ) -> None: ... + @typing.overload + def updateBlob(self, int: int, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def updateBlob( + self, int: int, inputStream: java.io.InputStream, long: int + ) -> None: ... + @typing.overload + def updateBlob(self, int: int, blob: Blob) -> None: ... + @typing.overload + def updateBlob( + self, string: java.lang.String | str, inputStream: java.io.InputStream + ) -> None: ... + @typing.overload + def updateBlob( + self, + string: java.lang.String | str, + inputStream: java.io.InputStream, + long: int, + ) -> None: ... + @typing.overload + def updateBlob(self, string: java.lang.String | str, blob: Blob) -> None: ... + @typing.overload + def updateBoolean(self, int: int, boolean: bool) -> None: ... + @typing.overload + def updateBoolean(self, string: java.lang.String | str, boolean: bool) -> None: ... + @typing.overload + def updateByte(self, int: int, byte: int) -> None: ... + @typing.overload + def updateByte(self, string: java.lang.String | str, byte: int) -> None: ... + @typing.overload + def updateBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def updateBytes( + self, + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + ) -> None: ... + @typing.overload + def updateCharacterStream(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def updateCharacterStream( + self, int: int, reader: java.io.Reader, int2: int + ) -> None: ... + @typing.overload + def updateCharacterStream( + self, int: int, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def updateCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader + ) -> None: ... + @typing.overload + def updateCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader, int: int + ) -> None: ... + @typing.overload + def updateCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def updateClob(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def updateClob(self, int: int, reader: java.io.Reader, long: int) -> None: ... + @typing.overload + def updateClob(self, int: int, clob: Clob) -> None: ... + @typing.overload + def updateClob( + self, string: java.lang.String | str, reader: java.io.Reader + ) -> None: ... + @typing.overload + def updateClob( + self, string: java.lang.String | str, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def updateClob(self, string: java.lang.String | str, clob: Clob) -> None: ... + @typing.overload + def updateDate(self, int: int, date: Date | datetime.date) -> None: ... + @typing.overload + def updateDate( + self, string: java.lang.String | str, date: Date | datetime.date + ) -> None: ... + @typing.overload + def updateDouble(self, int: int, double: float) -> None: ... + @typing.overload + def updateDouble(self, string: java.lang.String | str, double: float) -> None: ... + @typing.overload + def updateFloat(self, int: int, float: float) -> None: ... + @typing.overload + def updateFloat(self, string: java.lang.String | str, float: float) -> None: ... + @typing.overload + def updateInt(self, int: int, int2: int) -> None: ... + @typing.overload + def updateInt(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def updateLong(self, int: int, long: int) -> None: ... + @typing.overload + def updateLong(self, string: java.lang.String | str, long: int) -> None: ... + @typing.overload + def updateNCharacterStream(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def updateNCharacterStream( + self, int: int, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def updateNCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader + ) -> None: ... + @typing.overload + def updateNCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def updateNClob(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def updateNClob(self, int: int, reader: java.io.Reader, long: int) -> None: ... + @typing.overload + def updateNClob(self, int: int, nClob: NClob) -> None: ... + @typing.overload + def updateNClob( + self, string: java.lang.String | str, reader: java.io.Reader + ) -> None: ... + @typing.overload + def updateNClob( + self, string: java.lang.String | str, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def updateNClob(self, string: java.lang.String | str, nClob: NClob) -> None: ... + @typing.overload + def updateNString(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def updateNString( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def updateNull(self, int: int) -> None: ... + @typing.overload + def updateNull(self, string: java.lang.String | str) -> None: ... + @typing.overload + def updateObject(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def updateObject(self, int: int, object: typing.Any, int2: int) -> None: ... + @typing.overload + def updateObject( + self, string: java.lang.String | str, object: typing.Any + ) -> None: ... + @typing.overload + def updateObject( + self, string: java.lang.String | str, object: typing.Any, int: int + ) -> None: ... + @typing.overload + def updateObject(self, int: int, object: typing.Any, sQLType: SQLType) -> None: ... + @typing.overload + def updateObject( + self, int: int, object: typing.Any, sQLType: SQLType, int2: int + ) -> None: ... + @typing.overload + def updateObject( + self, string: java.lang.String | str, object: typing.Any, sQLType: SQLType + ) -> None: ... + @typing.overload + def updateObject( + self, + string: java.lang.String | str, + object: typing.Any, + sQLType: SQLType, + int: int, + ) -> None: ... + @typing.overload + def updateRef(self, int: int, ref: Ref) -> None: ... + @typing.overload + def updateRef(self, string: java.lang.String | str, ref: Ref) -> None: ... + def updateRow(self) -> None: ... + @typing.overload + def updateRowId(self, int: int, rowId: RowId | typing.Callable) -> None: ... + @typing.overload + def updateRowId( + self, string: java.lang.String | str, rowId: RowId | typing.Callable + ) -> None: ... + @typing.overload + def updateSQLXML(self, int: int, sQLXML: SQLXML) -> None: ... + @typing.overload + def updateSQLXML(self, string: java.lang.String | str, sQLXML: SQLXML) -> None: ... + @typing.overload + def updateShort(self, int: int, short: int) -> None: ... + @typing.overload + def updateShort(self, string: java.lang.String | str, short: int) -> None: ... + @typing.overload + def updateString(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def updateString( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def updateTime(self, int: int, time: Time | datetime.time) -> None: ... + @typing.overload + def updateTime( + self, string: java.lang.String | str, time: Time | datetime.time + ) -> None: ... + @typing.overload + def updateTimestamp( + self, int: int, timestamp: Timestamp | datetime.datetime + ) -> None: ... + @typing.overload + def updateTimestamp( + self, string: java.lang.String | str, timestamp: Timestamp | datetime.datetime + ) -> None: ... + def wasNull(self) -> bool: ... + +class ResultSetMetaData(Wrapper): + columnNoNulls: typing.ClassVar[int] = ... + columnNullable: typing.ClassVar[int] = ... + columnNullableUnknown: typing.ClassVar[int] = ... + def getCatalogName(self, int: int) -> java.lang.String: ... + def getColumnClassName(self, int: int) -> java.lang.String: ... + def getColumnCount(self) -> int: ... + def getColumnDisplaySize(self, int: int) -> int: ... + def getColumnLabel(self, int: int) -> java.lang.String: ... + def getColumnName(self, int: int) -> java.lang.String: ... + def getColumnType(self, int: int) -> int: ... + def getColumnTypeName(self, int: int) -> java.lang.String: ... + def getPrecision(self, int: int) -> int: ... + def getScale(self, int: int) -> int: ... + def getSchemaName(self, int: int) -> java.lang.String: ... + def getTableName(self, int: int) -> java.lang.String: ... + def isAutoIncrement(self, int: int) -> bool: ... + def isCaseSensitive(self, int: int) -> bool: ... + def isCurrency(self, int: int) -> bool: ... + def isDefinitelyWritable(self, int: int) -> bool: ... + def isNullable(self, int: int) -> int: ... + def isReadOnly(self, int: int) -> bool: ... + def isSearchable(self, int: int) -> bool: ... + def isSigned(self, int: int) -> bool: ... + def isWritable(self, int: int) -> bool: ... + +class SQLClientInfoException(SQLException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + map: java.util.Map[java.lang.String | str, ClientInfoStatus] + | typing.Mapping[java.lang.String | str, ClientInfoStatus], + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + map: java.util.Map[java.lang.String | str, ClientInfoStatus] + | typing.Mapping[java.lang.String | str, ClientInfoStatus], + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + map: java.util.Map[java.lang.String | str, ClientInfoStatus] + | typing.Mapping[java.lang.String | str, ClientInfoStatus], + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + map: java.util.Map[java.lang.String | str, ClientInfoStatus] + | typing.Mapping[java.lang.String | str, ClientInfoStatus], + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + map: java.util.Map[java.lang.String | str, ClientInfoStatus] + | typing.Mapping[java.lang.String | str, ClientInfoStatus], + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + map: java.util.Map[java.lang.String | str, ClientInfoStatus] + | typing.Mapping[java.lang.String | str, ClientInfoStatus], + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + map: java.util.Map[java.lang.String | str, ClientInfoStatus] + | typing.Mapping[java.lang.String | str, ClientInfoStatus], + ): ... + @typing.overload + def __init__( + self, + map: java.util.Map[java.lang.String | str, ClientInfoStatus] + | typing.Mapping[java.lang.String | str, ClientInfoStatus], + throwable: java.lang.Throwable, + ): ... + def getFailedProperties( + self, + ) -> java.util.Map[java.lang.String, ClientInfoStatus]: ... + +class SQLNonTransientException(SQLException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLRecoverableException(SQLException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLTransientException(SQLException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLWarning(SQLException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + def getNextWarning(self) -> SQLWarning: ... + def setNextWarning(self, sQLWarning: SQLWarning) -> None: ... + +class Statement(Wrapper, java.lang.AutoCloseable): + CLOSE_CURRENT_RESULT: typing.ClassVar[int] = ... + KEEP_CURRENT_RESULT: typing.ClassVar[int] = ... + CLOSE_ALL_RESULTS: typing.ClassVar[int] = ... + SUCCESS_NO_INFO: typing.ClassVar[int] = ... + EXECUTE_FAILED: typing.ClassVar[int] = ... + RETURN_GENERATED_KEYS: typing.ClassVar[int] = ... + NO_GENERATED_KEYS: typing.ClassVar[int] = ... + def addBatch(self, string: java.lang.String | str) -> None: ... + def cancel(self) -> None: ... + def clearBatch(self) -> None: ... + def clearWarnings(self) -> None: ... + def close(self) -> None: ... + def closeOnCompletion(self) -> None: ... + def enquoteIdentifier( + self, string: java.lang.String | str, boolean: bool + ) -> java.lang.String: ... + def enquoteLiteral(self, string: java.lang.String | str) -> java.lang.String: ... + def enquoteNCharLiteral( + self, string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def execute(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def execute(self, string: java.lang.String | str, int: int) -> bool: ... + @typing.overload + def execute( + self, string: java.lang.String | str, intArray: list[int] | jpype.JArray + ) -> bool: ... + @typing.overload + def execute( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> bool: ... + def executeBatch(self) -> typing.MutableSequence[int]: ... + def executeLargeBatch(self) -> typing.MutableSequence[int]: ... + @typing.overload + def executeLargeUpdate(self, string: java.lang.String | str) -> int: ... + @typing.overload + def executeLargeUpdate(self, string: java.lang.String | str, int: int) -> int: ... + @typing.overload + def executeLargeUpdate( + self, string: java.lang.String | str, intArray: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + def executeLargeUpdate( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> int: ... + def executeQuery(self, string: java.lang.String | str) -> ResultSet: ... + @typing.overload + def executeUpdate(self, string: java.lang.String | str) -> int: ... + @typing.overload + def executeUpdate(self, string: java.lang.String | str, int: int) -> int: ... + @typing.overload + def executeUpdate( + self, string: java.lang.String | str, intArray: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + def executeUpdate( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> int: ... + def getConnection(self) -> Connection: ... + def getFetchDirection(self) -> int: ... + def getFetchSize(self) -> int: ... + def getGeneratedKeys(self) -> ResultSet: ... + def getLargeMaxRows(self) -> int: ... + def getLargeUpdateCount(self) -> int: ... + def getMaxFieldSize(self) -> int: ... + def getMaxRows(self) -> int: ... + @typing.overload + def getMoreResults(self) -> bool: ... + @typing.overload + def getMoreResults(self, int: int) -> bool: ... + def getQueryTimeout(self) -> int: ... + def getResultSet(self) -> ResultSet: ... + def getResultSetConcurrency(self) -> int: ... + def getResultSetHoldability(self) -> int: ... + def getResultSetType(self) -> int: ... + def getUpdateCount(self) -> int: ... + def getWarnings(self) -> SQLWarning: ... + def isCloseOnCompletion(self) -> bool: ... + def isClosed(self) -> bool: ... + def isPoolable(self) -> bool: ... + def isSimpleIdentifier(self, string: java.lang.String | str) -> bool: ... + def setCursorName(self, string: java.lang.String | str) -> None: ... + def setEscapeProcessing(self, boolean: bool) -> None: ... + def setFetchDirection(self, int: int) -> None: ... + def setFetchSize(self, int: int) -> None: ... + def setLargeMaxRows(self, long: int) -> None: ... + def setMaxFieldSize(self, int: int) -> None: ... + def setMaxRows(self, int: int) -> None: ... + def setPoolable(self, boolean: bool) -> None: ... + def setQueryTimeout(self, int: int) -> None: ... + +class DataTruncation(SQLWarning): + @typing.overload + def __init__( + self, int: int, boolean: bool, boolean2: bool, int2: int, int3: int + ): ... + @typing.overload + def __init__( + self, + int: int, + boolean: bool, + boolean2: bool, + int2: int, + int3: int, + throwable: java.lang.Throwable, + ): ... + def getDataSize(self) -> int: ... + def getIndex(self) -> int: ... + def getParameter(self) -> bool: ... + def getRead(self) -> bool: ... + def getTransferSize(self) -> int: ... + +class PreparedStatement(Statement): + @typing.overload + def addBatch(self) -> None: ... + @typing.overload + def addBatch(self, string: java.lang.String | str) -> None: ... + def clearParameters(self) -> None: ... + @typing.overload + def execute(self) -> bool: ... + @typing.overload + def execute(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def execute(self, string: java.lang.String | str, int: int) -> bool: ... + @typing.overload + def execute( + self, string: java.lang.String | str, intArray: list[int] | jpype.JArray + ) -> bool: ... + @typing.overload + def execute( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> bool: ... + @typing.overload + def executeLargeUpdate(self) -> int: ... + @typing.overload + def executeLargeUpdate(self, string: java.lang.String | str) -> int: ... + @typing.overload + def executeLargeUpdate(self, string: java.lang.String | str, int: int) -> int: ... + @typing.overload + def executeLargeUpdate( + self, string: java.lang.String | str, intArray: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + def executeLargeUpdate( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> int: ... + @typing.overload + def executeQuery(self) -> ResultSet: ... + @typing.overload + def executeQuery(self, string: java.lang.String | str) -> ResultSet: ... + @typing.overload + def executeUpdate(self) -> int: ... + @typing.overload + def executeUpdate(self, string: java.lang.String | str) -> int: ... + @typing.overload + def executeUpdate(self, string: java.lang.String | str, int: int) -> int: ... + @typing.overload + def executeUpdate( + self, string: java.lang.String | str, intArray: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + def executeUpdate( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> int: ... + def getMetaData(self) -> ResultSetMetaData: ... + def getParameterMetaData(self) -> ParameterMetaData: ... + def setArray(self, int: int, array: Array) -> None: ... + @typing.overload + def setAsciiStream(self, int: int, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def setAsciiStream( + self, int: int, inputStream: java.io.InputStream, int2: int + ) -> None: ... + @typing.overload + def setAsciiStream( + self, int: int, inputStream: java.io.InputStream, long: int + ) -> None: ... + def setBigDecimal( + self, int: int, bigDecimal: java.math.BigDecimal | decimal.Decimal + ) -> None: ... + @typing.overload + def setBinaryStream(self, int: int, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def setBinaryStream( + self, int: int, inputStream: java.io.InputStream, int2: int + ) -> None: ... + @typing.overload + def setBinaryStream( + self, int: int, inputStream: java.io.InputStream, long: int + ) -> None: ... + @typing.overload + def setBlob(self, int: int, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def setBlob( + self, int: int, inputStream: java.io.InputStream, long: int + ) -> None: ... + @typing.overload + def setBlob(self, int: int, blob: Blob) -> None: ... + def setBoolean(self, int: int, boolean: bool) -> None: ... + def setByte(self, int: int, byte: int) -> None: ... + def setBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def setCharacterStream(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def setCharacterStream( + self, int: int, reader: java.io.Reader, int2: int + ) -> None: ... + @typing.overload + def setCharacterStream( + self, int: int, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def setClob(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def setClob(self, int: int, reader: java.io.Reader, long: int) -> None: ... + @typing.overload + def setClob(self, int: int, clob: Clob) -> None: ... + @typing.overload + def setDate(self, int: int, date: Date | datetime.date) -> None: ... + @typing.overload + def setDate( + self, int: int, date: Date | datetime.date, calendar: java.util.Calendar + ) -> None: ... + def setDouble(self, int: int, double: float) -> None: ... + def setFloat(self, int: int, float: float) -> None: ... + def setInt(self, int: int, int2: int) -> None: ... + def setLong(self, int: int, long: int) -> None: ... + @typing.overload + def setNCharacterStream(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def setNCharacterStream( + self, int: int, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def setNClob(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def setNClob(self, int: int, reader: java.io.Reader, long: int) -> None: ... + @typing.overload + def setNClob(self, int: int, nClob: NClob) -> None: ... + def setNString(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setNull(self, int: int, int2: int) -> None: ... + @typing.overload + def setNull(self, int: int, int2: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setObject(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def setObject(self, int: int, object: typing.Any, int2: int) -> None: ... + @typing.overload + def setObject(self, int: int, object: typing.Any, int2: int, int3: int) -> None: ... + @typing.overload + def setObject(self, int: int, object: typing.Any, sQLType: SQLType) -> None: ... + @typing.overload + def setObject( + self, int: int, object: typing.Any, sQLType: SQLType, int2: int + ) -> None: ... + def setRef(self, int: int, ref: Ref) -> None: ... + def setRowId(self, int: int, rowId: RowId | typing.Callable) -> None: ... + def setSQLXML(self, int: int, sQLXML: SQLXML) -> None: ... + def setShort(self, int: int, short: int) -> None: ... + def setString(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setTime(self, int: int, time: Time | datetime.time) -> None: ... + @typing.overload + def setTime( + self, int: int, time: Time | datetime.time, calendar: java.util.Calendar + ) -> None: ... + @typing.overload + def setTimestamp( + self, int: int, timestamp: Timestamp | datetime.datetime + ) -> None: ... + @typing.overload + def setTimestamp( + self, + int: int, + timestamp: Timestamp | datetime.datetime, + calendar: java.util.Calendar, + ) -> None: ... + def setURL(self, int: int, uRL: java.net.URL) -> None: ... + def setUnicodeStream( + self, int: int, inputStream: java.io.InputStream, int2: int + ) -> None: ... + +class SQLDataException(SQLNonTransientException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLFeatureNotSupportedException(SQLNonTransientException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLIntegrityConstraintViolationException(SQLNonTransientException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLInvalidAuthorizationSpecException(SQLNonTransientException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLNonTransientConnectionException(SQLNonTransientException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLSyntaxErrorException(SQLNonTransientException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLTimeoutException(SQLTransientException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLTransactionRollbackException(SQLTransientException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SQLTransientConnectionException(SQLTransientException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class CallableStatement(PreparedStatement): + @typing.overload + def getArray(self, int: int) -> Array: ... + @typing.overload + def getArray(self, string: java.lang.String | str) -> Array: ... + @typing.overload + def getBigDecimal(self, int: int) -> java.math.BigDecimal: ... + @typing.overload + def getBigDecimal(self, int: int, int2: int) -> java.math.BigDecimal: ... + @typing.overload + def getBigDecimal(self, string: java.lang.String | str) -> java.math.BigDecimal: ... + @typing.overload + def getBlob(self, int: int) -> Blob: ... + @typing.overload + def getBlob(self, string: java.lang.String | str) -> Blob: ... + @typing.overload + def getBoolean(self, int: int) -> bool: ... + @typing.overload + def getBoolean(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def getByte(self, int: int) -> int: ... + @typing.overload + def getByte(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getBytes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getCharacterStream(self, int: int) -> java.io.Reader: ... + @typing.overload + def getCharacterStream(self, string: java.lang.String | str) -> java.io.Reader: ... + @typing.overload + def getClob(self, int: int) -> Clob: ... + @typing.overload + def getClob(self, string: java.lang.String | str) -> Clob: ... + @typing.overload + def getDate(self, int: int) -> Date: ... + @typing.overload + def getDate(self, int: int, calendar: java.util.Calendar) -> Date: ... + @typing.overload + def getDate(self, string: java.lang.String | str) -> Date: ... + @typing.overload + def getDate( + self, string: java.lang.String | str, calendar: java.util.Calendar + ) -> Date: ... + @typing.overload + def getDouble(self, int: int) -> float: ... + @typing.overload + def getDouble(self, string: java.lang.String | str) -> float: ... + @typing.overload + def getFloat(self, int: int) -> float: ... + @typing.overload + def getFloat(self, string: java.lang.String | str) -> float: ... + @typing.overload + def getInt(self, int: int) -> int: ... + @typing.overload + def getInt(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getLong(self, int: int) -> int: ... + @typing.overload + def getLong(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getNCharacterStream(self, int: int) -> java.io.Reader: ... + @typing.overload + def getNCharacterStream(self, string: java.lang.String | str) -> java.io.Reader: ... + @typing.overload + def getNClob(self, int: int) -> NClob: ... + @typing.overload + def getNClob(self, string: java.lang.String | str) -> NClob: ... + @typing.overload + def getNString(self, int: int) -> java.lang.String: ... + @typing.overload + def getNString(self, string: java.lang.String | str) -> java.lang.String: ... + _getObject_1__T = typing.TypeVar("_getObject_1__T") # + _getObject_4__T = typing.TypeVar("_getObject_4__T") # + @typing.overload + def getObject(self, int: int) -> typing.Any: ... + @typing.overload + def getObject(self, int: int, class_: type[_getObject_1__T]) -> _getObject_1__T: ... + @typing.overload + def getObject( + self, + int: int, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> typing.Any: ... + @typing.overload + def getObject(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def getObject( + self, string: java.lang.String | str, class_: type[_getObject_4__T] + ) -> _getObject_4__T: ... + @typing.overload + def getObject( + self, + string: java.lang.String | str, + map: java.util.Map[java.lang.String | str, type[typing.Any]] + | typing.Mapping[java.lang.String | str, type[typing.Any]], + ) -> typing.Any: ... + @typing.overload + def getRef(self, int: int) -> Ref: ... + @typing.overload + def getRef(self, string: java.lang.String | str) -> Ref: ... + @typing.overload + def getRowId(self, int: int) -> RowId: ... + @typing.overload + def getRowId(self, string: java.lang.String | str) -> RowId: ... + @typing.overload + def getSQLXML(self, int: int) -> SQLXML: ... + @typing.overload + def getSQLXML(self, string: java.lang.String | str) -> SQLXML: ... + @typing.overload + def getShort(self, int: int) -> int: ... + @typing.overload + def getShort(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getString(self, int: int) -> java.lang.String: ... + @typing.overload + def getString(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def getTime(self, int: int) -> Time: ... + @typing.overload + def getTime(self, int: int, calendar: java.util.Calendar) -> Time: ... + @typing.overload + def getTime(self, string: java.lang.String | str) -> Time: ... + @typing.overload + def getTime( + self, string: java.lang.String | str, calendar: java.util.Calendar + ) -> Time: ... + @typing.overload + def getTimestamp(self, int: int) -> Timestamp: ... + @typing.overload + def getTimestamp(self, int: int, calendar: java.util.Calendar) -> Timestamp: ... + @typing.overload + def getTimestamp(self, string: java.lang.String | str) -> Timestamp: ... + @typing.overload + def getTimestamp( + self, string: java.lang.String | str, calendar: java.util.Calendar + ) -> Timestamp: ... + @typing.overload + def getURL(self, int: int) -> java.net.URL: ... + @typing.overload + def getURL(self, string: java.lang.String | str) -> java.net.URL: ... + @typing.overload + def registerOutParameter(self, int: int, int2: int) -> None: ... + @typing.overload + def registerOutParameter(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def registerOutParameter( + self, int: int, int2: int, string: java.lang.String | str + ) -> None: ... + @typing.overload + def registerOutParameter( + self, string: java.lang.String | str, int: int + ) -> None: ... + @typing.overload + def registerOutParameter( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + @typing.overload + def registerOutParameter( + self, string: java.lang.String | str, int: int, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def registerOutParameter(self, int: int, sQLType: SQLType) -> None: ... + @typing.overload + def registerOutParameter(self, int: int, sQLType: SQLType, int2: int) -> None: ... + @typing.overload + def registerOutParameter( + self, int: int, sQLType: SQLType, string: java.lang.String | str + ) -> None: ... + @typing.overload + def registerOutParameter( + self, string: java.lang.String | str, sQLType: SQLType + ) -> None: ... + @typing.overload + def registerOutParameter( + self, string: java.lang.String | str, sQLType: SQLType, int: int + ) -> None: ... + @typing.overload + def registerOutParameter( + self, + string: java.lang.String | str, + sQLType: SQLType, + string2: java.lang.String | str, + ) -> None: ... + @typing.overload + def setAsciiStream( + self, string: java.lang.String | str, inputStream: java.io.InputStream + ) -> None: ... + @typing.overload + def setAsciiStream( + self, string: java.lang.String | str, inputStream: java.io.InputStream, int: int + ) -> None: ... + @typing.overload + def setAsciiStream( + self, + string: java.lang.String | str, + inputStream: java.io.InputStream, + long: int, + ) -> None: ... + @typing.overload + def setAsciiStream(self, int: int, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def setAsciiStream( + self, int: int, inputStream: java.io.InputStream, int2: int + ) -> None: ... + @typing.overload + def setAsciiStream( + self, int: int, inputStream: java.io.InputStream, long: int + ) -> None: ... + @typing.overload + def setBigDecimal( + self, + string: java.lang.String | str, + bigDecimal: java.math.BigDecimal | decimal.Decimal, + ) -> None: ... + @typing.overload + def setBigDecimal( + self, int: int, bigDecimal: java.math.BigDecimal | decimal.Decimal + ) -> None: ... + @typing.overload + def setBinaryStream( + self, string: java.lang.String | str, inputStream: java.io.InputStream + ) -> None: ... + @typing.overload + def setBinaryStream( + self, string: java.lang.String | str, inputStream: java.io.InputStream, int: int + ) -> None: ... + @typing.overload + def setBinaryStream( + self, + string: java.lang.String | str, + inputStream: java.io.InputStream, + long: int, + ) -> None: ... + @typing.overload + def setBinaryStream(self, int: int, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def setBinaryStream( + self, int: int, inputStream: java.io.InputStream, int2: int + ) -> None: ... + @typing.overload + def setBinaryStream( + self, int: int, inputStream: java.io.InputStream, long: int + ) -> None: ... + @typing.overload + def setBlob( + self, string: java.lang.String | str, inputStream: java.io.InputStream + ) -> None: ... + @typing.overload + def setBlob( + self, + string: java.lang.String | str, + inputStream: java.io.InputStream, + long: int, + ) -> None: ... + @typing.overload + def setBlob(self, string: java.lang.String | str, blob: Blob) -> None: ... + @typing.overload + def setBlob(self, int: int, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def setBlob( + self, int: int, inputStream: java.io.InputStream, long: int + ) -> None: ... + @typing.overload + def setBlob(self, int: int, blob: Blob) -> None: ... + @typing.overload + def setBoolean(self, string: java.lang.String | str, boolean: bool) -> None: ... + @typing.overload + def setBoolean(self, int: int, boolean: bool) -> None: ... + @typing.overload + def setByte(self, string: java.lang.String | str, byte: int) -> None: ... + @typing.overload + def setByte(self, int: int, byte: int) -> None: ... + @typing.overload + def setBytes( + self, + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + ) -> None: ... + @typing.overload + def setBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def setCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader + ) -> None: ... + @typing.overload + def setCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader, int: int + ) -> None: ... + @typing.overload + def setCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def setCharacterStream(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def setCharacterStream( + self, int: int, reader: java.io.Reader, int2: int + ) -> None: ... + @typing.overload + def setCharacterStream( + self, int: int, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def setClob( + self, string: java.lang.String | str, reader: java.io.Reader + ) -> None: ... + @typing.overload + def setClob( + self, string: java.lang.String | str, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def setClob(self, string: java.lang.String | str, clob: Clob) -> None: ... + @typing.overload + def setClob(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def setClob(self, int: int, reader: java.io.Reader, long: int) -> None: ... + @typing.overload + def setClob(self, int: int, clob: Clob) -> None: ... + @typing.overload + def setDate( + self, string: java.lang.String | str, date: Date | datetime.date + ) -> None: ... + @typing.overload + def setDate( + self, + string: java.lang.String | str, + date: Date | datetime.date, + calendar: java.util.Calendar, + ) -> None: ... + @typing.overload + def setDate(self, int: int, date: Date | datetime.date) -> None: ... + @typing.overload + def setDate( + self, int: int, date: Date | datetime.date, calendar: java.util.Calendar + ) -> None: ... + @typing.overload + def setDouble(self, string: java.lang.String | str, double: float) -> None: ... + @typing.overload + def setDouble(self, int: int, double: float) -> None: ... + @typing.overload + def setFloat(self, string: java.lang.String | str, float: float) -> None: ... + @typing.overload + def setFloat(self, int: int, float: float) -> None: ... + @typing.overload + def setInt(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def setInt(self, int: int, int2: int) -> None: ... + @typing.overload + def setLong(self, string: java.lang.String | str, long: int) -> None: ... + @typing.overload + def setLong(self, int: int, long: int) -> None: ... + @typing.overload + def setNCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader + ) -> None: ... + @typing.overload + def setNCharacterStream( + self, string: java.lang.String | str, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def setNCharacterStream(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def setNCharacterStream( + self, int: int, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def setNClob( + self, string: java.lang.String | str, reader: java.io.Reader + ) -> None: ... + @typing.overload + def setNClob( + self, string: java.lang.String | str, reader: java.io.Reader, long: int + ) -> None: ... + @typing.overload + def setNClob(self, string: java.lang.String | str, nClob: NClob) -> None: ... + @typing.overload + def setNClob(self, int: int, reader: java.io.Reader) -> None: ... + @typing.overload + def setNClob(self, int: int, reader: java.io.Reader, long: int) -> None: ... + @typing.overload + def setNClob(self, int: int, nClob: NClob) -> None: ... + @typing.overload + def setNString( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def setNString(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setNull(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def setNull( + self, string: java.lang.String | str, int: int, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def setNull(self, int: int, int2: int) -> None: ... + @typing.overload + def setNull(self, int: int, int2: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setObject(self, string: java.lang.String | str, object: typing.Any) -> None: ... + @typing.overload + def setObject( + self, string: java.lang.String | str, object: typing.Any, int: int + ) -> None: ... + @typing.overload + def setObject( + self, string: java.lang.String | str, object: typing.Any, int: int, int2: int + ) -> None: ... + @typing.overload + def setObject(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def setObject(self, int: int, object: typing.Any, int2: int) -> None: ... + @typing.overload + def setObject(self, int: int, object: typing.Any, int2: int, int3: int) -> None: ... + @typing.overload + def setObject( + self, string: java.lang.String | str, object: typing.Any, sQLType: SQLType + ) -> None: ... + @typing.overload + def setObject( + self, + string: java.lang.String | str, + object: typing.Any, + sQLType: SQLType, + int: int, + ) -> None: ... + @typing.overload + def setObject(self, int: int, object: typing.Any, sQLType: SQLType) -> None: ... + @typing.overload + def setObject( + self, int: int, object: typing.Any, sQLType: SQLType, int2: int + ) -> None: ... + @typing.overload + def setRowId( + self, string: java.lang.String | str, rowId: RowId | typing.Callable + ) -> None: ... + @typing.overload + def setRowId(self, int: int, rowId: RowId | typing.Callable) -> None: ... + @typing.overload + def setSQLXML(self, string: java.lang.String | str, sQLXML: SQLXML) -> None: ... + @typing.overload + def setSQLXML(self, int: int, sQLXML: SQLXML) -> None: ... + @typing.overload + def setShort(self, string: java.lang.String | str, short: int) -> None: ... + @typing.overload + def setShort(self, int: int, short: int) -> None: ... + @typing.overload + def setString( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def setString(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setTime( + self, string: java.lang.String | str, time: Time | datetime.time + ) -> None: ... + @typing.overload + def setTime( + self, + string: java.lang.String | str, + time: Time | datetime.time, + calendar: java.util.Calendar, + ) -> None: ... + @typing.overload + def setTime(self, int: int, time: Time | datetime.time) -> None: ... + @typing.overload + def setTime( + self, int: int, time: Time | datetime.time, calendar: java.util.Calendar + ) -> None: ... + @typing.overload + def setTimestamp( + self, string: java.lang.String | str, timestamp: Timestamp | datetime.datetime + ) -> None: ... + @typing.overload + def setTimestamp( + self, + string: java.lang.String | str, + timestamp: Timestamp | datetime.datetime, + calendar: java.util.Calendar, + ) -> None: ... + @typing.overload + def setTimestamp( + self, int: int, timestamp: Timestamp | datetime.datetime + ) -> None: ... + @typing.overload + def setTimestamp( + self, + int: int, + timestamp: Timestamp | datetime.datetime, + calendar: java.util.Calendar, + ) -> None: ... + @typing.overload + def setURL(self, string: java.lang.String | str, uRL: java.net.URL) -> None: ... + @typing.overload + def setURL(self, int: int, uRL: java.net.URL) -> None: ... + def wasNull(self) -> bool: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.sql")``. + + Array: type[Array] + BatchUpdateException: type[BatchUpdateException] + Blob: type[Blob] + CallableStatement: type[CallableStatement] + ClientInfoStatus: type[ClientInfoStatus] + Clob: type[Clob] + Connection: type[Connection] + ConnectionBuilder: type[ConnectionBuilder] + DataTruncation: type[DataTruncation] + DatabaseMetaData: type[DatabaseMetaData] + Date: type[Date] + Driver: type[Driver] + DriverAction: type[DriverAction] + DriverManager: type[DriverManager] + DriverPropertyInfo: type[DriverPropertyInfo] + JDBCType: type[JDBCType] + NClob: type[NClob] + ParameterMetaData: type[ParameterMetaData] + PreparedStatement: type[PreparedStatement] + PseudoColumnUsage: type[PseudoColumnUsage] + Ref: type[Ref] + ResultSet: type[ResultSet] + ResultSetMetaData: type[ResultSetMetaData] + RowId: type[RowId] + RowIdLifetime: type[RowIdLifetime] + SQLClientInfoException: type[SQLClientInfoException] + SQLData: type[SQLData] + SQLDataException: type[SQLDataException] + SQLException: type[SQLException] + SQLFeatureNotSupportedException: type[SQLFeatureNotSupportedException] + SQLInput: type[SQLInput] + SQLIntegrityConstraintViolationException: type[ + SQLIntegrityConstraintViolationException + ] + SQLInvalidAuthorizationSpecException: type[SQLInvalidAuthorizationSpecException] + SQLNonTransientConnectionException: type[SQLNonTransientConnectionException] + SQLNonTransientException: type[SQLNonTransientException] + SQLOutput: type[SQLOutput] + SQLPermission: type[SQLPermission] + SQLRecoverableException: type[SQLRecoverableException] + SQLSyntaxErrorException: type[SQLSyntaxErrorException] + SQLTimeoutException: type[SQLTimeoutException] + SQLTransactionRollbackException: type[SQLTransactionRollbackException] + SQLTransientConnectionException: type[SQLTransientConnectionException] + SQLTransientException: type[SQLTransientException] + SQLType: type[SQLType] + SQLWarning: type[SQLWarning] + SQLXML: type[SQLXML] + Savepoint: type[Savepoint] + ShardingKey: type[ShardingKey] + ShardingKeyBuilder: type[ShardingKeyBuilder] + Statement: type[Statement] + Struct: type[Struct] + Time: type[Time] + Timestamp: type[Timestamp] + Types: type[Types] + Wrapper: type[Wrapper] diff --git a/typings/java/text/__init__.pyi b/typings/java/text/__init__.pyi new file mode 100644 index 0000000..427f074 --- /dev/null +++ b/typings/java/text/__init__.pyi @@ -0,0 +1,1204 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.math +import java.text.spi +import java.util +import jpype + +class Annotation: + def __init__(self, object: typing.Any): ... + def getValue(self) -> typing.Any: ... + def toString(self) -> java.lang.String: ... + +class AttributedString: + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + map: java.util.Map[AttributedCharacterIterator.Attribute, typing.Any] + | typing.Mapping[AttributedCharacterIterator.Attribute, typing.Any], + ): ... + @typing.overload + def __init__(self, attributedCharacterIterator: AttributedCharacterIterator): ... + @typing.overload + def __init__( + self, + attributedCharacterIterator: AttributedCharacterIterator, + int: int, + int2: int, + ): ... + @typing.overload + def __init__( + self, + attributedCharacterIterator: AttributedCharacterIterator, + int: int, + int2: int, + attributeArray: list[AttributedCharacterIterator.Attribute] | jpype.JArray, + ): ... + @typing.overload + def addAttribute( + self, attribute: AttributedCharacterIterator.Attribute, object: typing.Any + ) -> None: ... + @typing.overload + def addAttribute( + self, + attribute: AttributedCharacterIterator.Attribute, + object: typing.Any, + int: int, + int2: int, + ) -> None: ... + def addAttributes( + self, + map: java.util.Map[AttributedCharacterIterator.Attribute, typing.Any] + | typing.Mapping[AttributedCharacterIterator.Attribute, typing.Any], + int: int, + int2: int, + ) -> None: ... + @typing.overload + def getIterator(self) -> AttributedCharacterIterator: ... + @typing.overload + def getIterator( + self, attributeArray: list[AttributedCharacterIterator.Attribute] | jpype.JArray + ) -> AttributedCharacterIterator: ... + @typing.overload + def getIterator( + self, + attributeArray: list[AttributedCharacterIterator.Attribute] | jpype.JArray, + int: int, + int2: int, + ) -> AttributedCharacterIterator: ... + +class Bidi: + DIRECTION_LEFT_TO_RIGHT: typing.ClassVar[int] = ... + DIRECTION_RIGHT_TO_LEFT: typing.ClassVar[int] = ... + DIRECTION_DEFAULT_LEFT_TO_RIGHT: typing.ClassVar[int] = ... + DIRECTION_DEFAULT_RIGHT_TO_LEFT: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, + charArray: list[str] | jpype.JArray, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + ): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + @typing.overload + def __init__(self, attributedCharacterIterator: AttributedCharacterIterator): ... + def baseIsLeftToRight(self) -> bool: ... + def createLineBidi(self, int: int, int2: int) -> Bidi: ... + def getBaseLevel(self) -> int: ... + def getLength(self) -> int: ... + def getLevelAt(self, int: int) -> int: ... + def getRunCount(self) -> int: ... + def getRunLevel(self, int: int) -> int: ... + def getRunLimit(self, int: int) -> int: ... + def getRunStart(self, int: int) -> int: ... + def isLeftToRight(self) -> bool: ... + def isMixed(self) -> bool: ... + def isRightToLeft(self) -> bool: ... + @staticmethod + def reorderVisually( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + objectArray: list[typing.Any] | jpype.JArray, + int2: int, + int3: int, + ) -> None: ... + @staticmethod + def requiresBidi( + charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> bool: ... + def toString(self) -> java.lang.String: ... + +class BreakIterator(java.lang.Cloneable): + DONE: typing.ClassVar[int] = ... + def clone(self) -> typing.Any: ... + def current(self) -> int: ... + def first(self) -> int: ... + def following(self, int: int) -> int: ... + @staticmethod + def getAvailableLocales() -> typing.MutableSequence[java.util.Locale]: ... + @typing.overload + @staticmethod + def getCharacterInstance() -> BreakIterator: ... + @typing.overload + @staticmethod + def getCharacterInstance(locale: java.util.Locale) -> BreakIterator: ... + @typing.overload + @staticmethod + def getLineInstance() -> BreakIterator: ... + @typing.overload + @staticmethod + def getLineInstance(locale: java.util.Locale) -> BreakIterator: ... + @typing.overload + @staticmethod + def getSentenceInstance() -> BreakIterator: ... + @typing.overload + @staticmethod + def getSentenceInstance(locale: java.util.Locale) -> BreakIterator: ... + def getText(self) -> CharacterIterator: ... + @typing.overload + @staticmethod + def getWordInstance() -> BreakIterator: ... + @typing.overload + @staticmethod + def getWordInstance(locale: java.util.Locale) -> BreakIterator: ... + def isBoundary(self, int: int) -> bool: ... + def last(self) -> int: ... + @typing.overload + def next(self) -> int: ... + @typing.overload + def next(self, int: int) -> int: ... + def preceding(self, int: int) -> int: ... + def previous(self) -> int: ... + @typing.overload + def setText(self, characterIterator: CharacterIterator) -> None: ... + @typing.overload + def setText(self, string: java.lang.String | str) -> None: ... + +class CharacterIterator(java.lang.Cloneable): + DONE: typing.ClassVar[str] = ... + def clone(self) -> typing.Any: ... + def current(self) -> str: ... + def first(self) -> str: ... + def getBeginIndex(self) -> int: ... + def getEndIndex(self) -> int: ... + def getIndex(self) -> int: ... + def last(self) -> str: ... + def next(self) -> str: ... + def previous(self) -> str: ... + def setIndex(self, int: int) -> str: ... + +class CollationElementIterator: + NULLORDER: typing.ClassVar[int] = ... + def getMaxExpansion(self, int: int) -> int: ... + def getOffset(self) -> int: ... + def next(self) -> int: ... + def previous(self) -> int: ... + @staticmethod + def primaryOrder(int: int) -> int: ... + def reset(self) -> None: ... + @staticmethod + def secondaryOrder(int: int) -> int: ... + def setOffset(self, int: int) -> None: ... + @typing.overload + def setText(self, string: java.lang.String | str) -> None: ... + @typing.overload + def setText(self, characterIterator: CharacterIterator) -> None: ... + @staticmethod + def tertiaryOrder(int: int) -> int: ... + +class CollationKey(java.lang.Comparable["CollationKey"]): + def compareTo(self, collationKey: CollationKey) -> int: ... + def getSourceString(self) -> java.lang.String: ... + def toByteArray(self) -> typing.MutableSequence[int]: ... + +class Collator(java.util.Comparator[typing.Any], java.lang.Cloneable): + PRIMARY: typing.ClassVar[int] = ... + SECONDARY: typing.ClassVar[int] = ... + TERTIARY: typing.ClassVar[int] = ... + IDENTICAL: typing.ClassVar[int] = ... + NO_DECOMPOSITION: typing.ClassVar[int] = ... + CANONICAL_DECOMPOSITION: typing.ClassVar[int] = ... + FULL_DECOMPOSITION: typing.ClassVar[int] = ... + def clone(self) -> typing.Any: ... + @typing.overload + def compare( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> int: ... + @typing.overload + def compare(self, object: typing.Any, object2: typing.Any) -> int: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def equals( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> bool: ... + @staticmethod + def getAvailableLocales() -> typing.MutableSequence[java.util.Locale]: ... + def getCollationKey(self, string: java.lang.String | str) -> CollationKey: ... + def getDecomposition(self) -> int: ... + @typing.overload + @staticmethod + def getInstance(locale: java.util.Locale) -> Collator: ... + @typing.overload + @staticmethod + def getInstance() -> Collator: ... + def getStrength(self) -> int: ... + def hashCode(self) -> int: ... + def setDecomposition(self, int: int) -> None: ... + def setStrength(self, int: int) -> None: ... + +class DateFormatSymbols(java.io.Serializable, java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, locale: java.util.Locale): ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + def getAmPmStrings(self) -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def getAvailableLocales() -> typing.MutableSequence[java.util.Locale]: ... + def getEras(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + @staticmethod + def getInstance() -> DateFormatSymbols: ... + @typing.overload + @staticmethod + def getInstance(locale: java.util.Locale) -> DateFormatSymbols: ... + def getLocalPatternChars(self) -> java.lang.String: ... + def getMonths(self) -> typing.MutableSequence[java.lang.String]: ... + def getShortMonths(self) -> typing.MutableSequence[java.lang.String]: ... + def getShortWeekdays(self) -> typing.MutableSequence[java.lang.String]: ... + def getWeekdays(self) -> typing.MutableSequence[java.lang.String]: ... + def getZoneStrings( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def hashCode(self) -> int: ... + def setAmPmStrings( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> None: ... + def setEras(self, stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def setLocalPatternChars(self, string: java.lang.String | str) -> None: ... + def setMonths(self, stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def setShortMonths( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> None: ... + def setShortWeekdays( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> None: ... + def setWeekdays( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> None: ... + def setZoneStrings( + self, stringArray: list[typing.MutableSequence[java.lang.String]] | jpype.JArray + ) -> None: ... + +class DecimalFormatSymbols(java.lang.Cloneable, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, locale: java.util.Locale): ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def getAvailableLocales() -> typing.MutableSequence[java.util.Locale]: ... + def getCurrency(self) -> java.util.Currency: ... + def getCurrencySymbol(self) -> java.lang.String: ... + def getDecimalSeparator(self) -> str: ... + def getDigit(self) -> str: ... + def getExponentSeparator(self) -> java.lang.String: ... + def getGroupingSeparator(self) -> str: ... + def getInfinity(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance() -> DecimalFormatSymbols: ... + @typing.overload + @staticmethod + def getInstance(locale: java.util.Locale) -> DecimalFormatSymbols: ... + def getInternationalCurrencySymbol(self) -> java.lang.String: ... + def getLocale(self) -> java.util.Locale: ... + def getMinusSign(self) -> str: ... + def getMonetaryDecimalSeparator(self) -> str: ... + def getMonetaryGroupingSeparator(self) -> str: ... + def getNaN(self) -> java.lang.String: ... + def getPatternSeparator(self) -> str: ... + def getPerMill(self) -> str: ... + def getPercent(self) -> str: ... + def getZeroDigit(self) -> str: ... + def hashCode(self) -> int: ... + def setCurrency(self, currency: java.util.Currency) -> None: ... + def setCurrencySymbol(self, string: java.lang.String | str) -> None: ... + def setDecimalSeparator(self, char: str) -> None: ... + def setDigit(self, char: str) -> None: ... + def setExponentSeparator(self, string: java.lang.String | str) -> None: ... + def setGroupingSeparator(self, char: str) -> None: ... + def setInfinity(self, string: java.lang.String | str) -> None: ... + def setInternationalCurrencySymbol( + self, string: java.lang.String | str + ) -> None: ... + def setMinusSign(self, char: str) -> None: ... + def setMonetaryDecimalSeparator(self, char: str) -> None: ... + def setMonetaryGroupingSeparator(self, char: str) -> None: ... + def setNaN(self, string: java.lang.String | str) -> None: ... + def setPatternSeparator(self, char: str) -> None: ... + def setPerMill(self, char: str) -> None: ... + def setPercent(self, char: str) -> None: ... + def setZeroDigit(self, char: str) -> None: ... + +class FieldPosition: + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, field: Format.Field): ... + @typing.overload + def __init__(self, field: Format.Field, int: int): ... + def equals(self, object: typing.Any) -> bool: ... + def getBeginIndex(self) -> int: ... + def getEndIndex(self) -> int: ... + def getField(self) -> int: ... + def getFieldAttribute(self) -> Format.Field: ... + def hashCode(self) -> int: ... + def setBeginIndex(self, int: int) -> None: ... + def setEndIndex(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class Normalizer: + @staticmethod + def isNormalized( + charSequence: java.lang.CharSequence | str, form: Normalizer.Form + ) -> bool: ... + @staticmethod + def normalize( + charSequence: java.lang.CharSequence | str, form: Normalizer.Form + ) -> java.lang.String: ... + class Form(java.lang.Enum["Normalizer.Form"]): + NFD: typing.ClassVar[Normalizer.Form] = ... + NFC: typing.ClassVar[Normalizer.Form] = ... + NFKD: typing.ClassVar[Normalizer.Form] = ... + NFKC: typing.ClassVar[Normalizer.Form] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Normalizer.Form: ... + @staticmethod + def values() -> typing.MutableSequence[Normalizer.Form]: ... + +class ParseException(java.lang.Exception): + def __init__(self, string: java.lang.String | str, int: int): ... + def getErrorOffset(self) -> int: ... + +class ParsePosition: + def __init__(self, int: int): ... + def equals(self, object: typing.Any) -> bool: ... + def getErrorIndex(self) -> int: ... + def getIndex(self) -> int: ... + def hashCode(self) -> int: ... + def setErrorIndex(self, int: int) -> None: ... + def setIndex(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class AttributedCharacterIterator(CharacterIterator): + def getAllAttributeKeys( + self, + ) -> java.util.Set[AttributedCharacterIterator.Attribute]: ... + def getAttribute( + self, attribute: AttributedCharacterIterator.Attribute + ) -> typing.Any: ... + def getAttributes( + self, + ) -> java.util.Map[AttributedCharacterIterator.Attribute, typing.Any]: ... + @typing.overload + def getRunLimit(self) -> int: ... + @typing.overload + def getRunLimit(self, attribute: AttributedCharacterIterator.Attribute) -> int: ... + @typing.overload + def getRunLimit( + self, set: java.util.Set[AttributedCharacterIterator.Attribute] + ) -> int: ... + @typing.overload + def getRunStart(self) -> int: ... + @typing.overload + def getRunStart(self, attribute: AttributedCharacterIterator.Attribute) -> int: ... + @typing.overload + def getRunStart( + self, set: java.util.Set[AttributedCharacterIterator.Attribute] + ) -> int: ... + class Attribute(java.io.Serializable): + LANGUAGE: typing.ClassVar[AttributedCharacterIterator.Attribute] = ... + READING: typing.ClassVar[AttributedCharacterIterator.Attribute] = ... + INPUT_METHOD_SEGMENT: typing.ClassVar[ + AttributedCharacterIterator.Attribute + ] = ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class RuleBasedCollator(Collator): + def __init__(self, string: java.lang.String | str): ... + def clone(self) -> typing.Any: ... + @typing.overload + def compare(self, object: typing.Any, object2: typing.Any) -> int: ... + @typing.overload + def compare( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> int: ... + @typing.overload + def equals( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def getCollationElementIterator( + self, string: java.lang.String | str + ) -> CollationElementIterator: ... + @typing.overload + def getCollationElementIterator( + self, characterIterator: CharacterIterator + ) -> CollationElementIterator: ... + def getCollationKey(self, string: java.lang.String | str) -> CollationKey: ... + def getRules(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + +class StringCharacterIterator(CharacterIterator): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ): ... + def clone(self) -> typing.Any: ... + def current(self) -> str: ... + def equals(self, object: typing.Any) -> bool: ... + def first(self) -> str: ... + def getBeginIndex(self) -> int: ... + def getEndIndex(self) -> int: ... + def getIndex(self) -> int: ... + def hashCode(self) -> int: ... + def last(self) -> str: ... + def next(self) -> str: ... + def previous(self) -> str: ... + def setIndex(self, int: int) -> str: ... + def setText(self, string: java.lang.String | str) -> None: ... + +class Format(java.io.Serializable, java.lang.Cloneable): + def clone(self) -> typing.Any: ... + @typing.overload + def format( + self, + object: typing.Any, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format(self, object: typing.Any) -> java.lang.String: ... + def formatToCharacterIterator( + self, object: typing.Any + ) -> AttributedCharacterIterator: ... + @typing.overload + def parseObject( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> typing.Any: ... + @typing.overload + def parseObject(self, string: java.lang.String | str) -> typing.Any: ... + class Field(AttributedCharacterIterator.Attribute): ... + +class DateFormat(Format): + ERA_FIELD: typing.ClassVar[int] = ... + YEAR_FIELD: typing.ClassVar[int] = ... + MONTH_FIELD: typing.ClassVar[int] = ... + DATE_FIELD: typing.ClassVar[int] = ... + HOUR_OF_DAY1_FIELD: typing.ClassVar[int] = ... + HOUR_OF_DAY0_FIELD: typing.ClassVar[int] = ... + MINUTE_FIELD: typing.ClassVar[int] = ... + SECOND_FIELD: typing.ClassVar[int] = ... + MILLISECOND_FIELD: typing.ClassVar[int] = ... + DAY_OF_WEEK_FIELD: typing.ClassVar[int] = ... + DAY_OF_YEAR_FIELD: typing.ClassVar[int] = ... + DAY_OF_WEEK_IN_MONTH_FIELD: typing.ClassVar[int] = ... + WEEK_OF_YEAR_FIELD: typing.ClassVar[int] = ... + WEEK_OF_MONTH_FIELD: typing.ClassVar[int] = ... + AM_PM_FIELD: typing.ClassVar[int] = ... + HOUR1_FIELD: typing.ClassVar[int] = ... + HOUR0_FIELD: typing.ClassVar[int] = ... + TIMEZONE_FIELD: typing.ClassVar[int] = ... + FULL: typing.ClassVar[int] = ... + LONG: typing.ClassVar[int] = ... + MEDIUM: typing.ClassVar[int] = ... + SHORT: typing.ClassVar[int] = ... + DEFAULT: typing.ClassVar[int] = ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def format( + self, + date: java.util.Date, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format(self, date: java.util.Date) -> java.lang.String: ... + @typing.overload + def format(self, object: typing.Any) -> java.lang.String: ... + @typing.overload + def format( + self, + object: typing.Any, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @staticmethod + def getAvailableLocales() -> typing.MutableSequence[java.util.Locale]: ... + def getCalendar(self) -> java.util.Calendar: ... + @typing.overload + @staticmethod + def getDateInstance() -> DateFormat: ... + @typing.overload + @staticmethod + def getDateInstance(int: int) -> DateFormat: ... + @typing.overload + @staticmethod + def getDateInstance(int: int, locale: java.util.Locale) -> DateFormat: ... + @typing.overload + @staticmethod + def getDateTimeInstance() -> DateFormat: ... + @typing.overload + @staticmethod + def getDateTimeInstance(int: int, int2: int) -> DateFormat: ... + @typing.overload + @staticmethod + def getDateTimeInstance( + int: int, int2: int, locale: java.util.Locale + ) -> DateFormat: ... + @staticmethod + def getInstance() -> DateFormat: ... + def getNumberFormat(self) -> NumberFormat: ... + @typing.overload + @staticmethod + def getTimeInstance() -> DateFormat: ... + @typing.overload + @staticmethod + def getTimeInstance(int: int) -> DateFormat: ... + @typing.overload + @staticmethod + def getTimeInstance(int: int, locale: java.util.Locale) -> DateFormat: ... + def getTimeZone(self) -> java.util.TimeZone: ... + def hashCode(self) -> int: ... + def isLenient(self) -> bool: ... + @typing.overload + def parse( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> java.util.Date: ... + @typing.overload + def parse(self, string: java.lang.String | str) -> java.util.Date: ... + @typing.overload + def parseObject( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> typing.Any: ... + @typing.overload + def parseObject(self, string: java.lang.String | str) -> typing.Any: ... + def setCalendar(self, calendar: java.util.Calendar) -> None: ... + def setLenient(self, boolean: bool) -> None: ... + def setNumberFormat(self, numberFormat: NumberFormat) -> None: ... + def setTimeZone(self, timeZone: java.util.TimeZone) -> None: ... + class Field(Format.Field): + ERA: typing.ClassVar[DateFormat.Field] = ... + YEAR: typing.ClassVar[DateFormat.Field] = ... + MONTH: typing.ClassVar[DateFormat.Field] = ... + DAY_OF_MONTH: typing.ClassVar[DateFormat.Field] = ... + HOUR_OF_DAY1: typing.ClassVar[DateFormat.Field] = ... + HOUR_OF_DAY0: typing.ClassVar[DateFormat.Field] = ... + MINUTE: typing.ClassVar[DateFormat.Field] = ... + SECOND: typing.ClassVar[DateFormat.Field] = ... + MILLISECOND: typing.ClassVar[DateFormat.Field] = ... + DAY_OF_WEEK: typing.ClassVar[DateFormat.Field] = ... + DAY_OF_YEAR: typing.ClassVar[DateFormat.Field] = ... + DAY_OF_WEEK_IN_MONTH: typing.ClassVar[DateFormat.Field] = ... + WEEK_OF_YEAR: typing.ClassVar[DateFormat.Field] = ... + WEEK_OF_MONTH: typing.ClassVar[DateFormat.Field] = ... + AM_PM: typing.ClassVar[DateFormat.Field] = ... + HOUR1: typing.ClassVar[DateFormat.Field] = ... + HOUR0: typing.ClassVar[DateFormat.Field] = ... + TIME_ZONE: typing.ClassVar[DateFormat.Field] = ... + def getCalendarField(self) -> int: ... + @staticmethod + def ofCalendarField(int: int) -> DateFormat.Field: ... + +class ListFormat(Format): + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def format(self, object: typing.Any) -> java.lang.String: ... + @typing.overload + def format( + self, list: java.util.List[java.lang.String | str] + ) -> java.lang.String: ... + @typing.overload + def format( + self, + object: typing.Any, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + def formatToCharacterIterator( + self, object: typing.Any + ) -> AttributedCharacterIterator: ... + @staticmethod + def getAvailableLocales() -> typing.MutableSequence[java.util.Locale]: ... + @typing.overload + @staticmethod + def getInstance() -> ListFormat: ... + @typing.overload + @staticmethod + def getInstance( + stringArray: list[java.lang.String] | jpype.JArray, + ) -> ListFormat: ... + @typing.overload + @staticmethod + def getInstance( + locale: java.util.Locale, type: ListFormat.Type, style: ListFormat.Style + ) -> ListFormat: ... + def getLocale(self) -> java.util.Locale: ... + def getPatterns(self) -> typing.MutableSequence[java.lang.String]: ... + def hashCode(self) -> int: ... + def parse( + self, string: java.lang.String | str + ) -> java.util.List[java.lang.String]: ... + @typing.overload + def parseObject(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def parseObject( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> typing.Any: ... + def toString(self) -> java.lang.String: ... + class Style(java.lang.Enum["ListFormat.Style"]): + FULL: typing.ClassVar[ListFormat.Style] = ... + SHORT: typing.ClassVar[ListFormat.Style] = ... + NARROW: typing.ClassVar[ListFormat.Style] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ListFormat.Style: ... + @staticmethod + def values() -> typing.MutableSequence[ListFormat.Style]: ... + + class Type(java.lang.Enum["ListFormat.Type"]): + STANDARD: typing.ClassVar[ListFormat.Type] = ... + OR: typing.ClassVar[ListFormat.Type] = ... + UNIT: typing.ClassVar[ListFormat.Type] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ListFormat.Type: ... + @staticmethod + def values() -> typing.MutableSequence[ListFormat.Type]: ... + +class MessageFormat(Format): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, locale: java.util.Locale): ... + def applyPattern(self, string: java.lang.String | str) -> None: ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def format(self, object: typing.Any) -> java.lang.String: ... + @typing.overload + def format( + self, + object: typing.Any, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format( + self, + objectArray: list[typing.Any] | jpype.JArray, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + @staticmethod + def format( + string: java.lang.String | str, *object: typing.Any + ) -> java.lang.String: ... + def formatToCharacterIterator( + self, object: typing.Any + ) -> AttributedCharacterIterator: ... + def getFormats(self) -> typing.MutableSequence[Format]: ... + def getFormatsByArgumentIndex(self) -> typing.MutableSequence[Format]: ... + def getLocale(self) -> java.util.Locale: ... + def hashCode(self) -> int: ... + @typing.overload + def parse( + self, string: java.lang.String | str + ) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def parse( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def parseObject(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def parseObject( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> typing.Any: ... + def setFormat(self, int: int, format: Format) -> None: ... + def setFormatByArgumentIndex(self, int: int, format: Format) -> None: ... + def setFormats(self, formatArray: list[Format] | jpype.JArray) -> None: ... + def setFormatsByArgumentIndex( + self, formatArray: list[Format] | jpype.JArray + ) -> None: ... + def setLocale(self, locale: java.util.Locale) -> None: ... + def toPattern(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + class Field(Format.Field): + ARGUMENT: typing.ClassVar[MessageFormat.Field] = ... + +class NumberFormat(Format): + INTEGER_FIELD: typing.ClassVar[int] = ... + FRACTION_FIELD: typing.ClassVar[int] = ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def format( + self, + double: float, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format( + self, + long: int, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format(self, object: typing.Any) -> java.lang.String: ... + @typing.overload + def format(self, double: float) -> java.lang.String: ... + @typing.overload + def format(self, long: int) -> java.lang.String: ... + @typing.overload + def format( + self, + object: typing.Any, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @staticmethod + def getAvailableLocales() -> typing.MutableSequence[java.util.Locale]: ... + @typing.overload + @staticmethod + def getCompactNumberInstance() -> NumberFormat: ... + @typing.overload + @staticmethod + def getCompactNumberInstance( + locale: java.util.Locale, style: NumberFormat.Style + ) -> NumberFormat: ... + def getCurrency(self) -> java.util.Currency: ... + @typing.overload + @staticmethod + def getCurrencyInstance() -> NumberFormat: ... + @typing.overload + @staticmethod + def getCurrencyInstance(locale: java.util.Locale) -> NumberFormat: ... + @typing.overload + @staticmethod + def getInstance() -> NumberFormat: ... + @typing.overload + @staticmethod + def getInstance(locale: java.util.Locale) -> NumberFormat: ... + @typing.overload + @staticmethod + def getIntegerInstance() -> NumberFormat: ... + @typing.overload + @staticmethod + def getIntegerInstance(locale: java.util.Locale) -> NumberFormat: ... + def getMaximumFractionDigits(self) -> int: ... + def getMaximumIntegerDigits(self) -> int: ... + def getMinimumFractionDigits(self) -> int: ... + def getMinimumIntegerDigits(self) -> int: ... + @typing.overload + @staticmethod + def getNumberInstance() -> NumberFormat: ... + @typing.overload + @staticmethod + def getNumberInstance(locale: java.util.Locale) -> NumberFormat: ... + @typing.overload + @staticmethod + def getPercentInstance() -> NumberFormat: ... + @typing.overload + @staticmethod + def getPercentInstance(locale: java.util.Locale) -> NumberFormat: ... + def getRoundingMode(self) -> java.math.RoundingMode: ... + def hashCode(self) -> int: ... + def isGroupingUsed(self) -> bool: ... + def isParseIntegerOnly(self) -> bool: ... + def isStrict(self) -> bool: ... + @typing.overload + def parse( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> java.lang.Number: ... + @typing.overload + def parse(self, string: java.lang.String | str) -> java.lang.Number: ... + @typing.overload + def parseObject( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> typing.Any: ... + @typing.overload + def parseObject(self, string: java.lang.String | str) -> typing.Any: ... + def setCurrency(self, currency: java.util.Currency) -> None: ... + def setGroupingUsed(self, boolean: bool) -> None: ... + def setMaximumFractionDigits(self, int: int) -> None: ... + def setMaximumIntegerDigits(self, int: int) -> None: ... + def setMinimumFractionDigits(self, int: int) -> None: ... + def setMinimumIntegerDigits(self, int: int) -> None: ... + def setParseIntegerOnly(self, boolean: bool) -> None: ... + def setRoundingMode(self, roundingMode: java.math.RoundingMode) -> None: ... + def setStrict(self, boolean: bool) -> None: ... + class Field(Format.Field): + INTEGER: typing.ClassVar[NumberFormat.Field] = ... + FRACTION: typing.ClassVar[NumberFormat.Field] = ... + EXPONENT: typing.ClassVar[NumberFormat.Field] = ... + DECIMAL_SEPARATOR: typing.ClassVar[NumberFormat.Field] = ... + SIGN: typing.ClassVar[NumberFormat.Field] = ... + GROUPING_SEPARATOR: typing.ClassVar[NumberFormat.Field] = ... + EXPONENT_SYMBOL: typing.ClassVar[NumberFormat.Field] = ... + PERCENT: typing.ClassVar[NumberFormat.Field] = ... + PERMILLE: typing.ClassVar[NumberFormat.Field] = ... + CURRENCY: typing.ClassVar[NumberFormat.Field] = ... + EXPONENT_SIGN: typing.ClassVar[NumberFormat.Field] = ... + PREFIX: typing.ClassVar[NumberFormat.Field] = ... + SUFFIX: typing.ClassVar[NumberFormat.Field] = ... + + class Style(java.lang.Enum["NumberFormat.Style"]): + SHORT: typing.ClassVar[NumberFormat.Style] = ... + LONG: typing.ClassVar[NumberFormat.Style] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> NumberFormat.Style: ... + @staticmethod + def values() -> typing.MutableSequence[NumberFormat.Style]: ... + +class ChoiceFormat(NumberFormat): + @typing.overload + def __init__( + self, + doubleArray: list[float] | jpype.JArray, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def applyPattern(self, string: java.lang.String | str) -> None: ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def format(self, object: typing.Any) -> java.lang.String: ... + @typing.overload + def format(self, double: float) -> java.lang.String: ... + @typing.overload + def format(self, long: int) -> java.lang.String: ... + @typing.overload + def format( + self, + double: float, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format( + self, + long: int, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format( + self, + object: typing.Any, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + def getFormats(self) -> typing.MutableSequence[typing.Any]: ... + def getLimits(self) -> typing.MutableSequence[float]: ... + def hashCode(self) -> int: ... + def isStrict(self) -> bool: ... + @typing.overload + @staticmethod + def nextDouble(double: float, boolean: bool) -> float: ... + @typing.overload + @staticmethod + def nextDouble(double: float) -> float: ... + @typing.overload + def parse( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> java.lang.Number: ... + @typing.overload + def parse(self, string: java.lang.String | str) -> java.lang.Number: ... + @staticmethod + def previousDouble(double: float) -> float: ... + def setChoices( + self, + doubleArray: list[float] | jpype.JArray, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> None: ... + def setStrict(self, boolean: bool) -> None: ... + def toPattern(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class CompactNumberFormat(NumberFormat): + @typing.overload + def __init__( + self, + string: java.lang.String | str, + decimalFormatSymbols: DecimalFormatSymbols, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + decimalFormatSymbols: DecimalFormatSymbols, + stringArray: list[java.lang.String] | jpype.JArray, + string3: java.lang.String | str, + ): ... + def clone(self) -> CompactNumberFormat: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def format(self, object: typing.Any) -> java.lang.String: ... + @typing.overload + def format(self, double: float) -> java.lang.String: ... + @typing.overload + def format(self, long: int) -> java.lang.String: ... + @typing.overload + def format( + self, + object: typing.Any, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format( + self, + double: float, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format( + self, + long: int, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + def formatToCharacterIterator( + self, object: typing.Any + ) -> AttributedCharacterIterator: ... + def getGroupingSize(self) -> int: ... + def getRoundingMode(self) -> java.math.RoundingMode: ... + def hashCode(self) -> int: ... + def isGroupingUsed(self) -> bool: ... + def isParseBigDecimal(self) -> bool: ... + def isParseIntegerOnly(self) -> bool: ... + def isStrict(self) -> bool: ... + @typing.overload + def parse( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> java.lang.Number: ... + @typing.overload + def parse(self, string: java.lang.String | str) -> java.lang.Number: ... + def setGroupingSize(self, int: int) -> None: ... + def setGroupingUsed(self, boolean: bool) -> None: ... + def setMaximumFractionDigits(self, int: int) -> None: ... + def setMaximumIntegerDigits(self, int: int) -> None: ... + def setMinimumFractionDigits(self, int: int) -> None: ... + def setMinimumIntegerDigits(self, int: int) -> None: ... + def setParseBigDecimal(self, boolean: bool) -> None: ... + def setParseIntegerOnly(self, boolean: bool) -> None: ... + def setRoundingMode(self, roundingMode: java.math.RoundingMode) -> None: ... + def setStrict(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class DecimalFormat(NumberFormat): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, decimalFormatSymbols: DecimalFormatSymbols + ): ... + def applyLocalizedPattern(self, string: java.lang.String | str) -> None: ... + def applyPattern(self, string: java.lang.String | str) -> None: ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def format(self, object: typing.Any) -> java.lang.String: ... + @typing.overload + def format(self, double: float) -> java.lang.String: ... + @typing.overload + def format(self, long: int) -> java.lang.String: ... + @typing.overload + def format( + self, + object: typing.Any, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format( + self, + double: float, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format( + self, + long: int, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + def formatToCharacterIterator( + self, object: typing.Any + ) -> AttributedCharacterIterator: ... + def getCurrency(self) -> java.util.Currency: ... + def getDecimalFormatSymbols(self) -> DecimalFormatSymbols: ... + def getGroupingSize(self) -> int: ... + def getMaximumFractionDigits(self) -> int: ... + def getMaximumIntegerDigits(self) -> int: ... + def getMinimumFractionDigits(self) -> int: ... + def getMinimumIntegerDigits(self) -> int: ... + def getMultiplier(self) -> int: ... + def getNegativePrefix(self) -> java.lang.String: ... + def getNegativeSuffix(self) -> java.lang.String: ... + def getPositivePrefix(self) -> java.lang.String: ... + def getPositiveSuffix(self) -> java.lang.String: ... + def getRoundingMode(self) -> java.math.RoundingMode: ... + def hashCode(self) -> int: ... + def isDecimalSeparatorAlwaysShown(self) -> bool: ... + def isParseBigDecimal(self) -> bool: ... + def isStrict(self) -> bool: ... + @typing.overload + def parse( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> java.lang.Number: ... + @typing.overload + def parse(self, string: java.lang.String | str) -> java.lang.Number: ... + def setCurrency(self, currency: java.util.Currency) -> None: ... + def setDecimalFormatSymbols( + self, decimalFormatSymbols: DecimalFormatSymbols + ) -> None: ... + def setDecimalSeparatorAlwaysShown(self, boolean: bool) -> None: ... + def setGroupingSize(self, int: int) -> None: ... + def setGroupingUsed(self, boolean: bool) -> None: ... + def setMaximumFractionDigits(self, int: int) -> None: ... + def setMaximumIntegerDigits(self, int: int) -> None: ... + def setMinimumFractionDigits(self, int: int) -> None: ... + def setMinimumIntegerDigits(self, int: int) -> None: ... + def setMultiplier(self, int: int) -> None: ... + def setNegativePrefix(self, string: java.lang.String | str) -> None: ... + def setNegativeSuffix(self, string: java.lang.String | str) -> None: ... + def setParseBigDecimal(self, boolean: bool) -> None: ... + def setPositivePrefix(self, string: java.lang.String | str) -> None: ... + def setPositiveSuffix(self, string: java.lang.String | str) -> None: ... + def setRoundingMode(self, roundingMode: java.math.RoundingMode) -> None: ... + def setStrict(self, boolean: bool) -> None: ... + def toLocalizedPattern(self) -> java.lang.String: ... + def toPattern(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class SimpleDateFormat(DateFormat): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, dateFormatSymbols: DateFormatSymbols + ): ... + @typing.overload + def __init__(self, string: java.lang.String | str, locale: java.util.Locale): ... + def applyLocalizedPattern(self, string: java.lang.String | str) -> None: ... + def applyPattern(self, string: java.lang.String | str) -> None: ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def format(self, date: java.util.Date) -> java.lang.String: ... + @typing.overload + def format(self, object: typing.Any) -> java.lang.String: ... + @typing.overload + def format( + self, + object: typing.Any, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + @typing.overload + def format( + self, + date: java.util.Date, + stringBuffer: java.lang.StringBuffer, + fieldPosition: FieldPosition, + ) -> java.lang.StringBuffer: ... + def formatToCharacterIterator( + self, object: typing.Any + ) -> AttributedCharacterIterator: ... + def get2DigitYearStart(self) -> java.util.Date: ... + def getDateFormatSymbols(self) -> DateFormatSymbols: ... + def hashCode(self) -> int: ... + @typing.overload + def parse(self, string: java.lang.String | str) -> java.util.Date: ... + @typing.overload + def parse( + self, string: java.lang.String | str, parsePosition: ParsePosition + ) -> java.util.Date: ... + def set2DigitYearStart(self, date: java.util.Date) -> None: ... + def setDateFormatSymbols(self, dateFormatSymbols: DateFormatSymbols) -> None: ... + def toLocalizedPattern(self) -> java.lang.String: ... + def toPattern(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.text")``. + + Annotation: type[Annotation] + AttributedCharacterIterator: type[AttributedCharacterIterator] + AttributedString: type[AttributedString] + Bidi: type[Bidi] + BreakIterator: type[BreakIterator] + CharacterIterator: type[CharacterIterator] + ChoiceFormat: type[ChoiceFormat] + CollationElementIterator: type[CollationElementIterator] + CollationKey: type[CollationKey] + Collator: type[Collator] + CompactNumberFormat: type[CompactNumberFormat] + DateFormat: type[DateFormat] + DateFormatSymbols: type[DateFormatSymbols] + DecimalFormat: type[DecimalFormat] + DecimalFormatSymbols: type[DecimalFormatSymbols] + FieldPosition: type[FieldPosition] + Format: type[Format] + ListFormat: type[ListFormat] + MessageFormat: type[MessageFormat] + Normalizer: type[Normalizer] + NumberFormat: type[NumberFormat] + ParseException: type[ParseException] + ParsePosition: type[ParsePosition] + RuleBasedCollator: type[RuleBasedCollator] + SimpleDateFormat: type[SimpleDateFormat] + StringCharacterIterator: type[StringCharacterIterator] + spi: java.text.spi.__module_protocol__ diff --git a/typings/java/text/spi/__init__.pyi b/typings/java/text/spi/__init__.pyi new file mode 100644 index 0000000..4f6ac5a --- /dev/null +++ b/typings/java/text/spi/__init__.pyi @@ -0,0 +1,62 @@ +from typing import Protocol + +import java.text +import java.util +import java.util.spi + +class BreakIteratorProvider(java.util.spi.LocaleServiceProvider): + def getCharacterInstance( + self, locale: java.util.Locale + ) -> java.text.BreakIterator: ... + def getLineInstance(self, locale: java.util.Locale) -> java.text.BreakIterator: ... + def getSentenceInstance( + self, locale: java.util.Locale + ) -> java.text.BreakIterator: ... + def getWordInstance(self, locale: java.util.Locale) -> java.text.BreakIterator: ... + +class CollatorProvider(java.util.spi.LocaleServiceProvider): + def getInstance(self, locale: java.util.Locale) -> java.text.Collator: ... + +class DateFormatProvider(java.util.spi.LocaleServiceProvider): + def getDateInstance( + self, int: int, locale: java.util.Locale + ) -> java.text.DateFormat: ... + def getDateTimeInstance( + self, int: int, int2: int, locale: java.util.Locale + ) -> java.text.DateFormat: ... + def getTimeInstance( + self, int: int, locale: java.util.Locale + ) -> java.text.DateFormat: ... + +class DateFormatSymbolsProvider(java.util.spi.LocaleServiceProvider): + def getInstance(self, locale: java.util.Locale) -> java.text.DateFormatSymbols: ... + +class DecimalFormatSymbolsProvider(java.util.spi.LocaleServiceProvider): + def getInstance( + self, locale: java.util.Locale + ) -> java.text.DecimalFormatSymbols: ... + +class NumberFormatProvider(java.util.spi.LocaleServiceProvider): + def getCompactNumberInstance( + self, locale: java.util.Locale, style: java.text.NumberFormat.Style + ) -> java.text.NumberFormat: ... + def getCurrencyInstance( + self, locale: java.util.Locale + ) -> java.text.NumberFormat: ... + def getIntegerInstance( + self, locale: java.util.Locale + ) -> java.text.NumberFormat: ... + def getNumberInstance(self, locale: java.util.Locale) -> java.text.NumberFormat: ... + def getPercentInstance( + self, locale: java.util.Locale + ) -> java.text.NumberFormat: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.text.spi")``. + + BreakIteratorProvider: type[BreakIteratorProvider] + CollatorProvider: type[CollatorProvider] + DateFormatProvider: type[DateFormatProvider] + DateFormatSymbolsProvider: type[DateFormatSymbolsProvider] + DecimalFormatSymbolsProvider: type[DecimalFormatSymbolsProvider] + NumberFormatProvider: type[NumberFormatProvider] diff --git a/typings/java/time/__init__.pyi b/typings/java/time/__init__.pyi new file mode 100644 index 0000000..95cd03e --- /dev/null +++ b/typings/java/time/__init__.pyi @@ -0,0 +1,1687 @@ +import datetime +import typing +from typing import Protocol + +import java.io +import java.lang +import java.time.chrono +import java.time.format +import java.time.temporal +import java.time.zone +import java.util +import java.util.stream + +class DateTimeException(java.lang.RuntimeException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + +class DayOfWeek( + java.lang.Enum["DayOfWeek"], + java.time.temporal.TemporalAccessor, + java.time.temporal.TemporalAdjuster, +): + MONDAY: typing.ClassVar[DayOfWeek] = ... + TUESDAY: typing.ClassVar[DayOfWeek] = ... + WEDNESDAY: typing.ClassVar[DayOfWeek] = ... + THURSDAY: typing.ClassVar[DayOfWeek] = ... + FRIDAY: typing.ClassVar[DayOfWeek] = ... + SATURDAY: typing.ClassVar[DayOfWeek] = ... + SUNDAY: typing.ClassVar[DayOfWeek] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> DayOfWeek: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getDisplayName( + self, textStyle: java.time.format.TextStyle, locale: java.util.Locale + ) -> java.lang.String: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getValue(self) -> int: ... + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + def minus(self, long: int) -> DayOfWeek: ... + @staticmethod + def of(int: int) -> DayOfWeek: ... + def plus(self, long: int) -> DayOfWeek: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> DayOfWeek: ... + @staticmethod + def values() -> typing.MutableSequence[DayOfWeek]: ... + +class Duration( + java.time.temporal.TemporalAmount, + java.lang.Comparable["Duration"], + java.io.Serializable, +): + ZERO: typing.ClassVar[Duration] = ... + def abs(self) -> Duration: ... + def addTo( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + @staticmethod + def between( + temporal: java.time.temporal.Temporal, temporal2: java.time.temporal.Temporal + ) -> Duration: ... + def compareTo(self, duration: Duration) -> int: ... + @typing.overload + def dividedBy(self, long: int) -> Duration: ... + @typing.overload + def dividedBy(self, duration: Duration) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_(temporalAmount: java.time.temporal.TemporalAmount) -> Duration: ... + def get(self, temporalUnit: java.time.temporal.TemporalUnit) -> int: ... + def getNano(self) -> int: ... + def getSeconds(self) -> int: ... + def getUnits(self) -> java.util.List[java.time.temporal.TemporalUnit]: ... + def hashCode(self) -> int: ... + def isNegative(self) -> bool: ... + def isPositive(self) -> bool: ... + def isZero(self) -> bool: ... + @typing.overload + def minus(self, duration: Duration) -> Duration: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> Duration: ... + def minusDays(self, long: int) -> Duration: ... + def minusHours(self, long: int) -> Duration: ... + def minusMillis(self, long: int) -> Duration: ... + def minusMinutes(self, long: int) -> Duration: ... + def minusNanos(self, long: int) -> Duration: ... + def minusSeconds(self, long: int) -> Duration: ... + def multipliedBy(self, long: int) -> Duration: ... + def negated(self) -> Duration: ... + @staticmethod + def of(long: int, temporalUnit: java.time.temporal.TemporalUnit) -> Duration: ... + @staticmethod + def ofDays(long: int) -> Duration: ... + @staticmethod + def ofHours(long: int) -> Duration: ... + @staticmethod + def ofMillis(long: int) -> Duration: ... + @staticmethod + def ofMinutes(long: int) -> Duration: ... + @staticmethod + def ofNanos(long: int) -> Duration: ... + @typing.overload + @staticmethod + def ofSeconds(long: int) -> Duration: ... + @typing.overload + @staticmethod + def ofSeconds(long: int, long2: int) -> Duration: ... + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> Duration: ... + @typing.overload + def plus(self, duration: Duration) -> Duration: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> Duration: ... + def plusDays(self, long: int) -> Duration: ... + def plusHours(self, long: int) -> Duration: ... + def plusMillis(self, long: int) -> Duration: ... + def plusMinutes(self, long: int) -> Duration: ... + def plusNanos(self, long: int) -> Duration: ... + def plusSeconds(self, long: int) -> Duration: ... + def subtractFrom( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def toDays(self) -> int: ... + def toDaysPart(self) -> int: ... + def toHours(self) -> int: ... + def toHoursPart(self) -> int: ... + def toMillis(self) -> int: ... + def toMillisPart(self) -> int: ... + def toMinutes(self) -> int: ... + def toMinutesPart(self) -> int: ... + def toNanos(self) -> int: ... + def toNanosPart(self) -> int: ... + def toSeconds(self) -> int: ... + def toSecondsPart(self) -> int: ... + def toString(self) -> java.lang.String: ... + def truncatedTo( + self, temporalUnit: java.time.temporal.TemporalUnit + ) -> Duration: ... + def withNanos(self, int: int) -> Duration: ... + def withSeconds(self, long: int) -> Duration: ... + +class Instant( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["Instant"], + java.io.Serializable, +): + EPOCH: typing.ClassVar[Instant] = ... + MIN: typing.ClassVar[Instant] = ... + MAX: typing.ClassVar[Instant] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atOffset(self, zoneOffset: ZoneOffset) -> OffsetDateTime: ... + def atZone(self, zoneId: ZoneId) -> ZonedDateTime: ... + def compareTo(self, instant: Instant | datetime.datetime) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> Instant: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getEpochSecond(self) -> int: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getNano(self) -> int: ... + def hashCode(self) -> int: ... + def isAfter(self, instant: Instant | datetime.datetime) -> bool: ... + def isBefore(self, instant: Instant | datetime.datetime) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + @typing.overload + def minus(self, temporalAmount: java.time.temporal.TemporalAmount) -> Instant: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> Instant: ... + def minusMillis(self, long: int) -> Instant: ... + def minusNanos(self, long: int) -> Instant: ... + def minusSeconds(self, long: int) -> Instant: ... + @typing.overload + @staticmethod + def now() -> Instant: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> Instant: ... + @staticmethod + def ofEpochMilli(long: int) -> Instant: ... + @typing.overload + @staticmethod + def ofEpochSecond(long: int) -> Instant: ... + @typing.overload + @staticmethod + def ofEpochSecond(long: int, long2: int) -> Instant: ... + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> Instant: ... + @typing.overload + def plus(self, temporalAmount: java.time.temporal.TemporalAmount) -> Instant: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> Instant: ... + def plusMillis(self, long: int) -> Instant: ... + def plusNanos(self, long: int) -> Instant: ... + def plusSeconds(self, long: int) -> Instant: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toEpochMilli(self) -> int: ... + def toString(self) -> java.lang.String: ... + def truncatedTo(self, temporalUnit: java.time.temporal.TemporalUnit) -> Instant: ... + @typing.overload + def until(self, instant: Instant | datetime.datetime) -> Duration: ... + @typing.overload + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> Instant: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> Instant: ... + +class InstantSource: + @staticmethod + def fixed(instant: Instant | datetime.datetime) -> InstantSource: ... + def instant(self) -> Instant: ... + def millis(self) -> int: ... + @staticmethod + def offset( + instantSource: InstantSource | typing.Callable, duration: Duration + ) -> InstantSource: ... + @staticmethod + def system() -> InstantSource: ... + @staticmethod + def tick( + instantSource: InstantSource | typing.Callable, duration: Duration + ) -> InstantSource: ... + def withZone(self, zoneId: ZoneId) -> Clock: ... + +class LocalDate( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.time.chrono.ChronoLocalDate, + java.io.Serializable, +): + MIN: typing.ClassVar[LocalDate] = ... + MAX: typing.ClassVar[LocalDate] = ... + EPOCH: typing.ClassVar[LocalDate] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + @typing.overload + def atStartOfDay(self) -> LocalDateTime: ... + @typing.overload + def atStartOfDay(self, zoneId: ZoneId) -> ZonedDateTime: ... + @typing.overload + def atTime(self, int: int, int2: int) -> LocalDateTime: ... + @typing.overload + def atTime(self, int: int, int2: int, int3: int) -> LocalDateTime: ... + @typing.overload + def atTime(self, int: int, int2: int, int3: int, int4: int) -> LocalDateTime: ... + @typing.overload + def atTime(self, localTime: LocalTime) -> LocalDateTime: ... + @typing.overload + def atTime(self, offsetTime: OffsetTime) -> OffsetDateTime: ... + def compareTo(self, chronoLocalDate: java.time.chrono.ChronoLocalDate) -> int: ... + @typing.overload + def datesUntil( + self, localDate: LocalDate + ) -> java.util.stream.Stream[LocalDate]: ... + @typing.overload + def datesUntil( + self, localDate: LocalDate, period: Period + ) -> java.util.stream.Stream[LocalDate]: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> LocalDate: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getChronology(self) -> java.time.chrono.IsoChronology: ... + def getDayOfMonth(self) -> int: ... + def getDayOfWeek(self) -> DayOfWeek: ... + def getDayOfYear(self) -> int: ... + def getEra(self) -> java.time.chrono.IsoEra: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getMonth(self) -> Month: ... + def getMonthValue(self) -> int: ... + def getYear(self) -> int: ... + def hashCode(self) -> int: ... + def isAfter(self, chronoLocalDate: java.time.chrono.ChronoLocalDate) -> bool: ... + def isBefore(self, chronoLocalDate: java.time.chrono.ChronoLocalDate) -> bool: ... + def isEqual(self, chronoLocalDate: java.time.chrono.ChronoLocalDate) -> bool: ... + def isLeapYear(self) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + def lengthOfMonth(self) -> int: ... + def lengthOfYear(self) -> int: ... + @typing.overload + def minus(self, temporalAmount: java.time.temporal.TemporalAmount) -> LocalDate: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> LocalDate: ... + def minusDays(self, long: int) -> LocalDate: ... + def minusMonths(self, long: int) -> LocalDate: ... + def minusWeeks(self, long: int) -> LocalDate: ... + def minusYears(self, long: int) -> LocalDate: ... + @typing.overload + @staticmethod + def now() -> LocalDate: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> LocalDate: ... + @typing.overload + @staticmethod + def now(zoneId: ZoneId) -> LocalDate: ... + @typing.overload + @staticmethod + def of(int: int, int2: int, int3: int) -> LocalDate: ... + @typing.overload + @staticmethod + def of(int: int, month: Month, int2: int) -> LocalDate: ... + @staticmethod + def ofEpochDay(long: int) -> LocalDate: ... + @staticmethod + def ofInstant( + instant: Instant | datetime.datetime, zoneId: ZoneId + ) -> LocalDate: ... + @staticmethod + def ofYearDay(int: int, int2: int) -> LocalDate: ... + @typing.overload + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> LocalDate: ... + @typing.overload + @staticmethod + def parse( + charSequence: java.lang.CharSequence | str, + dateTimeFormatter: java.time.format.DateTimeFormatter, + ) -> LocalDate: ... + @typing.overload + def plus(self, temporalAmount: java.time.temporal.TemporalAmount) -> LocalDate: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> LocalDate: ... + def plusDays(self, long: int) -> LocalDate: ... + def plusMonths(self, long: int) -> LocalDate: ... + def plusWeeks(self, long: int) -> LocalDate: ... + def plusYears(self, long: int) -> LocalDate: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toEpochDay(self) -> int: ... + def toEpochSecond(self, localTime: LocalTime, zoneOffset: ZoneOffset) -> int: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def until(self, chronoLocalDate: java.time.chrono.ChronoLocalDate) -> Period: ... + @typing.overload + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + def withDayOfMonth(self, int: int) -> LocalDate: ... + def withDayOfYear(self, int: int) -> LocalDate: ... + def withMonth(self, int: int) -> LocalDate: ... + def withYear(self, int: int) -> LocalDate: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> LocalDate: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> LocalDate: ... + +class LocalDateTime( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.time.chrono.ChronoLocalDateTime[LocalDate], + java.io.Serializable, +): + MIN: typing.ClassVar[LocalDateTime] = ... + MAX: typing.ClassVar[LocalDateTime] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atOffset(self, zoneOffset: ZoneOffset) -> OffsetDateTime: ... + def atZone(self, zoneId: ZoneId) -> ZonedDateTime: ... + def compareTo( + self, chronoLocalDateTime: java.time.chrono.ChronoLocalDateTime[typing.Any] + ) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_( + temporalAccessor: java.time.temporal.TemporalAccessor, + ) -> LocalDateTime: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getDayOfMonth(self) -> int: ... + def getDayOfWeek(self) -> DayOfWeek: ... + def getDayOfYear(self) -> int: ... + def getHour(self) -> int: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getMinute(self) -> int: ... + def getMonth(self) -> Month: ... + def getMonthValue(self) -> int: ... + def getNano(self) -> int: ... + def getSecond(self) -> int: ... + def getYear(self) -> int: ... + def hashCode(self) -> int: ... + def isAfter( + self, chronoLocalDateTime: java.time.chrono.ChronoLocalDateTime[typing.Any] + ) -> bool: ... + def isBefore( + self, chronoLocalDateTime: java.time.chrono.ChronoLocalDateTime[typing.Any] + ) -> bool: ... + def isEqual( + self, chronoLocalDateTime: java.time.chrono.ChronoLocalDateTime[typing.Any] + ) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> LocalDateTime: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> LocalDateTime: ... + def minusDays(self, long: int) -> LocalDateTime: ... + def minusHours(self, long: int) -> LocalDateTime: ... + def minusMinutes(self, long: int) -> LocalDateTime: ... + def minusMonths(self, long: int) -> LocalDateTime: ... + def minusNanos(self, long: int) -> LocalDateTime: ... + def minusSeconds(self, long: int) -> LocalDateTime: ... + def minusWeeks(self, long: int) -> LocalDateTime: ... + def minusYears(self, long: int) -> LocalDateTime: ... + @typing.overload + @staticmethod + def now() -> LocalDateTime: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> LocalDateTime: ... + @typing.overload + @staticmethod + def now(zoneId: ZoneId) -> LocalDateTime: ... + @typing.overload + @staticmethod + def of(int: int, int2: int, int3: int, int4: int, int5: int) -> LocalDateTime: ... + @typing.overload + @staticmethod + def of( + int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> LocalDateTime: ... + @typing.overload + @staticmethod + def of( + int: int, int2: int, int3: int, int4: int, int5: int, int6: int, int7: int + ) -> LocalDateTime: ... + @typing.overload + @staticmethod + def of( + int: int, month: Month, int2: int, int3: int, int4: int + ) -> LocalDateTime: ... + @typing.overload + @staticmethod + def of( + int: int, month: Month, int2: int, int3: int, int4: int, int5: int + ) -> LocalDateTime: ... + @typing.overload + @staticmethod + def of( + int: int, month: Month, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> LocalDateTime: ... + @typing.overload + @staticmethod + def of(localDate: LocalDate, localTime: LocalTime) -> LocalDateTime: ... + @staticmethod + def ofEpochSecond(long: int, int: int, zoneOffset: ZoneOffset) -> LocalDateTime: ... + @staticmethod + def ofInstant( + instant: Instant | datetime.datetime, zoneId: ZoneId + ) -> LocalDateTime: ... + @typing.overload + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> LocalDateTime: ... + @typing.overload + @staticmethod + def parse( + charSequence: java.lang.CharSequence | str, + dateTimeFormatter: java.time.format.DateTimeFormatter, + ) -> LocalDateTime: ... + @typing.overload + def plus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> LocalDateTime: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> LocalDateTime: ... + def plusDays(self, long: int) -> LocalDateTime: ... + def plusHours(self, long: int) -> LocalDateTime: ... + def plusMinutes(self, long: int) -> LocalDateTime: ... + def plusMonths(self, long: int) -> LocalDateTime: ... + def plusNanos(self, long: int) -> LocalDateTime: ... + def plusSeconds(self, long: int) -> LocalDateTime: ... + def plusWeeks(self, long: int) -> LocalDateTime: ... + def plusYears(self, long: int) -> LocalDateTime: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toLocalDate(self) -> LocalDate: ... + def toLocalTime(self) -> LocalTime: ... + def toString(self) -> java.lang.String: ... + def truncatedTo( + self, temporalUnit: java.time.temporal.TemporalUnit + ) -> LocalDateTime: ... + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + def withDayOfMonth(self, int: int) -> LocalDateTime: ... + def withDayOfYear(self, int: int) -> LocalDateTime: ... + def withHour(self, int: int) -> LocalDateTime: ... + def withMinute(self, int: int) -> LocalDateTime: ... + def withMonth(self, int: int) -> LocalDateTime: ... + def withNano(self, int: int) -> LocalDateTime: ... + def withSecond(self, int: int) -> LocalDateTime: ... + def withYear(self, int: int) -> LocalDateTime: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> LocalDateTime: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> LocalDateTime: ... + +class LocalTime( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["LocalTime"], + java.io.Serializable, +): + MIN: typing.ClassVar[LocalTime] = ... + MAX: typing.ClassVar[LocalTime] = ... + MIDNIGHT: typing.ClassVar[LocalTime] = ... + NOON: typing.ClassVar[LocalTime] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atDate(self, localDate: LocalDate) -> LocalDateTime: ... + def atOffset(self, zoneOffset: ZoneOffset) -> OffsetTime: ... + def compareTo(self, localTime: LocalTime) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> LocalTime: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getHour(self) -> int: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getMinute(self) -> int: ... + def getNano(self) -> int: ... + def getSecond(self) -> int: ... + def hashCode(self) -> int: ... + def isAfter(self, localTime: LocalTime) -> bool: ... + def isBefore(self, localTime: LocalTime) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + @typing.overload + def minus(self, temporalAmount: java.time.temporal.TemporalAmount) -> LocalTime: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> LocalTime: ... + def minusHours(self, long: int) -> LocalTime: ... + def minusMinutes(self, long: int) -> LocalTime: ... + def minusNanos(self, long: int) -> LocalTime: ... + def minusSeconds(self, long: int) -> LocalTime: ... + @typing.overload + @staticmethod + def now() -> LocalTime: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> LocalTime: ... + @typing.overload + @staticmethod + def now(zoneId: ZoneId) -> LocalTime: ... + @typing.overload + @staticmethod + def of(int: int, int2: int) -> LocalTime: ... + @typing.overload + @staticmethod + def of(int: int, int2: int, int3: int) -> LocalTime: ... + @typing.overload + @staticmethod + def of(int: int, int2: int, int3: int, int4: int) -> LocalTime: ... + @staticmethod + def ofInstant( + instant: Instant | datetime.datetime, zoneId: ZoneId + ) -> LocalTime: ... + @staticmethod + def ofNanoOfDay(long: int) -> LocalTime: ... + @staticmethod + def ofSecondOfDay(long: int) -> LocalTime: ... + @typing.overload + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> LocalTime: ... + @typing.overload + @staticmethod + def parse( + charSequence: java.lang.CharSequence | str, + dateTimeFormatter: java.time.format.DateTimeFormatter, + ) -> LocalTime: ... + @typing.overload + def plus(self, temporalAmount: java.time.temporal.TemporalAmount) -> LocalTime: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> LocalTime: ... + def plusHours(self, long: int) -> LocalTime: ... + def plusMinutes(self, long: int) -> LocalTime: ... + def plusNanos(self, long: int) -> LocalTime: ... + def plusSeconds(self, long: int) -> LocalTime: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toEpochSecond(self, localDate: LocalDate, zoneOffset: ZoneOffset) -> int: ... + def toNanoOfDay(self) -> int: ... + def toSecondOfDay(self) -> int: ... + def toString(self) -> java.lang.String: ... + def truncatedTo( + self, temporalUnit: java.time.temporal.TemporalUnit + ) -> LocalTime: ... + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + def withHour(self, int: int) -> LocalTime: ... + def withMinute(self, int: int) -> LocalTime: ... + def withNano(self, int: int) -> LocalTime: ... + def withSecond(self, int: int) -> LocalTime: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> LocalTime: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> LocalTime: ... + +class Month( + java.lang.Enum["Month"], + java.time.temporal.TemporalAccessor, + java.time.temporal.TemporalAdjuster, +): + JANUARY: typing.ClassVar[Month] = ... + FEBRUARY: typing.ClassVar[Month] = ... + MARCH: typing.ClassVar[Month] = ... + APRIL: typing.ClassVar[Month] = ... + MAY: typing.ClassVar[Month] = ... + JUNE: typing.ClassVar[Month] = ... + JULY: typing.ClassVar[Month] = ... + AUGUST: typing.ClassVar[Month] = ... + SEPTEMBER: typing.ClassVar[Month] = ... + OCTOBER: typing.ClassVar[Month] = ... + NOVEMBER: typing.ClassVar[Month] = ... + DECEMBER: typing.ClassVar[Month] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def firstDayOfYear(self, boolean: bool) -> int: ... + def firstMonthOfQuarter(self) -> Month: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> Month: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getDisplayName( + self, textStyle: java.time.format.TextStyle, locale: java.util.Locale + ) -> java.lang.String: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getValue(self) -> int: ... + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + def length(self, boolean: bool) -> int: ... + def maxLength(self) -> int: ... + def minLength(self) -> int: ... + def minus(self, long: int) -> Month: ... + @staticmethod + def of(int: int) -> Month: ... + def plus(self, long: int) -> Month: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Month: ... + @staticmethod + def values() -> typing.MutableSequence[Month]: ... + +class MonthDay( + java.time.temporal.TemporalAccessor, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["MonthDay"], + java.io.Serializable, +): + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atYear(self, int: int) -> LocalDate: ... + def compareTo(self, monthDay: MonthDay) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> MonthDay: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getDayOfMonth(self) -> int: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getMonth(self) -> Month: ... + def getMonthValue(self) -> int: ... + def hashCode(self) -> int: ... + def isAfter(self, monthDay: MonthDay) -> bool: ... + def isBefore(self, monthDay: MonthDay) -> bool: ... + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + def isValidYear(self, int: int) -> bool: ... + @typing.overload + @staticmethod + def now() -> MonthDay: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> MonthDay: ... + @typing.overload + @staticmethod + def now(zoneId: ZoneId) -> MonthDay: ... + @typing.overload + @staticmethod + def of(int: int, int2: int) -> MonthDay: ... + @typing.overload + @staticmethod + def of(month: Month, int: int) -> MonthDay: ... + @typing.overload + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> MonthDay: ... + @typing.overload + @staticmethod + def parse( + charSequence: java.lang.CharSequence | str, + dateTimeFormatter: java.time.format.DateTimeFormatter, + ) -> MonthDay: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toString(self) -> java.lang.String: ... + def withDayOfMonth(self, int: int) -> MonthDay: ... + def withMonth(self, int: int) -> MonthDay: ... + def with_(self, month: Month) -> MonthDay: ... + +class OffsetDateTime( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["OffsetDateTime"], + java.io.Serializable, +): + MIN: typing.ClassVar[OffsetDateTime] = ... + MAX: typing.ClassVar[OffsetDateTime] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atZoneSameInstant(self, zoneId: ZoneId) -> ZonedDateTime: ... + def atZoneSimilarLocal(self, zoneId: ZoneId) -> ZonedDateTime: ... + def compareTo(self, offsetDateTime: OffsetDateTime) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_( + temporalAccessor: java.time.temporal.TemporalAccessor, + ) -> OffsetDateTime: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getDayOfMonth(self) -> int: ... + def getDayOfWeek(self) -> DayOfWeek: ... + def getDayOfYear(self) -> int: ... + def getHour(self) -> int: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getMinute(self) -> int: ... + def getMonth(self) -> Month: ... + def getMonthValue(self) -> int: ... + def getNano(self) -> int: ... + def getOffset(self) -> ZoneOffset: ... + def getSecond(self) -> int: ... + def getYear(self) -> int: ... + def hashCode(self) -> int: ... + def isAfter(self, offsetDateTime: OffsetDateTime) -> bool: ... + def isBefore(self, offsetDateTime: OffsetDateTime) -> bool: ... + def isEqual(self, offsetDateTime: OffsetDateTime) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> OffsetDateTime: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> OffsetDateTime: ... + def minusDays(self, long: int) -> OffsetDateTime: ... + def minusHours(self, long: int) -> OffsetDateTime: ... + def minusMinutes(self, long: int) -> OffsetDateTime: ... + def minusMonths(self, long: int) -> OffsetDateTime: ... + def minusNanos(self, long: int) -> OffsetDateTime: ... + def minusSeconds(self, long: int) -> OffsetDateTime: ... + def minusWeeks(self, long: int) -> OffsetDateTime: ... + def minusYears(self, long: int) -> OffsetDateTime: ... + @typing.overload + @staticmethod + def now() -> OffsetDateTime: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> OffsetDateTime: ... + @typing.overload + @staticmethod + def now(zoneId: ZoneId) -> OffsetDateTime: ... + @typing.overload + @staticmethod + def of( + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + zoneOffset: ZoneOffset, + ) -> OffsetDateTime: ... + @typing.overload + @staticmethod + def of( + localDate: LocalDate, localTime: LocalTime, zoneOffset: ZoneOffset + ) -> OffsetDateTime: ... + @typing.overload + @staticmethod + def of(localDateTime: LocalDateTime, zoneOffset: ZoneOffset) -> OffsetDateTime: ... + @staticmethod + def ofInstant( + instant: Instant | datetime.datetime, zoneId: ZoneId + ) -> OffsetDateTime: ... + @typing.overload + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> OffsetDateTime: ... + @typing.overload + @staticmethod + def parse( + charSequence: java.lang.CharSequence | str, + dateTimeFormatter: java.time.format.DateTimeFormatter, + ) -> OffsetDateTime: ... + @typing.overload + def plus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> OffsetDateTime: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> OffsetDateTime: ... + def plusDays(self, long: int) -> OffsetDateTime: ... + def plusHours(self, long: int) -> OffsetDateTime: ... + def plusMinutes(self, long: int) -> OffsetDateTime: ... + def plusMonths(self, long: int) -> OffsetDateTime: ... + def plusNanos(self, long: int) -> OffsetDateTime: ... + def plusSeconds(self, long: int) -> OffsetDateTime: ... + def plusWeeks(self, long: int) -> OffsetDateTime: ... + def plusYears(self, long: int) -> OffsetDateTime: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + @staticmethod + def timeLineOrder() -> java.util.Comparator[OffsetDateTime]: ... + def toEpochSecond(self) -> int: ... + def toInstant(self) -> Instant: ... + def toLocalDate(self) -> LocalDate: ... + def toLocalDateTime(self) -> LocalDateTime: ... + def toLocalTime(self) -> LocalTime: ... + def toOffsetTime(self) -> OffsetTime: ... + def toString(self) -> java.lang.String: ... + def toZonedDateTime(self) -> ZonedDateTime: ... + def truncatedTo( + self, temporalUnit: java.time.temporal.TemporalUnit + ) -> OffsetDateTime: ... + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + def withDayOfMonth(self, int: int) -> OffsetDateTime: ... + def withDayOfYear(self, int: int) -> OffsetDateTime: ... + def withHour(self, int: int) -> OffsetDateTime: ... + def withMinute(self, int: int) -> OffsetDateTime: ... + def withMonth(self, int: int) -> OffsetDateTime: ... + def withNano(self, int: int) -> OffsetDateTime: ... + def withOffsetSameInstant(self, zoneOffset: ZoneOffset) -> OffsetDateTime: ... + def withOffsetSameLocal(self, zoneOffset: ZoneOffset) -> OffsetDateTime: ... + def withSecond(self, int: int) -> OffsetDateTime: ... + def withYear(self, int: int) -> OffsetDateTime: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> OffsetDateTime: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> OffsetDateTime: ... + +class OffsetTime( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["OffsetTime"], + java.io.Serializable, +): + MIN: typing.ClassVar[OffsetTime] = ... + MAX: typing.ClassVar[OffsetTime] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atDate(self, localDate: LocalDate) -> OffsetDateTime: ... + def compareTo(self, offsetTime: OffsetTime) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> OffsetTime: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getHour(self) -> int: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getMinute(self) -> int: ... + def getNano(self) -> int: ... + def getOffset(self) -> ZoneOffset: ... + def getSecond(self) -> int: ... + def hashCode(self) -> int: ... + def isAfter(self, offsetTime: OffsetTime) -> bool: ... + def isBefore(self, offsetTime: OffsetTime) -> bool: ... + def isEqual(self, offsetTime: OffsetTime) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> OffsetTime: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> OffsetTime: ... + def minusHours(self, long: int) -> OffsetTime: ... + def minusMinutes(self, long: int) -> OffsetTime: ... + def minusNanos(self, long: int) -> OffsetTime: ... + def minusSeconds(self, long: int) -> OffsetTime: ... + @typing.overload + @staticmethod + def now() -> OffsetTime: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> OffsetTime: ... + @typing.overload + @staticmethod + def now(zoneId: ZoneId) -> OffsetTime: ... + @typing.overload + @staticmethod + def of( + int: int, int2: int, int3: int, int4: int, zoneOffset: ZoneOffset + ) -> OffsetTime: ... + @typing.overload + @staticmethod + def of(localTime: LocalTime, zoneOffset: ZoneOffset) -> OffsetTime: ... + @staticmethod + def ofInstant( + instant: Instant | datetime.datetime, zoneId: ZoneId + ) -> OffsetTime: ... + @typing.overload + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> OffsetTime: ... + @typing.overload + @staticmethod + def parse( + charSequence: java.lang.CharSequence | str, + dateTimeFormatter: java.time.format.DateTimeFormatter, + ) -> OffsetTime: ... + @typing.overload + def plus(self, temporalAmount: java.time.temporal.TemporalAmount) -> OffsetTime: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> OffsetTime: ... + def plusHours(self, long: int) -> OffsetTime: ... + def plusMinutes(self, long: int) -> OffsetTime: ... + def plusNanos(self, long: int) -> OffsetTime: ... + def plusSeconds(self, long: int) -> OffsetTime: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toEpochSecond(self, localDate: LocalDate) -> int: ... + def toLocalTime(self) -> LocalTime: ... + def toString(self) -> java.lang.String: ... + def truncatedTo( + self, temporalUnit: java.time.temporal.TemporalUnit + ) -> OffsetTime: ... + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + def withHour(self, int: int) -> OffsetTime: ... + def withMinute(self, int: int) -> OffsetTime: ... + def withNano(self, int: int) -> OffsetTime: ... + def withOffsetSameInstant(self, zoneOffset: ZoneOffset) -> OffsetTime: ... + def withOffsetSameLocal(self, zoneOffset: ZoneOffset) -> OffsetTime: ... + def withSecond(self, int: int) -> OffsetTime: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> OffsetTime: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> OffsetTime: ... + +class Period(java.time.chrono.ChronoPeriod, java.io.Serializable): + ZERO: typing.ClassVar[Period] = ... + def addTo( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + @staticmethod + def between(localDate: LocalDate, localDate2: LocalDate) -> Period: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_(temporalAmount: java.time.temporal.TemporalAmount) -> Period: ... + def get(self, temporalUnit: java.time.temporal.TemporalUnit) -> int: ... + def getChronology(self) -> java.time.chrono.IsoChronology: ... + def getDays(self) -> int: ... + def getMonths(self) -> int: ... + def getUnits(self) -> java.util.List[java.time.temporal.TemporalUnit]: ... + def getYears(self) -> int: ... + def hashCode(self) -> int: ... + def isNegative(self) -> bool: ... + def isZero(self) -> bool: ... + def minus(self, temporalAmount: java.time.temporal.TemporalAmount) -> Period: ... + def minusDays(self, long: int) -> Period: ... + def minusMonths(self, long: int) -> Period: ... + def minusYears(self, long: int) -> Period: ... + def multipliedBy(self, int: int) -> Period: ... + def negated(self) -> Period: ... + def normalized(self) -> Period: ... + @staticmethod + def of(int: int, int2: int, int3: int) -> Period: ... + @staticmethod + def ofDays(int: int) -> Period: ... + @staticmethod + def ofMonths(int: int) -> Period: ... + @staticmethod + def ofWeeks(int: int) -> Period: ... + @staticmethod + def ofYears(int: int) -> Period: ... + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> Period: ... + def plus(self, temporalAmount: java.time.temporal.TemporalAmount) -> Period: ... + def plusDays(self, long: int) -> Period: ... + def plusMonths(self, long: int) -> Period: ... + def plusYears(self, long: int) -> Period: ... + def subtractFrom( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def toString(self) -> java.lang.String: ... + def toTotalMonths(self) -> int: ... + def withDays(self, int: int) -> Period: ... + def withMonths(self, int: int) -> Period: ... + def withYears(self, int: int) -> Period: ... + +class Year( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["Year"], + java.io.Serializable, +): + MIN_VALUE: typing.ClassVar[int] = ... + MAX_VALUE: typing.ClassVar[int] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atDay(self, int: int) -> LocalDate: ... + @typing.overload + def atMonth(self, int: int) -> YearMonth: ... + @typing.overload + def atMonth(self, month: Month) -> YearMonth: ... + def atMonthDay(self, monthDay: MonthDay) -> LocalDate: ... + def compareTo(self, year: Year) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> Year: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getValue(self) -> int: ... + def hashCode(self) -> int: ... + def isAfter(self, year: Year) -> bool: ... + def isBefore(self, year: Year) -> bool: ... + @typing.overload + def isLeap(self) -> bool: ... + @typing.overload + @staticmethod + def isLeap(long: int) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + def isValidMonthDay(self, monthDay: MonthDay) -> bool: ... + def length(self) -> int: ... + @typing.overload + def minus(self, temporalAmount: java.time.temporal.TemporalAmount) -> Year: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> Year: ... + def minusYears(self, long: int) -> Year: ... + @typing.overload + @staticmethod + def now() -> Year: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> Year: ... + @typing.overload + @staticmethod + def now(zoneId: ZoneId) -> Year: ... + @staticmethod + def of(int: int) -> Year: ... + @typing.overload + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> Year: ... + @typing.overload + @staticmethod + def parse( + charSequence: java.lang.CharSequence | str, + dateTimeFormatter: java.time.format.DateTimeFormatter, + ) -> Year: ... + @typing.overload + def plus(self, temporalAmount: java.time.temporal.TemporalAmount) -> Year: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> Year: ... + def plusYears(self, long: int) -> Year: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toString(self) -> java.lang.String: ... + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> Year: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> Year: ... + +class YearMonth( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["YearMonth"], + java.io.Serializable, +): + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atDay(self, int: int) -> LocalDate: ... + def atEndOfMonth(self) -> LocalDate: ... + def compareTo(self, yearMonth: YearMonth) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> YearMonth: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getMonth(self) -> Month: ... + def getMonthValue(self) -> int: ... + def getYear(self) -> int: ... + def hashCode(self) -> int: ... + def isAfter(self, yearMonth: YearMonth) -> bool: ... + def isBefore(self, yearMonth: YearMonth) -> bool: ... + def isLeapYear(self) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + def isValidDay(self, int: int) -> bool: ... + def lengthOfMonth(self) -> int: ... + def lengthOfYear(self) -> int: ... + @typing.overload + def minus(self, temporalAmount: java.time.temporal.TemporalAmount) -> YearMonth: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> YearMonth: ... + def minusMonths(self, long: int) -> YearMonth: ... + def minusYears(self, long: int) -> YearMonth: ... + @typing.overload + @staticmethod + def now() -> YearMonth: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> YearMonth: ... + @typing.overload + @staticmethod + def now(zoneId: ZoneId) -> YearMonth: ... + @typing.overload + @staticmethod + def of(int: int, int2: int) -> YearMonth: ... + @typing.overload + @staticmethod + def of(int: int, month: Month) -> YearMonth: ... + @typing.overload + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> YearMonth: ... + @typing.overload + @staticmethod + def parse( + charSequence: java.lang.CharSequence | str, + dateTimeFormatter: java.time.format.DateTimeFormatter, + ) -> YearMonth: ... + @typing.overload + def plus(self, temporalAmount: java.time.temporal.TemporalAmount) -> YearMonth: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> YearMonth: ... + def plusMonths(self, long: int) -> YearMonth: ... + def plusYears(self, long: int) -> YearMonth: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toString(self) -> java.lang.String: ... + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + def withMonth(self, int: int) -> YearMonth: ... + def withYear(self, int: int) -> YearMonth: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> YearMonth: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> YearMonth: ... + +class ZoneId(java.io.Serializable): + SHORT_IDS: typing.ClassVar[java.util.Map] = ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> ZoneId: ... + @staticmethod + def getAvailableZoneIds() -> java.util.Set[java.lang.String]: ... + def getDisplayName( + self, textStyle: java.time.format.TextStyle, locale: java.util.Locale + ) -> java.lang.String: ... + def getId(self) -> java.lang.String: ... + def getRules(self) -> java.time.zone.ZoneRules: ... + def hashCode(self) -> int: ... + def normalized(self) -> ZoneId: ... + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> ZoneId: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, + map: java.util.Map[java.lang.String | str, java.lang.String | str] + | typing.Mapping[java.lang.String | str, java.lang.String | str], + ) -> ZoneId: ... + @staticmethod + def ofOffset(string: java.lang.String | str, zoneOffset: ZoneOffset) -> ZoneId: ... + @staticmethod + def systemDefault() -> ZoneId: ... + def toString(self) -> java.lang.String: ... + +class ZonedDateTime( + java.time.temporal.Temporal, + java.time.chrono.ChronoZonedDateTime[LocalDate], + java.io.Serializable, +): + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_( + temporalAccessor: java.time.temporal.TemporalAccessor, + ) -> ZonedDateTime: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getDayOfMonth(self) -> int: ... + def getDayOfWeek(self) -> DayOfWeek: ... + def getDayOfYear(self) -> int: ... + def getHour(self) -> int: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getMinute(self) -> int: ... + def getMonth(self) -> Month: ... + def getMonthValue(self) -> int: ... + def getNano(self) -> int: ... + def getOffset(self) -> ZoneOffset: ... + def getSecond(self) -> int: ... + def getYear(self) -> int: ... + def getZone(self) -> ZoneId: ... + def hashCode(self) -> int: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ZonedDateTime: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ZonedDateTime: ... + def minusDays(self, long: int) -> ZonedDateTime: ... + def minusHours(self, long: int) -> ZonedDateTime: ... + def minusMinutes(self, long: int) -> ZonedDateTime: ... + def minusMonths(self, long: int) -> ZonedDateTime: ... + def minusNanos(self, long: int) -> ZonedDateTime: ... + def minusSeconds(self, long: int) -> ZonedDateTime: ... + def minusWeeks(self, long: int) -> ZonedDateTime: ... + def minusYears(self, long: int) -> ZonedDateTime: ... + @typing.overload + @staticmethod + def now() -> ZonedDateTime: ... + @typing.overload + @staticmethod + def now(clock: Clock) -> ZonedDateTime: ... + @typing.overload + @staticmethod + def now(zoneId: ZoneId) -> ZonedDateTime: ... + @typing.overload + @staticmethod + def of( + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + zoneId: ZoneId, + ) -> ZonedDateTime: ... + @typing.overload + @staticmethod + def of( + localDate: LocalDate, localTime: LocalTime, zoneId: ZoneId + ) -> ZonedDateTime: ... + @typing.overload + @staticmethod + def of(localDateTime: LocalDateTime, zoneId: ZoneId) -> ZonedDateTime: ... + @typing.overload + @staticmethod + def ofInstant( + instant: Instant | datetime.datetime, zoneId: ZoneId + ) -> ZonedDateTime: ... + @typing.overload + @staticmethod + def ofInstant( + localDateTime: LocalDateTime, zoneOffset: ZoneOffset, zoneId: ZoneId + ) -> ZonedDateTime: ... + @staticmethod + def ofLocal( + localDateTime: LocalDateTime, zoneId: ZoneId, zoneOffset: ZoneOffset + ) -> ZonedDateTime: ... + @staticmethod + def ofStrict( + localDateTime: LocalDateTime, zoneOffset: ZoneOffset, zoneId: ZoneId + ) -> ZonedDateTime: ... + @typing.overload + @staticmethod + def parse(charSequence: java.lang.CharSequence | str) -> ZonedDateTime: ... + @typing.overload + @staticmethod + def parse( + charSequence: java.lang.CharSequence | str, + dateTimeFormatter: java.time.format.DateTimeFormatter, + ) -> ZonedDateTime: ... + @typing.overload + def plus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ZonedDateTime: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ZonedDateTime: ... + def plusDays(self, long: int) -> ZonedDateTime: ... + def plusHours(self, long: int) -> ZonedDateTime: ... + def plusMinutes(self, long: int) -> ZonedDateTime: ... + def plusMonths(self, long: int) -> ZonedDateTime: ... + def plusNanos(self, long: int) -> ZonedDateTime: ... + def plusSeconds(self, long: int) -> ZonedDateTime: ... + def plusWeeks(self, long: int) -> ZonedDateTime: ... + def plusYears(self, long: int) -> ZonedDateTime: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toLocalDate(self) -> LocalDate: ... + def toLocalDateTime(self) -> LocalDateTime: ... + def toLocalTime(self) -> LocalTime: ... + def toOffsetDateTime(self) -> OffsetDateTime: ... + def toString(self) -> java.lang.String: ... + def truncatedTo( + self, temporalUnit: java.time.temporal.TemporalUnit + ) -> ZonedDateTime: ... + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + def withDayOfMonth(self, int: int) -> ZonedDateTime: ... + def withDayOfYear(self, int: int) -> ZonedDateTime: ... + def withEarlierOffsetAtOverlap(self) -> ZonedDateTime: ... + def withFixedOffsetZone(self) -> ZonedDateTime: ... + def withHour(self, int: int) -> ZonedDateTime: ... + def withLaterOffsetAtOverlap(self) -> ZonedDateTime: ... + def withMinute(self, int: int) -> ZonedDateTime: ... + def withMonth(self, int: int) -> ZonedDateTime: ... + def withNano(self, int: int) -> ZonedDateTime: ... + def withSecond(self, int: int) -> ZonedDateTime: ... + def withYear(self, int: int) -> ZonedDateTime: ... + def withZoneSameInstant(self, zoneId: ZoneId) -> ZonedDateTime: ... + def withZoneSameLocal(self, zoneId: ZoneId) -> ZonedDateTime: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> ZonedDateTime: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> ZonedDateTime: ... + +class Clock(InstantSource): + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def fixed(instant: Instant | datetime.datetime, zoneId: ZoneId) -> Clock: ... + def getZone(self) -> ZoneId: ... + def hashCode(self) -> int: ... + def instant(self) -> Instant: ... + def millis(self) -> int: ... + @staticmethod + def offset(clock: Clock, duration: Duration) -> Clock: ... + @staticmethod + def system(zoneId: ZoneId) -> Clock: ... + @staticmethod + def systemDefaultZone() -> Clock: ... + @staticmethod + def systemUTC() -> Clock: ... + @staticmethod + def tick(clock: Clock, duration: Duration) -> Clock: ... + @staticmethod + def tickMillis(zoneId: ZoneId) -> Clock: ... + @staticmethod + def tickMinutes(zoneId: ZoneId) -> Clock: ... + @staticmethod + def tickSeconds(zoneId: ZoneId) -> Clock: ... + def withZone(self, zoneId: ZoneId) -> Clock: ... + +class ZoneOffset( + ZoneId, + java.time.temporal.TemporalAccessor, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["ZoneOffset"], + java.io.Serializable, +): + UTC: typing.ClassVar[ZoneOffset] = ... + MIN: typing.ClassVar[ZoneOffset] = ... + MAX: typing.ClassVar[ZoneOffset] = ... + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def compareTo(self, zoneOffset: ZoneOffset) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> ZoneId: ... + @typing.overload + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> ZoneOffset: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getId(self) -> java.lang.String: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getRules(self) -> java.time.zone.ZoneRules: ... + def getTotalSeconds(self) -> int: ... + def hashCode(self) -> int: ... + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + def normalized(self) -> ZoneId: ... + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> ZoneId: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, + map: java.util.Map[java.lang.String | str, java.lang.String | str] + | typing.Mapping[java.lang.String | str, java.lang.String | str], + ) -> ZoneId: ... + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> ZoneOffset: ... + @staticmethod + def ofHours(int: int) -> ZoneOffset: ... + @staticmethod + def ofHoursMinutes(int: int, int2: int) -> ZoneOffset: ... + @staticmethod + def ofHoursMinutesSeconds(int: int, int2: int, int3: int) -> ZoneOffset: ... + @staticmethod + def ofTotalSeconds(int: int) -> ZoneOffset: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.time")``. + + Clock: type[Clock] + DateTimeException: type[DateTimeException] + DayOfWeek: type[DayOfWeek] + Duration: type[Duration] + Instant: type[Instant] + InstantSource: type[InstantSource] + LocalDate: type[LocalDate] + LocalDateTime: type[LocalDateTime] + LocalTime: type[LocalTime] + Month: type[Month] + MonthDay: type[MonthDay] + OffsetDateTime: type[OffsetDateTime] + OffsetTime: type[OffsetTime] + Period: type[Period] + Year: type[Year] + YearMonth: type[YearMonth] + ZoneId: type[ZoneId] + ZoneOffset: type[ZoneOffset] + ZonedDateTime: type[ZonedDateTime] + chrono: java.time.chrono.__module_protocol__ + format: java.time.format.__module_protocol__ + temporal: java.time.temporal.__module_protocol__ + zone: java.time.zone.__module_protocol__ diff --git a/typings/java/time/chrono/__init__.pyi b/typings/java/time/chrono/__init__.pyi new file mode 100644 index 0000000..4748b76 --- /dev/null +++ b/typings/java/time/chrono/__init__.pyi @@ -0,0 +1,1067 @@ +import datetime +import typing +from typing import Protocol + +import java +import java.io +import java.lang +import java.time +import java.time.format +import java.time.temporal +import java.util + +class ChronoLocalDate( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["ChronoLocalDate"], +): + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atTime( + self, localTime: java.time.LocalTime + ) -> ChronoLocalDateTime[typing.Any]: ... + def compareTo(self, chronoLocalDate: ChronoLocalDate) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_( + temporalAccessor: java.time.temporal.TemporalAccessor, + ) -> ChronoLocalDate: ... + def getChronology(self) -> Chronology: ... + def getEra(self) -> Era: ... + def hashCode(self) -> int: ... + def isAfter(self, chronoLocalDate: ChronoLocalDate) -> bool: ... + def isBefore(self, chronoLocalDate: ChronoLocalDate) -> bool: ... + def isEqual(self, chronoLocalDate: ChronoLocalDate) -> bool: ... + def isLeapYear(self) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + def lengthOfMonth(self) -> int: ... + def lengthOfYear(self) -> int: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ChronoLocalDate: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ChronoLocalDate: ... + @typing.overload + def plus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ChronoLocalDate: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ChronoLocalDate: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + @staticmethod + def timeLineOrder() -> java.util.Comparator[ChronoLocalDate]: ... + def toEpochDay(self) -> int: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def until(self, chronoLocalDate: ChronoLocalDate) -> ChronoPeriod: ... + @typing.overload + def until( + self, + temporal: java.time.temporal.Temporal, + temporalUnit: java.time.temporal.TemporalUnit, + ) -> int: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> ChronoLocalDate: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> ChronoLocalDate: ... + +_ChronoLocalDateTime__D = typing.TypeVar( + "_ChronoLocalDateTime__D", bound=ChronoLocalDate +) # + +class ChronoLocalDateTime( + java.time.temporal.Temporal, + java.time.temporal.TemporalAdjuster, + java.lang.Comparable["ChronoLocalDateTime"[typing.Any]], + typing.Generic[_ChronoLocalDateTime__D], +): + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def atZone( + self, zoneId: java.time.ZoneId + ) -> ChronoZonedDateTime[_ChronoLocalDateTime__D]: ... + def compareTo( + self, chronoLocalDateTime: ChronoLocalDateTime[typing.Any] + ) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_( + temporalAccessor: java.time.temporal.TemporalAccessor, + ) -> ChronoLocalDateTime[typing.Any]: ... + def getChronology(self) -> Chronology: ... + def hashCode(self) -> int: ... + def isAfter(self, chronoLocalDateTime: ChronoLocalDateTime[typing.Any]) -> bool: ... + def isBefore( + self, chronoLocalDateTime: ChronoLocalDateTime[typing.Any] + ) -> bool: ... + def isEqual(self, chronoLocalDateTime: ChronoLocalDateTime[typing.Any]) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ChronoLocalDateTime[_ChronoLocalDateTime__D]: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ChronoLocalDateTime[_ChronoLocalDateTime__D]: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ChronoLocalDateTime[_ChronoLocalDateTime__D]: ... + @typing.overload + def plus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ChronoLocalDateTime[_ChronoLocalDateTime__D]: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + @staticmethod + def timeLineOrder() -> java.util.Comparator[ChronoLocalDateTime[typing.Any]]: ... + def toEpochSecond(self, zoneOffset: java.time.ZoneOffset) -> int: ... + def toInstant(self, zoneOffset: java.time.ZoneOffset) -> java.time.Instant: ... + def toLocalDate(self) -> _ChronoLocalDateTime__D: ... + def toLocalTime(self) -> java.time.LocalTime: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> ChronoLocalDateTime[_ChronoLocalDateTime__D]: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> ChronoLocalDateTime[_ChronoLocalDateTime__D]: ... + +class ChronoPeriod(java.time.temporal.TemporalAmount): + def addTo( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + @staticmethod + def between( + chronoLocalDate: ChronoLocalDate, chronoLocalDate2: ChronoLocalDate + ) -> ChronoPeriod: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, temporalUnit: java.time.temporal.TemporalUnit) -> int: ... + def getChronology(self) -> Chronology: ... + def getUnits(self) -> java.util.List[java.time.temporal.TemporalUnit]: ... + def hashCode(self) -> int: ... + def isNegative(self) -> bool: ... + def isZero(self) -> bool: ... + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ChronoPeriod: ... + def multipliedBy(self, int: int) -> ChronoPeriod: ... + def negated(self) -> ChronoPeriod: ... + def normalized(self) -> ChronoPeriod: ... + def plus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ChronoPeriod: ... + def subtractFrom( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def toString(self) -> java.lang.String: ... + +_ChronoZonedDateTime__D = typing.TypeVar( + "_ChronoZonedDateTime__D", bound=ChronoLocalDate +) # + +class ChronoZonedDateTime( + java.time.temporal.Temporal, + java.lang.Comparable["ChronoZonedDateTime"[typing.Any]], + typing.Generic[_ChronoZonedDateTime__D], +): + def compareTo( + self, chronoZonedDateTime: ChronoZonedDateTime[typing.Any] + ) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def format( + self, dateTimeFormatter: java.time.format.DateTimeFormatter + ) -> java.lang.String: ... + @staticmethod + def from_( + temporalAccessor: java.time.temporal.TemporalAccessor, + ) -> ChronoZonedDateTime[typing.Any]: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getChronology(self) -> Chronology: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getOffset(self) -> java.time.ZoneOffset: ... + def getZone(self) -> java.time.ZoneId: ... + def hashCode(self) -> int: ... + def isAfter(self, chronoZonedDateTime: ChronoZonedDateTime[typing.Any]) -> bool: ... + def isBefore( + self, chronoZonedDateTime: ChronoZonedDateTime[typing.Any] + ) -> bool: ... + def isEqual(self, chronoZonedDateTime: ChronoZonedDateTime[typing.Any]) -> bool: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + @typing.overload + def plus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + @staticmethod + def timeLineOrder() -> java.util.Comparator[ChronoZonedDateTime[typing.Any]]: ... + def toEpochSecond(self) -> int: ... + def toInstant(self) -> java.time.Instant: ... + def toLocalDate(self) -> _ChronoZonedDateTime__D: ... + def toLocalDateTime(self) -> ChronoLocalDateTime[_ChronoZonedDateTime__D]: ... + def toLocalTime(self) -> java.time.LocalTime: ... + def toString(self) -> java.lang.String: ... + def withEarlierOffsetAtOverlap( + self, + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + def withLaterOffsetAtOverlap( + self, + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + def withZoneSameInstant( + self, zoneId: java.time.ZoneId + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + def withZoneSameLocal( + self, zoneId: java.time.ZoneId + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> ChronoZonedDateTime[_ChronoZonedDateTime__D]: ... + +class Chronology(java.lang.Comparable["Chronology"]): + def compareTo(self, chronology: Chronology) -> int: ... + @typing.overload + def date(self, int: int, int2: int, int3: int) -> ChronoLocalDate: ... + @typing.overload + def date( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoLocalDate: ... + @typing.overload + def date( + self, era: Era | typing.Callable, int: int, int2: int, int3: int + ) -> ChronoLocalDate: ... + def dateEpochDay(self, long: int) -> ChronoLocalDate: ... + @typing.overload + def dateNow(self) -> ChronoLocalDate: ... + @typing.overload + def dateNow(self, clock: java.time.Clock) -> ChronoLocalDate: ... + @typing.overload + def dateNow(self, zoneId: java.time.ZoneId) -> ChronoLocalDate: ... + @typing.overload + def dateYearDay(self, int: int, int2: int) -> ChronoLocalDate: ... + @typing.overload + def dateYearDay( + self, era: Era | typing.Callable, int: int, int2: int + ) -> ChronoLocalDate: ... + @typing.overload + def epochSecond( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + zoneOffset: java.time.ZoneOffset, + ) -> int: ... + @typing.overload + def epochSecond( + self, + era: Era | typing.Callable, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + zoneOffset: java.time.ZoneOffset, + ) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def eraOf(self, int: int) -> Era: ... + def eras(self) -> java.util.List[Era]: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> Chronology: ... + @staticmethod + def getAvailableChronologies() -> java.util.Set[Chronology]: ... + def getCalendarType(self) -> java.lang.String: ... + def getDisplayName( + self, textStyle: java.time.format.TextStyle, locale: java.util.Locale + ) -> java.lang.String: ... + def getId(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def isIsoBased(self) -> bool: ... + def isLeapYear(self, long: int) -> bool: ... + def localDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoLocalDateTime[ChronoLocalDate]: ... + @staticmethod + def of(string: java.lang.String | str) -> Chronology: ... + @staticmethod + def ofLocale(locale: java.util.Locale) -> Chronology: ... + def period(self, int: int, int2: int, int3: int) -> ChronoPeriod: ... + def prolepticYear(self, era: Era | typing.Callable, int: int) -> int: ... + def range( + self, chronoField: java.time.temporal.ChronoField + ) -> java.time.temporal.ValueRange: ... + def resolveDate( + self, + map: java.util.Map[java.time.temporal.TemporalField, int] + | typing.Mapping[java.time.temporal.TemporalField, int], + resolverStyle: java.time.format.ResolverStyle, + ) -> ChronoLocalDate: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def zonedDateTime( + self, instant: java.time.Instant | datetime.datetime, zoneId: java.time.ZoneId + ) -> ChronoZonedDateTime[ChronoLocalDate]: ... + @typing.overload + def zonedDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoZonedDateTime[ChronoLocalDate]: ... + +class Era(java.time.temporal.TemporalAccessor, java.time.temporal.TemporalAdjuster): + def adjustInto( + self, temporal: java.time.temporal.Temporal + ) -> java.time.temporal.Temporal: ... + def get(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getDisplayName( + self, textStyle: java.time.format.TextStyle, locale: java.util.Locale + ) -> java.lang.String: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def getValue(self) -> int: ... + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: java.time.temporal.TemporalQuery[_query__R] + | typing.Callable[[java.time.temporal.TemporalAccessor], _query__R], + ) -> _query__R: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + +class AbstractChronology(Chronology): + def compareTo(self, chronology: Chronology) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def resolveDate( + self, + map: java.util.Map[java.time.temporal.TemporalField, int] + | typing.Mapping[java.time.temporal.TemporalField, int], + resolverStyle: java.time.format.ResolverStyle, + ) -> ChronoLocalDate: ... + def toString(self) -> java.lang.String: ... + +class HijrahEra(java.lang.Enum["HijrahEra"], Era): + AH: typing.ClassVar[HijrahEra] = ... + def getDisplayName( + self, textStyle: java.time.format.TextStyle, locale: java.util.Locale + ) -> java.lang.String: ... + def getValue(self) -> int: ... + @staticmethod + def of(int: int) -> HijrahEra: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> HijrahEra: ... + @staticmethod + def values() -> typing.MutableSequence[HijrahEra]: ... + +class IsoEra(java.lang.Enum["IsoEra"], Era): + BCE: typing.ClassVar[IsoEra] = ... + CE: typing.ClassVar[IsoEra] = ... + def getValue(self) -> int: ... + @staticmethod + def of(int: int) -> IsoEra: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> IsoEra: ... + @staticmethod + def values() -> typing.MutableSequence[IsoEra]: ... + +class JapaneseEra(Era, java.io.Serializable): + MEIJI: typing.ClassVar[JapaneseEra] = ... + TAISHO: typing.ClassVar[JapaneseEra] = ... + SHOWA: typing.ClassVar[JapaneseEra] = ... + HEISEI: typing.ClassVar[JapaneseEra] = ... + REIWA: typing.ClassVar[JapaneseEra] = ... + def getDisplayName( + self, textStyle: java.time.format.TextStyle, locale: java.util.Locale + ) -> java.lang.String: ... + def getValue(self) -> int: ... + @staticmethod + def of(int: int) -> JapaneseEra: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toString(self) -> java.lang.String: ... + @staticmethod + def valueOf(string: java.lang.String | str) -> JapaneseEra: ... + @staticmethod + def values() -> typing.MutableSequence[JapaneseEra]: ... + +class MinguoEra(java.lang.Enum["MinguoEra"], Era): + BEFORE_ROC: typing.ClassVar[MinguoEra] = ... + ROC: typing.ClassVar[MinguoEra] = ... + def getDisplayName( + self, textStyle: java.time.format.TextStyle, locale: java.util.Locale + ) -> java.lang.String: ... + def getValue(self) -> int: ... + @staticmethod + def of(int: int) -> MinguoEra: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> MinguoEra: ... + @staticmethod + def values() -> typing.MutableSequence[MinguoEra]: ... + +class ThaiBuddhistEra(java.lang.Enum["ThaiBuddhistEra"], Era): + BEFORE_BE: typing.ClassVar[ThaiBuddhistEra] = ... + BE: typing.ClassVar[ThaiBuddhistEra] = ... + def getDisplayName( + self, textStyle: java.time.format.TextStyle, locale: java.util.Locale + ) -> java.lang.String: ... + def getValue(self) -> int: ... + @staticmethod + def of(int: int) -> ThaiBuddhistEra: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ThaiBuddhistEra: ... + @staticmethod + def values() -> typing.MutableSequence[ThaiBuddhistEra]: ... + +class HijrahChronology(AbstractChronology, java.io.Serializable): + INSTANCE: typing.ClassVar[HijrahChronology] = ... + @typing.overload + def date(self, int: int, int2: int, int3: int) -> HijrahDate: ... + @typing.overload + def date( + self, era: Era | typing.Callable, int: int, int2: int, int3: int + ) -> HijrahDate: ... + @typing.overload + def date( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> HijrahDate: ... + def dateEpochDay(self, long: int) -> HijrahDate: ... + @typing.overload + def dateNow(self) -> HijrahDate: ... + @typing.overload + def dateNow(self, clock: java.time.Clock) -> HijrahDate: ... + @typing.overload + def dateNow(self, zoneId: java.time.ZoneId) -> HijrahDate: ... + @typing.overload + def dateYearDay(self, int: int, int2: int) -> HijrahDate: ... + @typing.overload + def dateYearDay( + self, era: Era | typing.Callable, int: int, int2: int + ) -> HijrahDate: ... + def eraOf(self, int: int) -> HijrahEra: ... + def eras(self) -> java.util.List[Era]: ... + def getCalendarType(self) -> java.lang.String: ... + def getId(self) -> java.lang.String: ... + def isLeapYear(self, long: int) -> bool: ... + def localDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoLocalDateTime[HijrahDate]: ... + def prolepticYear(self, era: Era | typing.Callable, int: int) -> int: ... + def range( + self, chronoField: java.time.temporal.ChronoField + ) -> java.time.temporal.ValueRange: ... + def resolveDate( + self, + map: java.util.Map[java.time.temporal.TemporalField, int] + | typing.Mapping[java.time.temporal.TemporalField, int], + resolverStyle: java.time.format.ResolverStyle, + ) -> HijrahDate: ... + @typing.overload + def zonedDateTime( + self, instant: java.time.Instant | datetime.datetime, zoneId: java.time.ZoneId + ) -> ChronoZonedDateTime[HijrahDate]: ... + @typing.overload + def zonedDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoZonedDateTime[HijrahDate]: ... + +class IsoChronology(AbstractChronology, java.io.Serializable): + INSTANCE: typing.ClassVar[IsoChronology] = ... + @typing.overload + def date(self, int: int, int2: int, int3: int) -> java.time.LocalDate: ... + @typing.overload + def date( + self, era: Era | typing.Callable, int: int, int2: int, int3: int + ) -> java.time.LocalDate: ... + @typing.overload + def date( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> java.time.LocalDate: ... + def dateEpochDay(self, long: int) -> java.time.LocalDate: ... + @typing.overload + def dateNow(self) -> java.time.LocalDate: ... + @typing.overload + def dateNow(self, clock: java.time.Clock) -> java.time.LocalDate: ... + @typing.overload + def dateNow(self, zoneId: java.time.ZoneId) -> java.time.LocalDate: ... + @typing.overload + def dateYearDay(self, int: int, int2: int) -> java.time.LocalDate: ... + @typing.overload + def dateYearDay( + self, era: Era | typing.Callable, int: int, int2: int + ) -> java.time.LocalDate: ... + @typing.overload + def epochSecond( + self, + era: Era | typing.Callable, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + zoneOffset: java.time.ZoneOffset, + ) -> int: ... + @typing.overload + def epochSecond( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + zoneOffset: java.time.ZoneOffset, + ) -> int: ... + def eraOf(self, int: int) -> IsoEra: ... + def eras(self) -> java.util.List[Era]: ... + def getCalendarType(self) -> java.lang.String: ... + def getId(self) -> java.lang.String: ... + def isIsoBased(self) -> bool: ... + def isLeapYear(self, long: int) -> bool: ... + def localDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> java.time.LocalDateTime: ... + def period(self, int: int, int2: int, int3: int) -> java.time.Period: ... + def prolepticYear(self, era: Era | typing.Callable, int: int) -> int: ... + def range( + self, chronoField: java.time.temporal.ChronoField + ) -> java.time.temporal.ValueRange: ... + def resolveDate( + self, + map: java.util.Map[java.time.temporal.TemporalField, int] + | typing.Mapping[java.time.temporal.TemporalField, int], + resolverStyle: java.time.format.ResolverStyle, + ) -> java.time.LocalDate: ... + @typing.overload + def zonedDateTime( + self, instant: java.time.Instant | datetime.datetime, zoneId: java.time.ZoneId + ) -> java.time.ZonedDateTime: ... + @typing.overload + def zonedDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> java.time.ZonedDateTime: ... + +class JapaneseChronology(AbstractChronology, java.io.Serializable): + INSTANCE: typing.ClassVar[JapaneseChronology] = ... + @typing.overload + def date(self, int: int, int2: int, int3: int) -> JapaneseDate: ... + @typing.overload + def date( + self, era: Era | typing.Callable, int: int, int2: int, int3: int + ) -> JapaneseDate: ... + @typing.overload + def date( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> JapaneseDate: ... + def dateEpochDay(self, long: int) -> JapaneseDate: ... + @typing.overload + def dateNow(self) -> JapaneseDate: ... + @typing.overload + def dateNow(self, clock: java.time.Clock) -> JapaneseDate: ... + @typing.overload + def dateNow(self, zoneId: java.time.ZoneId) -> JapaneseDate: ... + @typing.overload + def dateYearDay(self, int: int, int2: int) -> JapaneseDate: ... + @typing.overload + def dateYearDay( + self, era: Era | typing.Callable, int: int, int2: int + ) -> JapaneseDate: ... + def eraOf(self, int: int) -> JapaneseEra: ... + def eras(self) -> java.util.List[Era]: ... + def getCalendarType(self) -> java.lang.String: ... + def getId(self) -> java.lang.String: ... + def isIsoBased(self) -> bool: ... + def isLeapYear(self, long: int) -> bool: ... + def localDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoLocalDateTime[JapaneseDate]: ... + def prolepticYear(self, era: Era | typing.Callable, int: int) -> int: ... + def range( + self, chronoField: java.time.temporal.ChronoField + ) -> java.time.temporal.ValueRange: ... + def resolveDate( + self, + map: java.util.Map[java.time.temporal.TemporalField, int] + | typing.Mapping[java.time.temporal.TemporalField, int], + resolverStyle: java.time.format.ResolverStyle, + ) -> JapaneseDate: ... + @typing.overload + def zonedDateTime( + self, instant: java.time.Instant | datetime.datetime, zoneId: java.time.ZoneId + ) -> ChronoZonedDateTime[JapaneseDate]: ... + @typing.overload + def zonedDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoZonedDateTime[JapaneseDate]: ... + +class MinguoChronology(AbstractChronology, java.io.Serializable): + INSTANCE: typing.ClassVar[MinguoChronology] = ... + @typing.overload + def date(self, int: int, int2: int, int3: int) -> MinguoDate: ... + @typing.overload + def date( + self, era: Era | typing.Callable, int: int, int2: int, int3: int + ) -> MinguoDate: ... + @typing.overload + def date( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> MinguoDate: ... + def dateEpochDay(self, long: int) -> MinguoDate: ... + @typing.overload + def dateNow(self) -> MinguoDate: ... + @typing.overload + def dateNow(self, clock: java.time.Clock) -> MinguoDate: ... + @typing.overload + def dateNow(self, zoneId: java.time.ZoneId) -> MinguoDate: ... + @typing.overload + def dateYearDay(self, int: int, int2: int) -> MinguoDate: ... + @typing.overload + def dateYearDay( + self, era: Era | typing.Callable, int: int, int2: int + ) -> MinguoDate: ... + def eraOf(self, int: int) -> MinguoEra: ... + def eras(self) -> java.util.List[Era]: ... + def getCalendarType(self) -> java.lang.String: ... + def getId(self) -> java.lang.String: ... + def isIsoBased(self) -> bool: ... + def isLeapYear(self, long: int) -> bool: ... + def localDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoLocalDateTime[MinguoDate]: ... + def prolepticYear(self, era: Era | typing.Callable, int: int) -> int: ... + def range( + self, chronoField: java.time.temporal.ChronoField + ) -> java.time.temporal.ValueRange: ... + def resolveDate( + self, + map: java.util.Map[java.time.temporal.TemporalField, int] + | typing.Mapping[java.time.temporal.TemporalField, int], + resolverStyle: java.time.format.ResolverStyle, + ) -> MinguoDate: ... + @typing.overload + def zonedDateTime( + self, instant: java.time.Instant | datetime.datetime, zoneId: java.time.ZoneId + ) -> ChronoZonedDateTime[MinguoDate]: ... + @typing.overload + def zonedDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoZonedDateTime[MinguoDate]: ... + +class ThaiBuddhistChronology(AbstractChronology, java.io.Serializable): + INSTANCE: typing.ClassVar[ThaiBuddhistChronology] = ... + @typing.overload + def date(self, int: int, int2: int, int3: int) -> ThaiBuddhistDate: ... + @typing.overload + def date( + self, era: Era | typing.Callable, int: int, int2: int, int3: int + ) -> ThaiBuddhistDate: ... + @typing.overload + def date( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ThaiBuddhistDate: ... + def dateEpochDay(self, long: int) -> ThaiBuddhistDate: ... + @typing.overload + def dateNow(self) -> ThaiBuddhistDate: ... + @typing.overload + def dateNow(self, clock: java.time.Clock) -> ThaiBuddhistDate: ... + @typing.overload + def dateNow(self, zoneId: java.time.ZoneId) -> ThaiBuddhistDate: ... + @typing.overload + def dateYearDay(self, int: int, int2: int) -> ThaiBuddhistDate: ... + @typing.overload + def dateYearDay( + self, era: Era | typing.Callable, int: int, int2: int + ) -> ThaiBuddhistDate: ... + def eraOf(self, int: int) -> ThaiBuddhistEra: ... + def eras(self) -> java.util.List[Era]: ... + def getCalendarType(self) -> java.lang.String: ... + def getId(self) -> java.lang.String: ... + def isIsoBased(self) -> bool: ... + def isLeapYear(self, long: int) -> bool: ... + def localDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoLocalDateTime[ThaiBuddhistDate]: ... + def prolepticYear(self, era: Era | typing.Callable, int: int) -> int: ... + def range( + self, chronoField: java.time.temporal.ChronoField + ) -> java.time.temporal.ValueRange: ... + def resolveDate( + self, + map: java.util.Map[java.time.temporal.TemporalField, int] + | typing.Mapping[java.time.temporal.TemporalField, int], + resolverStyle: java.time.format.ResolverStyle, + ) -> ThaiBuddhistDate: ... + @typing.overload + def zonedDateTime( + self, instant: java.time.Instant | datetime.datetime, zoneId: java.time.ZoneId + ) -> ChronoZonedDateTime[ThaiBuddhistDate]: ... + @typing.overload + def zonedDateTime( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> ChronoZonedDateTime[ThaiBuddhistDate]: ... + +class HijrahDate( + java.time.chrono.ChronoLocalDateImpl["HijrahDate"], + ChronoLocalDate, + java.io.Serializable, +): + def atTime( + self, localTime: java.time.LocalTime + ) -> ChronoLocalDateTime[HijrahDate]: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> HijrahDate: ... + def getChronology(self) -> HijrahChronology: ... + def getEra(self) -> HijrahEra: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def hashCode(self) -> int: ... + def isLeapYear(self) -> bool: ... + def lengthOfMonth(self) -> int: ... + def lengthOfYear(self) -> int: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> HijrahDate: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> HijrahDate: ... + @typing.overload + @staticmethod + def now() -> HijrahDate: ... + @typing.overload + @staticmethod + def now(clock: java.time.Clock) -> HijrahDate: ... + @typing.overload + @staticmethod + def now(zoneId: java.time.ZoneId) -> HijrahDate: ... + @staticmethod + def of(int: int, int2: int, int3: int) -> HijrahDate: ... + @typing.overload + def plus(self, temporalAmount: java.time.temporal.TemporalAmount) -> HijrahDate: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> HijrahDate: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toEpochDay(self) -> int: ... + def until(self, chronoLocalDate: ChronoLocalDate) -> ChronoPeriod: ... + def withVariant(self, hijrahChronology: HijrahChronology) -> HijrahDate: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> HijrahDate: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> HijrahDate: ... + +class JapaneseDate( + java.time.chrono.ChronoLocalDateImpl["JapaneseDate"], + ChronoLocalDate, + java.io.Serializable, +): + def atTime( + self, localTime: java.time.LocalTime + ) -> ChronoLocalDateTime[JapaneseDate]: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_( + temporalAccessor: java.time.temporal.TemporalAccessor, + ) -> JapaneseDate: ... + def getChronology(self) -> JapaneseChronology: ... + def getEra(self) -> JapaneseEra: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def hashCode(self) -> int: ... + @typing.overload + def isSupported(self, temporalField: java.time.temporal.TemporalField) -> bool: ... + @typing.overload + def isSupported(self, temporalUnit: java.time.temporal.TemporalUnit) -> bool: ... + def lengthOfMonth(self) -> int: ... + def lengthOfYear(self) -> int: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> JapaneseDate: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> JapaneseDate: ... + @typing.overload + @staticmethod + def now() -> JapaneseDate: ... + @typing.overload + @staticmethod + def now(clock: java.time.Clock) -> JapaneseDate: ... + @typing.overload + @staticmethod + def now(zoneId: java.time.ZoneId) -> JapaneseDate: ... + @typing.overload + @staticmethod + def of(int: int, int2: int, int3: int) -> JapaneseDate: ... + @typing.overload + @staticmethod + def of( + japaneseEra: JapaneseEra, int: int, int2: int, int3: int + ) -> JapaneseDate: ... + @typing.overload + def plus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> JapaneseDate: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> JapaneseDate: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toEpochDay(self) -> int: ... + def until(self, chronoLocalDate: ChronoLocalDate) -> ChronoPeriod: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> JapaneseDate: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> JapaneseDate: ... + +class MinguoDate( + java.time.chrono.ChronoLocalDateImpl["MinguoDate"], + ChronoLocalDate, + java.io.Serializable, +): + def atTime( + self, localTime: java.time.LocalTime + ) -> ChronoLocalDateTime[MinguoDate]: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_(temporalAccessor: java.time.temporal.TemporalAccessor) -> MinguoDate: ... + def getChronology(self) -> MinguoChronology: ... + def getEra(self) -> MinguoEra: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def hashCode(self) -> int: ... + def lengthOfMonth(self) -> int: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> MinguoDate: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> MinguoDate: ... + @typing.overload + @staticmethod + def now() -> MinguoDate: ... + @typing.overload + @staticmethod + def now(clock: java.time.Clock) -> MinguoDate: ... + @typing.overload + @staticmethod + def now(zoneId: java.time.ZoneId) -> MinguoDate: ... + @staticmethod + def of(int: int, int2: int, int3: int) -> MinguoDate: ... + @typing.overload + def plus(self, temporalAmount: java.time.temporal.TemporalAmount) -> MinguoDate: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> MinguoDate: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toEpochDay(self) -> int: ... + def until(self, chronoLocalDate: ChronoLocalDate) -> ChronoPeriod: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> MinguoDate: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> MinguoDate: ... + +class ThaiBuddhistDate( + java.time.chrono.ChronoLocalDateImpl["ThaiBuddhistDate"], + ChronoLocalDate, + java.io.Serializable, +): + def atTime( + self, localTime: java.time.LocalTime + ) -> ChronoLocalDateTime[ThaiBuddhistDate]: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_( + temporalAccessor: java.time.temporal.TemporalAccessor, + ) -> ThaiBuddhistDate: ... + def getChronology(self) -> ThaiBuddhistChronology: ... + def getEra(self) -> ThaiBuddhistEra: ... + def getLong(self, temporalField: java.time.temporal.TemporalField) -> int: ... + def hashCode(self) -> int: ... + def lengthOfMonth(self) -> int: ... + @typing.overload + def minus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ThaiBuddhistDate: ... + @typing.overload + def minus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ThaiBuddhistDate: ... + @typing.overload + @staticmethod + def now() -> ThaiBuddhistDate: ... + @typing.overload + @staticmethod + def now(clock: java.time.Clock) -> ThaiBuddhistDate: ... + @typing.overload + @staticmethod + def now(zoneId: java.time.ZoneId) -> ThaiBuddhistDate: ... + @staticmethod + def of(int: int, int2: int, int3: int) -> ThaiBuddhistDate: ... + @typing.overload + def plus( + self, temporalAmount: java.time.temporal.TemporalAmount + ) -> ThaiBuddhistDate: ... + @typing.overload + def plus( + self, long: int, temporalUnit: java.time.temporal.TemporalUnit + ) -> ThaiBuddhistDate: ... + def range( + self, temporalField: java.time.temporal.TemporalField + ) -> java.time.temporal.ValueRange: ... + def toEpochDay(self) -> int: ... + def until(self, chronoLocalDate: ChronoLocalDate) -> ChronoPeriod: ... + @typing.overload + def with_( + self, temporalAdjuster: java.time.temporal.TemporalAdjuster | typing.Callable + ) -> ThaiBuddhistDate: ... + @typing.overload + def with_( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> ThaiBuddhistDate: ... + +class ChronoLocalDateImpl: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.time.chrono")``. + + AbstractChronology: type[AbstractChronology] + ChronoLocalDate: type[ChronoLocalDate] + ChronoLocalDateImpl: type[ChronoLocalDateImpl] + ChronoLocalDateTime: type[ChronoLocalDateTime] + ChronoPeriod: type[ChronoPeriod] + ChronoZonedDateTime: type[ChronoZonedDateTime] + Chronology: type[Chronology] + Era: type[Era] + HijrahChronology: type[HijrahChronology] + HijrahDate: type[HijrahDate] + HijrahEra: type[HijrahEra] + IsoChronology: type[IsoChronology] + IsoEra: type[IsoEra] + JapaneseChronology: type[JapaneseChronology] + JapaneseDate: type[JapaneseDate] + JapaneseEra: type[JapaneseEra] + MinguoChronology: type[MinguoChronology] + MinguoDate: type[MinguoDate] + MinguoEra: type[MinguoEra] + ThaiBuddhistChronology: type[ThaiBuddhistChronology] + ThaiBuddhistDate: type[ThaiBuddhistDate] + ThaiBuddhistEra: type[ThaiBuddhistEra] diff --git a/typings/java/time/format/__init__.pyi b/typings/java/time/format/__init__.pyi new file mode 100644 index 0000000..96142ad --- /dev/null +++ b/typings/java/time/format/__init__.pyi @@ -0,0 +1,389 @@ +import typing +from typing import Protocol + +import java.lang +import java.text +import java.time +import java.time.chrono +import java.time.temporal +import java.util + +class DateTimeFormatter: + ISO_LOCAL_DATE: typing.ClassVar[DateTimeFormatter] = ... + ISO_OFFSET_DATE: typing.ClassVar[DateTimeFormatter] = ... + ISO_DATE: typing.ClassVar[DateTimeFormatter] = ... + ISO_LOCAL_TIME: typing.ClassVar[DateTimeFormatter] = ... + ISO_OFFSET_TIME: typing.ClassVar[DateTimeFormatter] = ... + ISO_TIME: typing.ClassVar[DateTimeFormatter] = ... + ISO_LOCAL_DATE_TIME: typing.ClassVar[DateTimeFormatter] = ... + ISO_OFFSET_DATE_TIME: typing.ClassVar[DateTimeFormatter] = ... + ISO_ZONED_DATE_TIME: typing.ClassVar[DateTimeFormatter] = ... + ISO_DATE_TIME: typing.ClassVar[DateTimeFormatter] = ... + ISO_ORDINAL_DATE: typing.ClassVar[DateTimeFormatter] = ... + ISO_WEEK_DATE: typing.ClassVar[DateTimeFormatter] = ... + ISO_INSTANT: typing.ClassVar[DateTimeFormatter] = ... + BASIC_ISO_DATE: typing.ClassVar[DateTimeFormatter] = ... + RFC_1123_DATE_TIME: typing.ClassVar[DateTimeFormatter] = ... + def format( + self, temporalAccessor: java.time.temporal.TemporalAccessor + ) -> java.lang.String: ... + def formatTo( + self, + temporalAccessor: java.time.temporal.TemporalAccessor, + appendable: java.lang.Appendable, + ) -> None: ... + def getChronology(self) -> java.time.chrono.Chronology: ... + def getDecimalStyle(self) -> DecimalStyle: ... + def getLocale(self) -> java.util.Locale: ... + def getResolverFields(self) -> java.util.Set[java.time.temporal.TemporalField]: ... + def getResolverStyle(self) -> ResolverStyle: ... + def getZone(self) -> java.time.ZoneId: ... + def localizedBy(self, locale: java.util.Locale) -> DateTimeFormatter: ... + @staticmethod + def ofLocalizedDate(formatStyle: FormatStyle) -> DateTimeFormatter: ... + @typing.overload + @staticmethod + def ofLocalizedDateTime(formatStyle: FormatStyle) -> DateTimeFormatter: ... + @typing.overload + @staticmethod + def ofLocalizedDateTime( + formatStyle: FormatStyle, formatStyle2: FormatStyle + ) -> DateTimeFormatter: ... + @staticmethod + def ofLocalizedPattern(string: java.lang.String | str) -> DateTimeFormatter: ... + @staticmethod + def ofLocalizedTime(formatStyle: FormatStyle) -> DateTimeFormatter: ... + @typing.overload + @staticmethod + def ofPattern(string: java.lang.String | str) -> DateTimeFormatter: ... + @typing.overload + @staticmethod + def ofPattern( + string: java.lang.String | str, locale: java.util.Locale + ) -> DateTimeFormatter: ... + _parse_0__T = typing.TypeVar("_parse_0__T") # + @typing.overload + def parse( + self, + charSequence: java.lang.CharSequence | str, + temporalQuery: java.time.temporal.TemporalQuery[_parse_0__T] + | typing.Callable[[java.time.temporal.TemporalAccessor], _parse_0__T], + ) -> _parse_0__T: ... + @typing.overload + def parse( + self, charSequence: java.lang.CharSequence | str + ) -> java.time.temporal.TemporalAccessor: ... + @typing.overload + def parse( + self, + charSequence: java.lang.CharSequence | str, + parsePosition: java.text.ParsePosition, + ) -> java.time.temporal.TemporalAccessor: ... + def parseBest( + self, + charSequence: java.lang.CharSequence | str, + *temporalQuery: java.time.temporal.TemporalQuery[typing.Any] + | typing.Callable[[java.time.temporal.TemporalAccessor], typing.Any], + ) -> java.time.temporal.TemporalAccessor: ... + def parseUnresolved( + self, + charSequence: java.lang.CharSequence | str, + parsePosition: java.text.ParsePosition, + ) -> java.time.temporal.TemporalAccessor: ... + @staticmethod + def parsedExcessDays() -> java.time.temporal.TemporalQuery[java.time.Period]: ... + @staticmethod + def parsedLeapSecond() -> java.time.temporal.TemporalQuery[bool]: ... + @typing.overload + def toFormat(self) -> java.text.Format: ... + @typing.overload + def toFormat( + self, + temporalQuery: java.time.temporal.TemporalQuery[typing.Any] + | typing.Callable[[java.time.temporal.TemporalAccessor], typing.Any], + ) -> java.text.Format: ... + def toString(self) -> java.lang.String: ... + def withChronology( + self, chronology: java.time.chrono.Chronology + ) -> DateTimeFormatter: ... + def withDecimalStyle(self, decimalStyle: DecimalStyle) -> DateTimeFormatter: ... + def withLocale(self, locale: java.util.Locale) -> DateTimeFormatter: ... + @typing.overload + def withResolverFields( + self, *temporalField: java.time.temporal.TemporalField + ) -> DateTimeFormatter: ... + @typing.overload + def withResolverFields( + self, set: java.util.Set[java.time.temporal.TemporalField] + ) -> DateTimeFormatter: ... + def withResolverStyle(self, resolverStyle: ResolverStyle) -> DateTimeFormatter: ... + def withZone(self, zoneId: java.time.ZoneId) -> DateTimeFormatter: ... + +class DateTimeFormatterBuilder: + def __init__(self): ... + def append( + self, dateTimeFormatter: DateTimeFormatter + ) -> DateTimeFormatterBuilder: ... + def appendChronologyId(self) -> DateTimeFormatterBuilder: ... + def appendChronologyText( + self, textStyle: TextStyle + ) -> DateTimeFormatterBuilder: ... + def appendDayPeriodText(self, textStyle: TextStyle) -> DateTimeFormatterBuilder: ... + def appendFraction( + self, + temporalField: java.time.temporal.TemporalField, + int: int, + int2: int, + boolean: bool, + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendGenericZoneText( + self, textStyle: TextStyle + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendGenericZoneText( + self, textStyle: TextStyle, set: java.util.Set[java.time.ZoneId] + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendInstant(self) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendInstant(self, int: int) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendLiteral(self, char: str) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendLiteral( + self, string: java.lang.String | str + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendLocalized( + self, string: java.lang.String | str + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendLocalized( + self, formatStyle: FormatStyle, formatStyle2: FormatStyle + ) -> DateTimeFormatterBuilder: ... + def appendLocalizedOffset( + self, textStyle: TextStyle + ) -> DateTimeFormatterBuilder: ... + def appendOffset( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> DateTimeFormatterBuilder: ... + def appendOffsetId(self) -> DateTimeFormatterBuilder: ... + def appendOptional( + self, dateTimeFormatter: DateTimeFormatter + ) -> DateTimeFormatterBuilder: ... + def appendPattern( + self, string: java.lang.String | str + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendText( + self, temporalField: java.time.temporal.TemporalField + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendText( + self, temporalField: java.time.temporal.TemporalField, textStyle: TextStyle + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendText( + self, + temporalField: java.time.temporal.TemporalField, + map: java.util.Map[int, java.lang.String | str] + | typing.Mapping[int, java.lang.String | str], + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendValue( + self, temporalField: java.time.temporal.TemporalField + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendValue( + self, temporalField: java.time.temporal.TemporalField, int: int + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendValue( + self, + temporalField: java.time.temporal.TemporalField, + int: int, + int2: int, + signStyle: SignStyle, + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendValueReduced( + self, + temporalField: java.time.temporal.TemporalField, + int: int, + int2: int, + int3: int, + ) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendValueReduced( + self, + temporalField: java.time.temporal.TemporalField, + int: int, + int2: int, + chronoLocalDate: java.time.chrono.ChronoLocalDate, + ) -> DateTimeFormatterBuilder: ... + def appendZoneId(self) -> DateTimeFormatterBuilder: ... + def appendZoneOrOffsetId(self) -> DateTimeFormatterBuilder: ... + def appendZoneRegionId(self) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendZoneText(self, textStyle: TextStyle) -> DateTimeFormatterBuilder: ... + @typing.overload + def appendZoneText( + self, textStyle: TextStyle, set: java.util.Set[java.time.ZoneId] + ) -> DateTimeFormatterBuilder: ... + @typing.overload + @staticmethod + def getLocalizedDateTimePattern( + string: java.lang.String | str, + chronology: java.time.chrono.Chronology, + locale: java.util.Locale, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def getLocalizedDateTimePattern( + formatStyle: FormatStyle, + formatStyle2: FormatStyle, + chronology: java.time.chrono.Chronology, + locale: java.util.Locale, + ) -> java.lang.String: ... + def optionalEnd(self) -> DateTimeFormatterBuilder: ... + def optionalStart(self) -> DateTimeFormatterBuilder: ... + @typing.overload + def padNext(self, int: int) -> DateTimeFormatterBuilder: ... + @typing.overload + def padNext(self, int: int, char: str) -> DateTimeFormatterBuilder: ... + def parseCaseInsensitive(self) -> DateTimeFormatterBuilder: ... + def parseCaseSensitive(self) -> DateTimeFormatterBuilder: ... + def parseDefaulting( + self, temporalField: java.time.temporal.TemporalField, long: int + ) -> DateTimeFormatterBuilder: ... + def parseLenient(self) -> DateTimeFormatterBuilder: ... + def parseStrict(self) -> DateTimeFormatterBuilder: ... + @typing.overload + def toFormatter(self) -> DateTimeFormatter: ... + @typing.overload + def toFormatter(self, locale: java.util.Locale) -> DateTimeFormatter: ... + +class DateTimeParseException(java.time.DateTimeException): + @typing.overload + def __init__( + self, + string: java.lang.String | str, + charSequence: java.lang.CharSequence | str, + int: int, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + charSequence: java.lang.CharSequence | str, + int: int, + throwable: java.lang.Throwable, + ): ... + def getErrorIndex(self) -> int: ... + def getParsedString(self) -> java.lang.String: ... + +class DecimalStyle: + STANDARD: typing.ClassVar[DecimalStyle] = ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def getAvailableLocales() -> java.util.Set[java.util.Locale]: ... + def getDecimalSeparator(self) -> str: ... + def getNegativeSign(self) -> str: ... + def getPositiveSign(self) -> str: ... + def getZeroDigit(self) -> str: ... + def hashCode(self) -> int: ... + @staticmethod + def of(locale: java.util.Locale) -> DecimalStyle: ... + @staticmethod + def ofDefaultLocale() -> DecimalStyle: ... + def toString(self) -> java.lang.String: ... + def withDecimalSeparator(self, char: str) -> DecimalStyle: ... + def withNegativeSign(self, char: str) -> DecimalStyle: ... + def withPositiveSign(self, char: str) -> DecimalStyle: ... + def withZeroDigit(self, char: str) -> DecimalStyle: ... + +class FormatStyle(java.lang.Enum["FormatStyle"]): + FULL: typing.ClassVar[FormatStyle] = ... + LONG: typing.ClassVar[FormatStyle] = ... + MEDIUM: typing.ClassVar[FormatStyle] = ... + SHORT: typing.ClassVar[FormatStyle] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> FormatStyle: ... + @staticmethod + def values() -> typing.MutableSequence[FormatStyle]: ... + +class ResolverStyle(java.lang.Enum["ResolverStyle"]): + STRICT: typing.ClassVar[ResolverStyle] = ... + SMART: typing.ClassVar[ResolverStyle] = ... + LENIENT: typing.ClassVar[ResolverStyle] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ResolverStyle: ... + @staticmethod + def values() -> typing.MutableSequence[ResolverStyle]: ... + +class SignStyle(java.lang.Enum["SignStyle"]): + NORMAL: typing.ClassVar[SignStyle] = ... + ALWAYS: typing.ClassVar[SignStyle] = ... + NEVER: typing.ClassVar[SignStyle] = ... + NOT_NEGATIVE: typing.ClassVar[SignStyle] = ... + EXCEEDS_PAD: typing.ClassVar[SignStyle] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> SignStyle: ... + @staticmethod + def values() -> typing.MutableSequence[SignStyle]: ... + +class TextStyle(java.lang.Enum["TextStyle"]): + FULL: typing.ClassVar[TextStyle] = ... + FULL_STANDALONE: typing.ClassVar[TextStyle] = ... + SHORT: typing.ClassVar[TextStyle] = ... + SHORT_STANDALONE: typing.ClassVar[TextStyle] = ... + NARROW: typing.ClassVar[TextStyle] = ... + NARROW_STANDALONE: typing.ClassVar[TextStyle] = ... + def asNormal(self) -> TextStyle: ... + def asStandalone(self) -> TextStyle: ... + def isStandalone(self) -> bool: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> TextStyle: ... + @staticmethod + def values() -> typing.MutableSequence[TextStyle]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.time.format")``. + + DateTimeFormatter: type[DateTimeFormatter] + DateTimeFormatterBuilder: type[DateTimeFormatterBuilder] + DateTimeParseException: type[DateTimeParseException] + DecimalStyle: type[DecimalStyle] + FormatStyle: type[FormatStyle] + ResolverStyle: type[ResolverStyle] + SignStyle: type[SignStyle] + TextStyle: type[TextStyle] diff --git a/typings/java/time/temporal/__init__.pyi b/typings/java/time/temporal/__init__.pyi new file mode 100644 index 0000000..b8abbe5 --- /dev/null +++ b/typings/java/time/temporal/__init__.pyi @@ -0,0 +1,320 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.time +import java.time.chrono +import java.time.format +import java.util +import java.util.function + +class IsoFields: + DAY_OF_QUARTER: typing.ClassVar[TemporalField] = ... + QUARTER_OF_YEAR: typing.ClassVar[TemporalField] = ... + WEEK_OF_WEEK_BASED_YEAR: typing.ClassVar[TemporalField] = ... + WEEK_BASED_YEAR: typing.ClassVar[TemporalField] = ... + WEEK_BASED_YEARS: typing.ClassVar[TemporalUnit] = ... + QUARTER_YEARS: typing.ClassVar[TemporalUnit] = ... + +class JulianFields: + JULIAN_DAY: typing.ClassVar[TemporalField] = ... + MODIFIED_JULIAN_DAY: typing.ClassVar[TemporalField] = ... + RATA_DIE: typing.ClassVar[TemporalField] = ... + +class TemporalAccessor: + def get(self, temporalField: TemporalField) -> int: ... + def getLong(self, temporalField: TemporalField) -> int: ... + def isSupported(self, temporalField: TemporalField) -> bool: ... + _query__R = typing.TypeVar("_query__R") # + def query( + self, + temporalQuery: TemporalQuery[_query__R] + | typing.Callable[[TemporalAccessor], _query__R], + ) -> _query__R: ... + def range(self, temporalField: TemporalField) -> ValueRange: ... + +class TemporalAdjuster: + def adjustInto(self, temporal: Temporal) -> Temporal: ... + +class TemporalAdjusters: + @staticmethod + def dayOfWeekInMonth( + int: int, dayOfWeek: java.time.DayOfWeek + ) -> TemporalAdjuster: ... + @staticmethod + def firstDayOfMonth() -> TemporalAdjuster: ... + @staticmethod + def firstDayOfNextMonth() -> TemporalAdjuster: ... + @staticmethod + def firstDayOfNextYear() -> TemporalAdjuster: ... + @staticmethod + def firstDayOfYear() -> TemporalAdjuster: ... + @staticmethod + def firstInMonth(dayOfWeek: java.time.DayOfWeek) -> TemporalAdjuster: ... + @staticmethod + def lastDayOfMonth() -> TemporalAdjuster: ... + @staticmethod + def lastDayOfYear() -> TemporalAdjuster: ... + @staticmethod + def lastInMonth(dayOfWeek: java.time.DayOfWeek) -> TemporalAdjuster: ... + @staticmethod + def next(dayOfWeek: java.time.DayOfWeek) -> TemporalAdjuster: ... + @staticmethod + def nextOrSame(dayOfWeek: java.time.DayOfWeek) -> TemporalAdjuster: ... + @staticmethod + def ofDateAdjuster( + unaryOperator: java.util.function.UnaryOperator[java.time.LocalDate] + | typing.Callable, + ) -> TemporalAdjuster: ... + @staticmethod + def previous(dayOfWeek: java.time.DayOfWeek) -> TemporalAdjuster: ... + @staticmethod + def previousOrSame(dayOfWeek: java.time.DayOfWeek) -> TemporalAdjuster: ... + +class TemporalAmount: + def addTo(self, temporal: Temporal) -> Temporal: ... + def get(self, temporalUnit: TemporalUnit) -> int: ... + def getUnits(self) -> java.util.List[TemporalUnit]: ... + def subtractFrom(self, temporal: Temporal) -> Temporal: ... + +class TemporalField: + _adjustInto__R = typing.TypeVar("_adjustInto__R", bound="Temporal") # + def adjustInto(self, r: _adjustInto__R, long: int) -> _adjustInto__R: ... + def getBaseUnit(self) -> TemporalUnit: ... + def getDisplayName(self, locale: java.util.Locale) -> java.lang.String: ... + def getFrom(self, temporalAccessor: TemporalAccessor) -> int: ... + def getRangeUnit(self) -> TemporalUnit: ... + def isDateBased(self) -> bool: ... + def isSupportedBy(self, temporalAccessor: TemporalAccessor) -> bool: ... + def isTimeBased(self) -> bool: ... + def range(self) -> ValueRange: ... + def rangeRefinedBy(self, temporalAccessor: TemporalAccessor) -> ValueRange: ... + def resolve( + self, + map: java.util.Map[TemporalField, int] | typing.Mapping[TemporalField, int], + temporalAccessor: TemporalAccessor, + resolverStyle: java.time.format.ResolverStyle, + ) -> TemporalAccessor: ... + def toString(self) -> java.lang.String: ... + +class TemporalQueries: + @staticmethod + def chronology() -> TemporalQuery[java.time.chrono.Chronology]: ... + @staticmethod + def localDate() -> TemporalQuery[java.time.LocalDate]: ... + @staticmethod + def localTime() -> TemporalQuery[java.time.LocalTime]: ... + @staticmethod + def offset() -> TemporalQuery[java.time.ZoneOffset]: ... + @staticmethod + def precision() -> TemporalQuery[TemporalUnit]: ... + @staticmethod + def zone() -> TemporalQuery[java.time.ZoneId]: ... + @staticmethod + def zoneId() -> TemporalQuery[java.time.ZoneId]: ... + +_TemporalQuery__R = typing.TypeVar("_TemporalQuery__R") # + +class TemporalQuery(typing.Generic[_TemporalQuery__R]): + def queryFrom(self, temporalAccessor: TemporalAccessor) -> _TemporalQuery__R: ... + +class TemporalUnit: + _addTo__R = typing.TypeVar("_addTo__R", bound="Temporal") # + def addTo(self, r: _addTo__R, long: int) -> _addTo__R: ... + def between(self, temporal: Temporal, temporal2: Temporal) -> int: ... + def getDuration(self) -> java.time.Duration: ... + def isDateBased(self) -> bool: ... + def isDurationEstimated(self) -> bool: ... + def isSupportedBy(self, temporal: Temporal) -> bool: ... + def isTimeBased(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class UnsupportedTemporalTypeException(java.time.DateTimeException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + +class ValueRange(java.io.Serializable): + def checkValidIntValue(self, long: int, temporalField: TemporalField) -> int: ... + def checkValidValue(self, long: int, temporalField: TemporalField) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getLargestMinimum(self) -> int: ... + def getMaximum(self) -> int: ... + def getMinimum(self) -> int: ... + def getSmallestMaximum(self) -> int: ... + def hashCode(self) -> int: ... + def isFixed(self) -> bool: ... + def isIntValue(self) -> bool: ... + def isValidIntValue(self, long: int) -> bool: ... + def isValidValue(self, long: int) -> bool: ... + @typing.overload + @staticmethod + def of(long: int, long2: int) -> ValueRange: ... + @typing.overload + @staticmethod + def of(long: int, long2: int, long3: int) -> ValueRange: ... + @typing.overload + @staticmethod + def of(long: int, long2: int, long3: int, long4: int) -> ValueRange: ... + def toString(self) -> java.lang.String: ... + +class WeekFields(java.io.Serializable): + ISO: typing.ClassVar[WeekFields] = ... + SUNDAY_START: typing.ClassVar[WeekFields] = ... + WEEK_BASED_YEARS: typing.ClassVar[TemporalUnit] = ... + def dayOfWeek(self) -> TemporalField: ... + def equals(self, object: typing.Any) -> bool: ... + def getFirstDayOfWeek(self) -> java.time.DayOfWeek: ... + def getMinimalDaysInFirstWeek(self) -> int: ... + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def of(dayOfWeek: java.time.DayOfWeek, int: int) -> WeekFields: ... + @typing.overload + @staticmethod + def of(locale: java.util.Locale) -> WeekFields: ... + def toString(self) -> java.lang.String: ... + def weekBasedYear(self) -> TemporalField: ... + def weekOfMonth(self) -> TemporalField: ... + def weekOfWeekBasedYear(self) -> TemporalField: ... + def weekOfYear(self) -> TemporalField: ... + +class ChronoField(java.lang.Enum["ChronoField"], TemporalField): + NANO_OF_SECOND: typing.ClassVar[ChronoField] = ... + NANO_OF_DAY: typing.ClassVar[ChronoField] = ... + MICRO_OF_SECOND: typing.ClassVar[ChronoField] = ... + MICRO_OF_DAY: typing.ClassVar[ChronoField] = ... + MILLI_OF_SECOND: typing.ClassVar[ChronoField] = ... + MILLI_OF_DAY: typing.ClassVar[ChronoField] = ... + SECOND_OF_MINUTE: typing.ClassVar[ChronoField] = ... + SECOND_OF_DAY: typing.ClassVar[ChronoField] = ... + MINUTE_OF_HOUR: typing.ClassVar[ChronoField] = ... + MINUTE_OF_DAY: typing.ClassVar[ChronoField] = ... + HOUR_OF_AMPM: typing.ClassVar[ChronoField] = ... + CLOCK_HOUR_OF_AMPM: typing.ClassVar[ChronoField] = ... + HOUR_OF_DAY: typing.ClassVar[ChronoField] = ... + CLOCK_HOUR_OF_DAY: typing.ClassVar[ChronoField] = ... + AMPM_OF_DAY: typing.ClassVar[ChronoField] = ... + DAY_OF_WEEK: typing.ClassVar[ChronoField] = ... + ALIGNED_DAY_OF_WEEK_IN_MONTH: typing.ClassVar[ChronoField] = ... + ALIGNED_DAY_OF_WEEK_IN_YEAR: typing.ClassVar[ChronoField] = ... + DAY_OF_MONTH: typing.ClassVar[ChronoField] = ... + DAY_OF_YEAR: typing.ClassVar[ChronoField] = ... + EPOCH_DAY: typing.ClassVar[ChronoField] = ... + ALIGNED_WEEK_OF_MONTH: typing.ClassVar[ChronoField] = ... + ALIGNED_WEEK_OF_YEAR: typing.ClassVar[ChronoField] = ... + MONTH_OF_YEAR: typing.ClassVar[ChronoField] = ... + PROLEPTIC_MONTH: typing.ClassVar[ChronoField] = ... + YEAR_OF_ERA: typing.ClassVar[ChronoField] = ... + YEAR: typing.ClassVar[ChronoField] = ... + ERA: typing.ClassVar[ChronoField] = ... + INSTANT_SECONDS: typing.ClassVar[ChronoField] = ... + OFFSET_SECONDS: typing.ClassVar[ChronoField] = ... + _adjustInto__R = typing.TypeVar("_adjustInto__R", bound="Temporal") # + def adjustInto(self, r: _adjustInto__R, long: int) -> _adjustInto__R: ... + def checkValidIntValue(self, long: int) -> int: ... + def checkValidValue(self, long: int) -> int: ... + def getBaseUnit(self) -> TemporalUnit: ... + def getDisplayName(self, locale: java.util.Locale) -> java.lang.String: ... + def getFrom(self, temporalAccessor: TemporalAccessor) -> int: ... + def getRangeUnit(self) -> TemporalUnit: ... + def isDateBased(self) -> bool: ... + def isSupportedBy(self, temporalAccessor: TemporalAccessor) -> bool: ... + def isTimeBased(self) -> bool: ... + def range(self) -> ValueRange: ... + def rangeRefinedBy(self, temporalAccessor: TemporalAccessor) -> ValueRange: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ChronoField: ... + @staticmethod + def values() -> typing.MutableSequence[ChronoField]: ... + +class ChronoUnit(java.lang.Enum["ChronoUnit"], TemporalUnit): + NANOS: typing.ClassVar[ChronoUnit] = ... + MICROS: typing.ClassVar[ChronoUnit] = ... + MILLIS: typing.ClassVar[ChronoUnit] = ... + SECONDS: typing.ClassVar[ChronoUnit] = ... + MINUTES: typing.ClassVar[ChronoUnit] = ... + HOURS: typing.ClassVar[ChronoUnit] = ... + HALF_DAYS: typing.ClassVar[ChronoUnit] = ... + DAYS: typing.ClassVar[ChronoUnit] = ... + WEEKS: typing.ClassVar[ChronoUnit] = ... + MONTHS: typing.ClassVar[ChronoUnit] = ... + YEARS: typing.ClassVar[ChronoUnit] = ... + DECADES: typing.ClassVar[ChronoUnit] = ... + CENTURIES: typing.ClassVar[ChronoUnit] = ... + MILLENNIA: typing.ClassVar[ChronoUnit] = ... + ERAS: typing.ClassVar[ChronoUnit] = ... + FOREVER: typing.ClassVar[ChronoUnit] = ... + _addTo__R = typing.TypeVar("_addTo__R", bound="Temporal") # + def addTo(self, r: _addTo__R, long: int) -> _addTo__R: ... + def between(self, temporal: Temporal, temporal2: Temporal) -> int: ... + def getDuration(self) -> java.time.Duration: ... + def isDateBased(self) -> bool: ... + def isDurationEstimated(self) -> bool: ... + def isSupportedBy(self, temporal: Temporal) -> bool: ... + def isTimeBased(self) -> bool: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ChronoUnit: ... + @staticmethod + def values() -> typing.MutableSequence[ChronoUnit]: ... + +class Temporal(TemporalAccessor): + @typing.overload + def isSupported(self, temporalUnit: TemporalUnit) -> bool: ... + @typing.overload + def isSupported(self, temporalField: TemporalField) -> bool: ... + @typing.overload + def minus(self, temporalAmount: TemporalAmount) -> Temporal: ... + @typing.overload + def minus(self, long: int, temporalUnit: TemporalUnit) -> Temporal: ... + @typing.overload + def plus(self, long: int, temporalUnit: TemporalUnit) -> Temporal: ... + @typing.overload + def plus(self, temporalAmount: TemporalAmount) -> Temporal: ... + def until(self, temporal: Temporal, temporalUnit: TemporalUnit) -> int: ... + @typing.overload + def with_(self, temporalField: TemporalField, long: int) -> Temporal: ... + @typing.overload + def with_( + self, temporalAdjuster: TemporalAdjuster | typing.Callable + ) -> Temporal: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.time.temporal")``. + + ChronoField: type[ChronoField] + ChronoUnit: type[ChronoUnit] + IsoFields: type[IsoFields] + JulianFields: type[JulianFields] + Temporal: type[Temporal] + TemporalAccessor: type[TemporalAccessor] + TemporalAdjuster: type[TemporalAdjuster] + TemporalAdjusters: type[TemporalAdjusters] + TemporalAmount: type[TemporalAmount] + TemporalField: type[TemporalField] + TemporalQueries: type[TemporalQueries] + TemporalQuery: type[TemporalQuery] + TemporalUnit: type[TemporalUnit] + UnsupportedTemporalTypeException: type[UnsupportedTemporalTypeException] + ValueRange: type[ValueRange] + WeekFields: type[WeekFields] diff --git a/typings/java/time/zone/__init__.pyi b/typings/java/time/zone/__init__.pyi new file mode 100644 index 0000000..d552604 --- /dev/null +++ b/typings/java/time/zone/__init__.pyi @@ -0,0 +1,167 @@ +import datetime +import typing +from typing import Protocol + +import java.io +import java.lang +import java.time +import java.util + +class ZoneOffsetTransition( + java.lang.Comparable["ZoneOffsetTransition"], java.io.Serializable +): + def compareTo(self, zoneOffsetTransition: ZoneOffsetTransition) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getDateTimeAfter(self) -> java.time.LocalDateTime: ... + def getDateTimeBefore(self) -> java.time.LocalDateTime: ... + def getDuration(self) -> java.time.Duration: ... + def getInstant(self) -> java.time.Instant: ... + def getOffsetAfter(self) -> java.time.ZoneOffset: ... + def getOffsetBefore(self) -> java.time.ZoneOffset: ... + def hashCode(self) -> int: ... + def isGap(self) -> bool: ... + def isOverlap(self) -> bool: ... + def isValidOffset(self, zoneOffset: java.time.ZoneOffset) -> bool: ... + @staticmethod + def of( + localDateTime: java.time.LocalDateTime, + zoneOffset: java.time.ZoneOffset, + zoneOffset2: java.time.ZoneOffset, + ) -> ZoneOffsetTransition: ... + def toEpochSecond(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class ZoneOffsetTransitionRule(java.io.Serializable): + def createTransition(self, int: int) -> ZoneOffsetTransition: ... + def equals(self, object: typing.Any) -> bool: ... + def getDayOfMonthIndicator(self) -> int: ... + def getDayOfWeek(self) -> java.time.DayOfWeek: ... + def getLocalTime(self) -> java.time.LocalTime: ... + def getMonth(self) -> java.time.Month: ... + def getOffsetAfter(self) -> java.time.ZoneOffset: ... + def getOffsetBefore(self) -> java.time.ZoneOffset: ... + def getStandardOffset(self) -> java.time.ZoneOffset: ... + def getTimeDefinition(self) -> ZoneOffsetTransitionRule.TimeDefinition: ... + def hashCode(self) -> int: ... + def isMidnightEndOfDay(self) -> bool: ... + @staticmethod + def of( + month: java.time.Month, + int: int, + dayOfWeek: java.time.DayOfWeek, + localTime: java.time.LocalTime, + boolean: bool, + timeDefinition: ZoneOffsetTransitionRule.TimeDefinition, + zoneOffset: java.time.ZoneOffset, + zoneOffset2: java.time.ZoneOffset, + zoneOffset3: java.time.ZoneOffset, + ) -> ZoneOffsetTransitionRule: ... + def toString(self) -> java.lang.String: ... + class TimeDefinition(java.lang.Enum["ZoneOffsetTransitionRule.TimeDefinition"]): + UTC: typing.ClassVar[ZoneOffsetTransitionRule.TimeDefinition] = ... + WALL: typing.ClassVar[ZoneOffsetTransitionRule.TimeDefinition] = ... + STANDARD: typing.ClassVar[ZoneOffsetTransitionRule.TimeDefinition] = ... + def createDateTime( + self, + localDateTime: java.time.LocalDateTime, + zoneOffset: java.time.ZoneOffset, + zoneOffset2: java.time.ZoneOffset, + ) -> java.time.LocalDateTime: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> ZoneOffsetTransitionRule.TimeDefinition: ... + @staticmethod + def values() -> typing.MutableSequence[ + ZoneOffsetTransitionRule.TimeDefinition + ]: ... + +class ZoneRules(java.io.Serializable): + def equals(self, object: typing.Any) -> bool: ... + def getDaylightSavings( + self, instant: java.time.Instant | datetime.datetime + ) -> java.time.Duration: ... + @typing.overload + def getOffset( + self, instant: java.time.Instant | datetime.datetime + ) -> java.time.ZoneOffset: ... + @typing.overload + def getOffset( + self, localDateTime: java.time.LocalDateTime + ) -> java.time.ZoneOffset: ... + def getStandardOffset( + self, instant: java.time.Instant | datetime.datetime + ) -> java.time.ZoneOffset: ... + def getTransition( + self, localDateTime: java.time.LocalDateTime + ) -> ZoneOffsetTransition: ... + def getTransitionRules(self) -> java.util.List[ZoneOffsetTransitionRule]: ... + def getTransitions(self) -> java.util.List[ZoneOffsetTransition]: ... + def getValidOffsets( + self, localDateTime: java.time.LocalDateTime + ) -> java.util.List[java.time.ZoneOffset]: ... + def hashCode(self) -> int: ... + def isDaylightSavings( + self, instant: java.time.Instant | datetime.datetime + ) -> bool: ... + def isFixedOffset(self) -> bool: ... + def isValidOffset( + self, localDateTime: java.time.LocalDateTime, zoneOffset: java.time.ZoneOffset + ) -> bool: ... + def nextTransition( + self, instant: java.time.Instant | datetime.datetime + ) -> ZoneOffsetTransition: ... + @typing.overload + @staticmethod + def of(zoneOffset: java.time.ZoneOffset) -> ZoneRules: ... + @typing.overload + @staticmethod + def of( + zoneOffset: java.time.ZoneOffset, + zoneOffset2: java.time.ZoneOffset, + list: java.util.List[ZoneOffsetTransition], + list2: java.util.List[ZoneOffsetTransition], + list3: java.util.List[ZoneOffsetTransitionRule], + ) -> ZoneRules: ... + def previousTransition( + self, instant: java.time.Instant | datetime.datetime + ) -> ZoneOffsetTransition: ... + def toString(self) -> java.lang.String: ... + +class ZoneRulesException(java.time.DateTimeException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + +class ZoneRulesProvider: + @staticmethod + def getAvailableZoneIds() -> java.util.Set[java.lang.String]: ... + @staticmethod + def getRules(string: java.lang.String | str, boolean: bool) -> ZoneRules: ... + @staticmethod + def getVersions( + string: java.lang.String | str, + ) -> java.util.NavigableMap[java.lang.String, ZoneRules]: ... + @staticmethod + def refresh() -> bool: ... + @staticmethod + def registerProvider(zoneRulesProvider: ZoneRulesProvider) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.time.zone")``. + + ZoneOffsetTransition: type[ZoneOffsetTransition] + ZoneOffsetTransitionRule: type[ZoneOffsetTransitionRule] + ZoneRules: type[ZoneRules] + ZoneRulesException: type[ZoneRulesException] + ZoneRulesProvider: type[ZoneRulesProvider] diff --git a/typings/java/util/__init__.pyi b/typings/java/util/__init__.pyi new file mode 100644 index 0000000..c556850 --- /dev/null +++ b/typings/java/util/__init__.pyi @@ -0,0 +1,6950 @@ +import builtins +import datetime +import typing +from typing import Protocol + +import java +import java.io +import java.lang +import java.math +import java.nio +import java.nio.channels +import java.nio.charset +import java.nio.file +import java.security +import java.time +import java.util.concurrent +import java.util.function +import java.util.jar +import java.util.logging +import java.util.prefs +import java.util.random +import java.util.regex +import java.util.spi +import java.util.stream +import java.util.zip +import jpype +import jpype.protocol +from jpype._jcollection import ( + _JCollection, + _JEnumeration, + _JIterator, + _JList, + _JMap, + _JMapEntry, + _JSet, +) + +class Arrays: + _asList__T = typing.TypeVar("_asList__T") # + @staticmethod + def asList(*t: _asList__T) -> List[_asList__T]: ... + _binarySearch_11__T = typing.TypeVar("_binarySearch_11__T") # + _binarySearch_13__T = typing.TypeVar("_binarySearch_13__T") # + @typing.overload + @staticmethod + def binarySearch( + byteArray: list[int] | jpype.JArray | bytes, byte2: int + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int, byte2: int + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch(charArray: list[str] | jpype.JArray, char2: str) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + charArray: list[str] | jpype.JArray, int: int, int2: int, char2: str + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + doubleArray: list[float] | jpype.JArray, double2: float + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + doubleArray: list[float] | jpype.JArray, int: int, int2: int, double2: float + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch(floatArray: list[float] | jpype.JArray, float2: float) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + floatArray: list[float] | jpype.JArray, int: int, int2: int, float2: float + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch(intArray: list[int] | jpype.JArray, int2: int) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + intArray: list[int] | jpype.JArray, int2: int, int3: int, int4: int + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + objectArray: list[typing.Any] | jpype.JArray, + int: int, + int2: int, + object2: typing.Any, + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + tArray: list[_binarySearch_11__T] | jpype.JArray, + int: int, + int2: int, + t2: _binarySearch_11__T, + comparator: Comparator[_binarySearch_11__T] + | typing.Callable[[_binarySearch_11__T, _binarySearch_11__T], int], + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + objectArray: list[typing.Any] | jpype.JArray, object2: typing.Any + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + tArray: list[_binarySearch_13__T] | jpype.JArray, + t2: _binarySearch_13__T, + comparator: Comparator[_binarySearch_13__T] + | typing.Callable[[_binarySearch_13__T, _binarySearch_13__T], int], + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + longArray: list[int] | jpype.JArray, int: int, int2: int, long2: int + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch(longArray: list[int] | jpype.JArray, long2: int) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + shortArray: list[int] | jpype.JArray, int: int, int2: int, short2: int + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch(shortArray: list[int] | jpype.JArray, short2: int) -> int: ... + _compare_12__T = typing.TypeVar("_compare_12__T", bound=java.lang.Comparable) # + _compare_13__T = typing.TypeVar("_compare_13__T", bound=java.lang.Comparable) # + _compare_14__T = typing.TypeVar("_compare_14__T") # + _compare_15__T = typing.TypeVar("_compare_15__T") # + @typing.overload + @staticmethod + def compare( + booleanArray: list[bool] | jpype.JArray, + booleanArray2: list[bool] | jpype.JArray, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + booleanArray: list[bool] | jpype.JArray, + int: int, + int2: int, + booleanArray2: list[bool] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + byteArray2: list[int] | jpype.JArray | bytes, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + charArray: list[str] | jpype.JArray, charArray2: list[str] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def compare( + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + charArray2: list[str] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + doubleArray: list[float] | jpype.JArray, + doubleArray2: list[float] | jpype.JArray, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + doubleArray: list[float] | jpype.JArray, + int: int, + int2: int, + doubleArray2: list[float] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + floatArray: list[float] | jpype.JArray, floatArray2: list[float] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def compare( + floatArray: list[float] | jpype.JArray, + int: int, + int2: int, + floatArray2: list[float] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + intArray: list[int] | jpype.JArray, + int2: int, + int3: int, + intArray2: list[int] | jpype.JArray, + int5: int, + int6: int, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def compare( + tArray: list[_compare_12__T] | jpype.JArray, + int: int, + int2: int, + tArray2: list[_compare_12__T] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + tArray: list[_compare_13__T] | jpype.JArray, + tArray2: list[_compare_13__T] | jpype.JArray, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + tArray: list[_compare_14__T] | jpype.JArray, + int: int, + int2: int, + tArray2: list[_compare_14__T] | jpype.JArray, + int3: int, + int4: int, + comparator: Comparator[_compare_14__T] + | typing.Callable[[_compare_14__T, _compare_14__T], int], + ) -> int: ... + @typing.overload + @staticmethod + def compare( + tArray: list[_compare_15__T] | jpype.JArray, + tArray2: list[_compare_15__T] | jpype.JArray, + comparator: Comparator[_compare_15__T] + | typing.Callable[[_compare_15__T, _compare_15__T], int], + ) -> int: ... + @typing.overload + @staticmethod + def compare( + longArray: list[int] | jpype.JArray, + int: int, + int2: int, + longArray2: list[int] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + longArray: list[int] | jpype.JArray, longArray2: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def compare( + shortArray: list[int] | jpype.JArray, + int: int, + int2: int, + shortArray2: list[int] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compare( + shortArray: list[int] | jpype.JArray, shortArray2: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def compareUnsigned( + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> int: ... + @typing.overload + @staticmethod + def compareUnsigned( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + byteArray2: list[int] | jpype.JArray | bytes, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compareUnsigned( + intArray: list[int] | jpype.JArray, + int2: int, + int3: int, + intArray2: list[int] | jpype.JArray, + int5: int, + int6: int, + ) -> int: ... + @typing.overload + @staticmethod + def compareUnsigned( + intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def compareUnsigned( + longArray: list[int] | jpype.JArray, + int: int, + int2: int, + longArray2: list[int] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compareUnsigned( + longArray: list[int] | jpype.JArray, longArray2: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def compareUnsigned( + shortArray: list[int] | jpype.JArray, + int: int, + int2: int, + shortArray2: list[int] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def compareUnsigned( + shortArray: list[int] | jpype.JArray, shortArray2: list[int] | jpype.JArray + ) -> int: ... + _copyOf_6__T = typing.TypeVar("_copyOf_6__T") # + _copyOf_7__T = typing.TypeVar("_copyOf_7__T") # + _copyOf_7__U = typing.TypeVar("_copyOf_7__U") # + @typing.overload + @staticmethod + def copyOf( + booleanArray: list[bool] | jpype.JArray, int: int + ) -> typing.MutableSequence[bool]: ... + @typing.overload + @staticmethod + def copyOf( + byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def copyOf( + charArray: list[str] | jpype.JArray, int: int + ) -> typing.MutableSequence[str]: ... + @typing.overload + @staticmethod + def copyOf( + doubleArray: list[float] | jpype.JArray, int: int + ) -> typing.MutableSequence[float]: ... + @typing.overload + @staticmethod + def copyOf( + floatArray: list[float] | jpype.JArray, int: int + ) -> typing.MutableSequence[float]: ... + @typing.overload + @staticmethod + def copyOf( + intArray: list[int] | jpype.JArray, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def copyOf( + tArray: list[_copyOf_6__T] | jpype.JArray, int: int + ) -> typing.MutableSequence[_copyOf_6__T]: ... + @typing.overload + @staticmethod + def copyOf( + uArray: list[_copyOf_7__U] | jpype.JArray, + int: int, + class_: type[typing.MutableSequence[_copyOf_7__T]], + ) -> typing.MutableSequence[_copyOf_7__T]: ... + @typing.overload + @staticmethod + def copyOf( + longArray: list[int] | jpype.JArray, int: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def copyOf( + shortArray: list[int] | jpype.JArray, int: int + ) -> typing.MutableSequence[int]: ... + _copyOfRange_6__T = typing.TypeVar("_copyOfRange_6__T") # + _copyOfRange_7__T = typing.TypeVar("_copyOfRange_7__T") # + _copyOfRange_7__U = typing.TypeVar("_copyOfRange_7__U") # + @typing.overload + @staticmethod + def copyOfRange( + booleanArray: list[bool] | jpype.JArray, int: int, int2: int + ) -> typing.MutableSequence[bool]: ... + @typing.overload + @staticmethod + def copyOfRange( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def copyOfRange( + charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> typing.MutableSequence[str]: ... + @typing.overload + @staticmethod + def copyOfRange( + doubleArray: list[float] | jpype.JArray, int: int, int2: int + ) -> typing.MutableSequence[float]: ... + @typing.overload + @staticmethod + def copyOfRange( + floatArray: list[float] | jpype.JArray, int: int, int2: int + ) -> typing.MutableSequence[float]: ... + @typing.overload + @staticmethod + def copyOfRange( + intArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def copyOfRange( + tArray: list[_copyOfRange_6__T] | jpype.JArray, int: int, int2: int + ) -> typing.MutableSequence[_copyOfRange_6__T]: ... + @typing.overload + @staticmethod + def copyOfRange( + uArray: list[_copyOfRange_7__U] | jpype.JArray, + int: int, + int2: int, + class_: type[typing.MutableSequence[_copyOfRange_7__T]], + ) -> typing.MutableSequence[_copyOfRange_7__T]: ... + @typing.overload + @staticmethod + def copyOfRange( + longArray: list[int] | jpype.JArray, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def copyOfRange( + shortArray: list[int] | jpype.JArray, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @staticmethod + def deepEquals( + objectArray: list[typing.Any] | jpype.JArray, + objectArray2: list[typing.Any] | jpype.JArray, + ) -> bool: ... + @staticmethod + def deepHashCode(objectArray: list[typing.Any] | jpype.JArray) -> int: ... + @staticmethod + def deepToString( + objectArray: list[typing.Any] | jpype.JArray, + ) -> java.lang.String: ... + _equals_14__T = typing.TypeVar("_equals_14__T") # + _equals_16__T = typing.TypeVar("_equals_16__T") # + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + @staticmethod + def equals( + booleanArray: list[bool] | jpype.JArray, + booleanArray2: list[bool] | jpype.JArray, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + booleanArray: list[bool] | jpype.JArray, + int: int, + int2: int, + booleanArray2: list[bool] | jpype.JArray, + int3: int, + int4: int, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + byteArray2: list[int] | jpype.JArray | bytes, + int3: int, + int4: int, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + charArray: list[str] | jpype.JArray, charArray2: list[str] | jpype.JArray + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + charArray2: list[str] | jpype.JArray, + int3: int, + int4: int, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + doubleArray: list[float] | jpype.JArray, + doubleArray2: list[float] | jpype.JArray, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + doubleArray: list[float] | jpype.JArray, + int: int, + int2: int, + doubleArray2: list[float] | jpype.JArray, + int3: int, + int4: int, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + floatArray: list[float] | jpype.JArray, floatArray2: list[float] | jpype.JArray + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + floatArray: list[float] | jpype.JArray, + int: int, + int2: int, + floatArray2: list[float] | jpype.JArray, + int3: int, + int4: int, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + intArray: list[int] | jpype.JArray, + int2: int, + int3: int, + intArray2: list[int] | jpype.JArray, + int5: int, + int6: int, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + objectArray: list[typing.Any] | jpype.JArray, + int: int, + int2: int, + objectArray2: list[typing.Any] | jpype.JArray, + int3: int, + int4: int, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + tArray: list[_equals_14__T] | jpype.JArray, + int: int, + int2: int, + tArray2: list[_equals_14__T] | jpype.JArray, + int3: int, + int4: int, + comparator: Comparator[_equals_14__T] + | typing.Callable[[_equals_14__T, _equals_14__T], int], + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + objectArray: list[typing.Any] | jpype.JArray, + objectArray2: list[typing.Any] | jpype.JArray, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + tArray: list[_equals_16__T] | jpype.JArray, + tArray2: list[_equals_16__T] | jpype.JArray, + comparator: Comparator[_equals_16__T] + | typing.Callable[[_equals_16__T, _equals_16__T], int], + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + longArray: list[int] | jpype.JArray, + int: int, + int2: int, + longArray2: list[int] | jpype.JArray, + int3: int, + int4: int, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + longArray: list[int] | jpype.JArray, longArray2: list[int] | jpype.JArray + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + shortArray: list[int] | jpype.JArray, + int: int, + int2: int, + shortArray2: list[int] | jpype.JArray, + int3: int, + int4: int, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + shortArray: list[int] | jpype.JArray, shortArray2: list[int] | jpype.JArray + ) -> bool: ... + @typing.overload + @staticmethod + def fill(booleanArray: list[bool] | jpype.JArray, boolean2: bool) -> None: ... + @typing.overload + @staticmethod + def fill( + booleanArray: list[bool] | jpype.JArray, int: int, int2: int, boolean2: bool + ) -> None: ... + @typing.overload + @staticmethod + def fill(byteArray: list[int] | jpype.JArray | bytes, byte2: int) -> None: ... + @typing.overload + @staticmethod + def fill( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int, byte2: int + ) -> None: ... + @typing.overload + @staticmethod + def fill(charArray: list[str] | jpype.JArray, char2: str) -> None: ... + @typing.overload + @staticmethod + def fill( + charArray: list[str] | jpype.JArray, int: int, int2: int, char2: str + ) -> None: ... + @typing.overload + @staticmethod + def fill(doubleArray: list[float] | jpype.JArray, double2: float) -> None: ... + @typing.overload + @staticmethod + def fill( + doubleArray: list[float] | jpype.JArray, int: int, int2: int, double2: float + ) -> None: ... + @typing.overload + @staticmethod + def fill(floatArray: list[float] | jpype.JArray, float2: float) -> None: ... + @typing.overload + @staticmethod + def fill( + floatArray: list[float] | jpype.JArray, int: int, int2: int, float2: float + ) -> None: ... + @typing.overload + @staticmethod + def fill(intArray: list[int] | jpype.JArray, int2: int) -> None: ... + @typing.overload + @staticmethod + def fill( + intArray: list[int] | jpype.JArray, int2: int, int3: int, int4: int + ) -> None: ... + @typing.overload + @staticmethod + def fill( + objectArray: list[typing.Any] | jpype.JArray, + int: int, + int2: int, + object2: typing.Any, + ) -> None: ... + @typing.overload + @staticmethod + def fill( + objectArray: list[typing.Any] | jpype.JArray, object2: typing.Any + ) -> None: ... + @typing.overload + @staticmethod + def fill( + longArray: list[int] | jpype.JArray, int: int, int2: int, long2: int + ) -> None: ... + @typing.overload + @staticmethod + def fill(longArray: list[int] | jpype.JArray, long2: int) -> None: ... + @typing.overload + @staticmethod + def fill( + shortArray: list[int] | jpype.JArray, int: int, int2: int, short2: int + ) -> None: ... + @typing.overload + @staticmethod + def fill(shortArray: list[int] | jpype.JArray, short2: int) -> None: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(booleanArray: list[bool] | jpype.JArray) -> int: ... + @typing.overload + @staticmethod + def hashCode(byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + @staticmethod + def hashCode(charArray: list[str] | jpype.JArray) -> int: ... + @typing.overload + @staticmethod + def hashCode(doubleArray: list[float] | jpype.JArray) -> int: ... + @typing.overload + @staticmethod + def hashCode(floatArray: list[float] | jpype.JArray) -> int: ... + @typing.overload + @staticmethod + def hashCode(intArray: list[int] | jpype.JArray) -> int: ... + @typing.overload + @staticmethod + def hashCode(objectArray: list[typing.Any] | jpype.JArray) -> int: ... + @typing.overload + @staticmethod + def hashCode(longArray: list[int] | jpype.JArray) -> int: ... + @typing.overload + @staticmethod + def hashCode(shortArray: list[int] | jpype.JArray) -> int: ... + _mismatch_13__T = typing.TypeVar("_mismatch_13__T") # + _mismatch_15__T = typing.TypeVar("_mismatch_15__T") # + @typing.overload + @staticmethod + def mismatch( + booleanArray: list[bool] | jpype.JArray, + booleanArray2: list[bool] | jpype.JArray, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + booleanArray: list[bool] | jpype.JArray, + int: int, + int2: int, + booleanArray2: list[bool] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + byteArray2: list[int] | jpype.JArray | bytes, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + charArray: list[str] | jpype.JArray, charArray2: list[str] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + charArray2: list[str] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + doubleArray: list[float] | jpype.JArray, + doubleArray2: list[float] | jpype.JArray, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + doubleArray: list[float] | jpype.JArray, + int: int, + int2: int, + doubleArray2: list[float] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + floatArray: list[float] | jpype.JArray, floatArray2: list[float] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + floatArray: list[float] | jpype.JArray, + int: int, + int2: int, + floatArray2: list[float] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + intArray: list[int] | jpype.JArray, + int2: int, + int3: int, + intArray2: list[int] | jpype.JArray, + int5: int, + int6: int, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + objectArray: list[typing.Any] | jpype.JArray, + int: int, + int2: int, + objectArray2: list[typing.Any] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + tArray: list[_mismatch_13__T] | jpype.JArray, + int: int, + int2: int, + tArray2: list[_mismatch_13__T] | jpype.JArray, + int3: int, + int4: int, + comparator: Comparator[_mismatch_13__T] + | typing.Callable[[_mismatch_13__T, _mismatch_13__T], int], + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + objectArray: list[typing.Any] | jpype.JArray, + objectArray2: list[typing.Any] | jpype.JArray, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + tArray: list[_mismatch_15__T] | jpype.JArray, + tArray2: list[_mismatch_15__T] | jpype.JArray, + comparator: Comparator[_mismatch_15__T] + | typing.Callable[[_mismatch_15__T, _mismatch_15__T], int], + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + longArray: list[int] | jpype.JArray, + int: int, + int2: int, + longArray2: list[int] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + longArray: list[int] | jpype.JArray, longArray2: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + shortArray: list[int] | jpype.JArray, + int: int, + int2: int, + shortArray2: list[int] | jpype.JArray, + int3: int, + int4: int, + ) -> int: ... + @typing.overload + @staticmethod + def mismatch( + shortArray: list[int] | jpype.JArray, shortArray2: list[int] | jpype.JArray + ) -> int: ... + _parallelPrefix_4__T = typing.TypeVar("_parallelPrefix_4__T") # + _parallelPrefix_5__T = typing.TypeVar("_parallelPrefix_5__T") # + @typing.overload + @staticmethod + def parallelPrefix( + doubleArray: list[float] | jpype.JArray, + int: int, + int2: int, + doubleBinaryOperator: java.util.function.DoubleBinaryOperator | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def parallelPrefix( + doubleArray: list[float] | jpype.JArray, + doubleBinaryOperator: java.util.function.DoubleBinaryOperator | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def parallelPrefix( + intArray: list[int] | jpype.JArray, + int2: int, + int3: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def parallelPrefix( + intArray: list[int] | jpype.JArray, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def parallelPrefix( + tArray: list[_parallelPrefix_4__T] | jpype.JArray, + int: int, + int2: int, + binaryOperator: java.util.function.BinaryOperator[_parallelPrefix_4__T] + | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def parallelPrefix( + tArray: list[_parallelPrefix_5__T] | jpype.JArray, + binaryOperator: java.util.function.BinaryOperator[_parallelPrefix_5__T] + | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def parallelPrefix( + longArray: list[int] | jpype.JArray, + int: int, + int2: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def parallelPrefix( + longArray: list[int] | jpype.JArray, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> None: ... + _parallelSetAll_2__T = typing.TypeVar("_parallelSetAll_2__T") # + @typing.overload + @staticmethod + def parallelSetAll( + doubleArray: list[float] | jpype.JArray, + intToDoubleFunction: java.util.function.IntToDoubleFunction | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def parallelSetAll( + intArray: list[int] | jpype.JArray, + intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def parallelSetAll( + tArray: list[_parallelSetAll_2__T] | jpype.JArray, + intFunction: java.util.function.IntFunction[_parallelSetAll_2__T] + | typing.Callable[[int], _parallelSetAll_2__T], + ) -> None: ... + @typing.overload + @staticmethod + def parallelSetAll( + longArray: list[int] | jpype.JArray, + intToLongFunction: java.util.function.IntToLongFunction | typing.Callable, + ) -> None: ... + _parallelSort_10__T = typing.TypeVar( + "_parallelSort_10__T", bound=java.lang.Comparable + ) # + _parallelSort_11__T = typing.TypeVar( + "_parallelSort_11__T", bound=java.lang.Comparable + ) # + _parallelSort_12__T = typing.TypeVar("_parallelSort_12__T") # + _parallelSort_13__T = typing.TypeVar("_parallelSort_13__T") # + @typing.overload + @staticmethod + def parallelSort(byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + @staticmethod + def parallelSort(charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + @staticmethod + def parallelSort(doubleArray: list[float] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + doubleArray: list[float] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + @staticmethod + def parallelSort(floatArray: list[float] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + floatArray: list[float] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + @staticmethod + def parallelSort(intArray: list[int] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + intArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> None: ... + @typing.overload + @staticmethod + def parallelSort(tArray: list[_parallelSort_10__T] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + tArray: list[_parallelSort_11__T] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + tArray: list[_parallelSort_12__T] | jpype.JArray, + int: int, + int2: int, + comparator: Comparator[_parallelSort_12__T] + | typing.Callable[[_parallelSort_12__T, _parallelSort_12__T], int], + ) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + tArray: list[_parallelSort_13__T] | jpype.JArray, + comparator: Comparator[_parallelSort_13__T] + | typing.Callable[[_parallelSort_13__T, _parallelSort_13__T], int], + ) -> None: ... + @typing.overload + @staticmethod + def parallelSort(longArray: list[int] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + longArray: list[int] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + @staticmethod + def parallelSort(shortArray: list[int] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def parallelSort( + shortArray: list[int] | jpype.JArray, int: int, int2: int + ) -> None: ... + _setAll_2__T = typing.TypeVar("_setAll_2__T") # + @typing.overload + @staticmethod + def setAll( + doubleArray: list[float] | jpype.JArray, + intToDoubleFunction: java.util.function.IntToDoubleFunction | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def setAll( + intArray: list[int] | jpype.JArray, + intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable, + ) -> None: ... + @typing.overload + @staticmethod + def setAll( + tArray: list[_setAll_2__T] | jpype.JArray, + intFunction: java.util.function.IntFunction[_setAll_2__T] + | typing.Callable[[int], _setAll_2__T], + ) -> None: ... + @typing.overload + @staticmethod + def setAll( + longArray: list[int] | jpype.JArray, + intToLongFunction: java.util.function.IntToLongFunction | typing.Callable, + ) -> None: ... + _sort_12__T = typing.TypeVar("_sort_12__T") # + _sort_13__T = typing.TypeVar("_sort_13__T") # + @typing.overload + @staticmethod + def sort(byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + @staticmethod + def sort( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + @staticmethod + def sort(charArray: list[str] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def sort(charArray: list[str] | jpype.JArray, int: int, int2: int) -> None: ... + @typing.overload + @staticmethod + def sort(doubleArray: list[float] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def sort(doubleArray: list[float] | jpype.JArray, int: int, int2: int) -> None: ... + @typing.overload + @staticmethod + def sort(floatArray: list[float] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def sort(floatArray: list[float] | jpype.JArray, int: int, int2: int) -> None: ... + @typing.overload + @staticmethod + def sort(intArray: list[int] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def sort(intArray: list[int] | jpype.JArray, int2: int, int3: int) -> None: ... + @typing.overload + @staticmethod + def sort(objectArray: list[typing.Any] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def sort( + objectArray: list[typing.Any] | jpype.JArray, int: int, int2: int + ) -> None: ... + @typing.overload + @staticmethod + def sort( + tArray: list[_sort_12__T] | jpype.JArray, + int: int, + int2: int, + comparator: Comparator[_sort_12__T] + | typing.Callable[[_sort_12__T, _sort_12__T], int], + ) -> None: ... + @typing.overload + @staticmethod + def sort( + tArray: list[_sort_13__T] | jpype.JArray, + comparator: Comparator[_sort_13__T] + | typing.Callable[[_sort_13__T, _sort_13__T], int], + ) -> None: ... + @typing.overload + @staticmethod + def sort(longArray: list[int] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def sort(longArray: list[int] | jpype.JArray, int: int, int2: int) -> None: ... + @typing.overload + @staticmethod + def sort(shortArray: list[int] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def sort(shortArray: list[int] | jpype.JArray, int: int, int2: int) -> None: ... + _spliterator_0__T = typing.TypeVar("_spliterator_0__T") # + _spliterator_1__T = typing.TypeVar("_spliterator_1__T") # + @typing.overload + @staticmethod + def spliterator( + tArray: list[_spliterator_0__T] | jpype.JArray, + ) -> Spliterator[_spliterator_0__T]: ... + @typing.overload + @staticmethod + def spliterator( + tArray: list[_spliterator_1__T] | jpype.JArray, int: int, int2: int + ) -> Spliterator[_spliterator_1__T]: ... + @typing.overload + @staticmethod + def spliterator( + doubleArray: list[float] | jpype.JArray, + ) -> Spliterator.OfDouble: ... + @typing.overload + @staticmethod + def spliterator( + doubleArray: list[float] | jpype.JArray, int: int, int2: int + ) -> Spliterator.OfDouble: ... + @typing.overload + @staticmethod + def spliterator(intArray: list[int] | jpype.JArray) -> Spliterator.OfInt: ... + @typing.overload + @staticmethod + def spliterator( + intArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> Spliterator.OfInt: ... + @typing.overload + @staticmethod + def spliterator(longArray: list[int] | jpype.JArray) -> Spliterator.OfLong: ... + @typing.overload + @staticmethod + def spliterator( + longArray: list[int] | jpype.JArray, int: int, int2: int + ) -> Spliterator.OfLong: ... + _stream_6__T = typing.TypeVar("_stream_6__T") # + _stream_7__T = typing.TypeVar("_stream_7__T") # + @typing.overload + @staticmethod + def stream( + doubleArray: list[float] | jpype.JArray, + ) -> java.util.stream.DoubleStream: ... + @typing.overload + @staticmethod + def stream( + doubleArray: list[float] | jpype.JArray, int: int, int2: int + ) -> java.util.stream.DoubleStream: ... + @typing.overload + @staticmethod + def stream(intArray: list[int] | jpype.JArray) -> java.util.stream.IntStream: ... + @typing.overload + @staticmethod + def stream( + intArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> java.util.stream.IntStream: ... + @typing.overload + @staticmethod + def stream(longArray: list[int] | jpype.JArray) -> java.util.stream.LongStream: ... + @typing.overload + @staticmethod + def stream( + longArray: list[int] | jpype.JArray, int: int, int2: int + ) -> java.util.stream.LongStream: ... + @typing.overload + @staticmethod + def stream( + tArray: list[_stream_6__T] | jpype.JArray, + ) -> java.util.stream.Stream[_stream_6__T]: ... + @typing.overload + @staticmethod + def stream( + tArray: list[_stream_7__T] | jpype.JArray, int: int, int2: int + ) -> java.util.stream.Stream[_stream_7__T]: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(booleanArray: list[bool] | jpype.JArray) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(byteArray: list[int] | jpype.JArray | bytes) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(charArray: list[str] | jpype.JArray) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(doubleArray: list[float] | jpype.JArray) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(floatArray: list[float] | jpype.JArray) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(intArray: list[int] | jpype.JArray) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(objectArray: list[typing.Any] | jpype.JArray) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(longArray: list[int] | jpype.JArray) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(shortArray: list[int] | jpype.JArray) -> java.lang.String: ... + +class Base64: + @staticmethod + def getDecoder() -> Base64.Decoder: ... + @staticmethod + def getEncoder() -> Base64.Encoder: ... + @staticmethod + def getMimeDecoder() -> Base64.Decoder: ... + @typing.overload + @staticmethod + def getMimeEncoder() -> Base64.Encoder: ... + @typing.overload + @staticmethod + def getMimeEncoder( + int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> Base64.Encoder: ... + @staticmethod + def getUrlDecoder() -> Base64.Decoder: ... + @staticmethod + def getUrlEncoder() -> Base64.Encoder: ... + class Decoder: + @typing.overload + def decode( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decode( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decode( + self, + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> int: ... + @typing.overload + def decode(self, byteBuffer: java.nio.ByteBuffer) -> java.nio.ByteBuffer: ... + def wrap(self, inputStream: java.io.InputStream) -> java.io.InputStream: ... + + class Encoder: + @typing.overload + def encode( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def encode( + self, + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> int: ... + @typing.overload + def encode(self, byteBuffer: java.nio.ByteBuffer) -> java.nio.ByteBuffer: ... + def encodeToString( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> java.lang.String: ... + def withoutPadding(self) -> Base64.Encoder: ... + def wrap(self, outputStream: java.io.OutputStream) -> java.io.OutputStream: ... + +class BitSet(java.lang.Cloneable, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + def andNot(self, bitSet: BitSet) -> None: ... + def and_(self, bitSet: BitSet) -> None: ... + def cardinality(self) -> int: ... + @typing.overload + def clear(self) -> None: ... + @typing.overload + def clear(self, int: int) -> None: ... + @typing.overload + def clear(self, int: int, int2: int) -> None: ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def flip(self, int: int) -> None: ... + @typing.overload + def flip(self, int: int, int2: int) -> None: ... + @typing.overload + def get(self, int: int) -> bool: ... + @typing.overload + def get(self, int: int, int2: int) -> BitSet: ... + def hashCode(self) -> int: ... + def intersects(self, bitSet: BitSet) -> bool: ... + def isEmpty(self) -> bool: ... + def length(self) -> int: ... + def nextClearBit(self, int: int) -> int: ... + def nextSetBit(self, int: int) -> int: ... + def or_(self, bitSet: BitSet) -> None: ... + def previousClearBit(self, int: int) -> int: ... + def previousSetBit(self, int: int) -> int: ... + @typing.overload + def set(self, int: int) -> None: ... + @typing.overload + def set(self, int: int, boolean: bool) -> None: ... + @typing.overload + def set(self, int: int, int2: int) -> None: ... + @typing.overload + def set(self, int: int, int2: int, boolean: bool) -> None: ... + def size(self) -> int: ... + def stream(self) -> java.util.stream.IntStream: ... + def toByteArray(self) -> typing.MutableSequence[int]: ... + def toLongArray(self) -> typing.MutableSequence[int]: ... + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def valueOf(byteArray: list[int] | jpype.JArray | bytes) -> BitSet: ... + @typing.overload + @staticmethod + def valueOf(byteBuffer: java.nio.ByteBuffer) -> BitSet: ... + @typing.overload + @staticmethod + def valueOf(longBuffer: java.nio.LongBuffer) -> BitSet: ... + @typing.overload + @staticmethod + def valueOf(longArray: list[int] | jpype.JArray) -> BitSet: ... + def xor(self, bitSet: BitSet) -> None: ... + +class Calendar( + java.io.Serializable, java.lang.Cloneable, java.lang.Comparable["Calendar"] +): + ERA: typing.ClassVar[int] = ... + YEAR: typing.ClassVar[int] = ... + MONTH: typing.ClassVar[int] = ... + WEEK_OF_YEAR: typing.ClassVar[int] = ... + WEEK_OF_MONTH: typing.ClassVar[int] = ... + DATE: typing.ClassVar[int] = ... + DAY_OF_MONTH: typing.ClassVar[int] = ... + DAY_OF_YEAR: typing.ClassVar[int] = ... + DAY_OF_WEEK: typing.ClassVar[int] = ... + DAY_OF_WEEK_IN_MONTH: typing.ClassVar[int] = ... + AM_PM: typing.ClassVar[int] = ... + HOUR: typing.ClassVar[int] = ... + HOUR_OF_DAY: typing.ClassVar[int] = ... + MINUTE: typing.ClassVar[int] = ... + SECOND: typing.ClassVar[int] = ... + MILLISECOND: typing.ClassVar[int] = ... + ZONE_OFFSET: typing.ClassVar[int] = ... + DST_OFFSET: typing.ClassVar[int] = ... + FIELD_COUNT: typing.ClassVar[int] = ... + SUNDAY: typing.ClassVar[int] = ... + MONDAY: typing.ClassVar[int] = ... + TUESDAY: typing.ClassVar[int] = ... + WEDNESDAY: typing.ClassVar[int] = ... + THURSDAY: typing.ClassVar[int] = ... + FRIDAY: typing.ClassVar[int] = ... + SATURDAY: typing.ClassVar[int] = ... + JANUARY: typing.ClassVar[int] = ... + FEBRUARY: typing.ClassVar[int] = ... + MARCH: typing.ClassVar[int] = ... + APRIL: typing.ClassVar[int] = ... + MAY: typing.ClassVar[int] = ... + JUNE: typing.ClassVar[int] = ... + JULY: typing.ClassVar[int] = ... + AUGUST: typing.ClassVar[int] = ... + SEPTEMBER: typing.ClassVar[int] = ... + OCTOBER: typing.ClassVar[int] = ... + NOVEMBER: typing.ClassVar[int] = ... + DECEMBER: typing.ClassVar[int] = ... + UNDECIMBER: typing.ClassVar[int] = ... + AM: typing.ClassVar[int] = ... + PM: typing.ClassVar[int] = ... + ALL_STYLES: typing.ClassVar[int] = ... + SHORT: typing.ClassVar[int] = ... + LONG: typing.ClassVar[int] = ... + NARROW_FORMAT: typing.ClassVar[int] = ... + NARROW_STANDALONE: typing.ClassVar[int] = ... + SHORT_FORMAT: typing.ClassVar[int] = ... + LONG_FORMAT: typing.ClassVar[int] = ... + SHORT_STANDALONE: typing.ClassVar[int] = ... + LONG_STANDALONE: typing.ClassVar[int] = ... + def add(self, int: int, int2: int) -> None: ... + def after(self, object: typing.Any) -> bool: ... + def before(self, object: typing.Any) -> bool: ... + @typing.overload + def clear(self) -> None: ... + @typing.overload + def clear(self, int: int) -> None: ... + def clone(self) -> typing.Any: ... + def compareTo(self, calendar: Calendar) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, int: int) -> int: ... + def getActualMaximum(self, int: int) -> int: ... + def getActualMinimum(self, int: int) -> int: ... + @staticmethod + def getAvailableCalendarTypes() -> Set[java.lang.String]: ... + @staticmethod + def getAvailableLocales() -> typing.MutableSequence[Locale]: ... + def getCalendarType(self) -> java.lang.String: ... + def getDisplayName( + self, int: int, int2: int, locale: Locale + ) -> java.lang.String: ... + def getDisplayNames( + self, int: int, int2: int, locale: Locale + ) -> Map[java.lang.String, int]: ... + def getFirstDayOfWeek(self) -> int: ... + def getGreatestMinimum(self, int: int) -> int: ... + @typing.overload + @staticmethod + def getInstance() -> Calendar: ... + @typing.overload + @staticmethod + def getInstance(locale: Locale) -> Calendar: ... + @typing.overload + @staticmethod + def getInstance(timeZone: TimeZone) -> Calendar: ... + @typing.overload + @staticmethod + def getInstance(timeZone: TimeZone, locale: Locale) -> Calendar: ... + def getLeastMaximum(self, int: int) -> int: ... + def getMaximum(self, int: int) -> int: ... + def getMinimalDaysInFirstWeek(self) -> int: ... + def getMinimum(self, int: int) -> int: ... + def getTime(self) -> Date: ... + def getTimeInMillis(self) -> int: ... + def getTimeZone(self) -> TimeZone: ... + def getWeekYear(self) -> int: ... + def getWeeksInWeekYear(self) -> int: ... + def hashCode(self) -> int: ... + def isLenient(self) -> bool: ... + def isSet(self, int: int) -> bool: ... + def isWeekDateSupported(self) -> bool: ... + @typing.overload + def roll(self, int: int, boolean: bool) -> None: ... + @typing.overload + def roll(self, int: int, int2: int) -> None: ... + @typing.overload + def set(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def set(self, int: int, int2: int, int3: int, int4: int, int5: int) -> None: ... + @typing.overload + def set( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def set(self, int: int, int2: int) -> None: ... + def setFirstDayOfWeek(self, int: int) -> None: ... + def setLenient(self, boolean: bool) -> None: ... + def setMinimalDaysInFirstWeek(self, int: int) -> None: ... + def setTime(self, date: Date) -> None: ... + def setTimeInMillis(self, long: int) -> None: ... + def setTimeZone(self, timeZone: TimeZone) -> None: ... + def setWeekDate(self, int: int, int2: int, int3: int) -> None: ... + def toInstant(self) -> java.time.Instant: ... + def toString(self) -> java.lang.String: ... + class Builder: + def __init__(self): ... + def build(self) -> Calendar: ... + def set(self, int: int, int2: int) -> Calendar.Builder: ... + def setCalendarType( + self, string: java.lang.String | str + ) -> Calendar.Builder: ... + def setDate(self, int: int, int2: int, int3: int) -> Calendar.Builder: ... + def setFields(self, *int: int) -> Calendar.Builder: ... + @typing.overload + def setInstant(self, date: Date) -> Calendar.Builder: ... + @typing.overload + def setInstant(self, long: int) -> Calendar.Builder: ... + def setLenient(self, boolean: bool) -> Calendar.Builder: ... + def setLocale(self, locale: Locale) -> Calendar.Builder: ... + @typing.overload + def setTimeOfDay(self, int: int, int2: int, int3: int) -> Calendar.Builder: ... + @typing.overload + def setTimeOfDay( + self, int: int, int2: int, int3: int, int4: int + ) -> Calendar.Builder: ... + def setTimeZone(self, timeZone: TimeZone) -> Calendar.Builder: ... + def setWeekDate(self, int: int, int2: int, int3: int) -> Calendar.Builder: ... + def setWeekDefinition(self, int: int, int2: int) -> Calendar.Builder: ... + +_Collection__E = typing.TypeVar("_Collection__E") # + +class Collection( + java.lang.Iterable[_Collection__E], + typing.Generic[_Collection__E], + _JCollection[_Collection__E], +): + def add(self, e: _Collection__E) -> bool: ... + def addAll( + self, + collection: Collection[_Collection__E] + | typing.Sequence[_Collection__E] + | set[_Collection__E], + ) -> bool: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> Iterator[_Collection__E]: ... + def parallelStream(self) -> java.util.stream.Stream[_Collection__E]: ... + def remove(self, object: typing.Any) -> bool: ... + def removeAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_Collection__E] + | typing.Callable[[_Collection__E], bool], + ) -> bool: ... + def retainAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> Spliterator[_Collection__E]: ... + def stream(self) -> java.util.stream.Stream[_Collection__E]: ... + _toArray_1__T = typing.TypeVar("_toArray_1__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_1__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_1__T]: ... + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_2__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_2__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_2__T]: ... + +class Collections: + EMPTY_SET: typing.ClassVar[Set] = ... + EMPTY_LIST: typing.ClassVar[List] = ... + EMPTY_MAP: typing.ClassVar[Map] = ... + _addAll__T = typing.TypeVar("_addAll__T") # + @staticmethod + def addAll( + collection: Collection[_addAll__T] + | typing.Sequence[_addAll__T] + | set[_addAll__T], + *t: _addAll__T, + ) -> bool: ... + _asLifoQueue__T = typing.TypeVar("_asLifoQueue__T") # + @staticmethod + def asLifoQueue(deque: Deque[_asLifoQueue__T]) -> Queue[_asLifoQueue__T]: ... + _binarySearch_0__T = typing.TypeVar("_binarySearch_0__T") # + _binarySearch_1__T = typing.TypeVar("_binarySearch_1__T") # + @typing.overload + @staticmethod + def binarySearch( + list: List[java.lang.Comparable[_binarySearch_0__T]], t: _binarySearch_0__T + ) -> int: ... + @typing.overload + @staticmethod + def binarySearch( + list: List[_binarySearch_1__T], + t: _binarySearch_1__T, + comparator: Comparator[_binarySearch_1__T] + | typing.Callable[[_binarySearch_1__T, _binarySearch_1__T], int], + ) -> int: ... + _checkedCollection__E = typing.TypeVar("_checkedCollection__E") # + @staticmethod + def checkedCollection( + collection: Collection[_checkedCollection__E] + | typing.Sequence[_checkedCollection__E] + | set[_checkedCollection__E], + class_: type[_checkedCollection__E], + ) -> Collection[_checkedCollection__E]: ... + _checkedList__E = typing.TypeVar("_checkedList__E") # + @staticmethod + def checkedList( + list: List[_checkedList__E], class_: type[_checkedList__E] + ) -> List[_checkedList__E]: ... + _checkedMap__K = typing.TypeVar("_checkedMap__K") # + _checkedMap__V = typing.TypeVar("_checkedMap__V") # + @staticmethod + def checkedMap( + map: Map[_checkedMap__K, _checkedMap__V] + | typing.Mapping[_checkedMap__K, _checkedMap__V], + class_: type[_checkedMap__K], + class2: type[_checkedMap__V], + ) -> Map[_checkedMap__K, _checkedMap__V]: ... + _checkedNavigableMap__K = typing.TypeVar("_checkedNavigableMap__K") # + _checkedNavigableMap__V = typing.TypeVar("_checkedNavigableMap__V") # + @staticmethod + def checkedNavigableMap( + navigableMap: NavigableMap[_checkedNavigableMap__K, _checkedNavigableMap__V], + class_: type[_checkedNavigableMap__K], + class2: type[_checkedNavigableMap__V], + ) -> NavigableMap[_checkedNavigableMap__K, _checkedNavigableMap__V]: ... + _checkedNavigableSet__E = typing.TypeVar("_checkedNavigableSet__E") # + @staticmethod + def checkedNavigableSet( + navigableSet: NavigableSet[_checkedNavigableSet__E], + class_: type[_checkedNavigableSet__E], + ) -> NavigableSet[_checkedNavigableSet__E]: ... + _checkedQueue__E = typing.TypeVar("_checkedQueue__E") # + @staticmethod + def checkedQueue( + queue: Queue[_checkedQueue__E], class_: type[_checkedQueue__E] + ) -> Queue[_checkedQueue__E]: ... + _checkedSet__E = typing.TypeVar("_checkedSet__E") # + @staticmethod + def checkedSet( + set: Set[_checkedSet__E], class_: type[_checkedSet__E] + ) -> Set[_checkedSet__E]: ... + _checkedSortedMap__K = typing.TypeVar("_checkedSortedMap__K") # + _checkedSortedMap__V = typing.TypeVar("_checkedSortedMap__V") # + @staticmethod + def checkedSortedMap( + sortedMap: SortedMap[_checkedSortedMap__K, _checkedSortedMap__V], + class_: type[_checkedSortedMap__K], + class2: type[_checkedSortedMap__V], + ) -> SortedMap[_checkedSortedMap__K, _checkedSortedMap__V]: ... + _checkedSortedSet__E = typing.TypeVar("_checkedSortedSet__E") # + @staticmethod + def checkedSortedSet( + sortedSet: SortedSet[_checkedSortedSet__E], class_: type[_checkedSortedSet__E] + ) -> SortedSet[_checkedSortedSet__E]: ... + _copy__T = typing.TypeVar("_copy__T") # + @staticmethod + def copy(list: List[_copy__T], list2: List[_copy__T]) -> None: ... + @staticmethod + def disjoint( + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + collection2: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + _emptyEnumeration__T = typing.TypeVar("_emptyEnumeration__T") # + @staticmethod + def emptyEnumeration() -> Enumeration[_emptyEnumeration__T]: ... + _emptyIterator__T = typing.TypeVar("_emptyIterator__T") # + @staticmethod + def emptyIterator() -> Iterator[_emptyIterator__T]: ... + _emptyList__T = typing.TypeVar("_emptyList__T") # + @staticmethod + def emptyList() -> List[_emptyList__T]: ... + _emptyListIterator__T = typing.TypeVar("_emptyListIterator__T") # + @staticmethod + def emptyListIterator() -> ListIterator[_emptyListIterator__T]: ... + _emptyMap__K = typing.TypeVar("_emptyMap__K") # + _emptyMap__V = typing.TypeVar("_emptyMap__V") # + @staticmethod + def emptyMap() -> Map[_emptyMap__K, _emptyMap__V]: ... + _emptyNavigableMap__K = typing.TypeVar("_emptyNavigableMap__K") # + _emptyNavigableMap__V = typing.TypeVar("_emptyNavigableMap__V") # + @staticmethod + def emptyNavigableMap() -> NavigableMap[ + _emptyNavigableMap__K, _emptyNavigableMap__V + ]: ... + _emptyNavigableSet__E = typing.TypeVar("_emptyNavigableSet__E") # + @staticmethod + def emptyNavigableSet() -> NavigableSet[_emptyNavigableSet__E]: ... + _emptySet__T = typing.TypeVar("_emptySet__T") # + @staticmethod + def emptySet() -> Set[_emptySet__T]: ... + _emptySortedMap__K = typing.TypeVar("_emptySortedMap__K") # + _emptySortedMap__V = typing.TypeVar("_emptySortedMap__V") # + @staticmethod + def emptySortedMap() -> SortedMap[_emptySortedMap__K, _emptySortedMap__V]: ... + _emptySortedSet__E = typing.TypeVar("_emptySortedSet__E") # + @staticmethod + def emptySortedSet() -> SortedSet[_emptySortedSet__E]: ... + _enumeration__T = typing.TypeVar("_enumeration__T") # + @staticmethod + def enumeration( + collection: Collection[_enumeration__T] + | typing.Sequence[_enumeration__T] + | set[_enumeration__T], + ) -> Enumeration[_enumeration__T]: ... + _fill__T = typing.TypeVar("_fill__T") # + @staticmethod + def fill(list: List[_fill__T], t: _fill__T) -> None: ... + @staticmethod + def frequency( + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + object: typing.Any, + ) -> int: ... + @staticmethod + def indexOfSubList(list: List[typing.Any], list2: List[typing.Any]) -> int: ... + @staticmethod + def lastIndexOfSubList(list: List[typing.Any], list2: List[typing.Any]) -> int: ... + _list__T = typing.TypeVar("_list__T") # + @staticmethod + def list(enumeration: Enumeration[_list__T]) -> ArrayList[_list__T]: ... + _max_0__T = typing.TypeVar("_max_0__T") # + _max_1__T = typing.TypeVar("_max_1__T") # + @typing.overload + @staticmethod + def max( + collection: Collection[_max_0__T] | typing.Sequence[_max_0__T] | set[_max_0__T], + ) -> _max_0__T: ... + @typing.overload + @staticmethod + def max( + collection: Collection[_max_1__T] | typing.Sequence[_max_1__T] | set[_max_1__T], + comparator: Comparator[_max_1__T] + | typing.Callable[[_max_1__T, _max_1__T], int], + ) -> _max_1__T: ... + _min_0__T = typing.TypeVar("_min_0__T") # + _min_1__T = typing.TypeVar("_min_1__T") # + @typing.overload + @staticmethod + def min( + collection: Collection[_min_0__T] | typing.Sequence[_min_0__T] | set[_min_0__T], + ) -> _min_0__T: ... + @typing.overload + @staticmethod + def min( + collection: Collection[_min_1__T] | typing.Sequence[_min_1__T] | set[_min_1__T], + comparator: Comparator[_min_1__T] + | typing.Callable[[_min_1__T, _min_1__T], int], + ) -> _min_1__T: ... + _nCopies__T = typing.TypeVar("_nCopies__T") # + @staticmethod + def nCopies(int: int, t: _nCopies__T) -> List[_nCopies__T]: ... + _newSequencedSetFromMap__E = typing.TypeVar("_newSequencedSetFromMap__E") # + @staticmethod + def newSequencedSetFromMap( + sequencedMap: SequencedMap[_newSequencedSetFromMap__E, bool], + ) -> SequencedSet[_newSequencedSetFromMap__E]: ... + _newSetFromMap__E = typing.TypeVar("_newSetFromMap__E") # + @staticmethod + def newSetFromMap( + map: Map[_newSetFromMap__E, bool] | typing.Mapping[_newSetFromMap__E, bool], + ) -> Set[_newSetFromMap__E]: ... + _replaceAll__T = typing.TypeVar("_replaceAll__T") # + @staticmethod + def replaceAll( + list: List[_replaceAll__T], t: _replaceAll__T, t2: _replaceAll__T + ) -> bool: ... + @staticmethod + def reverse(list: List[typing.Any]) -> None: ... + _reverseOrder_0__T = typing.TypeVar("_reverseOrder_0__T") # + _reverseOrder_1__T = typing.TypeVar("_reverseOrder_1__T") # + @typing.overload + @staticmethod + def reverseOrder() -> Comparator[_reverseOrder_0__T]: ... + @typing.overload + @staticmethod + def reverseOrder( + comparator: Comparator[_reverseOrder_1__T] + | typing.Callable[[_reverseOrder_1__T, _reverseOrder_1__T], int], + ) -> Comparator[_reverseOrder_1__T]: ... + @staticmethod + def rotate(list: List[typing.Any], int: int) -> None: ... + @typing.overload + @staticmethod + def shuffle(list: List[typing.Any]) -> None: ... + @typing.overload + @staticmethod + def shuffle(list: List[typing.Any], random: Random) -> None: ... + @typing.overload + @staticmethod + def shuffle( + list: List[typing.Any], + randomGenerator: java.util.random.RandomGenerator | typing.Callable, + ) -> None: ... + _singleton__T = typing.TypeVar("_singleton__T") # + @staticmethod + def singleton(t: _singleton__T) -> Set[_singleton__T]: ... + _singletonList__T = typing.TypeVar("_singletonList__T") # + @staticmethod + def singletonList(t: _singletonList__T) -> List[_singletonList__T]: ... + _singletonMap__K = typing.TypeVar("_singletonMap__K") # + _singletonMap__V = typing.TypeVar("_singletonMap__V") # + @staticmethod + def singletonMap( + k: _singletonMap__K, v: _singletonMap__V + ) -> Map[_singletonMap__K, _singletonMap__V]: ... + _sort_0__T = typing.TypeVar("_sort_0__T", bound=java.lang.Comparable) # + _sort_1__T = typing.TypeVar("_sort_1__T") # + @typing.overload + @staticmethod + def sort(list: List[_sort_0__T]) -> None: ... + @typing.overload + @staticmethod + def sort( + list: List[_sort_1__T], + comparator: Comparator[_sort_1__T] + | typing.Callable[[_sort_1__T, _sort_1__T], int], + ) -> None: ... + @staticmethod + def swap(list: List[typing.Any], int: int, int2: int) -> None: ... + _synchronizedCollection__T = typing.TypeVar("_synchronizedCollection__T") # + @staticmethod + def synchronizedCollection( + collection: Collection[_synchronizedCollection__T] + | typing.Sequence[_synchronizedCollection__T] + | set[_synchronizedCollection__T], + ) -> Collection[_synchronizedCollection__T]: ... + _synchronizedList__T = typing.TypeVar("_synchronizedList__T") # + @staticmethod + def synchronizedList( + list: List[_synchronizedList__T], + ) -> List[_synchronizedList__T]: ... + _synchronizedMap__K = typing.TypeVar("_synchronizedMap__K") # + _synchronizedMap__V = typing.TypeVar("_synchronizedMap__V") # + @staticmethod + def synchronizedMap( + map: Map[_synchronizedMap__K, _synchronizedMap__V] + | typing.Mapping[_synchronizedMap__K, _synchronizedMap__V], + ) -> Map[_synchronizedMap__K, _synchronizedMap__V]: ... + _synchronizedNavigableMap__K = typing.TypeVar("_synchronizedNavigableMap__K") # + _synchronizedNavigableMap__V = typing.TypeVar("_synchronizedNavigableMap__V") # + @staticmethod + def synchronizedNavigableMap( + navigableMap: NavigableMap[ + _synchronizedNavigableMap__K, _synchronizedNavigableMap__V + ], + ) -> NavigableMap[_synchronizedNavigableMap__K, _synchronizedNavigableMap__V]: ... + _synchronizedNavigableSet__T = typing.TypeVar("_synchronizedNavigableSet__T") # + @staticmethod + def synchronizedNavigableSet( + navigableSet: NavigableSet[_synchronizedNavigableSet__T], + ) -> NavigableSet[_synchronizedNavigableSet__T]: ... + _synchronizedSet__T = typing.TypeVar("_synchronizedSet__T") # + @staticmethod + def synchronizedSet(set: Set[_synchronizedSet__T]) -> Set[_synchronizedSet__T]: ... + _synchronizedSortedMap__K = typing.TypeVar("_synchronizedSortedMap__K") # + _synchronizedSortedMap__V = typing.TypeVar("_synchronizedSortedMap__V") # + @staticmethod + def synchronizedSortedMap( + sortedMap: SortedMap[_synchronizedSortedMap__K, _synchronizedSortedMap__V], + ) -> SortedMap[_synchronizedSortedMap__K, _synchronizedSortedMap__V]: ... + _synchronizedSortedSet__T = typing.TypeVar("_synchronizedSortedSet__T") # + @staticmethod + def synchronizedSortedSet( + sortedSet: SortedSet[_synchronizedSortedSet__T], + ) -> SortedSet[_synchronizedSortedSet__T]: ... + _unmodifiableCollection__T = typing.TypeVar("_unmodifiableCollection__T") # + @staticmethod + def unmodifiableCollection( + collection: Collection[_unmodifiableCollection__T] + | typing.Sequence[_unmodifiableCollection__T] + | set[_unmodifiableCollection__T], + ) -> Collection[_unmodifiableCollection__T]: ... + _unmodifiableList__T = typing.TypeVar("_unmodifiableList__T") # + @staticmethod + def unmodifiableList( + list: List[_unmodifiableList__T], + ) -> List[_unmodifiableList__T]: ... + _unmodifiableMap__K = typing.TypeVar("_unmodifiableMap__K") # + _unmodifiableMap__V = typing.TypeVar("_unmodifiableMap__V") # + @staticmethod + def unmodifiableMap( + map: Map[_unmodifiableMap__K, _unmodifiableMap__V] + | typing.Mapping[_unmodifiableMap__K, _unmodifiableMap__V], + ) -> Map[_unmodifiableMap__K, _unmodifiableMap__V]: ... + _unmodifiableNavigableMap__K = typing.TypeVar("_unmodifiableNavigableMap__K") # + _unmodifiableNavigableMap__V = typing.TypeVar("_unmodifiableNavigableMap__V") # + @staticmethod + def unmodifiableNavigableMap( + navigableMap: NavigableMap[ + _unmodifiableNavigableMap__K, _unmodifiableNavigableMap__V + ], + ) -> NavigableMap[_unmodifiableNavigableMap__K, _unmodifiableNavigableMap__V]: ... + _unmodifiableNavigableSet__T = typing.TypeVar("_unmodifiableNavigableSet__T") # + @staticmethod + def unmodifiableNavigableSet( + navigableSet: NavigableSet[_unmodifiableNavigableSet__T], + ) -> NavigableSet[_unmodifiableNavigableSet__T]: ... + _unmodifiableSequencedCollection__T = typing.TypeVar( + "_unmodifiableSequencedCollection__T" + ) # + @staticmethod + def unmodifiableSequencedCollection( + sequencedCollection: SequencedCollection[_unmodifiableSequencedCollection__T], + ) -> SequencedCollection[_unmodifiableSequencedCollection__T]: ... + _unmodifiableSequencedMap__K = typing.TypeVar("_unmodifiableSequencedMap__K") # + _unmodifiableSequencedMap__V = typing.TypeVar("_unmodifiableSequencedMap__V") # + @staticmethod + def unmodifiableSequencedMap( + sequencedMap: SequencedMap[ + _unmodifiableSequencedMap__K, _unmodifiableSequencedMap__V + ], + ) -> SequencedMap[_unmodifiableSequencedMap__K, _unmodifiableSequencedMap__V]: ... + _unmodifiableSequencedSet__T = typing.TypeVar("_unmodifiableSequencedSet__T") # + @staticmethod + def unmodifiableSequencedSet( + sequencedSet: SequencedSet[_unmodifiableSequencedSet__T], + ) -> SequencedSet[_unmodifiableSequencedSet__T]: ... + _unmodifiableSet__T = typing.TypeVar("_unmodifiableSet__T") # + @staticmethod + def unmodifiableSet(set: Set[_unmodifiableSet__T]) -> Set[_unmodifiableSet__T]: ... + _unmodifiableSortedMap__K = typing.TypeVar("_unmodifiableSortedMap__K") # + _unmodifiableSortedMap__V = typing.TypeVar("_unmodifiableSortedMap__V") # + @staticmethod + def unmodifiableSortedMap( + sortedMap: SortedMap[_unmodifiableSortedMap__K, _unmodifiableSortedMap__V], + ) -> SortedMap[_unmodifiableSortedMap__K, _unmodifiableSortedMap__V]: ... + _unmodifiableSortedSet__T = typing.TypeVar("_unmodifiableSortedSet__T") # + @staticmethod + def unmodifiableSortedSet( + sortedSet: SortedSet[_unmodifiableSortedSet__T], + ) -> SortedSet[_unmodifiableSortedSet__T]: ... + +_Comparator__T = typing.TypeVar("_Comparator__T") # + +class Comparator(typing.Generic[_Comparator__T]): + def compare(self, t: _Comparator__T, t2: _Comparator__T) -> int: ... + _comparing_0__T = typing.TypeVar("_comparing_0__T") # + _comparing_0__U = typing.TypeVar( + "_comparing_0__U", bound=java.lang.Comparable + ) # + _comparing_1__T = typing.TypeVar("_comparing_1__T") # + _comparing_1__U = typing.TypeVar("_comparing_1__U") # + @typing.overload + @staticmethod + def comparing( + function: java.util.function.Function[_comparing_0__T, _comparing_0__U] + | typing.Callable[[_comparing_0__T], _comparing_0__U], + ) -> Comparator[_comparing_0__T]: ... + @typing.overload + @staticmethod + def comparing( + function: java.util.function.Function[_comparing_1__T, _comparing_1__U] + | typing.Callable[[_comparing_1__T], _comparing_1__U], + comparator: Comparator[_comparing_1__U] + | typing.Callable[[_comparing_1__U, _comparing_1__U], int], + ) -> Comparator[_comparing_1__T]: ... + _comparingDouble__T = typing.TypeVar("_comparingDouble__T") # + @staticmethod + def comparingDouble( + toDoubleFunction: java.util.function.ToDoubleFunction[_comparingDouble__T] + | typing.Callable[[_comparingDouble__T], float], + ) -> Comparator[_comparingDouble__T]: ... + _comparingInt__T = typing.TypeVar("_comparingInt__T") # + @staticmethod + def comparingInt( + toIntFunction: java.util.function.ToIntFunction[_comparingInt__T] + | typing.Callable[[_comparingInt__T], int], + ) -> Comparator[_comparingInt__T]: ... + _comparingLong__T = typing.TypeVar("_comparingLong__T") # + @staticmethod + def comparingLong( + toLongFunction: java.util.function.ToLongFunction[_comparingLong__T] + | typing.Callable[[_comparingLong__T], int], + ) -> Comparator[_comparingLong__T]: ... + def equals(self, object: typing.Any) -> bool: ... + _naturalOrder__T = typing.TypeVar( + "_naturalOrder__T", bound=java.lang.Comparable + ) # + @staticmethod + def naturalOrder() -> Comparator[_naturalOrder__T]: ... + _nullsFirst__T = typing.TypeVar("_nullsFirst__T") # + @staticmethod + def nullsFirst( + comparator: Comparator[_nullsFirst__T] + | typing.Callable[[_nullsFirst__T, _nullsFirst__T], int], + ) -> Comparator[_nullsFirst__T]: ... + _nullsLast__T = typing.TypeVar("_nullsLast__T") # + @staticmethod + def nullsLast( + comparator: Comparator[_nullsLast__T] + | typing.Callable[[_nullsLast__T, _nullsLast__T], int], + ) -> Comparator[_nullsLast__T]: ... + _reverseOrder__T = typing.TypeVar( + "_reverseOrder__T", bound=java.lang.Comparable + ) # + @staticmethod + def reverseOrder() -> Comparator[_reverseOrder__T]: ... + def reversed(self) -> Comparator[_Comparator__T]: ... + _thenComparing_1__U = typing.TypeVar( + "_thenComparing_1__U", bound=java.lang.Comparable + ) # + _thenComparing_2__U = typing.TypeVar("_thenComparing_2__U") # + @typing.overload + def thenComparing( + self, + comparator: Comparator[_Comparator__T] + | typing.Callable[[_Comparator__T, _Comparator__T], int], + ) -> Comparator[_Comparator__T]: ... + @typing.overload + def thenComparing( + self, + function: java.util.function.Function[_Comparator__T, _thenComparing_1__U] + | typing.Callable[[_Comparator__T], _thenComparing_1__U], + ) -> Comparator[_Comparator__T]: ... + @typing.overload + def thenComparing( + self, + function: java.util.function.Function[_Comparator__T, _thenComparing_2__U] + | typing.Callable[[_Comparator__T], _thenComparing_2__U], + comparator: Comparator[_thenComparing_2__U] + | typing.Callable[[_thenComparing_2__U, _thenComparing_2__U], int], + ) -> Comparator[_Comparator__T]: ... + def thenComparingDouble( + self, + toDoubleFunction: java.util.function.ToDoubleFunction[_Comparator__T] + | typing.Callable[[_Comparator__T], float], + ) -> Comparator[_Comparator__T]: ... + def thenComparingInt( + self, + toIntFunction: java.util.function.ToIntFunction[_Comparator__T] + | typing.Callable[[_Comparator__T], int], + ) -> Comparator[_Comparator__T]: ... + def thenComparingLong( + self, + toLongFunction: java.util.function.ToLongFunction[_Comparator__T] + | typing.Callable[[_Comparator__T], int], + ) -> Comparator[_Comparator__T]: ... + +class ConcurrentModificationException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class Currency(java.io.Serializable): + @staticmethod + def availableCurrencies() -> java.util.stream.Stream[Currency]: ... + @staticmethod + def getAvailableCurrencies() -> Set[Currency]: ... + def getCurrencyCode(self) -> java.lang.String: ... + def getDefaultFractionDigits(self) -> int: ... + @typing.overload + def getDisplayName(self) -> java.lang.String: ... + @typing.overload + def getDisplayName(self, locale: Locale) -> java.lang.String: ... + @typing.overload + @staticmethod + def getInstance(string: java.lang.String | str) -> Currency: ... + @typing.overload + @staticmethod + def getInstance(locale: Locale) -> Currency: ... + def getNumericCode(self) -> int: ... + def getNumericCodeAsString(self) -> java.lang.String: ... + @typing.overload + def getSymbol(self) -> java.lang.String: ... + @typing.overload + def getSymbol(self, locale: Locale) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class Date(java.io.Serializable, java.lang.Cloneable, java.lang.Comparable["Date"]): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int, int5: int): ... + @typing.overload + def __init__( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, long: int): ... + @staticmethod + def UTC(int: int, int2: int, int3: int, int4: int, int5: int, int6: int) -> int: ... + def after(self, date: Date) -> bool: ... + def before(self, date: Date) -> bool: ... + def clone(self) -> typing.Any: ... + def compareTo(self, date: Date) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_(instant: java.time.Instant | datetime.datetime) -> Date: ... + def getDate(self) -> int: ... + def getDay(self) -> int: ... + def getHours(self) -> int: ... + def getMinutes(self) -> int: ... + def getMonth(self) -> int: ... + def getSeconds(self) -> int: ... + def getTime(self) -> int: ... + def getTimezoneOffset(self) -> int: ... + def getYear(self) -> int: ... + def hashCode(self) -> int: ... + @staticmethod + def parse(string: java.lang.String | str) -> int: ... + def setDate(self, int: int) -> None: ... + def setHours(self, int: int) -> None: ... + def setMinutes(self, int: int) -> None: ... + def setMonth(self, int: int) -> None: ... + def setSeconds(self, int: int) -> None: ... + def setTime(self, long: int) -> None: ... + def setYear(self, int: int) -> None: ... + def toGMTString(self) -> java.lang.String: ... + def toInstant(self) -> java.time.Instant: ... + def toLocaleString(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +_Dictionary__K = typing.TypeVar("_Dictionary__K") # +_Dictionary__V = typing.TypeVar("_Dictionary__V") # + +class Dictionary(typing.Generic[_Dictionary__K, _Dictionary__V]): + def __init__(self): ... + def elements(self) -> Enumeration[_Dictionary__V]: ... + def get(self, object: typing.Any) -> _Dictionary__V: ... + def isEmpty(self) -> bool: ... + def keys(self) -> Enumeration[_Dictionary__K]: ... + def put(self, k: _Dictionary__K, v: _Dictionary__V) -> _Dictionary__V: ... + def remove(self, object: typing.Any) -> _Dictionary__V: ... + def size(self) -> int: ... + +class DoubleSummaryStatistics(java.util.function.DoubleConsumer): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, long: int, double: float, double2: float, double3: float): ... + def accept(self, double: float) -> None: ... + def combine(self, doubleSummaryStatistics: DoubleSummaryStatistics) -> None: ... + def getAverage(self) -> float: ... + def getCount(self) -> int: ... + def getMax(self) -> float: ... + def getMin(self) -> float: ... + def getSum(self) -> float: ... + def toString(self) -> java.lang.String: ... + +class EmptyStackException(java.lang.RuntimeException): + def __init__(self): ... + +_Enumeration__E = typing.TypeVar("_Enumeration__E") # + +class Enumeration(typing.Generic[_Enumeration__E], _JEnumeration[_Enumeration__E]): + def asIterator(self) -> Iterator[_Enumeration__E]: ... + def hasMoreElements(self) -> bool: ... + def nextElement(self) -> _Enumeration__E: ... + +class EventListener: ... + +class EventObject(java.io.Serializable): + def __init__(self, object: typing.Any): ... + def getSource(self) -> typing.Any: ... + def toString(self) -> java.lang.String: ... + +class Formattable: + def formatTo( + self, formatter: Formatter, int: int, int2: int, int3: int + ) -> None: ... + +class FormattableFlags: + LEFT_JUSTIFY: typing.ClassVar[int] = ... + UPPERCASE: typing.ClassVar[int] = ... + ALTERNATE: typing.ClassVar[int] = ... + +class Formatter(java.io.Closeable, java.io.Flushable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, file: java.io.File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + string: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + string: java.lang.String | str, + locale: Locale, + ): ... + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + locale: Locale, + ): ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream): ... + @typing.overload + def __init__( + self, outputStream: java.io.OutputStream, string: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + outputStream: java.io.OutputStream, + string: java.lang.String | str, + locale: Locale, + ): ... + @typing.overload + def __init__( + self, + outputStream: java.io.OutputStream, + charset: java.nio.charset.Charset, + locale: Locale, + ): ... + @typing.overload + def __init__(self, printStream: java.io.PrintStream): ... + @typing.overload + def __init__(self, appendable: java.lang.Appendable): ... + @typing.overload + def __init__(self, appendable: java.lang.Appendable, locale: Locale): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + locale: Locale, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + charset: java.nio.charset.Charset, + locale: Locale, + ): ... + @typing.overload + def __init__(self, locale: Locale): ... + def close(self) -> None: ... + def flush(self) -> None: ... + @typing.overload + def format( + self, string: java.lang.String | str, *object: typing.Any + ) -> Formatter: ... + @typing.overload + def format( + self, locale: Locale, string: java.lang.String | str, *object: typing.Any + ) -> Formatter: ... + def ioException(self) -> java.io.IOException: ... + def locale(self) -> Locale: ... + def out(self) -> java.lang.Appendable: ... + def toString(self) -> java.lang.String: ... + class BigDecimalLayoutForm(java.lang.Enum["Formatter.BigDecimalLayoutForm"]): + SCIENTIFIC: typing.ClassVar[Formatter.BigDecimalLayoutForm] = ... + DECIMAL_FLOAT: typing.ClassVar[Formatter.BigDecimalLayoutForm] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> Formatter.BigDecimalLayoutForm: ... + @staticmethod + def values() -> typing.MutableSequence[Formatter.BigDecimalLayoutForm]: ... + +class FormatterClosedException(java.lang.IllegalStateException): + def __init__(self): ... + +class HexFormat: + def delimiter(self) -> java.lang.String: ... + def equals(self, object: typing.Any) -> bool: ... + _formatHex_0__A = typing.TypeVar( + "_formatHex_0__A", bound=java.lang.Appendable + ) # + _formatHex_1__A = typing.TypeVar( + "_formatHex_1__A", bound=java.lang.Appendable + ) # + @typing.overload + def formatHex( + self, a: _formatHex_0__A, byteArray: list[int] | jpype.JArray | bytes + ) -> _formatHex_0__A: ... + @typing.overload + def formatHex( + self, + a: _formatHex_1__A, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + ) -> _formatHex_1__A: ... + @typing.overload + def formatHex( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> java.lang.String: ... + @typing.overload + def formatHex( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> java.lang.String: ... + @staticmethod + def fromHexDigit(int: int) -> int: ... + @typing.overload + @staticmethod + def fromHexDigits(charSequence: java.lang.CharSequence | str) -> int: ... + @typing.overload + @staticmethod + def fromHexDigits( + charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> int: ... + @typing.overload + @staticmethod + def fromHexDigitsToLong(charSequence: java.lang.CharSequence | str) -> int: ... + @typing.overload + @staticmethod + def fromHexDigitsToLong( + charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> int: ... + def hashCode(self) -> int: ... + @staticmethod + def isHexDigit(int: int) -> bool: ... + def isUpperCase(self) -> bool: ... + @staticmethod + def of() -> HexFormat: ... + @staticmethod + def ofDelimiter(string: java.lang.String | str) -> HexFormat: ... + @typing.overload + def parseHex( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def parseHex( + self, charSequence: java.lang.CharSequence | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def parseHex( + self, charSequence: java.lang.CharSequence | str, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + def prefix(self) -> java.lang.String: ... + def suffix(self) -> java.lang.String: ... + _toHexDigits_0__A = typing.TypeVar( + "_toHexDigits_0__A", bound=java.lang.Appendable + ) # + @typing.overload + def toHexDigits(self, a: _toHexDigits_0__A, byte: int) -> _toHexDigits_0__A: ... + @typing.overload + def toHexDigits(self, byte: int) -> java.lang.String: ... + @typing.overload + def toHexDigits(self, char: str) -> java.lang.String: ... + @typing.overload + def toHexDigits(self, int: int) -> java.lang.String: ... + @typing.overload + def toHexDigits(self, long: int) -> java.lang.String: ... + @typing.overload + def toHexDigits(self, long: int, int: int) -> java.lang.String: ... + @typing.overload + def toHexDigits(self, short: int) -> java.lang.String: ... + def toHighHexDigit(self, int: int) -> str: ... + def toLowHexDigit(self, int: int) -> str: ... + def toString(self) -> java.lang.String: ... + def withDelimiter(self, string: java.lang.String | str) -> HexFormat: ... + def withLowerCase(self) -> HexFormat: ... + def withPrefix(self, string: java.lang.String | str) -> HexFormat: ... + def withSuffix(self, string: java.lang.String | str) -> HexFormat: ... + def withUpperCase(self) -> HexFormat: ... + +class IllegalFormatException(java.lang.IllegalArgumentException): ... + +class IllformedLocaleException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + def getErrorIndex(self) -> int: ... + +class IntSummaryStatistics(java.util.function.IntConsumer): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, long: int, int: int, int2: int, long2: int): ... + def accept(self, int: int) -> None: ... + def combine(self, intSummaryStatistics: IntSummaryStatistics) -> None: ... + def getAverage(self) -> float: ... + def getCount(self) -> int: ... + def getMax(self) -> int: ... + def getMin(self) -> int: ... + def getSum(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class InvalidPropertiesFormatException(java.io.IOException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +_Iterator__E = typing.TypeVar("_Iterator__E") # + +class Iterator(typing.Generic[_Iterator__E], _JIterator[_Iterator__E]): + def forEachRemaining( + self, + consumer: java.util.function.Consumer[_Iterator__E] + | typing.Callable[[_Iterator__E], None], + ) -> None: ... + def hasNext(self) -> bool: ... + def next(self) -> _Iterator__E: ... + def remove(self) -> None: ... + +class Locale(java.lang.Cloneable, java.io.Serializable): + ENGLISH: typing.ClassVar[Locale] = ... + FRENCH: typing.ClassVar[Locale] = ... + GERMAN: typing.ClassVar[Locale] = ... + ITALIAN: typing.ClassVar[Locale] = ... + JAPANESE: typing.ClassVar[Locale] = ... + KOREAN: typing.ClassVar[Locale] = ... + CHINESE: typing.ClassVar[Locale] = ... + SIMPLIFIED_CHINESE: typing.ClassVar[Locale] = ... + TRADITIONAL_CHINESE: typing.ClassVar[Locale] = ... + FRANCE: typing.ClassVar[Locale] = ... + GERMANY: typing.ClassVar[Locale] = ... + ITALY: typing.ClassVar[Locale] = ... + JAPAN: typing.ClassVar[Locale] = ... + KOREA: typing.ClassVar[Locale] = ... + UK: typing.ClassVar[Locale] = ... + US: typing.ClassVar[Locale] = ... + CANADA: typing.ClassVar[Locale] = ... + CANADA_FRENCH: typing.ClassVar[Locale] = ... + ROOT: typing.ClassVar[Locale] = ... + CHINA: typing.ClassVar[Locale] = ... + PRC: typing.ClassVar[Locale] = ... + TAIWAN: typing.ClassVar[Locale] = ... + PRIVATE_USE_EXTENSION: typing.ClassVar[str] = ... + UNICODE_LOCALE_EXTENSION: typing.ClassVar[str] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + @staticmethod + def availableLocales() -> java.util.stream.Stream[Locale]: ... + @staticmethod + def caseFoldLanguageTag(string: java.lang.String | str) -> java.lang.String: ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + @staticmethod + def filter( + list: List[Locale.LanguageRange], + collection: Collection[Locale] | typing.Sequence[Locale] | set[Locale], + ) -> List[Locale]: ... + @typing.overload + @staticmethod + def filter( + list: List[Locale.LanguageRange], + collection: Collection[Locale] | typing.Sequence[Locale] | set[Locale], + filteringMode: Locale.FilteringMode, + ) -> List[Locale]: ... + @typing.overload + @staticmethod + def filterTags( + list: List[Locale.LanguageRange], + collection: Collection[java.lang.String | str] + | typing.Sequence[java.lang.String | str] + | set[java.lang.String | str], + ) -> List[java.lang.String]: ... + @typing.overload + @staticmethod + def filterTags( + list: List[Locale.LanguageRange], + collection: Collection[java.lang.String | str] + | typing.Sequence[java.lang.String | str] + | set[java.lang.String | str], + filteringMode: Locale.FilteringMode, + ) -> List[java.lang.String]: ... + @staticmethod + def forLanguageTag(string: java.lang.String | str) -> Locale: ... + @staticmethod + def getAvailableLocales() -> typing.MutableSequence[Locale]: ... + def getCountry(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getDefault() -> Locale: ... + @typing.overload + @staticmethod + def getDefault(category: Locale.Category) -> Locale: ... + @typing.overload + def getDisplayCountry(self) -> java.lang.String: ... + @typing.overload + def getDisplayCountry(self, locale: Locale) -> java.lang.String: ... + @typing.overload + def getDisplayLanguage(self) -> java.lang.String: ... + @typing.overload + def getDisplayLanguage(self, locale: Locale) -> java.lang.String: ... + @typing.overload + def getDisplayName(self) -> java.lang.String: ... + @typing.overload + def getDisplayName(self, locale: Locale) -> java.lang.String: ... + @typing.overload + def getDisplayScript(self) -> java.lang.String: ... + @typing.overload + def getDisplayScript(self, locale: Locale) -> java.lang.String: ... + @typing.overload + def getDisplayVariant(self) -> java.lang.String: ... + @typing.overload + def getDisplayVariant(self, locale: Locale) -> java.lang.String: ... + def getExtension(self, char: str) -> java.lang.String: ... + def getExtensionKeys(self) -> Set[str]: ... + def getISO3Country(self) -> java.lang.String: ... + def getISO3Language(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getISOCountries() -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + @staticmethod + def getISOCountries( + isoCountryCode: Locale.IsoCountryCode, + ) -> Set[java.lang.String]: ... + @staticmethod + def getISOLanguages() -> typing.MutableSequence[java.lang.String]: ... + def getLanguage(self) -> java.lang.String: ... + def getScript(self) -> java.lang.String: ... + def getUnicodeLocaleAttributes(self) -> Set[java.lang.String]: ... + def getUnicodeLocaleKeys(self) -> Set[java.lang.String]: ... + def getUnicodeLocaleType( + self, string: java.lang.String | str + ) -> java.lang.String: ... + def getVariant(self) -> java.lang.String: ... + def hasExtensions(self) -> bool: ... + def hashCode(self) -> int: ... + @staticmethod + def lookup( + list: List[Locale.LanguageRange], + collection: Collection[Locale] | typing.Sequence[Locale] | set[Locale], + ) -> Locale: ... + @staticmethod + def lookupTag( + list: List[Locale.LanguageRange], + collection: Collection[java.lang.String | str] + | typing.Sequence[java.lang.String | str] + | set[java.lang.String | str], + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def of(string: java.lang.String | str) -> Locale: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, string2: java.lang.String | str + ) -> Locale: ... + @typing.overload + @staticmethod + def of( + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> Locale: ... + @typing.overload + @staticmethod + def setDefault(category: Locale.Category, locale: Locale) -> None: ... + @typing.overload + @staticmethod + def setDefault(locale: Locale) -> None: ... + def stripExtensions(self) -> Locale: ... + def toLanguageTag(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + class Builder: + def __init__(self): ... + def addUnicodeLocaleAttribute( + self, string: java.lang.String | str + ) -> Locale.Builder: ... + def build(self) -> Locale: ... + def clear(self) -> Locale.Builder: ... + def clearExtensions(self) -> Locale.Builder: ... + def removeUnicodeLocaleAttribute( + self, string: java.lang.String | str + ) -> Locale.Builder: ... + def setExtension( + self, char: str, string: java.lang.String | str + ) -> Locale.Builder: ... + def setLanguage(self, string: java.lang.String | str) -> Locale.Builder: ... + def setLanguageTag(self, string: java.lang.String | str) -> Locale.Builder: ... + def setLocale(self, locale: Locale) -> Locale.Builder: ... + def setRegion(self, string: java.lang.String | str) -> Locale.Builder: ... + def setScript(self, string: java.lang.String | str) -> Locale.Builder: ... + def setUnicodeLocaleKeyword( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> Locale.Builder: ... + def setVariant(self, string: java.lang.String | str) -> Locale.Builder: ... + + class Category(java.lang.Enum["Locale.Category"]): + DISPLAY: typing.ClassVar[Locale.Category] = ... + FORMAT: typing.ClassVar[Locale.Category] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Locale.Category: ... + @staticmethod + def values() -> typing.MutableSequence[Locale.Category]: ... + + class FilteringMode(java.lang.Enum["Locale.FilteringMode"]): + AUTOSELECT_FILTERING: typing.ClassVar[Locale.FilteringMode] = ... + EXTENDED_FILTERING: typing.ClassVar[Locale.FilteringMode] = ... + IGNORE_EXTENDED_RANGES: typing.ClassVar[Locale.FilteringMode] = ... + MAP_EXTENDED_RANGES: typing.ClassVar[Locale.FilteringMode] = ... + REJECT_EXTENDED_RANGES: typing.ClassVar[Locale.FilteringMode] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Locale.FilteringMode: ... + @staticmethod + def values() -> typing.MutableSequence[Locale.FilteringMode]: ... + + class IsoCountryCode(java.lang.Enum["Locale.IsoCountryCode"]): + PART1_ALPHA2: typing.ClassVar[Locale.IsoCountryCode] = ... + PART1_ALPHA3: typing.ClassVar[Locale.IsoCountryCode] = ... + PART3: typing.ClassVar[Locale.IsoCountryCode] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Locale.IsoCountryCode: ... + @staticmethod + def values() -> typing.MutableSequence[Locale.IsoCountryCode]: ... + + class LanguageRange: + MAX_WEIGHT: typing.ClassVar[float] = ... + MIN_WEIGHT: typing.ClassVar[float] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, double: float): ... + def equals(self, object: typing.Any) -> bool: ... + def getRange(self) -> java.lang.String: ... + def getWeight(self) -> float: ... + def hashCode(self) -> int: ... + @staticmethod + def mapEquivalents( + list: List[Locale.LanguageRange], + map: Map[java.lang.String | str, List[java.lang.String | str]] + | typing.Mapping[java.lang.String | str, List[java.lang.String | str]], + ) -> List[Locale.LanguageRange]: ... + @typing.overload + @staticmethod + def parse(string: java.lang.String | str) -> List[Locale.LanguageRange]: ... + @typing.overload + @staticmethod + def parse( + string: java.lang.String | str, + map: Map[java.lang.String | str, List[java.lang.String | str]] + | typing.Mapping[java.lang.String | str, List[java.lang.String | str]], + ) -> List[Locale.LanguageRange]: ... + def toString(self) -> java.lang.String: ... + +class LongSummaryStatistics( + java.util.function.LongConsumer, java.util.function.IntConsumer +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, long: int, long2: int, long3: int, long4: int): ... + @typing.overload + def accept(self, int: int) -> None: ... + @typing.overload + def accept(self, long: int) -> None: ... + def combine(self, longSummaryStatistics: LongSummaryStatistics) -> None: ... + def getAverage(self) -> float: ... + def getCount(self) -> int: ... + def getMax(self) -> int: ... + def getMin(self) -> int: ... + def getSum(self) -> int: ... + def toString(self) -> java.lang.String: ... + +_Map__Entry__K = typing.TypeVar("_Map__Entry__K") # +_Map__Entry__V = typing.TypeVar("_Map__Entry__V") # +_Map__K = typing.TypeVar("_Map__K") # +_Map__V = typing.TypeVar("_Map__V") # + +class Map(typing.Generic[_Map__K, _Map__V], _JMap[_Map__K, _Map__V]): + def clear(self) -> None: ... + def compute( + self, + k: _Map__K, + biFunction: java.util.function.BiFunction[_Map__K, _Map__V, _Map__V] + | typing.Callable[[_Map__K, _Map__V], _Map__V], + ) -> _Map__V: ... + def computeIfAbsent( + self, + k: _Map__K, + function: java.util.function.Function[_Map__K, _Map__V] + | typing.Callable[[_Map__K], _Map__V], + ) -> _Map__V: ... + def computeIfPresent( + self, + k: _Map__K, + biFunction: java.util.function.BiFunction[_Map__K, _Map__V, _Map__V] + | typing.Callable[[_Map__K, _Map__V], _Map__V], + ) -> _Map__V: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + _copyOf__K = typing.TypeVar("_copyOf__K") # + _copyOf__V = typing.TypeVar("_copyOf__V") # + @staticmethod + def copyOf( + map: Map[_copyOf__K, _copyOf__V] | typing.Mapping[_copyOf__K, _copyOf__V], + ) -> Map[_copyOf__K, _copyOf__V]: ... + _entry__K = typing.TypeVar("_entry__K") # + _entry__V = typing.TypeVar("_entry__V") # + @staticmethod + def entry(k: _entry__K, v: _entry__V) -> Map.Entry[_entry__K, _entry__V]: ... + def entrySet(self) -> Set[Map.Entry[_Map__K, _Map__V]]: ... + def equals(self, object: typing.Any) -> bool: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[_Map__K, _Map__V] + | typing.Callable[[_Map__K, _Map__V], None], + ) -> None: ... + def get(self, object: typing.Any) -> _Map__V: ... + def getOrDefault(self, object: typing.Any, v: _Map__V) -> _Map__V: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> Set[_Map__K]: ... + def merge( + self, + k: _Map__K, + v: _Map__V, + biFunction: java.util.function.BiFunction[_Map__V, _Map__V, _Map__V] + | typing.Callable[[_Map__V, _Map__V], _Map__V], + ) -> _Map__V: ... + _of_0__K = typing.TypeVar("_of_0__K") # + _of_0__V = typing.TypeVar("_of_0__V") # + _of_1__K = typing.TypeVar("_of_1__K") # + _of_1__V = typing.TypeVar("_of_1__V") # + _of_2__K = typing.TypeVar("_of_2__K") # + _of_2__V = typing.TypeVar("_of_2__V") # + _of_3__K = typing.TypeVar("_of_3__K") # + _of_3__V = typing.TypeVar("_of_3__V") # + _of_4__K = typing.TypeVar("_of_4__K") # + _of_4__V = typing.TypeVar("_of_4__V") # + _of_5__K = typing.TypeVar("_of_5__K") # + _of_5__V = typing.TypeVar("_of_5__V") # + _of_6__K = typing.TypeVar("_of_6__K") # + _of_6__V = typing.TypeVar("_of_6__V") # + _of_7__K = typing.TypeVar("_of_7__K") # + _of_7__V = typing.TypeVar("_of_7__V") # + _of_8__K = typing.TypeVar("_of_8__K") # + _of_8__V = typing.TypeVar("_of_8__V") # + _of_9__K = typing.TypeVar("_of_9__K") # + _of_9__V = typing.TypeVar("_of_9__V") # + _of_10__K = typing.TypeVar("_of_10__K") # + _of_10__V = typing.TypeVar("_of_10__V") # + @typing.overload + @staticmethod + def of() -> Map[_of_0__K, _of_0__V]: ... + @typing.overload + @staticmethod + def of(k: _of_1__K, v: _of_1__V) -> Map[_of_1__K, _of_1__V]: ... + @typing.overload + @staticmethod + def of( + k: _of_2__K, v: _of_2__V, k2: _of_2__K, v2: _of_2__V + ) -> Map[_of_2__K, _of_2__V]: ... + @typing.overload + @staticmethod + def of( + k: _of_3__K, v: _of_3__V, k2: _of_3__K, v2: _of_3__V, k3: _of_3__K, v3: _of_3__V + ) -> Map[_of_3__K, _of_3__V]: ... + @typing.overload + @staticmethod + def of( + k: _of_4__K, + v: _of_4__V, + k2: _of_4__K, + v2: _of_4__V, + k3: _of_4__K, + v3: _of_4__V, + k4: _of_4__K, + v4: _of_4__V, + ) -> Map[_of_4__K, _of_4__V]: ... + @typing.overload + @staticmethod + def of( + k: _of_5__K, + v: _of_5__V, + k2: _of_5__K, + v2: _of_5__V, + k3: _of_5__K, + v3: _of_5__V, + k4: _of_5__K, + v4: _of_5__V, + k5: _of_5__K, + v5: _of_5__V, + ) -> Map[_of_5__K, _of_5__V]: ... + @typing.overload + @staticmethod + def of( + k: _of_6__K, + v: _of_6__V, + k2: _of_6__K, + v2: _of_6__V, + k3: _of_6__K, + v3: _of_6__V, + k4: _of_6__K, + v4: _of_6__V, + k5: _of_6__K, + v5: _of_6__V, + k6: _of_6__K, + v6: _of_6__V, + ) -> Map[_of_6__K, _of_6__V]: ... + @typing.overload + @staticmethod + def of( + k: _of_7__K, + v: _of_7__V, + k2: _of_7__K, + v2: _of_7__V, + k3: _of_7__K, + v3: _of_7__V, + k4: _of_7__K, + v4: _of_7__V, + k5: _of_7__K, + v5: _of_7__V, + k6: _of_7__K, + v6: _of_7__V, + k7: _of_7__K, + v7: _of_7__V, + ) -> Map[_of_7__K, _of_7__V]: ... + @typing.overload + @staticmethod + def of( + k: _of_8__K, + v: _of_8__V, + k2: _of_8__K, + v2: _of_8__V, + k3: _of_8__K, + v3: _of_8__V, + k4: _of_8__K, + v4: _of_8__V, + k5: _of_8__K, + v5: _of_8__V, + k6: _of_8__K, + v6: _of_8__V, + k7: _of_8__K, + v7: _of_8__V, + k8: _of_8__K, + v8: _of_8__V, + ) -> Map[_of_8__K, _of_8__V]: ... + @typing.overload + @staticmethod + def of( + k: _of_9__K, + v: _of_9__V, + k2: _of_9__K, + v2: _of_9__V, + k3: _of_9__K, + v3: _of_9__V, + k4: _of_9__K, + v4: _of_9__V, + k5: _of_9__K, + v5: _of_9__V, + k6: _of_9__K, + v6: _of_9__V, + k7: _of_9__K, + v7: _of_9__V, + k8: _of_9__K, + v8: _of_9__V, + k9: _of_9__K, + v9: _of_9__V, + ) -> Map[_of_9__K, _of_9__V]: ... + @typing.overload + @staticmethod + def of( + k: _of_10__K, + v: _of_10__V, + k2: _of_10__K, + v2: _of_10__V, + k3: _of_10__K, + v3: _of_10__V, + k4: _of_10__K, + v4: _of_10__V, + k5: _of_10__K, + v5: _of_10__V, + k6: _of_10__K, + v6: _of_10__V, + k7: _of_10__K, + v7: _of_10__V, + k8: _of_10__K, + v8: _of_10__V, + k9: _of_10__K, + v9: _of_10__V, + k10: _of_10__K, + v10: _of_10__V, + ) -> Map[_of_10__K, _of_10__V]: ... + _ofEntries__K = typing.TypeVar("_ofEntries__K") # + _ofEntries__V = typing.TypeVar("_ofEntries__V") # + @staticmethod + def ofEntries( + *entry: Map.Entry[_ofEntries__K, _ofEntries__V], + ) -> Map[_ofEntries__K, _ofEntries__V]: ... + def put(self, k: _Map__K, v: _Map__V) -> _Map__V: ... + def putAll( + self, map: Map[_Map__K, _Map__V] | typing.Mapping[_Map__K, _Map__V] + ) -> None: ... + def putIfAbsent(self, k: _Map__K, v: _Map__V) -> _Map__V: ... + @typing.overload + def remove(self, object: typing.Any) -> _Map__V: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def replace(self, k: _Map__K, v: _Map__V, v2: _Map__V) -> bool: ... + @typing.overload + def replace(self, k: _Map__K, v: _Map__V) -> _Map__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[_Map__K, _Map__V, _Map__V] + | typing.Callable[[_Map__K, _Map__V], _Map__V], + ) -> None: ... + def size(self) -> int: ... + def values(self) -> Collection[_Map__V]: ... + class Entry( + typing.Generic[_Map__Entry__K, _Map__Entry__V], + _JMapEntry[_Map__Entry__K, _Map__Entry__V], + ): + _comparingByKey_0__K = typing.TypeVar( + "_comparingByKey_0__K", bound=java.lang.Comparable + ) # + _comparingByKey_0__V = typing.TypeVar("_comparingByKey_0__V") # + _comparingByKey_1__K = typing.TypeVar("_comparingByKey_1__K") # + _comparingByKey_1__V = typing.TypeVar("_comparingByKey_1__V") # + @typing.overload + @staticmethod + def comparingByKey() -> Comparator[ + Map.Entry[_comparingByKey_0__K, _comparingByKey_0__V] + ]: ... + @typing.overload + @staticmethod + def comparingByKey( + comparator: Comparator[_comparingByKey_1__K] + | typing.Callable[[_comparingByKey_1__K, _comparingByKey_1__K], int], + ) -> Comparator[Map.Entry[_comparingByKey_1__K, _comparingByKey_1__V]]: ... + _comparingByValue_0__K = typing.TypeVar("_comparingByValue_0__K") # + _comparingByValue_0__V = typing.TypeVar( + "_comparingByValue_0__V", bound=java.lang.Comparable + ) # + _comparingByValue_1__K = typing.TypeVar("_comparingByValue_1__K") # + _comparingByValue_1__V = typing.TypeVar("_comparingByValue_1__V") # + @typing.overload + @staticmethod + def comparingByValue() -> Comparator[ + Map.Entry[_comparingByValue_0__K, _comparingByValue_0__V] + ]: ... + @typing.overload + @staticmethod + def comparingByValue( + comparator: Comparator[_comparingByValue_1__V] + | typing.Callable[[_comparingByValue_1__V, _comparingByValue_1__V], int], + ) -> Comparator[Map.Entry[_comparingByValue_1__K, _comparingByValue_1__V]]: ... + _copyOf__K = typing.TypeVar("_copyOf__K") # + _copyOf__V = typing.TypeVar("_copyOf__V") # + @staticmethod + def copyOf( + entry: Map.Entry[_copyOf__K, _copyOf__V], + ) -> Map.Entry[_copyOf__K, _copyOf__V]: ... + def equals(self, object: typing.Any) -> bool: ... + def getKey(self) -> _Map__Entry__K: ... + def getValue(self) -> _Map__Entry__V: ... + def hashCode(self) -> int: ... + def setValue(self, v: _Map__Entry__V) -> _Map__Entry__V: ... + +class MissingResourceException(java.lang.RuntimeException): + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + def getClassName(self) -> java.lang.String: ... + def getKey(self) -> java.lang.String: ... + +class NoSuchElementException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class Objects: + @typing.overload + @staticmethod + def checkFromIndexSize(int: int, int2: int, int3: int) -> int: ... + @typing.overload + @staticmethod + def checkFromIndexSize(long: int, long2: int, long3: int) -> int: ... + @typing.overload + @staticmethod + def checkFromToIndex(int: int, int2: int, int3: int) -> int: ... + @typing.overload + @staticmethod + def checkFromToIndex(long: int, long2: int, long3: int) -> int: ... + @typing.overload + @staticmethod + def checkIndex(int: int, int2: int) -> int: ... + @typing.overload + @staticmethod + def checkIndex(long: int, long2: int) -> int: ... + _compare__T = typing.TypeVar("_compare__T") # + @staticmethod + def compare( + t: _compare__T, + t2: _compare__T, + comparator: Comparator[_compare__T] + | typing.Callable[[_compare__T, _compare__T], int], + ) -> int: ... + @staticmethod + def deepEquals(object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + @staticmethod + def equals(object: typing.Any, object2: typing.Any) -> bool: ... + @staticmethod + def hash(*object: typing.Any) -> int: ... + @typing.overload + def hashCode(self) -> int: ... + @typing.overload + @staticmethod + def hashCode(object: typing.Any) -> int: ... + @staticmethod + def isNull(object: typing.Any) -> bool: ... + @staticmethod + def nonNull(object: typing.Any) -> bool: ... + _requireNonNull_0__T = typing.TypeVar("_requireNonNull_0__T") # + _requireNonNull_1__T = typing.TypeVar("_requireNonNull_1__T") # + _requireNonNull_2__T = typing.TypeVar("_requireNonNull_2__T") # + @typing.overload + @staticmethod + def requireNonNull(t: _requireNonNull_0__T) -> _requireNonNull_0__T: ... + @typing.overload + @staticmethod + def requireNonNull( + t: _requireNonNull_1__T, string: java.lang.String | str + ) -> _requireNonNull_1__T: ... + @typing.overload + @staticmethod + def requireNonNull( + t: _requireNonNull_2__T, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> _requireNonNull_2__T: ... + _requireNonNullElse__T = typing.TypeVar("_requireNonNullElse__T") # + @staticmethod + def requireNonNullElse( + t: _requireNonNullElse__T, t2: _requireNonNullElse__T + ) -> _requireNonNullElse__T: ... + _requireNonNullElseGet__T = typing.TypeVar("_requireNonNullElseGet__T") # + @staticmethod + def requireNonNullElseGet( + t: _requireNonNullElseGet__T, + supplier: java.util.function.Supplier[_requireNonNullElseGet__T] + | typing.Callable[[], _requireNonNullElseGet__T], + ) -> _requireNonNullElseGet__T: ... + @staticmethod + def toIdentityString(object: typing.Any) -> java.lang.String: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(object: typing.Any) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString( + object: typing.Any, string: java.lang.String | str + ) -> java.lang.String: ... + +class Observable: + def __init__(self): ... + def addObserver(self, observer: Observer | typing.Callable) -> None: ... + def countObservers(self) -> int: ... + def deleteObserver(self, observer: Observer | typing.Callable) -> None: ... + def deleteObservers(self) -> None: ... + def hasChanged(self) -> bool: ... + @typing.overload + def notifyObservers(self) -> None: ... + @typing.overload + def notifyObservers(self, object: typing.Any) -> None: ... + +class Observer: + def update(self, observable: Observable, object: typing.Any) -> None: ... + +_Optional__T = typing.TypeVar("_Optional__T") # + +class Optional(typing.Generic[_Optional__T]): + _empty__T = typing.TypeVar("_empty__T") # + @staticmethod + def empty() -> Optional[_empty__T]: ... + def equals(self, object: typing.Any) -> bool: ... + def filter( + self, + predicate: java.util.function.Predicate[_Optional__T] + | typing.Callable[[_Optional__T], bool], + ) -> Optional[_Optional__T]: ... + _flatMap__U = typing.TypeVar("_flatMap__U") # + def flatMap( + self, + function: java.util.function.Function[_Optional__T, Optional[_flatMap__U]] + | typing.Callable[[_Optional__T], Optional[_flatMap__U]], + ) -> Optional[_flatMap__U]: ... + def get(self) -> _Optional__T: ... + def hashCode(self) -> int: ... + def ifPresent( + self, + consumer: java.util.function.Consumer[_Optional__T] + | typing.Callable[[_Optional__T], None], + ) -> None: ... + def ifPresentOrElse( + self, + consumer: java.util.function.Consumer[_Optional__T] + | typing.Callable[[_Optional__T], None], + runnable: java.lang.Runnable | typing.Callable, + ) -> None: ... + def isEmpty(self) -> bool: ... + def isPresent(self) -> bool: ... + _map__U = typing.TypeVar("_map__U") # + def map( + self, + function: java.util.function.Function[_Optional__T, _map__U] + | typing.Callable[[_Optional__T], _map__U], + ) -> Optional[_map__U]: ... + _of__T = typing.TypeVar("_of__T") # + @staticmethod + def of(t: _of__T) -> Optional[_of__T]: ... + _ofNullable__T = typing.TypeVar("_ofNullable__T") # + @staticmethod + def ofNullable(t: _ofNullable__T) -> Optional[_ofNullable__T]: ... + def orElse(self, t: _Optional__T) -> _Optional__T: ... + def orElseGet( + self, + supplier: java.util.function.Supplier[_Optional__T] + | typing.Callable[[], _Optional__T], + ) -> _Optional__T: ... + _orElseThrow_1__X = typing.TypeVar( + "_orElseThrow_1__X", bound=java.lang.Throwable + ) # + @typing.overload + def orElseThrow(self) -> _Optional__T: ... + @typing.overload + def orElseThrow( + self, + supplier: java.util.function.Supplier[_orElseThrow_1__X] + | typing.Callable[[], _orElseThrow_1__X], + ) -> _Optional__T: ... + def or_( + self, + supplier: java.util.function.Supplier[Optional[_Optional__T]] + | typing.Callable[[], Optional[_Optional__T]], + ) -> Optional[_Optional__T]: ... + def stream(self) -> java.util.stream.Stream[_Optional__T]: ... + def toString(self) -> java.lang.String: ... + +class OptionalDouble: + @staticmethod + def empty() -> OptionalDouble: ... + def equals(self, object: typing.Any) -> bool: ... + def getAsDouble(self) -> float: ... + def hashCode(self) -> int: ... + def ifPresent( + self, doubleConsumer: java.util.function.DoubleConsumer | typing.Callable + ) -> None: ... + def ifPresentOrElse( + self, + doubleConsumer: java.util.function.DoubleConsumer | typing.Callable, + runnable: java.lang.Runnable | typing.Callable, + ) -> None: ... + def isEmpty(self) -> bool: ... + def isPresent(self) -> bool: ... + @staticmethod + def of(double: float) -> OptionalDouble: ... + def orElse(self, double: float) -> float: ... + def orElseGet( + self, doubleSupplier: java.util.function.DoubleSupplier | typing.Callable + ) -> float: ... + _orElseThrow_1__X = typing.TypeVar( + "_orElseThrow_1__X", bound=java.lang.Throwable + ) # + @typing.overload + def orElseThrow(self) -> float: ... + @typing.overload + def orElseThrow( + self, + supplier: java.util.function.Supplier[_orElseThrow_1__X] + | typing.Callable[[], _orElseThrow_1__X], + ) -> float: ... + def stream(self) -> java.util.stream.DoubleStream: ... + def toString(self) -> java.lang.String: ... + +class OptionalInt: + @staticmethod + def empty() -> OptionalInt: ... + def equals(self, object: typing.Any) -> bool: ... + def getAsInt(self) -> int: ... + def hashCode(self) -> int: ... + def ifPresent( + self, intConsumer: java.util.function.IntConsumer | typing.Callable + ) -> None: ... + def ifPresentOrElse( + self, + intConsumer: java.util.function.IntConsumer | typing.Callable, + runnable: java.lang.Runnable | typing.Callable, + ) -> None: ... + def isEmpty(self) -> bool: ... + def isPresent(self) -> bool: ... + @staticmethod + def of(int: int) -> OptionalInt: ... + def orElse(self, int: int) -> int: ... + def orElseGet( + self, intSupplier: java.util.function.IntSupplier | typing.Callable + ) -> int: ... + _orElseThrow_1__X = typing.TypeVar( + "_orElseThrow_1__X", bound=java.lang.Throwable + ) # + @typing.overload + def orElseThrow(self) -> int: ... + @typing.overload + def orElseThrow( + self, + supplier: java.util.function.Supplier[_orElseThrow_1__X] + | typing.Callable[[], _orElseThrow_1__X], + ) -> int: ... + def stream(self) -> java.util.stream.IntStream: ... + def toString(self) -> java.lang.String: ... + +class OptionalLong: + @staticmethod + def empty() -> OptionalLong: ... + def equals(self, object: typing.Any) -> bool: ... + def getAsLong(self) -> int: ... + def hashCode(self) -> int: ... + def ifPresent( + self, longConsumer: java.util.function.LongConsumer | typing.Callable + ) -> None: ... + def ifPresentOrElse( + self, + longConsumer: java.util.function.LongConsumer | typing.Callable, + runnable: java.lang.Runnable | typing.Callable, + ) -> None: ... + def isEmpty(self) -> bool: ... + def isPresent(self) -> bool: ... + @staticmethod + def of(long: int) -> OptionalLong: ... + def orElse(self, long: int) -> int: ... + def orElseGet( + self, longSupplier: java.util.function.LongSupplier | typing.Callable + ) -> int: ... + _orElseThrow_1__X = typing.TypeVar( + "_orElseThrow_1__X", bound=java.lang.Throwable + ) # + @typing.overload + def orElseThrow(self) -> int: ... + @typing.overload + def orElseThrow( + self, + supplier: java.util.function.Supplier[_orElseThrow_1__X] + | typing.Callable[[], _orElseThrow_1__X], + ) -> int: ... + def stream(self) -> java.util.stream.LongStream: ... + def toString(self) -> java.lang.String: ... + +class PropertyPermission(java.security.BasicPermission): + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getActions(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def implies(self, permission: java.security.Permission) -> bool: ... + def newPermissionCollection(self) -> java.security.PermissionCollection: ... + +class Random(java.util.random.RandomGenerator, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, long: int): ... + @typing.overload + def doubles(self) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles( + self, double: float, double2: float + ) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles(self, long: int) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles( + self, long: int, double: float, double2: float + ) -> java.util.stream.DoubleStream: ... + @staticmethod + def from_( + randomGenerator: java.util.random.RandomGenerator | typing.Callable, + ) -> Random: ... + @typing.overload + def ints(self) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, int: int, int2: int) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, long: int) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, long: int, int: int, int2: int) -> java.util.stream.IntStream: ... + @typing.overload + def longs(self) -> java.util.stream.LongStream: ... + @typing.overload + def longs(self, long: int) -> java.util.stream.LongStream: ... + @typing.overload + def longs(self, long: int, long2: int) -> java.util.stream.LongStream: ... + @typing.overload + def longs( + self, long: int, long2: int, long3: int + ) -> java.util.stream.LongStream: ... + def nextBoolean(self) -> bool: ... + def nextBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def nextDouble(self, double: float) -> float: ... + @typing.overload + def nextDouble(self, double: float, double2: float) -> float: ... + @typing.overload + def nextDouble(self) -> float: ... + @typing.overload + def nextFloat(self, float: float) -> float: ... + @typing.overload + def nextFloat(self, float: float, float2: float) -> float: ... + @typing.overload + def nextFloat(self) -> float: ... + @typing.overload + def nextGaussian(self, double: float, double2: float) -> float: ... + @typing.overload + def nextGaussian(self) -> float: ... + @typing.overload + def nextInt(self, int: int, int2: int) -> int: ... + @typing.overload + def nextInt(self) -> int: ... + @typing.overload + def nextInt(self, int: int) -> int: ... + @typing.overload + def nextLong(self, long: int) -> int: ... + @typing.overload + def nextLong(self, long: int, long2: int) -> int: ... + @typing.overload + def nextLong(self) -> int: ... + def setSeed(self, long: int) -> None: ... + +class RandomAccess: ... + +class ResourceBundle: + def __init__(self): ... + @typing.overload + @staticmethod + def clearCache() -> None: ... + @typing.overload + @staticmethod + def clearCache(classLoader: java.lang.ClassLoader) -> None: ... + def containsKey(self, string: java.lang.String | str) -> bool: ... + def getBaseBundleName(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getBundle(string: java.lang.String | str) -> ResourceBundle: ... + @typing.overload + @staticmethod + def getBundle(string: java.lang.String | str, locale: Locale) -> ResourceBundle: ... + @typing.overload + @staticmethod + def getBundle( + string: java.lang.String | str, locale: Locale, control: ResourceBundle.Control + ) -> ResourceBundle: ... + @typing.overload + @staticmethod + def getBundle( + string: java.lang.String | str, control: ResourceBundle.Control + ) -> ResourceBundle: ... + @typing.overload + @staticmethod + def getBundle( + string: java.lang.String | str, module: java.lang.Module + ) -> ResourceBundle: ... + @typing.overload + @staticmethod + def getBundle( + string: java.lang.String | str, + locale: Locale, + classLoader: java.lang.ClassLoader, + ) -> ResourceBundle: ... + @typing.overload + @staticmethod + def getBundle( + string: java.lang.String | str, + locale: Locale, + classLoader: java.lang.ClassLoader, + control: ResourceBundle.Control, + ) -> ResourceBundle: ... + @typing.overload + @staticmethod + def getBundle( + string: java.lang.String | str, locale: Locale, module: java.lang.Module + ) -> ResourceBundle: ... + def getKeys(self) -> Enumeration[java.lang.String]: ... + def getLocale(self) -> Locale: ... + def getObject(self, string: java.lang.String | str) -> typing.Any: ... + def getString(self, string: java.lang.String | str) -> java.lang.String: ... + def getStringArray( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + def keySet(self) -> Set[java.lang.String]: ... + class Control: + FORMAT_DEFAULT: typing.ClassVar[List] = ... + FORMAT_CLASS: typing.ClassVar[List] = ... + FORMAT_PROPERTIES: typing.ClassVar[List] = ... + TTL_DONT_CACHE: typing.ClassVar[int] = ... + TTL_NO_EXPIRATION_CONTROL: typing.ClassVar[int] = ... + def getCandidateLocales( + self, string: java.lang.String | str, locale: Locale + ) -> List[Locale]: ... + @staticmethod + def getControl( + list: List[java.lang.String | str], + ) -> ResourceBundle.Control: ... + def getFallbackLocale( + self, string: java.lang.String | str, locale: Locale + ) -> Locale: ... + def getFormats( + self, string: java.lang.String | str + ) -> List[java.lang.String]: ... + @staticmethod + def getNoFallbackControl( + list: List[java.lang.String | str], + ) -> ResourceBundle.Control: ... + def getTimeToLive( + self, string: java.lang.String | str, locale: Locale + ) -> int: ... + def needsReload( + self, + string: java.lang.String | str, + locale: Locale, + string2: java.lang.String | str, + classLoader: java.lang.ClassLoader, + resourceBundle: ResourceBundle, + long: int, + ) -> bool: ... + def newBundle( + self, + string: java.lang.String | str, + locale: Locale, + string2: java.lang.String | str, + classLoader: java.lang.ClassLoader, + boolean: bool, + ) -> ResourceBundle: ... + def toBundleName( + self, string: java.lang.String | str, locale: Locale + ) -> java.lang.String: ... + def toResourceName( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + +class ServiceConfigurationError(java.lang.Error): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + +_ServiceLoader__Provider__S = typing.TypeVar("_ServiceLoader__Provider__S") # +_ServiceLoader__S = typing.TypeVar("_ServiceLoader__S") # + +class ServiceLoader( + java.lang.Iterable[_ServiceLoader__S], typing.Generic[_ServiceLoader__S] +): + def findFirst(self) -> Optional[_ServiceLoader__S]: ... + def iterator(self) -> Iterator[_ServiceLoader__S]: ... + _load_0__S = typing.TypeVar("_load_0__S") # + _load_1__S = typing.TypeVar("_load_1__S") # + _load_2__S = typing.TypeVar("_load_2__S") # + @typing.overload + @staticmethod + def load(class_: type[_load_0__S]) -> ServiceLoader[_load_0__S]: ... + @typing.overload + @staticmethod + def load( + class_: type[_load_1__S], classLoader: java.lang.ClassLoader + ) -> ServiceLoader[_load_1__S]: ... + @typing.overload + @staticmethod + def load( + moduleLayer: java.lang.ModuleLayer, class_: type[_load_2__S] + ) -> ServiceLoader[_load_2__S]: ... + _loadInstalled__S = typing.TypeVar("_loadInstalled__S") # + @staticmethod + def loadInstalled( + class_: type[_loadInstalled__S], + ) -> ServiceLoader[_loadInstalled__S]: ... + def reload(self) -> None: ... + def stream( + self, + ) -> java.util.stream.Stream[ServiceLoader.Provider[_ServiceLoader__S]]: ... + def toString(self) -> java.lang.String: ... + class Provider( + java.util.function.Supplier[_ServiceLoader__Provider__S], + typing.Generic[_ServiceLoader__Provider__S], + ): + def get(self) -> _ServiceLoader__Provider__S: ... + def type(self) -> builtins.type[_ServiceLoader__Provider__S]: ... + +class SplittableRandom( + java.util.random.RandomGenerator, + java.util.random.RandomGenerator.SplittableGenerator, +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, long: int): ... + @typing.overload + def doubles(self) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles( + self, double: float, double2: float + ) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles(self, long: int) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles( + self, long: int, double: float, double2: float + ) -> java.util.stream.DoubleStream: ... + @typing.overload + def ints(self) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, int: int, int2: int) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, long: int) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, long: int, int: int, int2: int) -> java.util.stream.IntStream: ... + @typing.overload + def longs(self) -> java.util.stream.LongStream: ... + @typing.overload + def longs(self, long: int) -> java.util.stream.LongStream: ... + @typing.overload + def longs(self, long: int, long2: int) -> java.util.stream.LongStream: ... + @typing.overload + def longs( + self, long: int, long2: int, long3: int + ) -> java.util.stream.LongStream: ... + def nextBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def nextInt(self, int: int) -> int: ... + @typing.overload + def nextInt(self, int: int, int2: int) -> int: ... + @typing.overload + def nextInt(self) -> int: ... + @typing.overload + def nextLong(self, long: int) -> int: ... + @typing.overload + def nextLong(self, long: int, long2: int) -> int: ... + @typing.overload + def nextLong(self) -> int: ... + @typing.overload + def split(self) -> SplittableRandom: ... + @typing.overload + def split( + self, splittableGenerator: java.util.random.RandomGenerator.SplittableGenerator + ) -> SplittableRandom: ... + @typing.overload + def splits( + self, + ) -> java.util.stream.Stream[ + java.util.random.RandomGenerator.SplittableGenerator + ]: ... + @typing.overload + def splits( + self, splittableGenerator: java.util.random.RandomGenerator.SplittableGenerator + ) -> java.util.stream.Stream[ + java.util.random.RandomGenerator.SplittableGenerator + ]: ... + @typing.overload + def splits( + self, long: int + ) -> java.util.stream.Stream[ + java.util.random.RandomGenerator.SplittableGenerator + ]: ... + @typing.overload + def splits( + self, + long: int, + splittableGenerator: java.util.random.RandomGenerator.SplittableGenerator, + ) -> java.util.stream.Stream[ + java.util.random.RandomGenerator.SplittableGenerator + ]: ... + +class StringJoiner: + @typing.overload + def __init__(self, charSequence: java.lang.CharSequence | str): ... + @typing.overload + def __init__( + self, + charSequence: java.lang.CharSequence | str, + charSequence2: java.lang.CharSequence | str, + charSequence3: java.lang.CharSequence | str, + ): ... + def add(self, charSequence: java.lang.CharSequence | str) -> StringJoiner: ... + def length(self) -> int: ... + def merge(self, stringJoiner: StringJoiner) -> StringJoiner: ... + def setEmptyValue( + self, charSequence: java.lang.CharSequence | str + ) -> StringJoiner: ... + def toString(self) -> java.lang.String: ... + +class TimeZone(java.io.Serializable, java.lang.Cloneable): + SHORT: typing.ClassVar[int] = ... + LONG: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + @staticmethod + def availableIDs() -> java.util.stream.Stream[java.lang.String]: ... + @typing.overload + @staticmethod + def availableIDs(int: int) -> java.util.stream.Stream[java.lang.String]: ... + def clone(self) -> typing.Any: ... + @typing.overload + @staticmethod + def getAvailableIDs() -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + @staticmethod + def getAvailableIDs(int: int) -> typing.MutableSequence[java.lang.String]: ... + def getDSTSavings(self) -> int: ... + @staticmethod + def getDefault() -> TimeZone: ... + @typing.overload + def getDisplayName(self) -> java.lang.String: ... + @typing.overload + def getDisplayName(self, boolean: bool, int: int) -> java.lang.String: ... + @typing.overload + def getDisplayName(self, locale: Locale) -> java.lang.String: ... + @typing.overload + def getDisplayName( + self, boolean: bool, int: int, locale: Locale + ) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + @typing.overload + def getOffset( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + @typing.overload + def getOffset(self, long: int) -> int: ... + def getRawOffset(self) -> int: ... + @typing.overload + @staticmethod + def getTimeZone(string: java.lang.String | str) -> TimeZone: ... + @typing.overload + @staticmethod + def getTimeZone(zoneId: java.time.ZoneId) -> TimeZone: ... + def hasSameRules(self, timeZone: TimeZone) -> bool: ... + def inDaylightTime(self, date: Date) -> bool: ... + def observesDaylightTime(self) -> bool: ... + @staticmethod + def setDefault(timeZone: TimeZone) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setRawOffset(self, int: int) -> None: ... + def toZoneId(self) -> java.time.ZoneId: ... + def useDaylightTime(self) -> bool: ... + +class Timer: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + def cancel(self) -> None: ... + def purge(self) -> int: ... + @typing.overload + def schedule(self, timerTask: TimerTask, date: Date) -> None: ... + @typing.overload + def schedule(self, timerTask: TimerTask, date: Date, long: int) -> None: ... + @typing.overload + def schedule(self, timerTask: TimerTask, long: int) -> None: ... + @typing.overload + def schedule(self, timerTask: TimerTask, long: int, long2: int) -> None: ... + @typing.overload + def scheduleAtFixedRate( + self, timerTask: TimerTask, date: Date, long: int + ) -> None: ... + @typing.overload + def scheduleAtFixedRate( + self, timerTask: TimerTask, long: int, long2: int + ) -> None: ... + +class TimerTask(java.lang.Runnable): + def cancel(self) -> bool: ... + def run(self) -> None: ... + def scheduledExecutionTime(self) -> int: ... + +class TooManyListenersException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class UUID(java.io.Serializable, java.lang.Comparable["UUID"]): + def __init__(self, long: int, long2: int): ... + def clockSequence(self) -> int: ... + def compareTo(self, uUID: UUID) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def fromString(string: java.lang.String | str) -> UUID: ... + def getLeastSignificantBits(self) -> int: ... + def getMostSignificantBits(self) -> int: ... + def hashCode(self) -> int: ... + @staticmethod + def nameUUIDFromBytes(byteArray: list[int] | jpype.JArray | bytes) -> UUID: ... + def node(self) -> int: ... + @staticmethod + def randomUUID() -> UUID: ... + def timestamp(self) -> int: ... + def toString(self) -> java.lang.String: ... + def variant(self) -> int: ... + def version(self) -> int: ... + +_AbstractCollection__E = typing.TypeVar("_AbstractCollection__E") # + +class AbstractCollection( + Collection[_AbstractCollection__E], typing.Generic[_AbstractCollection__E] +): + def add(self, e: _AbstractCollection__E) -> bool: ... + def addAll( + self, + collection: Collection[_AbstractCollection__E] + | typing.Sequence[_AbstractCollection__E] + | set[_AbstractCollection__E], + ) -> bool: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> Iterator[_AbstractCollection__E]: ... + def remove(self, object: typing.Any) -> bool: ... + def removeAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def retainAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + +_AbstractMap__SimpleEntry__K = typing.TypeVar("_AbstractMap__SimpleEntry__K") # +_AbstractMap__SimpleEntry__V = typing.TypeVar("_AbstractMap__SimpleEntry__V") # +_AbstractMap__SimpleImmutableEntry__K = typing.TypeVar( + "_AbstractMap__SimpleImmutableEntry__K" +) # +_AbstractMap__SimpleImmutableEntry__V = typing.TypeVar( + "_AbstractMap__SimpleImmutableEntry__V" +) # +_AbstractMap__K = typing.TypeVar("_AbstractMap__K") # +_AbstractMap__V = typing.TypeVar("_AbstractMap__V") # + +class AbstractMap( + Map[_AbstractMap__K, _AbstractMap__V], + typing.Generic[_AbstractMap__K, _AbstractMap__V], +): + def clear(self) -> None: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def entrySet(self) -> Set[Map.Entry[_AbstractMap__K, _AbstractMap__V]]: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, object: typing.Any) -> _AbstractMap__V: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> Set[_AbstractMap__K]: ... + def put(self, k: _AbstractMap__K, v: _AbstractMap__V) -> _AbstractMap__V: ... + def putAll( + self, + map: Map[_AbstractMap__K, _AbstractMap__V] + | typing.Mapping[_AbstractMap__K, _AbstractMap__V], + ) -> None: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _AbstractMap__V: ... + def size(self) -> int: ... + def toString(self) -> java.lang.String: ... + def values(self) -> Collection[_AbstractMap__V]: ... + class SimpleEntry( + Map.Entry[_AbstractMap__SimpleEntry__K, _AbstractMap__SimpleEntry__V], + java.io.Serializable, + typing.Generic[_AbstractMap__SimpleEntry__K, _AbstractMap__SimpleEntry__V], + ): + @typing.overload + def __init__( + self, k: _AbstractMap__SimpleEntry__K, v: _AbstractMap__SimpleEntry__V + ): ... + @typing.overload + def __init__( + self, + entry: Map.Entry[ + _AbstractMap__SimpleEntry__K, _AbstractMap__SimpleEntry__V + ], + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getKey(self) -> _AbstractMap__SimpleEntry__K: ... + def getValue(self) -> _AbstractMap__SimpleEntry__V: ... + def hashCode(self) -> int: ... + def setValue( + self, v: _AbstractMap__SimpleEntry__V + ) -> _AbstractMap__SimpleEntry__V: ... + def toString(self) -> java.lang.String: ... + + class SimpleImmutableEntry( + Map.Entry[ + _AbstractMap__SimpleImmutableEntry__K, _AbstractMap__SimpleImmutableEntry__V + ], + java.io.Serializable, + typing.Generic[ + _AbstractMap__SimpleImmutableEntry__K, _AbstractMap__SimpleImmutableEntry__V + ], + ): + @typing.overload + def __init__( + self, + k: _AbstractMap__SimpleImmutableEntry__K, + v: _AbstractMap__SimpleImmutableEntry__V, + ): ... + @typing.overload + def __init__( + self, + entry: Map.Entry[ + _AbstractMap__SimpleImmutableEntry__K, + _AbstractMap__SimpleImmutableEntry__V, + ], + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getKey(self) -> _AbstractMap__SimpleImmutableEntry__K: ... + def getValue(self) -> _AbstractMap__SimpleImmutableEntry__V: ... + def hashCode(self) -> int: ... + def setValue( + self, v: _AbstractMap__SimpleImmutableEntry__V + ) -> _AbstractMap__SimpleImmutableEntry__V: ... + def toString(self) -> java.lang.String: ... + +class DuplicateFormatFlagsException(IllegalFormatException): + def __init__(self, string: java.lang.String | str): ... + def getFlags(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + +_EventListenerProxy__T = typing.TypeVar( + "_EventListenerProxy__T", bound=EventListener +) # + +class EventListenerProxy(EventListener, typing.Generic[_EventListenerProxy__T]): + def __init__(self, t: _EventListenerProxy__T): ... + def getListener(self) -> _EventListenerProxy__T: ... + +class FormatFlagsConversionMismatchException(IllegalFormatException): + def __init__(self, string: java.lang.String | str, char: str): ... + def getConversion(self) -> str: ... + def getFlags(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + +class GregorianCalendar(Calendar): + BC: typing.ClassVar[int] = ... + AD: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int, int5: int): ... + @typing.overload + def __init__( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ): ... + @typing.overload + def __init__(self, locale: Locale): ... + @typing.overload + def __init__(self, timeZone: TimeZone): ... + @typing.overload + def __init__(self, timeZone: TimeZone, locale: Locale): ... + def add(self, int: int, int2: int) -> None: ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + @staticmethod + def from_(zonedDateTime: java.time.ZonedDateTime) -> GregorianCalendar: ... + def getActualMaximum(self, int: int) -> int: ... + def getActualMinimum(self, int: int) -> int: ... + def getCalendarType(self) -> java.lang.String: ... + def getGreatestMinimum(self, int: int) -> int: ... + def getGregorianChange(self) -> Date: ... + def getLeastMaximum(self, int: int) -> int: ... + def getMaximum(self, int: int) -> int: ... + def getMinimum(self, int: int) -> int: ... + def getTimeZone(self) -> TimeZone: ... + def getWeekYear(self) -> int: ... + def getWeeksInWeekYear(self) -> int: ... + def hashCode(self) -> int: ... + def isLeapYear(self, int: int) -> bool: ... + def isWeekDateSupported(self) -> bool: ... + @typing.overload + def roll(self, int: int, boolean: bool) -> None: ... + @typing.overload + def roll(self, int: int, int2: int) -> None: ... + def setGregorianChange(self, date: Date) -> None: ... + def setTimeZone(self, timeZone: TimeZone) -> None: ... + def setWeekDate(self, int: int, int2: int, int3: int) -> None: ... + def toZonedDateTime(self) -> java.time.ZonedDateTime: ... + +_Hashtable__K = typing.TypeVar("_Hashtable__K") # +_Hashtable__V = typing.TypeVar("_Hashtable__V") # + +class Hashtable( + Dictionary[_Hashtable__K, _Hashtable__V], + Map[_Hashtable__K, _Hashtable__V], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_Hashtable__K, _Hashtable__V], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, float: float): ... + @typing.overload + def __init__( + self, + map: Map[_Hashtable__K, _Hashtable__V] + | typing.Mapping[_Hashtable__K, _Hashtable__V], + ): ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def compute( + self, + k: _Hashtable__K, + biFunction: java.util.function.BiFunction[ + _Hashtable__K, _Hashtable__V, _Hashtable__V + ] + | typing.Callable[[_Hashtable__K, _Hashtable__V], _Hashtable__V], + ) -> _Hashtable__V: ... + def computeIfAbsent( + self, + k: _Hashtable__K, + function: java.util.function.Function[_Hashtable__K, _Hashtable__V] + | typing.Callable[[_Hashtable__K], _Hashtable__V], + ) -> _Hashtable__V: ... + def computeIfPresent( + self, + k: _Hashtable__K, + biFunction: java.util.function.BiFunction[ + _Hashtable__K, _Hashtable__V, _Hashtable__V + ] + | typing.Callable[[_Hashtable__K, _Hashtable__V], _Hashtable__V], + ) -> _Hashtable__V: ... + def contains(self, object: typing.Any) -> bool: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def elements(self) -> Enumeration[_Hashtable__V]: ... + def entrySet(self) -> Set[Map.Entry[_Hashtable__K, _Hashtable__V]]: ... + def equals(self, object: typing.Any) -> bool: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[_Hashtable__K, _Hashtable__V] + | typing.Callable[[_Hashtable__K, _Hashtable__V], None], + ) -> None: ... + def get(self, object: typing.Any) -> _Hashtable__V: ... + def getOrDefault(self, object: typing.Any, v: _Hashtable__V) -> _Hashtable__V: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> Set[_Hashtable__K]: ... + def keys(self) -> Enumeration[_Hashtable__K]: ... + def merge( + self, + k: _Hashtable__K, + v: _Hashtable__V, + biFunction: java.util.function.BiFunction[ + _Hashtable__V, _Hashtable__V, _Hashtable__V + ] + | typing.Callable[[_Hashtable__V, _Hashtable__V], _Hashtable__V], + ) -> _Hashtable__V: ... + def put(self, k: _Hashtable__K, v: _Hashtable__V) -> _Hashtable__V: ... + def putAll( + self, + map: Map[_Hashtable__K, _Hashtable__V] + | typing.Mapping[_Hashtable__K, _Hashtable__V], + ) -> None: ... + def putIfAbsent(self, k: _Hashtable__K, v: _Hashtable__V) -> _Hashtable__V: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _Hashtable__V: ... + @typing.overload + def replace( + self, k: _Hashtable__K, v: _Hashtable__V, v2: _Hashtable__V + ) -> bool: ... + @typing.overload + def replace(self, k: _Hashtable__K, v: _Hashtable__V) -> _Hashtable__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[ + _Hashtable__K, _Hashtable__V, _Hashtable__V + ] + | typing.Callable[[_Hashtable__K, _Hashtable__V], _Hashtable__V], + ) -> None: ... + def size(self) -> int: ... + def toString(self) -> java.lang.String: ... + def values(self) -> Collection[_Hashtable__V]: ... + +class IllegalFormatCodePointException(IllegalFormatException): + def __init__(self, int: int): ... + def getCodePoint(self) -> int: ... + def getMessage(self) -> java.lang.String: ... + +class IllegalFormatConversionException(IllegalFormatException): + def __init__(self, char: str, class_: type[typing.Any]): ... + def getArgumentClass(self) -> type[typing.Any]: ... + def getConversion(self) -> str: ... + def getMessage(self) -> java.lang.String: ... + +class IllegalFormatFlagsException(IllegalFormatException): + def __init__(self, string: java.lang.String | str): ... + def getFlags(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + +class IllegalFormatPrecisionException(IllegalFormatException): + def __init__(self, int: int): ... + def getMessage(self) -> java.lang.String: ... + def getPrecision(self) -> int: ... + +class IllegalFormatWidthException(IllegalFormatException): + def __init__(self, int: int): ... + def getMessage(self) -> java.lang.String: ... + def getWidth(self) -> int: ... + +class InputMismatchException(NoSuchElementException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +_ListIterator__E = typing.TypeVar("_ListIterator__E") # + +class ListIterator(Iterator[_ListIterator__E], typing.Generic[_ListIterator__E]): + def add(self, e: _ListIterator__E) -> None: ... + def hasNext(self) -> bool: ... + def hasPrevious(self) -> bool: ... + def next(self) -> _ListIterator__E: ... + def nextIndex(self) -> int: ... + def previous(self) -> _ListIterator__E: ... + def previousIndex(self) -> int: ... + def remove(self) -> None: ... + def set(self, e: _ListIterator__E) -> None: ... + +class ListResourceBundle(ResourceBundle): + def __init__(self): ... + def getKeys(self) -> Enumeration[java.lang.String]: ... + def handleGetObject(self, string: java.lang.String | str) -> typing.Any: ... + +class MissingFormatArgumentException(IllegalFormatException): + def __init__(self, string: java.lang.String | str): ... + def getFormatSpecifier(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + +class MissingFormatWidthException(IllegalFormatException): + def __init__(self, string: java.lang.String | str): ... + def getFormatSpecifier(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + +class PropertyResourceBundle(ResourceBundle): + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + @typing.overload + def __init__(self, reader: java.io.Reader): ... + def getKeys(self) -> Enumeration[java.lang.String]: ... + def handleGetObject(self, string: java.lang.String | str) -> typing.Any: ... + +_Queue__E = typing.TypeVar("_Queue__E") # + +class Queue(Collection[_Queue__E], typing.Generic[_Queue__E]): + def add(self, e: _Queue__E) -> bool: ... + def element(self) -> _Queue__E: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def offer(self, e: _Queue__E) -> bool: ... + def peek(self) -> _Queue__E: ... + def poll(self) -> _Queue__E: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _Queue__E: ... + +class Scanner(Iterator[java.lang.String], java.io.Closeable): + @typing.overload + def __init__(self, file: java.io.File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + string: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + @typing.overload + def __init__( + self, inputStream: java.io.InputStream, string: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, inputStream: java.io.InputStream, charset: java.nio.charset.Charset + ): ... + @typing.overload + def __init__(self, readable: java.lang.Readable | typing.Callable): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, readableByteChannel: java.nio.channels.ReadableByteChannel): ... + @typing.overload + def __init__( + self, + readableByteChannel: java.nio.channels.ReadableByteChannel, + string: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + readableByteChannel: java.nio.channels.ReadableByteChannel, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__(self, path: java.nio.file.Path | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + string: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + path: java.nio.file.Path | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + ): ... + def close(self) -> None: ... + def delimiter(self) -> java.util.regex.Pattern: ... + @typing.overload + def findAll( + self, string: java.lang.String | str + ) -> java.util.stream.Stream[java.util.regex.MatchResult]: ... + @typing.overload + def findAll( + self, pattern: java.util.regex.Pattern + ) -> java.util.stream.Stream[java.util.regex.MatchResult]: ... + @typing.overload + def findInLine(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def findInLine(self, pattern: java.util.regex.Pattern) -> java.lang.String: ... + @typing.overload + def findWithinHorizon( + self, string: java.lang.String | str, int: int + ) -> java.lang.String: ... + @typing.overload + def findWithinHorizon( + self, pattern: java.util.regex.Pattern, int: int + ) -> java.lang.String: ... + @typing.overload + def hasNext(self) -> bool: ... + @typing.overload + def hasNext(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def hasNext(self, pattern: java.util.regex.Pattern) -> bool: ... + def hasNextBigDecimal(self) -> bool: ... + @typing.overload + def hasNextBigInteger(self) -> bool: ... + @typing.overload + def hasNextBigInteger(self, int: int) -> bool: ... + def hasNextBoolean(self) -> bool: ... + @typing.overload + def hasNextByte(self) -> bool: ... + @typing.overload + def hasNextByte(self, int: int) -> bool: ... + def hasNextDouble(self) -> bool: ... + def hasNextFloat(self) -> bool: ... + @typing.overload + def hasNextInt(self) -> bool: ... + @typing.overload + def hasNextInt(self, int: int) -> bool: ... + def hasNextLine(self) -> bool: ... + @typing.overload + def hasNextLong(self) -> bool: ... + @typing.overload + def hasNextLong(self, int: int) -> bool: ... + @typing.overload + def hasNextShort(self) -> bool: ... + @typing.overload + def hasNextShort(self, int: int) -> bool: ... + def ioException(self) -> java.io.IOException: ... + def locale(self) -> Locale: ... + def match(self) -> java.util.regex.MatchResult: ... + @typing.overload + def next(self) -> java.lang.String: ... + @typing.overload + def next(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def next(self, pattern: java.util.regex.Pattern) -> java.lang.String: ... + def nextBigDecimal(self) -> java.math.BigDecimal: ... + @typing.overload + def nextBigInteger(self) -> java.math.BigInteger: ... + @typing.overload + def nextBigInteger(self, int: int) -> java.math.BigInteger: ... + def nextBoolean(self) -> bool: ... + @typing.overload + def nextByte(self) -> int: ... + @typing.overload + def nextByte(self, int: int) -> int: ... + def nextDouble(self) -> float: ... + def nextFloat(self) -> float: ... + @typing.overload + def nextInt(self) -> int: ... + @typing.overload + def nextInt(self, int: int) -> int: ... + def nextLine(self) -> java.lang.String: ... + @typing.overload + def nextLong(self) -> int: ... + @typing.overload + def nextLong(self, int: int) -> int: ... + @typing.overload + def nextShort(self) -> int: ... + @typing.overload + def nextShort(self, int: int) -> int: ... + def radix(self) -> int: ... + def remove(self) -> None: ... + def reset(self) -> Scanner: ... + @typing.overload + def skip(self, string: java.lang.String | str) -> Scanner: ... + @typing.overload + def skip(self, pattern: java.util.regex.Pattern) -> Scanner: ... + def toString(self) -> java.lang.String: ... + def tokens(self) -> java.util.stream.Stream[java.lang.String]: ... + @typing.overload + def useDelimiter(self, string: java.lang.String | str) -> Scanner: ... + @typing.overload + def useDelimiter(self, pattern: java.util.regex.Pattern) -> Scanner: ... + def useLocale(self, locale: Locale) -> Scanner: ... + def useRadix(self, int: int) -> Scanner: ... + +_SequencedCollection__E = typing.TypeVar("_SequencedCollection__E") # + +class SequencedCollection( + Collection[_SequencedCollection__E], typing.Generic[_SequencedCollection__E] +): + def addFirst(self, e: _SequencedCollection__E) -> None: ... + def addLast(self, e: _SequencedCollection__E) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getFirst(self) -> _SequencedCollection__E: ... + def getLast(self) -> _SequencedCollection__E: ... + def hashCode(self) -> int: ... + def removeFirst(self) -> _SequencedCollection__E: ... + def removeLast(self) -> _SequencedCollection__E: ... + def reversed(self) -> SequencedCollection[_SequencedCollection__E]: ... + +_SequencedMap__K = typing.TypeVar("_SequencedMap__K") # +_SequencedMap__V = typing.TypeVar("_SequencedMap__V") # + +class SequencedMap( + Map[_SequencedMap__K, _SequencedMap__V], + typing.Generic[_SequencedMap__K, _SequencedMap__V], +): + def equals(self, object: typing.Any) -> bool: ... + def firstEntry(self) -> Map.Entry[_SequencedMap__K, _SequencedMap__V]: ... + def hashCode(self) -> int: ... + def lastEntry(self) -> Map.Entry[_SequencedMap__K, _SequencedMap__V]: ... + def pollFirstEntry(self) -> Map.Entry[_SequencedMap__K, _SequencedMap__V]: ... + def pollLastEntry(self) -> Map.Entry[_SequencedMap__K, _SequencedMap__V]: ... + def putFirst( + self, k: _SequencedMap__K, v: _SequencedMap__V + ) -> _SequencedMap__V: ... + def putLast(self, k: _SequencedMap__K, v: _SequencedMap__V) -> _SequencedMap__V: ... + def reversed(self) -> SequencedMap[_SequencedMap__K, _SequencedMap__V]: ... + def sequencedEntrySet( + self, + ) -> SequencedSet[Map.Entry[_SequencedMap__K, _SequencedMap__V]]: ... + def sequencedKeySet(self) -> SequencedSet[_SequencedMap__K]: ... + def sequencedValues(self) -> SequencedCollection[_SequencedMap__V]: ... + +_Set__E = typing.TypeVar("_Set__E") # + +class Set(Collection[_Set__E], typing.Generic[_Set__E], _JSet[_Set__E]): + def add(self, e: _Set__E) -> bool: ... + def addAll( + self, collection: Collection[_Set__E] | typing.Sequence[_Set__E] | set[_Set__E] + ) -> bool: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + _copyOf__E = typing.TypeVar("_copyOf__E") # + @staticmethod + def copyOf( + collection: Collection[_copyOf__E] + | typing.Sequence[_copyOf__E] + | set[_copyOf__E], + ) -> Set[_copyOf__E]: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> Iterator[_Set__E]: ... + _of_0__E = typing.TypeVar("_of_0__E") # + _of_1__E = typing.TypeVar("_of_1__E") # + _of_2__E = typing.TypeVar("_of_2__E") # + _of_3__E = typing.TypeVar("_of_3__E") # + _of_4__E = typing.TypeVar("_of_4__E") # + _of_5__E = typing.TypeVar("_of_5__E") # + _of_6__E = typing.TypeVar("_of_6__E") # + _of_7__E = typing.TypeVar("_of_7__E") # + _of_8__E = typing.TypeVar("_of_8__E") # + _of_9__E = typing.TypeVar("_of_9__E") # + _of_10__E = typing.TypeVar("_of_10__E") # + _of_11__E = typing.TypeVar("_of_11__E") # + @typing.overload + @staticmethod + def of() -> Set[_of_0__E]: ... + @typing.overload + @staticmethod + def of(e: _of_1__E) -> Set[_of_1__E]: ... + @typing.overload + @staticmethod + def of(e: _of_2__E, e2: _of_2__E) -> Set[_of_2__E]: ... + @typing.overload + @staticmethod + def of(e: _of_3__E, e2: _of_3__E, e3: _of_3__E) -> Set[_of_3__E]: ... + @typing.overload + @staticmethod + def of(e: _of_4__E, e2: _of_4__E, e3: _of_4__E, e4: _of_4__E) -> Set[_of_4__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_5__E, e2: _of_5__E, e3: _of_5__E, e4: _of_5__E, e5: _of_5__E + ) -> Set[_of_5__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_6__E, + e2: _of_6__E, + e3: _of_6__E, + e4: _of_6__E, + e5: _of_6__E, + e6: _of_6__E, + ) -> Set[_of_6__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_7__E, + e2: _of_7__E, + e3: _of_7__E, + e4: _of_7__E, + e5: _of_7__E, + e6: _of_7__E, + e7: _of_7__E, + ) -> Set[_of_7__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_8__E, + e2: _of_8__E, + e3: _of_8__E, + e4: _of_8__E, + e5: _of_8__E, + e6: _of_8__E, + e7: _of_8__E, + e8: _of_8__E, + ) -> Set[_of_8__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_9__E, + e2: _of_9__E, + e3: _of_9__E, + e4: _of_9__E, + e5: _of_9__E, + e6: _of_9__E, + e7: _of_9__E, + e8: _of_9__E, + e9: _of_9__E, + ) -> Set[_of_9__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_10__E, + e2: _of_10__E, + e3: _of_10__E, + e4: _of_10__E, + e5: _of_10__E, + e6: _of_10__E, + e7: _of_10__E, + e8: _of_10__E, + e9: _of_10__E, + e10: _of_10__E, + ) -> Set[_of_10__E]: ... + @typing.overload + @staticmethod + def of(*e: _of_11__E) -> Set[_of_11__E]: ... + def remove(self, object: typing.Any) -> bool: ... + def removeAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def retainAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> Spliterator[_Set__E]: ... + _toArray_1__T = typing.TypeVar("_toArray_1__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_1__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_1__T]: ... + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_2__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_2__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_2__T]: ... + +class SimpleTimeZone(TimeZone): + WALL_TIME: typing.ClassVar[int] = ... + STANDARD_TIME: typing.ClassVar[int] = ... + UTC_TIME: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, int: int, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + int: int, + string: java.lang.String | str, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + int9: int, + ): ... + @typing.overload + def __init__( + self, + int: int, + string: java.lang.String | str, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + int9: int, + int10: int, + ): ... + @typing.overload + def __init__( + self, + int: int, + string: java.lang.String | str, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + int9: int, + int10: int, + int11: int, + int12: int, + ): ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + def getDSTSavings(self) -> int: ... + @typing.overload + def getOffset( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + @typing.overload + def getOffset(self, long: int) -> int: ... + def getRawOffset(self) -> int: ... + def hasSameRules(self, timeZone: TimeZone) -> bool: ... + def hashCode(self) -> int: ... + def inDaylightTime(self, date: Date) -> bool: ... + def observesDaylightTime(self) -> bool: ... + def setDSTSavings(self, int: int) -> None: ... + @typing.overload + def setEndRule(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def setEndRule(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setEndRule( + self, int: int, int2: int, int3: int, int4: int, boolean: bool + ) -> None: ... + def setRawOffset(self, int: int) -> None: ... + @typing.overload + def setStartRule(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def setStartRule(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setStartRule( + self, int: int, int2: int, int3: int, int4: int, boolean: bool + ) -> None: ... + def setStartYear(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + def useDaylightTime(self) -> bool: ... + +class StringTokenizer(Enumeration[typing.Any]): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + boolean: bool, + ): ... + def countTokens(self) -> int: ... + def hasMoreElements(self) -> bool: ... + def hasMoreTokens(self) -> bool: ... + def nextElement(self) -> typing.Any: ... + @typing.overload + def nextToken(self) -> java.lang.String: ... + @typing.overload + def nextToken(self, string: java.lang.String | str) -> java.lang.String: ... + +class UnknownFormatConversionException(IllegalFormatException): + def __init__(self, string: java.lang.String | str): ... + def getConversion(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + +class UnknownFormatFlagsException(IllegalFormatException): + def __init__(self, string: java.lang.String | str): ... + def getFlags(self) -> java.lang.String: ... + def getMessage(self) -> java.lang.String: ... + +_AbstractQueue__E = typing.TypeVar("_AbstractQueue__E") # + +class AbstractQueue( + AbstractCollection[_AbstractQueue__E], + Queue[_AbstractQueue__E], + typing.Generic[_AbstractQueue__E], +): + def add(self, e: _AbstractQueue__E) -> bool: ... + def addAll( + self, + collection: Collection[_AbstractQueue__E] + | typing.Sequence[_AbstractQueue__E] + | set[_AbstractQueue__E], + ) -> bool: ... + def clear(self) -> None: ... + def element(self) -> _AbstractQueue__E: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _AbstractQueue__E: ... + +_AbstractSet__E = typing.TypeVar("_AbstractSet__E") # + +class AbstractSet( + AbstractCollection[_AbstractSet__E], + Set[_AbstractSet__E], + typing.Generic[_AbstractSet__E], +): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def removeAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + +_Deque__E = typing.TypeVar("_Deque__E") # + +class Deque( + Queue[_Deque__E], SequencedCollection[_Deque__E], typing.Generic[_Deque__E] +): + def add(self, e: _Deque__E) -> bool: ... + def addAll( + self, + collection: Collection[_Deque__E] | typing.Sequence[_Deque__E] | set[_Deque__E], + ) -> bool: ... + def addFirst(self, e: _Deque__E) -> None: ... + def addLast(self, e: _Deque__E) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def descendingIterator(self) -> Iterator[_Deque__E]: ... + def element(self) -> _Deque__E: ... + def equals(self, object: typing.Any) -> bool: ... + def getFirst(self) -> _Deque__E: ... + def getLast(self) -> _Deque__E: ... + def hashCode(self) -> int: ... + def iterator(self) -> Iterator[_Deque__E]: ... + def offer(self, e: _Deque__E) -> bool: ... + def offerFirst(self, e: _Deque__E) -> bool: ... + def offerLast(self, e: _Deque__E) -> bool: ... + def peek(self) -> _Deque__E: ... + def peekFirst(self) -> _Deque__E: ... + def peekLast(self) -> _Deque__E: ... + def poll(self) -> _Deque__E: ... + def pollFirst(self) -> _Deque__E: ... + def pollLast(self) -> _Deque__E: ... + def pop(self) -> _Deque__E: ... + def push(self, e: _Deque__E) -> None: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _Deque__E: ... + def removeFirst(self) -> _Deque__E: ... + def removeFirstOccurrence(self, object: typing.Any) -> bool: ... + def removeLast(self) -> _Deque__E: ... + def removeLastOccurrence(self, object: typing.Any) -> bool: ... + def reversed(self) -> Deque[_Deque__E]: ... + def size(self) -> int: ... + +_EnumMap__K = typing.TypeVar("_EnumMap__K", bound=java.lang.Enum) # +_EnumMap__V = typing.TypeVar("_EnumMap__V") # + +class EnumMap( + AbstractMap[_EnumMap__K, _EnumMap__V], + java.io.Serializable, + java.lang.Cloneable, + typing.Generic[_EnumMap__K, _EnumMap__V], +): + @typing.overload + def __init__(self, class_: type[_EnumMap__K]): ... + @typing.overload + def __init__(self, enumMap: EnumMap[_EnumMap__K, _EnumMap__V]): ... + @typing.overload + def __init__( + self, + map: Map[_EnumMap__K, _EnumMap__V] | typing.Mapping[_EnumMap__K, _EnumMap__V], + ): ... + def clear(self) -> None: ... + def clone(self) -> EnumMap[_EnumMap__K, _EnumMap__V]: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def entrySet(self) -> Set[Map.Entry[_EnumMap__K, _EnumMap__V]]: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, object: typing.Any) -> _EnumMap__V: ... + def hashCode(self) -> int: ... + def keySet(self) -> Set[_EnumMap__K]: ... + def put(self, k: _EnumMap__K, v: _EnumMap__V) -> _EnumMap__V: ... + def putAll( + self, + map: Map[_EnumMap__K, _EnumMap__V] | typing.Mapping[_EnumMap__K, _EnumMap__V], + ) -> None: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _EnumMap__V: ... + def size(self) -> int: ... + def values(self) -> Collection[_EnumMap__V]: ... + +_HashMap__K = typing.TypeVar("_HashMap__K") # +_HashMap__V = typing.TypeVar("_HashMap__V") # + +class HashMap( + AbstractMap[_HashMap__K, _HashMap__V], + Map[_HashMap__K, _HashMap__V], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_HashMap__K, _HashMap__V], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, float: float): ... + @typing.overload + def __init__( + self, + map: Map[_HashMap__K, _HashMap__V] | typing.Mapping[_HashMap__K, _HashMap__V], + ): ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def compute( + self, + k: _HashMap__K, + biFunction: java.util.function.BiFunction[_HashMap__K, _HashMap__V, _HashMap__V] + | typing.Callable[[_HashMap__K, _HashMap__V], _HashMap__V], + ) -> _HashMap__V: ... + def computeIfAbsent( + self, + k: _HashMap__K, + function: java.util.function.Function[_HashMap__K, _HashMap__V] + | typing.Callable[[_HashMap__K], _HashMap__V], + ) -> _HashMap__V: ... + def computeIfPresent( + self, + k: _HashMap__K, + biFunction: java.util.function.BiFunction[_HashMap__K, _HashMap__V, _HashMap__V] + | typing.Callable[[_HashMap__K, _HashMap__V], _HashMap__V], + ) -> _HashMap__V: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def entrySet(self) -> Set[Map.Entry[_HashMap__K, _HashMap__V]]: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[_HashMap__K, _HashMap__V] + | typing.Callable[[_HashMap__K, _HashMap__V], None], + ) -> None: ... + def get(self, object: typing.Any) -> _HashMap__V: ... + def getOrDefault(self, object: typing.Any, v: _HashMap__V) -> _HashMap__V: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> Set[_HashMap__K]: ... + def merge( + self, + k: _HashMap__K, + v: _HashMap__V, + biFunction: java.util.function.BiFunction[_HashMap__V, _HashMap__V, _HashMap__V] + | typing.Callable[[_HashMap__V, _HashMap__V], _HashMap__V], + ) -> _HashMap__V: ... + _newHashMap__K = typing.TypeVar("_newHashMap__K") # + _newHashMap__V = typing.TypeVar("_newHashMap__V") # + @staticmethod + def newHashMap(int: int) -> HashMap[_newHashMap__K, _newHashMap__V]: ... + def put(self, k: _HashMap__K, v: _HashMap__V) -> _HashMap__V: ... + def putAll( + self, + map: Map[_HashMap__K, _HashMap__V] | typing.Mapping[_HashMap__K, _HashMap__V], + ) -> None: ... + def putIfAbsent(self, k: _HashMap__K, v: _HashMap__V) -> _HashMap__V: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _HashMap__V: ... + @typing.overload + def replace(self, k: _HashMap__K, v: _HashMap__V, v2: _HashMap__V) -> bool: ... + @typing.overload + def replace(self, k: _HashMap__K, v: _HashMap__V) -> _HashMap__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[_HashMap__K, _HashMap__V, _HashMap__V] + | typing.Callable[[_HashMap__K, _HashMap__V], _HashMap__V], + ) -> None: ... + def size(self) -> int: ... + def values(self) -> Collection[_HashMap__V]: ... + +_IdentityHashMap__K = typing.TypeVar("_IdentityHashMap__K") # +_IdentityHashMap__V = typing.TypeVar("_IdentityHashMap__V") # + +class IdentityHashMap( + AbstractMap[_IdentityHashMap__K, _IdentityHashMap__V], + Map[_IdentityHashMap__K, _IdentityHashMap__V], + java.io.Serializable, + java.lang.Cloneable, + typing.Generic[_IdentityHashMap__K, _IdentityHashMap__V], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + map: Map[_IdentityHashMap__K, _IdentityHashMap__V] + | typing.Mapping[_IdentityHashMap__K, _IdentityHashMap__V], + ): ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def entrySet(self) -> Set[Map.Entry[_IdentityHashMap__K, _IdentityHashMap__V]]: ... + def equals(self, object: typing.Any) -> bool: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[ + _IdentityHashMap__K, _IdentityHashMap__V + ] + | typing.Callable[[_IdentityHashMap__K, _IdentityHashMap__V], None], + ) -> None: ... + def get(self, object: typing.Any) -> _IdentityHashMap__V: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> Set[_IdentityHashMap__K]: ... + def put( + self, k: _IdentityHashMap__K, v: _IdentityHashMap__V + ) -> _IdentityHashMap__V: ... + def putAll( + self, + map: Map[_IdentityHashMap__K, _IdentityHashMap__V] + | typing.Mapping[_IdentityHashMap__K, _IdentityHashMap__V], + ) -> None: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _IdentityHashMap__V: ... + @typing.overload + def replace( + self, k: _IdentityHashMap__K, v: _IdentityHashMap__V, v2: _IdentityHashMap__V + ) -> bool: ... + @typing.overload + def replace( + self, k: _IdentityHashMap__K, v: _IdentityHashMap__V + ) -> _IdentityHashMap__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[ + _IdentityHashMap__K, _IdentityHashMap__V, _IdentityHashMap__V + ] + | typing.Callable[ + [_IdentityHashMap__K, _IdentityHashMap__V], _IdentityHashMap__V + ], + ) -> None: ... + def size(self) -> int: ... + def values(self) -> Collection[_IdentityHashMap__V]: ... + +_List__E = typing.TypeVar("_List__E") # + +class List(SequencedCollection[_List__E], typing.Generic[_List__E], _JList[_List__E]): + @typing.overload + def add(self, e: _List__E) -> bool: ... + @typing.overload + def add(self, int: int, e: _List__E) -> None: ... + @typing.overload + def addAll( + self, + int: int, + collection: Collection[_List__E] + | typing.Sequence[_List__E] + | builtins.set[_List__E], + ) -> bool: ... + @typing.overload + def addAll( + self, + collection: Collection[_List__E] + | typing.Sequence[_List__E] + | builtins.set[_List__E], + ) -> bool: ... + def addFirst(self, e: _List__E) -> None: ... + def addLast(self, e: _List__E) -> None: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + _copyOf__E = typing.TypeVar("_copyOf__E") # + @staticmethod + def copyOf( + collection: Collection[_copyOf__E] + | typing.Sequence[_copyOf__E] + | builtins.set[_copyOf__E], + ) -> List[_copyOf__E]: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, int: int) -> _List__E: ... + def getFirst(self) -> _List__E: ... + def getLast(self) -> _List__E: ... + def hashCode(self) -> int: ... + def indexOf(self, object: typing.Any) -> int: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> Iterator[_List__E]: ... + def lastIndexOf(self, object: typing.Any) -> int: ... + @typing.overload + def listIterator(self) -> ListIterator[_List__E]: ... + @typing.overload + def listIterator(self, int: int) -> ListIterator[_List__E]: ... + _of_0__E = typing.TypeVar("_of_0__E") # + _of_1__E = typing.TypeVar("_of_1__E") # + _of_2__E = typing.TypeVar("_of_2__E") # + _of_3__E = typing.TypeVar("_of_3__E") # + _of_4__E = typing.TypeVar("_of_4__E") # + _of_5__E = typing.TypeVar("_of_5__E") # + _of_6__E = typing.TypeVar("_of_6__E") # + _of_7__E = typing.TypeVar("_of_7__E") # + _of_8__E = typing.TypeVar("_of_8__E") # + _of_9__E = typing.TypeVar("_of_9__E") # + _of_10__E = typing.TypeVar("_of_10__E") # + _of_11__E = typing.TypeVar("_of_11__E") # + @typing.overload + @staticmethod + def of() -> List[_of_0__E]: ... + @typing.overload + @staticmethod + def of(e: _of_1__E) -> List[_of_1__E]: ... + @typing.overload + @staticmethod + def of(e: _of_2__E, e2: _of_2__E) -> List[_of_2__E]: ... + @typing.overload + @staticmethod + def of(e: _of_3__E, e2: _of_3__E, e3: _of_3__E) -> List[_of_3__E]: ... + @typing.overload + @staticmethod + def of(e: _of_4__E, e2: _of_4__E, e3: _of_4__E, e4: _of_4__E) -> List[_of_4__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_5__E, e2: _of_5__E, e3: _of_5__E, e4: _of_5__E, e5: _of_5__E + ) -> List[_of_5__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_6__E, + e2: _of_6__E, + e3: _of_6__E, + e4: _of_6__E, + e5: _of_6__E, + e6: _of_6__E, + ) -> List[_of_6__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_7__E, + e2: _of_7__E, + e3: _of_7__E, + e4: _of_7__E, + e5: _of_7__E, + e6: _of_7__E, + e7: _of_7__E, + ) -> List[_of_7__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_8__E, + e2: _of_8__E, + e3: _of_8__E, + e4: _of_8__E, + e5: _of_8__E, + e6: _of_8__E, + e7: _of_8__E, + e8: _of_8__E, + ) -> List[_of_8__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_9__E, + e2: _of_9__E, + e3: _of_9__E, + e4: _of_9__E, + e5: _of_9__E, + e6: _of_9__E, + e7: _of_9__E, + e8: _of_9__E, + e9: _of_9__E, + ) -> List[_of_9__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_10__E, + e2: _of_10__E, + e3: _of_10__E, + e4: _of_10__E, + e5: _of_10__E, + e6: _of_10__E, + e7: _of_10__E, + e8: _of_10__E, + e9: _of_10__E, + e10: _of_10__E, + ) -> List[_of_10__E]: ... + @typing.overload + @staticmethod + def of(*e: _of_11__E) -> List[_of_11__E]: ... + def removeAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def removeFirst(self) -> _List__E: ... + def removeLast(self) -> _List__E: ... + def replaceAll( + self, + unaryOperator: java.util.function.UnaryOperator[_List__E] | typing.Callable, + ) -> None: ... + def retainAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def reversed(self) -> List[_List__E]: ... + def set(self, int: int, e: _List__E) -> _List__E: ... + def size(self) -> int: ... + def sort( + self, + comparator: Comparator[_List__E] | typing.Callable[[_List__E, _List__E], int], + ) -> None: ... + def spliterator(self) -> Spliterator[_List__E]: ... + def subList(self, int: int, int2: int) -> List[_List__E]: ... + _toArray_1__T = typing.TypeVar("_toArray_1__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_1__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_1__T]: ... + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_2__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_2__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_2__T]: ... + +class Properties(Hashtable[typing.Any, typing.Any]): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, properties: Properties): ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def compute( + self, + object: typing.Any, + biFunction: java.util.function.BiFunction[typing.Any, typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], typing.Any], + ) -> typing.Any: ... + def computeIfAbsent( + self, + object: typing.Any, + function: java.util.function.Function[typing.Any, typing.Any] + | typing.Callable[[typing.Any], typing.Any], + ) -> typing.Any: ... + def computeIfPresent( + self, + object: typing.Any, + biFunction: java.util.function.BiFunction[typing.Any, typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], typing.Any], + ) -> typing.Any: ... + def contains(self, object: typing.Any) -> bool: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def elements(self) -> Enumeration[typing.Any]: ... + def entrySet(self) -> Set[Map.Entry[typing.Any, typing.Any]]: ... + def equals(self, object: typing.Any) -> bool: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], None], + ) -> None: ... + def get(self, object: typing.Any) -> typing.Any: ... + def getOrDefault(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + @typing.overload + def getProperty(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def getProperty( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> Set[typing.Any]: ... + def keys(self) -> Enumeration[typing.Any]: ... + @typing.overload + def list(self, printStream: java.io.PrintStream) -> None: ... + @typing.overload + def list(self, printWriter: java.io.PrintWriter) -> None: ... + @typing.overload + def load(self, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def load(self, reader: java.io.Reader) -> None: ... + def loadFromXML(self, inputStream: java.io.InputStream) -> None: ... + def merge( + self, + object: typing.Any, + object2: typing.Any, + biFunction: java.util.function.BiFunction[typing.Any, typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], typing.Any], + ) -> typing.Any: ... + def propertyNames(self) -> Enumeration[typing.Any]: ... + def put(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + def putAll( + self, map: Map[typing.Any, typing.Any] | typing.Mapping[typing.Any, typing.Any] + ) -> None: ... + def putIfAbsent(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> typing.Any: ... + @typing.overload + def replace( + self, object: typing.Any, object2: typing.Any, object3: typing.Any + ) -> bool: ... + @typing.overload + def replace(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[typing.Any, typing.Any, typing.Any] + | typing.Callable[[typing.Any, typing.Any], typing.Any], + ) -> None: ... + def save( + self, outputStream: java.io.OutputStream, string: java.lang.String | str + ) -> None: ... + def setProperty( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> typing.Any: ... + def size(self) -> int: ... + @typing.overload + def store( + self, outputStream: java.io.OutputStream, string: java.lang.String | str + ) -> None: ... + @typing.overload + def store(self, writer: java.io.Writer, string: java.lang.String | str) -> None: ... + @typing.overload + def storeToXML( + self, outputStream: java.io.OutputStream, string: java.lang.String | str + ) -> None: ... + @typing.overload + def storeToXML( + self, + outputStream: java.io.OutputStream, + string: java.lang.String | str, + string2: java.lang.String | str, + ) -> None: ... + @typing.overload + def storeToXML( + self, + outputStream: java.io.OutputStream, + string: java.lang.String | str, + charset: java.nio.charset.Charset, + ) -> None: ... + def stringPropertyNames(self) -> Set[java.lang.String]: ... + def toString(self) -> java.lang.String: ... + def values(self) -> Collection[typing.Any]: ... + +_SequencedSet__E = typing.TypeVar("_SequencedSet__E") # + +class SequencedSet( + SequencedCollection[_SequencedSet__E], + Set[_SequencedSet__E], + typing.Generic[_SequencedSet__E], +): + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def reversed(self) -> SequencedSet[_SequencedSet__E]: ... + +_SortedMap__K = typing.TypeVar("_SortedMap__K") # +_SortedMap__V = typing.TypeVar("_SortedMap__V") # + +class SortedMap( + SequencedMap[_SortedMap__K, _SortedMap__V], + typing.Generic[_SortedMap__K, _SortedMap__V], +): + def comparator(self) -> Comparator[_SortedMap__K]: ... + def entrySet(self) -> Set[Map.Entry[_SortedMap__K, _SortedMap__V]]: ... + def equals(self, object: typing.Any) -> bool: ... + def firstKey(self) -> _SortedMap__K: ... + def hashCode(self) -> int: ... + def headMap(self, k: _SortedMap__K) -> SortedMap[_SortedMap__K, _SortedMap__V]: ... + def keySet(self) -> Set[_SortedMap__K]: ... + def lastKey(self) -> _SortedMap__K: ... + def putFirst(self, k: _SortedMap__K, v: _SortedMap__V) -> _SortedMap__V: ... + def putLast(self, k: _SortedMap__K, v: _SortedMap__V) -> _SortedMap__V: ... + def reversed(self) -> SortedMap[_SortedMap__K, _SortedMap__V]: ... + def subMap( + self, k: _SortedMap__K, k2: _SortedMap__K + ) -> SortedMap[_SortedMap__K, _SortedMap__V]: ... + def tailMap(self, k: _SortedMap__K) -> SortedMap[_SortedMap__K, _SortedMap__V]: ... + def values(self) -> Collection[_SortedMap__V]: ... + +_WeakHashMap__K = typing.TypeVar("_WeakHashMap__K") # +_WeakHashMap__V = typing.TypeVar("_WeakHashMap__V") # + +class WeakHashMap( + AbstractMap[_WeakHashMap__K, _WeakHashMap__V], + Map[_WeakHashMap__K, _WeakHashMap__V], + typing.Generic[_WeakHashMap__K, _WeakHashMap__V], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, float: float): ... + @typing.overload + def __init__( + self, + map: Map[_WeakHashMap__K, _WeakHashMap__V] + | typing.Mapping[_WeakHashMap__K, _WeakHashMap__V], + ): ... + def clear(self) -> None: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def entrySet(self) -> Set[Map.Entry[_WeakHashMap__K, _WeakHashMap__V]]: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[_WeakHashMap__K, _WeakHashMap__V] + | typing.Callable[[_WeakHashMap__K, _WeakHashMap__V], None], + ) -> None: ... + def get(self, object: typing.Any) -> _WeakHashMap__V: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> Set[_WeakHashMap__K]: ... + _newWeakHashMap__K = typing.TypeVar("_newWeakHashMap__K") # + _newWeakHashMap__V = typing.TypeVar("_newWeakHashMap__V") # + @staticmethod + def newWeakHashMap( + int: int, + ) -> WeakHashMap[_newWeakHashMap__K, _newWeakHashMap__V]: ... + def put(self, k: _WeakHashMap__K, v: _WeakHashMap__V) -> _WeakHashMap__V: ... + def putAll( + self, + map: Map[_WeakHashMap__K, _WeakHashMap__V] + | typing.Mapping[_WeakHashMap__K, _WeakHashMap__V], + ) -> None: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _WeakHashMap__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[ + _WeakHashMap__K, _WeakHashMap__V, _WeakHashMap__V + ] + | typing.Callable[[_WeakHashMap__K, _WeakHashMap__V], _WeakHashMap__V], + ) -> None: ... + def size(self) -> int: ... + def values(self) -> Collection[_WeakHashMap__V]: ... + +_AbstractList__E = typing.TypeVar("_AbstractList__E") # + +class AbstractList( + AbstractCollection[_AbstractList__E], + List[_AbstractList__E], + typing.Generic[_AbstractList__E], +): + @typing.overload + def add(self, e: _AbstractList__E) -> bool: ... + @typing.overload + def add(self, int: int, e: _AbstractList__E) -> None: ... + @typing.overload + def addAll( + self, + collection: Collection[_AbstractList__E] + | typing.Sequence[_AbstractList__E] + | builtins.set[_AbstractList__E], + ) -> bool: ... + @typing.overload + def addAll( + self, + int: int, + collection: Collection[_AbstractList__E] + | typing.Sequence[_AbstractList__E] + | builtins.set[_AbstractList__E], + ) -> bool: ... + def clear(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, int: int) -> _AbstractList__E: ... + def hashCode(self) -> int: ... + def indexOf(self, object: typing.Any) -> int: ... + def iterator(self) -> Iterator[_AbstractList__E]: ... + def lastIndexOf(self, object: typing.Any) -> int: ... + @typing.overload + def listIterator(self) -> ListIterator[_AbstractList__E]: ... + @typing.overload + def listIterator(self, int: int) -> ListIterator[_AbstractList__E]: ... + def set(self, int: int, e: _AbstractList__E) -> _AbstractList__E: ... + def subList(self, int: int, int2: int) -> List[_AbstractList__E]: ... + +_ArrayDeque__E = typing.TypeVar("_ArrayDeque__E") # + +class ArrayDeque( + AbstractCollection[_ArrayDeque__E], + Deque[_ArrayDeque__E], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_ArrayDeque__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + collection: Collection[_ArrayDeque__E] + | typing.Sequence[_ArrayDeque__E] + | set[_ArrayDeque__E], + ): ... + def add(self, e: _ArrayDeque__E) -> bool: ... + def addAll( + self, + collection: Collection[_ArrayDeque__E] + | typing.Sequence[_ArrayDeque__E] + | set[_ArrayDeque__E], + ) -> bool: ... + def addFirst(self, e: _ArrayDeque__E) -> None: ... + def addLast(self, e: _ArrayDeque__E) -> None: ... + def clear(self) -> None: ... + def clone(self) -> ArrayDeque[_ArrayDeque__E]: ... + def contains(self, object: typing.Any) -> bool: ... + def descendingIterator(self) -> Iterator[_ArrayDeque__E]: ... + def element(self) -> _ArrayDeque__E: ... + def forEach( + self, + consumer: java.util.function.Consumer[_ArrayDeque__E] + | typing.Callable[[_ArrayDeque__E], None], + ) -> None: ... + def getFirst(self) -> _ArrayDeque__E: ... + def getLast(self) -> _ArrayDeque__E: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> Iterator[_ArrayDeque__E]: ... + def offer(self, e: _ArrayDeque__E) -> bool: ... + def offerFirst(self, e: _ArrayDeque__E) -> bool: ... + def offerLast(self, e: _ArrayDeque__E) -> bool: ... + def peek(self) -> _ArrayDeque__E: ... + def peekFirst(self) -> _ArrayDeque__E: ... + def peekLast(self) -> _ArrayDeque__E: ... + def poll(self) -> _ArrayDeque__E: ... + def pollFirst(self) -> _ArrayDeque__E: ... + def pollLast(self) -> _ArrayDeque__E: ... + def pop(self) -> _ArrayDeque__E: ... + def push(self, e: _ArrayDeque__E) -> None: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _ArrayDeque__E: ... + def removeAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeFirst(self) -> _ArrayDeque__E: ... + def removeFirstOccurrence(self, object: typing.Any) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_ArrayDeque__E] + | typing.Callable[[_ArrayDeque__E], bool], + ) -> bool: ... + def removeLast(self) -> _ArrayDeque__E: ... + def removeLastOccurrence(self, object: typing.Any) -> bool: ... + def retainAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> Spliterator[_ArrayDeque__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + +_EnumSet__E = typing.TypeVar("_EnumSet__E", bound=java.lang.Enum) # + +class EnumSet( + AbstractSet[_EnumSet__E], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_EnumSet__E], +): + _allOf__E = typing.TypeVar("_allOf__E", bound=java.lang.Enum) # + @staticmethod + def allOf(class_: type[_allOf__E]) -> EnumSet[_allOf__E]: ... + def clone(self) -> EnumSet[_EnumSet__E]: ... + _complementOf__E = typing.TypeVar("_complementOf__E", bound=java.lang.Enum) # + @staticmethod + def complementOf( + enumSet: EnumSet[_complementOf__E], + ) -> EnumSet[_complementOf__E]: ... + _copyOf_0__E = typing.TypeVar("_copyOf_0__E", bound=java.lang.Enum) # + _copyOf_1__E = typing.TypeVar("_copyOf_1__E", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def copyOf( + collection: Collection[_copyOf_0__E] + | typing.Sequence[_copyOf_0__E] + | set[_copyOf_0__E], + ) -> EnumSet[_copyOf_0__E]: ... + @typing.overload + @staticmethod + def copyOf(enumSet: EnumSet[_copyOf_1__E]) -> EnumSet[_copyOf_1__E]: ... + _noneOf__E = typing.TypeVar("_noneOf__E", bound=java.lang.Enum) # + @staticmethod + def noneOf(class_: type[_noneOf__E]) -> EnumSet[_noneOf__E]: ... + _of_0__E = typing.TypeVar("_of_0__E", bound=java.lang.Enum) # + _of_1__E = typing.TypeVar("_of_1__E", bound=java.lang.Enum) # + _of_2__E = typing.TypeVar("_of_2__E", bound=java.lang.Enum) # + _of_3__E = typing.TypeVar("_of_3__E", bound=java.lang.Enum) # + _of_4__E = typing.TypeVar("_of_4__E", bound=java.lang.Enum) # + _of_5__E = typing.TypeVar("_of_5__E", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def of(e: _of_0__E) -> EnumSet[_of_0__E]: ... + @typing.overload + @staticmethod + def of(e: _of_1__E, e2: _of_1__E) -> EnumSet[_of_1__E]: ... + @typing.overload + @staticmethod + def of(e: _of_2__E, e2: _of_2__E, e3: _of_2__E) -> EnumSet[_of_2__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_3__E, e2: _of_3__E, e3: _of_3__E, e4: _of_3__E + ) -> EnumSet[_of_3__E]: ... + @typing.overload + @staticmethod + def of( + e: _of_4__E, e2: _of_4__E, e3: _of_4__E, e4: _of_4__E, e5: _of_4__E + ) -> EnumSet[_of_4__E]: ... + @typing.overload + @staticmethod + def of(e: _of_5__E, *e2: _of_5__E) -> EnumSet[_of_5__E]: ... + _range__E = typing.TypeVar("_range__E", bound=java.lang.Enum) # + @staticmethod + def range(e: _range__E, e2: _range__E) -> EnumSet[_range__E]: ... + +_HashSet__E = typing.TypeVar("_HashSet__E") # + +class HashSet( + AbstractSet[_HashSet__E], + Set[_HashSet__E], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_HashSet__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, float: float): ... + @typing.overload + def __init__( + self, + collection: Collection[_HashSet__E] + | typing.Sequence[_HashSet__E] + | set[_HashSet__E], + ): ... + def add(self, e: _HashSet__E) -> bool: ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def contains(self, object: typing.Any) -> bool: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> Iterator[_HashSet__E]: ... + _newHashSet__T = typing.TypeVar("_newHashSet__T") # + @staticmethod + def newHashSet(int: int) -> HashSet[_newHashSet__T]: ... + def remove(self, object: typing.Any) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> Spliterator[_HashSet__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + +_LinkedHashMap__K = typing.TypeVar("_LinkedHashMap__K") # +_LinkedHashMap__V = typing.TypeVar("_LinkedHashMap__V") # + +class LinkedHashMap( + HashMap[_LinkedHashMap__K, _LinkedHashMap__V], + SequencedMap[_LinkedHashMap__K, _LinkedHashMap__V], + typing.Generic[_LinkedHashMap__K, _LinkedHashMap__V], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, float: float): ... + @typing.overload + def __init__(self, int: int, float: float, boolean: bool): ... + @typing.overload + def __init__( + self, + map: Map[_LinkedHashMap__K, _LinkedHashMap__V] + | typing.Mapping[_LinkedHashMap__K, _LinkedHashMap__V], + ): ... + def clear(self) -> None: ... + def containsValue(self, object: typing.Any) -> bool: ... + def entrySet(self) -> Set[Map.Entry[_LinkedHashMap__K, _LinkedHashMap__V]]: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[_LinkedHashMap__K, _LinkedHashMap__V] + | typing.Callable[[_LinkedHashMap__K, _LinkedHashMap__V], None], + ) -> None: ... + def get(self, object: typing.Any) -> _LinkedHashMap__V: ... + def getOrDefault( + self, object: typing.Any, v: _LinkedHashMap__V + ) -> _LinkedHashMap__V: ... + def keySet(self) -> Set[_LinkedHashMap__K]: ... + _newLinkedHashMap__K = typing.TypeVar("_newLinkedHashMap__K") # + _newLinkedHashMap__V = typing.TypeVar("_newLinkedHashMap__V") # + @staticmethod + def newLinkedHashMap( + int: int, + ) -> LinkedHashMap[_newLinkedHashMap__K, _newLinkedHashMap__V]: ... + def putFirst( + self, k: _LinkedHashMap__K, v: _LinkedHashMap__V + ) -> _LinkedHashMap__V: ... + def putLast( + self, k: _LinkedHashMap__K, v: _LinkedHashMap__V + ) -> _LinkedHashMap__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[ + _LinkedHashMap__K, _LinkedHashMap__V, _LinkedHashMap__V + ] + | typing.Callable[[_LinkedHashMap__K, _LinkedHashMap__V], _LinkedHashMap__V], + ) -> None: ... + def reversed(self) -> SequencedMap[_LinkedHashMap__K, _LinkedHashMap__V]: ... + def sequencedEntrySet( + self, + ) -> SequencedSet[Map.Entry[_LinkedHashMap__K, _LinkedHashMap__V]]: ... + def sequencedKeySet(self) -> SequencedSet[_LinkedHashMap__K]: ... + def sequencedValues(self) -> SequencedCollection[_LinkedHashMap__V]: ... + def values(self) -> Collection[_LinkedHashMap__V]: ... + +_NavigableMap__K = typing.TypeVar("_NavigableMap__K") # +_NavigableMap__V = typing.TypeVar("_NavigableMap__V") # + +class NavigableMap( + SortedMap[_NavigableMap__K, _NavigableMap__V], + typing.Generic[_NavigableMap__K, _NavigableMap__V], +): + def ceilingEntry( + self, k: _NavigableMap__K + ) -> Map.Entry[_NavigableMap__K, _NavigableMap__V]: ... + def ceilingKey(self, k: _NavigableMap__K) -> _NavigableMap__K: ... + def descendingKeySet(self) -> NavigableSet[_NavigableMap__K]: ... + def descendingMap(self) -> NavigableMap[_NavigableMap__K, _NavigableMap__V]: ... + def equals(self, object: typing.Any) -> bool: ... + def firstEntry(self) -> Map.Entry[_NavigableMap__K, _NavigableMap__V]: ... + def floorEntry( + self, k: _NavigableMap__K + ) -> Map.Entry[_NavigableMap__K, _NavigableMap__V]: ... + def floorKey(self, k: _NavigableMap__K) -> _NavigableMap__K: ... + def hashCode(self) -> int: ... + @typing.overload + def headMap( + self, k: _NavigableMap__K, boolean: bool + ) -> NavigableMap[_NavigableMap__K, _NavigableMap__V]: ... + @typing.overload + def headMap( + self, k: _NavigableMap__K + ) -> SortedMap[_NavigableMap__K, _NavigableMap__V]: ... + def higherEntry( + self, k: _NavigableMap__K + ) -> Map.Entry[_NavigableMap__K, _NavigableMap__V]: ... + def higherKey(self, k: _NavigableMap__K) -> _NavigableMap__K: ... + def lastEntry(self) -> Map.Entry[_NavigableMap__K, _NavigableMap__V]: ... + def lowerEntry( + self, k: _NavigableMap__K + ) -> Map.Entry[_NavigableMap__K, _NavigableMap__V]: ... + def lowerKey(self, k: _NavigableMap__K) -> _NavigableMap__K: ... + def navigableKeySet(self) -> NavigableSet[_NavigableMap__K]: ... + def pollFirstEntry(self) -> Map.Entry[_NavigableMap__K, _NavigableMap__V]: ... + def pollLastEntry(self) -> Map.Entry[_NavigableMap__K, _NavigableMap__V]: ... + def reversed(self) -> NavigableMap[_NavigableMap__K, _NavigableMap__V]: ... + @typing.overload + def subMap( + self, k: _NavigableMap__K, boolean: bool, k2: _NavigableMap__K, boolean2: bool + ) -> NavigableMap[_NavigableMap__K, _NavigableMap__V]: ... + @typing.overload + def subMap( + self, k: _NavigableMap__K, k2: _NavigableMap__K + ) -> SortedMap[_NavigableMap__K, _NavigableMap__V]: ... + @typing.overload + def tailMap( + self, k: _NavigableMap__K, boolean: bool + ) -> NavigableMap[_NavigableMap__K, _NavigableMap__V]: ... + @typing.overload + def tailMap( + self, k: _NavigableMap__K + ) -> SortedMap[_NavigableMap__K, _NavigableMap__V]: ... + +_PriorityQueue__E = typing.TypeVar("_PriorityQueue__E") # + +class PriorityQueue( + AbstractQueue[_PriorityQueue__E], + java.io.Serializable, + typing.Generic[_PriorityQueue__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + int: int, + comparator: Comparator[_PriorityQueue__E] + | typing.Callable[[_PriorityQueue__E, _PriorityQueue__E], int], + ): ... + @typing.overload + def __init__( + self, + collection: Collection[_PriorityQueue__E] + | typing.Sequence[_PriorityQueue__E] + | set[_PriorityQueue__E], + ): ... + @typing.overload + def __init__( + self, + comparator: Comparator[_PriorityQueue__E] + | typing.Callable[[_PriorityQueue__E, _PriorityQueue__E], int], + ): ... + @typing.overload + def __init__(self, priorityQueue: PriorityQueue[_PriorityQueue__E]): ... + @typing.overload + def __init__(self, sortedSet: SortedSet[_PriorityQueue__E]): ... + def add(self, e: _PriorityQueue__E) -> bool: ... + def clear(self) -> None: ... + def comparator(self) -> Comparator[_PriorityQueue__E]: ... + def contains(self, object: typing.Any) -> bool: ... + def forEach( + self, + consumer: java.util.function.Consumer[_PriorityQueue__E] + | typing.Callable[[_PriorityQueue__E], None], + ) -> None: ... + def iterator(self) -> Iterator[_PriorityQueue__E]: ... + def offer(self, e: _PriorityQueue__E) -> bool: ... + def peek(self) -> _PriorityQueue__E: ... + def poll(self) -> _PriorityQueue__E: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _PriorityQueue__E: ... + def removeAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_PriorityQueue__E] + | typing.Callable[[_PriorityQueue__E], bool], + ) -> bool: ... + def retainAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> Spliterator[_PriorityQueue__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + +_SortedSet__E = typing.TypeVar("_SortedSet__E") # + +class SortedSet( + Set[_SortedSet__E], SequencedSet[_SortedSet__E], typing.Generic[_SortedSet__E] +): + def addFirst(self, e: _SortedSet__E) -> None: ... + def addLast(self, e: _SortedSet__E) -> None: ... + def comparator(self) -> Comparator[_SortedSet__E]: ... + def equals(self, object: typing.Any) -> bool: ... + def first(self) -> _SortedSet__E: ... + def getFirst(self) -> _SortedSet__E: ... + def getLast(self) -> _SortedSet__E: ... + def hashCode(self) -> int: ... + def headSet(self, e: _SortedSet__E) -> SortedSet[_SortedSet__E]: ... + def last(self) -> _SortedSet__E: ... + def removeFirst(self) -> _SortedSet__E: ... + def removeLast(self) -> _SortedSet__E: ... + def reversed(self) -> SortedSet[_SortedSet__E]: ... + def spliterator(self) -> Spliterator[_SortedSet__E]: ... + def subSet( + self, e: _SortedSet__E, e2: _SortedSet__E + ) -> SortedSet[_SortedSet__E]: ... + def tailSet(self, e: _SortedSet__E) -> SortedSet[_SortedSet__E]: ... + +_AbstractSequentialList__E = typing.TypeVar("_AbstractSequentialList__E") # + +class AbstractSequentialList( + AbstractList[_AbstractSequentialList__E], typing.Generic[_AbstractSequentialList__E] +): + @typing.overload + def add(self, e: _AbstractSequentialList__E) -> bool: ... + @typing.overload + def add(self, int: int, e: _AbstractSequentialList__E) -> None: ... + @typing.overload + def addAll( + self, + collection: Collection[_AbstractSequentialList__E] + | typing.Sequence[_AbstractSequentialList__E] + | builtins.set[_AbstractSequentialList__E], + ) -> bool: ... + @typing.overload + def addAll( + self, + int: int, + collection: Collection[_AbstractSequentialList__E] + | typing.Sequence[_AbstractSequentialList__E] + | builtins.set[_AbstractSequentialList__E], + ) -> bool: ... + def get(self, int: int) -> _AbstractSequentialList__E: ... + def iterator(self) -> Iterator[_AbstractSequentialList__E]: ... + @typing.overload + def listIterator(self, int: int) -> ListIterator[_AbstractSequentialList__E]: ... + @typing.overload + def listIterator(self) -> ListIterator[_AbstractSequentialList__E]: ... + def set( + self, int: int, e: _AbstractSequentialList__E + ) -> _AbstractSequentialList__E: ... + +_ArrayList__E = typing.TypeVar("_ArrayList__E") # + +class ArrayList( + AbstractList[_ArrayList__E], + List[_ArrayList__E], + RandomAccess, + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_ArrayList__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + collection: Collection[_ArrayList__E] + | typing.Sequence[_ArrayList__E] + | builtins.set[_ArrayList__E], + ): ... + @typing.overload + def add(self, e: _ArrayList__E) -> bool: ... + @typing.overload + def add(self, int: int, e: _ArrayList__E) -> None: ... + @typing.overload + def addAll( + self, + int: int, + collection: Collection[_ArrayList__E] + | typing.Sequence[_ArrayList__E] + | builtins.set[_ArrayList__E], + ) -> bool: ... + @typing.overload + def addAll( + self, + collection: Collection[_ArrayList__E] + | typing.Sequence[_ArrayList__E] + | builtins.set[_ArrayList__E], + ) -> bool: ... + def addFirst(self, e: _ArrayList__E) -> None: ... + def addLast(self, e: _ArrayList__E) -> None: ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def contains(self, object: typing.Any) -> bool: ... + def ensureCapacity(self, int: int) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def forEach( + self, + consumer: java.util.function.Consumer[_ArrayList__E] + | typing.Callable[[_ArrayList__E], None], + ) -> None: ... + def get(self, int: int) -> _ArrayList__E: ... + def getFirst(self) -> _ArrayList__E: ... + def getLast(self) -> _ArrayList__E: ... + def hashCode(self) -> int: ... + def indexOf(self, object: typing.Any) -> int: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> Iterator[_ArrayList__E]: ... + def lastIndexOf(self, object: typing.Any) -> int: ... + @typing.overload + def listIterator(self) -> ListIterator[_ArrayList__E]: ... + @typing.overload + def listIterator(self, int: int) -> ListIterator[_ArrayList__E]: ... + def removeAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def removeFirst(self) -> _ArrayList__E: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_ArrayList__E] + | typing.Callable[[_ArrayList__E], bool], + ) -> bool: ... + def removeLast(self) -> _ArrayList__E: ... + def replaceAll( + self, + unaryOperator: java.util.function.UnaryOperator[_ArrayList__E] + | typing.Callable, + ) -> None: ... + def retainAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def set(self, int: int, e: _ArrayList__E) -> _ArrayList__E: ... + def size(self) -> int: ... + def sort( + self, + comparator: Comparator[_ArrayList__E] + | typing.Callable[[_ArrayList__E, _ArrayList__E], int], + ) -> None: ... + def spliterator(self) -> Spliterator[_ArrayList__E]: ... + def subList(self, int: int, int2: int) -> List[_ArrayList__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def trimToSize(self) -> None: ... + +_LinkedHashSet__E = typing.TypeVar("_LinkedHashSet__E") # + +class LinkedHashSet( + HashSet[_LinkedHashSet__E], + SequencedSet[_LinkedHashSet__E], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_LinkedHashSet__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, float: float): ... + @typing.overload + def __init__( + self, + collection: Collection[_LinkedHashSet__E] + | typing.Sequence[_LinkedHashSet__E] + | set[_LinkedHashSet__E], + ): ... + def addFirst(self, e: _LinkedHashSet__E) -> None: ... + def addLast(self, e: _LinkedHashSet__E) -> None: ... + def getFirst(self) -> _LinkedHashSet__E: ... + def getLast(self) -> _LinkedHashSet__E: ... + _newLinkedHashSet__T = typing.TypeVar("_newLinkedHashSet__T") # + @staticmethod + def newLinkedHashSet(int: int) -> LinkedHashSet[_newLinkedHashSet__T]: ... + def removeFirst(self) -> _LinkedHashSet__E: ... + def removeLast(self) -> _LinkedHashSet__E: ... + def reversed(self) -> SequencedSet[_LinkedHashSet__E]: ... + def spliterator(self) -> Spliterator[_LinkedHashSet__E]: ... + +_NavigableSet__E = typing.TypeVar("_NavigableSet__E") # + +class NavigableSet(SortedSet[_NavigableSet__E], typing.Generic[_NavigableSet__E]): + def ceiling(self, e: _NavigableSet__E) -> _NavigableSet__E: ... + def descendingIterator(self) -> Iterator[_NavigableSet__E]: ... + def descendingSet(self) -> NavigableSet[_NavigableSet__E]: ... + def equals(self, object: typing.Any) -> bool: ... + def floor(self, e: _NavigableSet__E) -> _NavigableSet__E: ... + def hashCode(self) -> int: ... + @typing.overload + def headSet( + self, e: _NavigableSet__E, boolean: bool + ) -> NavigableSet[_NavigableSet__E]: ... + @typing.overload + def headSet(self, e: _NavigableSet__E) -> SortedSet[_NavigableSet__E]: ... + def higher(self, e: _NavigableSet__E) -> _NavigableSet__E: ... + def iterator(self) -> Iterator[_NavigableSet__E]: ... + def lower(self, e: _NavigableSet__E) -> _NavigableSet__E: ... + def pollFirst(self) -> _NavigableSet__E: ... + def pollLast(self) -> _NavigableSet__E: ... + def removeFirst(self) -> _NavigableSet__E: ... + def removeLast(self) -> _NavigableSet__E: ... + def reversed(self) -> NavigableSet[_NavigableSet__E]: ... + @typing.overload + def subSet( + self, e: _NavigableSet__E, boolean: bool, e2: _NavigableSet__E, boolean2: bool + ) -> NavigableSet[_NavigableSet__E]: ... + @typing.overload + def subSet( + self, e: _NavigableSet__E, e2: _NavigableSet__E + ) -> SortedSet[_NavigableSet__E]: ... + @typing.overload + def tailSet( + self, e: _NavigableSet__E, boolean: bool + ) -> NavigableSet[_NavigableSet__E]: ... + @typing.overload + def tailSet(self, e: _NavigableSet__E) -> SortedSet[_NavigableSet__E]: ... + +_TreeMap__K = typing.TypeVar("_TreeMap__K") # +_TreeMap__V = typing.TypeVar("_TreeMap__V") # + +class TreeMap( + AbstractMap[_TreeMap__K, _TreeMap__V], + NavigableMap[_TreeMap__K, _TreeMap__V], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_TreeMap__K, _TreeMap__V], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + comparator: Comparator[_TreeMap__K] + | typing.Callable[[_TreeMap__K, _TreeMap__K], int], + ): ... + @typing.overload + def __init__( + self, + map: Map[_TreeMap__K, _TreeMap__V] | typing.Mapping[_TreeMap__K, _TreeMap__V], + ): ... + @typing.overload + def __init__(self, sortedMap: SortedMap[_TreeMap__K, _TreeMap__V]): ... + def ceilingEntry(self, k: _TreeMap__K) -> Map.Entry[_TreeMap__K, _TreeMap__V]: ... + def ceilingKey(self, k: _TreeMap__K) -> _TreeMap__K: ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def comparator(self) -> Comparator[_TreeMap__K]: ... + def compute( + self, + k: _TreeMap__K, + biFunction: java.util.function.BiFunction[_TreeMap__K, _TreeMap__V, _TreeMap__V] + | typing.Callable[[_TreeMap__K, _TreeMap__V], _TreeMap__V], + ) -> _TreeMap__V: ... + def computeIfAbsent( + self, + k: _TreeMap__K, + function: java.util.function.Function[_TreeMap__K, _TreeMap__V] + | typing.Callable[[_TreeMap__K], _TreeMap__V], + ) -> _TreeMap__V: ... + def computeIfPresent( + self, + k: _TreeMap__K, + biFunction: java.util.function.BiFunction[_TreeMap__K, _TreeMap__V, _TreeMap__V] + | typing.Callable[[_TreeMap__K, _TreeMap__V], _TreeMap__V], + ) -> _TreeMap__V: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def descendingKeySet(self) -> NavigableSet[_TreeMap__K]: ... + def descendingMap(self) -> NavigableMap[_TreeMap__K, _TreeMap__V]: ... + def entrySet(self) -> Set[Map.Entry[_TreeMap__K, _TreeMap__V]]: ... + def firstEntry(self) -> Map.Entry[_TreeMap__K, _TreeMap__V]: ... + def firstKey(self) -> _TreeMap__K: ... + def floorEntry(self, k: _TreeMap__K) -> Map.Entry[_TreeMap__K, _TreeMap__V]: ... + def floorKey(self, k: _TreeMap__K) -> _TreeMap__K: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[_TreeMap__K, _TreeMap__V] + | typing.Callable[[_TreeMap__K, _TreeMap__V], None], + ) -> None: ... + def get(self, object: typing.Any) -> _TreeMap__V: ... + @typing.overload + def headMap( + self, k: _TreeMap__K, boolean: bool + ) -> NavigableMap[_TreeMap__K, _TreeMap__V]: ... + @typing.overload + def headMap(self, k: _TreeMap__K) -> SortedMap[_TreeMap__K, _TreeMap__V]: ... + def higherEntry(self, k: _TreeMap__K) -> Map.Entry[_TreeMap__K, _TreeMap__V]: ... + def higherKey(self, k: _TreeMap__K) -> _TreeMap__K: ... + def keySet(self) -> Set[_TreeMap__K]: ... + def lastEntry(self) -> Map.Entry[_TreeMap__K, _TreeMap__V]: ... + def lastKey(self) -> _TreeMap__K: ... + def lowerEntry(self, k: _TreeMap__K) -> Map.Entry[_TreeMap__K, _TreeMap__V]: ... + def lowerKey(self, k: _TreeMap__K) -> _TreeMap__K: ... + def merge( + self, + k: _TreeMap__K, + v: _TreeMap__V, + biFunction: java.util.function.BiFunction[_TreeMap__V, _TreeMap__V, _TreeMap__V] + | typing.Callable[[_TreeMap__V, _TreeMap__V], _TreeMap__V], + ) -> _TreeMap__V: ... + def navigableKeySet(self) -> NavigableSet[_TreeMap__K]: ... + def pollFirstEntry(self) -> Map.Entry[_TreeMap__K, _TreeMap__V]: ... + def pollLastEntry(self) -> Map.Entry[_TreeMap__K, _TreeMap__V]: ... + def put(self, k: _TreeMap__K, v: _TreeMap__V) -> _TreeMap__V: ... + def putAll( + self, + map: Map[_TreeMap__K, _TreeMap__V] | typing.Mapping[_TreeMap__K, _TreeMap__V], + ) -> None: ... + def putFirst(self, k: _TreeMap__K, v: _TreeMap__V) -> _TreeMap__V: ... + def putIfAbsent(self, k: _TreeMap__K, v: _TreeMap__V) -> _TreeMap__V: ... + def putLast(self, k: _TreeMap__K, v: _TreeMap__V) -> _TreeMap__V: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _TreeMap__V: ... + @typing.overload + def replace(self, k: _TreeMap__K, v: _TreeMap__V, v2: _TreeMap__V) -> bool: ... + @typing.overload + def replace(self, k: _TreeMap__K, v: _TreeMap__V) -> _TreeMap__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[_TreeMap__K, _TreeMap__V, _TreeMap__V] + | typing.Callable[[_TreeMap__K, _TreeMap__V], _TreeMap__V], + ) -> None: ... + def size(self) -> int: ... + @typing.overload + def subMap( + self, k: _TreeMap__K, boolean: bool, k2: _TreeMap__K, boolean2: bool + ) -> NavigableMap[_TreeMap__K, _TreeMap__V]: ... + @typing.overload + def subMap( + self, k: _TreeMap__K, k2: _TreeMap__K + ) -> SortedMap[_TreeMap__K, _TreeMap__V]: ... + @typing.overload + def tailMap( + self, k: _TreeMap__K, boolean: bool + ) -> NavigableMap[_TreeMap__K, _TreeMap__V]: ... + @typing.overload + def tailMap(self, k: _TreeMap__K) -> SortedMap[_TreeMap__K, _TreeMap__V]: ... + def values(self) -> Collection[_TreeMap__V]: ... + +_Vector__E = typing.TypeVar("_Vector__E") # + +class Vector( + AbstractList[_Vector__E], + List[_Vector__E], + RandomAccess, + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_Vector__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__( + self, + collection: Collection[_Vector__E] + | typing.Sequence[_Vector__E] + | builtins.set[_Vector__E], + ): ... + @typing.overload + def add(self, e: _Vector__E) -> bool: ... + @typing.overload + def add(self, int: int, e: _Vector__E) -> None: ... + @typing.overload + def addAll( + self, + collection: Collection[_Vector__E] + | typing.Sequence[_Vector__E] + | builtins.set[_Vector__E], + ) -> bool: ... + @typing.overload + def addAll( + self, + int: int, + collection: Collection[_Vector__E] + | typing.Sequence[_Vector__E] + | builtins.set[_Vector__E], + ) -> bool: ... + def addElement(self, e: _Vector__E) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def copyInto(self, objectArray: list[typing.Any] | jpype.JArray) -> None: ... + def elementAt(self, int: int) -> _Vector__E: ... + def elements(self) -> Enumeration[_Vector__E]: ... + def ensureCapacity(self, int: int) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def firstElement(self) -> _Vector__E: ... + def forEach( + self, + consumer: java.util.function.Consumer[_Vector__E] + | typing.Callable[[_Vector__E], None], + ) -> None: ... + def get(self, int: int) -> _Vector__E: ... + def hashCode(self) -> int: ... + @typing.overload + def indexOf(self, object: typing.Any) -> int: ... + @typing.overload + def indexOf(self, object: typing.Any, int: int) -> int: ... + def insertElementAt(self, e: _Vector__E, int: int) -> None: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> Iterator[_Vector__E]: ... + def lastElement(self) -> _Vector__E: ... + @typing.overload + def lastIndexOf(self, object: typing.Any) -> int: ... + @typing.overload + def lastIndexOf(self, object: typing.Any, int: int) -> int: ... + @typing.overload + def listIterator(self) -> ListIterator[_Vector__E]: ... + @typing.overload + def listIterator(self, int: int) -> ListIterator[_Vector__E]: ... + def removeAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def removeAllElements(self) -> None: ... + def removeElement(self, object: typing.Any) -> bool: ... + def removeElementAt(self, int: int) -> None: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_Vector__E] + | typing.Callable[[_Vector__E], bool], + ) -> bool: ... + def replaceAll( + self, + unaryOperator: java.util.function.UnaryOperator[_Vector__E] | typing.Callable, + ) -> None: ... + def retainAll( + self, + collection: Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def set(self, int: int, e: _Vector__E) -> _Vector__E: ... + def setElementAt(self, e: _Vector__E, int: int) -> None: ... + def setSize(self, int: int) -> None: ... + def size(self) -> int: ... + def sort( + self, + comparator: Comparator[_Vector__E] + | typing.Callable[[_Vector__E, _Vector__E], int], + ) -> None: ... + def spliterator(self) -> Spliterator[_Vector__E]: ... + def subList(self, int: int, int2: int) -> List[_Vector__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + def trimToSize(self) -> None: ... + +_LinkedList__E = typing.TypeVar("_LinkedList__E") # + +class LinkedList( + AbstractSequentialList[_LinkedList__E], + List[_LinkedList__E], + Deque[_LinkedList__E], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_LinkedList__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: Collection[_LinkedList__E] + | typing.Sequence[_LinkedList__E] + | builtins.set[_LinkedList__E], + ): ... + @typing.overload + def add(self, e: _LinkedList__E) -> bool: ... + @typing.overload + def add(self, int: int, e: _LinkedList__E) -> None: ... + @typing.overload + def addAll( + self, + int: int, + collection: Collection[_LinkedList__E] + | typing.Sequence[_LinkedList__E] + | builtins.set[_LinkedList__E], + ) -> bool: ... + @typing.overload + def addAll( + self, + collection: Collection[_LinkedList__E] + | typing.Sequence[_LinkedList__E] + | builtins.set[_LinkedList__E], + ) -> bool: ... + def addFirst(self, e: _LinkedList__E) -> None: ... + def addLast(self, e: _LinkedList__E) -> None: ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def contains(self, object: typing.Any) -> bool: ... + def descendingIterator(self) -> Iterator[_LinkedList__E]: ... + def element(self) -> _LinkedList__E: ... + def get(self, int: int) -> _LinkedList__E: ... + def getFirst(self) -> _LinkedList__E: ... + def getLast(self) -> _LinkedList__E: ... + def indexOf(self, object: typing.Any) -> int: ... + def lastIndexOf(self, object: typing.Any) -> int: ... + @typing.overload + def listIterator(self) -> ListIterator[_LinkedList__E]: ... + @typing.overload + def listIterator(self, int: int) -> ListIterator[_LinkedList__E]: ... + def offer(self, e: _LinkedList__E) -> bool: ... + def offerFirst(self, e: _LinkedList__E) -> bool: ... + def offerLast(self, e: _LinkedList__E) -> bool: ... + def peek(self) -> _LinkedList__E: ... + def peekFirst(self) -> _LinkedList__E: ... + def peekLast(self) -> _LinkedList__E: ... + def poll(self) -> _LinkedList__E: ... + def pollFirst(self) -> _LinkedList__E: ... + def pollLast(self) -> _LinkedList__E: ... + def pop(self) -> _LinkedList__E: ... + def push(self, e: _LinkedList__E) -> None: ... + def removeFirst(self) -> _LinkedList__E: ... + def removeFirstOccurrence(self, object: typing.Any) -> bool: ... + def removeLast(self) -> _LinkedList__E: ... + def removeLastOccurrence(self, object: typing.Any) -> bool: ... + def reversed(self) -> LinkedList[_LinkedList__E]: ... + def set(self, int: int, e: _LinkedList__E) -> _LinkedList__E: ... + def size(self) -> int: ... + def spliterator(self) -> Spliterator[_LinkedList__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + +_Stack__E = typing.TypeVar("_Stack__E") # + +class Stack(Vector[_Stack__E], typing.Generic[_Stack__E]): + def __init__(self): ... + def empty(self) -> bool: ... + def peek(self) -> _Stack__E: ... + def pop(self) -> _Stack__E: ... + def push(self, e: _Stack__E) -> _Stack__E: ... + def search(self, object: typing.Any) -> int: ... + +_TreeSet__E = typing.TypeVar("_TreeSet__E") # + +class TreeSet( + AbstractSet[_TreeSet__E], + NavigableSet[_TreeSet__E], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_TreeSet__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: Collection[_TreeSet__E] + | typing.Sequence[_TreeSet__E] + | set[_TreeSet__E], + ): ... + @typing.overload + def __init__( + self, + comparator: Comparator[_TreeSet__E] + | typing.Callable[[_TreeSet__E, _TreeSet__E], int], + ): ... + @typing.overload + def __init__(self, sortedSet: SortedSet[_TreeSet__E]): ... + def add(self, e: _TreeSet__E) -> bool: ... + def addAll( + self, + collection: Collection[_TreeSet__E] + | typing.Sequence[_TreeSet__E] + | set[_TreeSet__E], + ) -> bool: ... + def addFirst(self, e: _TreeSet__E) -> None: ... + def addLast(self, e: _TreeSet__E) -> None: ... + def ceiling(self, e: _TreeSet__E) -> _TreeSet__E: ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def comparator(self) -> Comparator[_TreeSet__E]: ... + def contains(self, object: typing.Any) -> bool: ... + def descendingIterator(self) -> Iterator[_TreeSet__E]: ... + def descendingSet(self) -> NavigableSet[_TreeSet__E]: ... + def first(self) -> _TreeSet__E: ... + def floor(self, e: _TreeSet__E) -> _TreeSet__E: ... + @typing.overload + def headSet(self, e: _TreeSet__E, boolean: bool) -> NavigableSet[_TreeSet__E]: ... + @typing.overload + def headSet(self, e: _TreeSet__E) -> SortedSet[_TreeSet__E]: ... + def higher(self, e: _TreeSet__E) -> _TreeSet__E: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> Iterator[_TreeSet__E]: ... + def last(self) -> _TreeSet__E: ... + def lower(self, e: _TreeSet__E) -> _TreeSet__E: ... + def pollFirst(self) -> _TreeSet__E: ... + def pollLast(self) -> _TreeSet__E: ... + def remove(self, object: typing.Any) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> Spliterator[_TreeSet__E]: ... + @typing.overload + def subSet( + self, e: _TreeSet__E, boolean: bool, e2: _TreeSet__E, boolean2: bool + ) -> NavigableSet[_TreeSet__E]: ... + @typing.overload + def subSet(self, e: _TreeSet__E, e2: _TreeSet__E) -> SortedSet[_TreeSet__E]: ... + @typing.overload + def tailSet(self, e: _TreeSet__E, boolean: bool) -> NavigableSet[_TreeSet__E]: ... + @typing.overload + def tailSet(self, e: _TreeSet__E) -> SortedSet[_TreeSet__E]: ... + +_PrimitiveIterator__T = typing.TypeVar("_PrimitiveIterator__T") # +_PrimitiveIterator__T_CONS = typing.TypeVar("_PrimitiveIterator__T_CONS") # + +class PrimitiveIterator( + Iterator[_PrimitiveIterator__T], + typing.Generic[_PrimitiveIterator__T, _PrimitiveIterator__T_CONS], +): + @typing.overload + def forEachRemaining(self, t_CONS: _PrimitiveIterator__T_CONS) -> None: ... + @typing.overload + def forEachRemaining( + self, + consumer: java.util.function.Consumer[typing.Any] + | typing.Callable[[typing.Any], None], + ) -> None: ... + class OfDouble( + java.util.PrimitiveIterator[float, java.util.function.DoubleConsumer] + ): + @typing.overload + def forEachRemaining( + self, + consumer: java.util.function.Consumer[float] + | typing.Callable[[float], None], + ) -> None: ... + @typing.overload + def forEachRemaining( + self, doubleConsumer: java.util.function.DoubleConsumer | typing.Callable + ) -> None: ... + def next(self) -> float: ... + def nextDouble(self) -> float: ... + + class OfInt(java.util.PrimitiveIterator[int, java.util.function.IntConsumer]): + @typing.overload + def forEachRemaining( + self, + consumer: java.util.function.Consumer[int] | typing.Callable[[int], None], + ) -> None: ... + @typing.overload + def forEachRemaining( + self, intConsumer: java.util.function.IntConsumer | typing.Callable + ) -> None: ... + def next(self) -> int: ... + def nextInt(self) -> int: ... + + class OfLong(java.util.PrimitiveIterator[int, java.util.function.LongConsumer]): + @typing.overload + def forEachRemaining( + self, + consumer: java.util.function.Consumer[int] | typing.Callable[[int], None], + ) -> None: ... + @typing.overload + def forEachRemaining( + self, longConsumer: java.util.function.LongConsumer | typing.Callable + ) -> None: ... + def next(self) -> int: ... + def nextLong(self) -> int: ... + +_Spliterator__OfPrimitive__T = typing.TypeVar("_Spliterator__OfPrimitive__T") # +_Spliterator__OfPrimitive__T_CONS = typing.TypeVar( + "_Spliterator__OfPrimitive__T_CONS" +) # +_Spliterator__OfPrimitive__T_SPLITR = typing.TypeVar( + "_Spliterator__OfPrimitive__T_SPLITR", bound="Spliterator.OfPrimitive" +) # +_Spliterator__T = typing.TypeVar("_Spliterator__T") # + +class Spliterator(typing.Generic[_Spliterator__T]): + ORDERED: typing.ClassVar[int] = ... + DISTINCT: typing.ClassVar[int] = ... + SORTED: typing.ClassVar[int] = ... + SIZED: typing.ClassVar[int] = ... + NONNULL: typing.ClassVar[int] = ... + IMMUTABLE: typing.ClassVar[int] = ... + CONCURRENT: typing.ClassVar[int] = ... + SUBSIZED: typing.ClassVar[int] = ... + def characteristics(self) -> int: ... + def estimateSize(self) -> int: ... + def forEachRemaining( + self, + consumer: java.util.function.Consumer[_Spliterator__T] + | typing.Callable[[_Spliterator__T], None], + ) -> None: ... + def getComparator(self) -> Comparator[_Spliterator__T]: ... + def getExactSizeIfKnown(self) -> int: ... + def hasCharacteristics(self, int: int) -> bool: ... + def tryAdvance( + self, + consumer: java.util.function.Consumer[_Spliterator__T] + | typing.Callable[[_Spliterator__T], None], + ) -> bool: ... + def trySplit(self) -> Spliterator[_Spliterator__T]: ... + class OfDouble( + java.util.Spliterator.OfPrimitive[ + float, java.util.function.DoubleConsumer, "Spliterator.OfDouble" + ] + ): + @typing.overload + def forEachRemaining( + self, + consumer: java.util.function.Consumer[float] + | typing.Callable[[float], None], + ) -> None: ... + @typing.overload + def forEachRemaining( + self, doubleConsumer: java.util.function.DoubleConsumer | typing.Callable + ) -> None: ... + @typing.overload + def tryAdvance( + self, doubleConsumer: java.util.function.DoubleConsumer | typing.Callable + ) -> bool: ... + @typing.overload + def tryAdvance( + self, + consumer: java.util.function.Consumer[float] + | typing.Callable[[float], None], + ) -> bool: ... + def trySplit(self) -> Spliterator.OfDouble: ... + + class OfInt( + java.util.Spliterator.OfPrimitive[ + int, java.util.function.IntConsumer, "Spliterator.OfInt" + ] + ): + @typing.overload + def forEachRemaining( + self, + consumer: java.util.function.Consumer[int] | typing.Callable[[int], None], + ) -> None: ... + @typing.overload + def forEachRemaining( + self, intConsumer: java.util.function.IntConsumer | typing.Callable + ) -> None: ... + @typing.overload + def tryAdvance( + self, intConsumer: java.util.function.IntConsumer | typing.Callable + ) -> bool: ... + @typing.overload + def tryAdvance( + self, + consumer: java.util.function.Consumer[int] | typing.Callable[[int], None], + ) -> bool: ... + def trySplit(self) -> Spliterator.OfInt: ... + + class OfLong( + java.util.Spliterator.OfPrimitive[ + int, java.util.function.LongConsumer, "Spliterator.OfLong" + ] + ): + @typing.overload + def forEachRemaining( + self, + consumer: java.util.function.Consumer[int] | typing.Callable[[int], None], + ) -> None: ... + @typing.overload + def forEachRemaining( + self, longConsumer: java.util.function.LongConsumer | typing.Callable + ) -> None: ... + @typing.overload + def tryAdvance( + self, longConsumer: java.util.function.LongConsumer | typing.Callable + ) -> bool: ... + @typing.overload + def tryAdvance( + self, + consumer: java.util.function.Consumer[int] | typing.Callable[[int], None], + ) -> bool: ... + def trySplit(self) -> Spliterator.OfLong: ... + + class OfPrimitive( + java.util.Spliterator[_Spliterator__OfPrimitive__T], + typing.Generic[ + _Spliterator__OfPrimitive__T, + _Spliterator__OfPrimitive__T_CONS, + _Spliterator__OfPrimitive__T_SPLITR, + ], + ): + @typing.overload + def forEachRemaining( + self, t_CONS: _Spliterator__OfPrimitive__T_CONS + ) -> None: ... + @typing.overload + def forEachRemaining( + self, + consumer: java.util.function.Consumer[_Spliterator__OfPrimitive__T] + | typing.Callable[[_Spliterator__OfPrimitive__T], None], + ) -> None: ... + @typing.overload + def tryAdvance(self, t_CONS: _Spliterator__OfPrimitive__T_CONS) -> bool: ... + @typing.overload + def tryAdvance( + self, + consumer: java.util.function.Consumer[_Spliterator__OfPrimitive__T] + | typing.Callable[[_Spliterator__OfPrimitive__T], None], + ) -> bool: ... + def trySplit(self) -> _Spliterator__OfPrimitive__T_SPLITR: ... + +_Spliterators__AbstractSpliterator__T = typing.TypeVar( + "_Spliterators__AbstractSpliterator__T" +) # + +class Spliterators: + @staticmethod + def emptyDoubleSpliterator() -> Spliterator.OfDouble: ... + @staticmethod + def emptyIntSpliterator() -> Spliterator.OfInt: ... + @staticmethod + def emptyLongSpliterator() -> Spliterator.OfLong: ... + _emptySpliterator__T = typing.TypeVar("_emptySpliterator__T") # + @staticmethod + def emptySpliterator() -> Spliterator[_emptySpliterator__T]: ... + _iterator_0__T = typing.TypeVar("_iterator_0__T") # + @typing.overload + @staticmethod + def iterator( + spliterator: Spliterator[_iterator_0__T], + ) -> Iterator[_iterator_0__T]: ... + @typing.overload + @staticmethod + def iterator(ofDouble: Spliterator.OfDouble) -> PrimitiveIterator.OfDouble: ... + @typing.overload + @staticmethod + def iterator(ofInt: Spliterator.OfInt) -> PrimitiveIterator.OfInt: ... + @typing.overload + @staticmethod + def iterator(ofLong: Spliterator.OfLong) -> PrimitiveIterator.OfLong: ... + _spliterator_0__T = typing.TypeVar("_spliterator_0__T") # + _spliterator_1__T = typing.TypeVar("_spliterator_1__T") # + _spliterator_2__T = typing.TypeVar("_spliterator_2__T") # + _spliterator_3__T = typing.TypeVar("_spliterator_3__T") # + @typing.overload + @staticmethod + def spliterator( + objectArray: list[typing.Any] | jpype.JArray, int: int + ) -> Spliterator[_spliterator_0__T]: ... + @typing.overload + @staticmethod + def spliterator( + objectArray: list[typing.Any] | jpype.JArray, int: int, int2: int, int3: int + ) -> Spliterator[_spliterator_1__T]: ... + @typing.overload + @staticmethod + def spliterator( + collection: Collection[_spliterator_2__T] + | typing.Sequence[_spliterator_2__T] + | set[_spliterator_2__T], + int: int, + ) -> Spliterator[_spliterator_2__T]: ... + @typing.overload + @staticmethod + def spliterator( + iterator: Iterator[_spliterator_3__T], long: int, int: int + ) -> Spliterator[_spliterator_3__T]: ... + @typing.overload + @staticmethod + def spliterator( + doubleArray: list[float] | jpype.JArray, int: int + ) -> Spliterator.OfDouble: ... + @typing.overload + @staticmethod + def spliterator( + doubleArray: list[float] | jpype.JArray, int: int, int2: int, int3: int + ) -> Spliterator.OfDouble: ... + @typing.overload + @staticmethod + def spliterator( + ofDouble: PrimitiveIterator.OfDouble, long: int, int: int + ) -> Spliterator.OfDouble: ... + @typing.overload + @staticmethod + def spliterator( + intArray: list[int] | jpype.JArray, int2: int + ) -> Spliterator.OfInt: ... + @typing.overload + @staticmethod + def spliterator( + intArray: list[int] | jpype.JArray, int2: int, int3: int, int4: int + ) -> Spliterator.OfInt: ... + @typing.overload + @staticmethod + def spliterator( + ofInt: PrimitiveIterator.OfInt, long: int, int: int + ) -> Spliterator.OfInt: ... + @typing.overload + @staticmethod + def spliterator( + ofLong: PrimitiveIterator.OfLong, long: int, int: int + ) -> Spliterator.OfLong: ... + @typing.overload + @staticmethod + def spliterator( + longArray: list[int] | jpype.JArray, int: int + ) -> Spliterator.OfLong: ... + @typing.overload + @staticmethod + def spliterator( + longArray: list[int] | jpype.JArray, int: int, int2: int, int3: int + ) -> Spliterator.OfLong: ... + _spliteratorUnknownSize_0__T = typing.TypeVar("_spliteratorUnknownSize_0__T") # + @typing.overload + @staticmethod + def spliteratorUnknownSize( + iterator: Iterator[_spliteratorUnknownSize_0__T], int: int + ) -> Spliterator[_spliteratorUnknownSize_0__T]: ... + @typing.overload + @staticmethod + def spliteratorUnknownSize( + ofDouble: PrimitiveIterator.OfDouble, int: int + ) -> Spliterator.OfDouble: ... + @typing.overload + @staticmethod + def spliteratorUnknownSize( + ofInt: PrimitiveIterator.OfInt, int: int + ) -> Spliterator.OfInt: ... + @typing.overload + @staticmethod + def spliteratorUnknownSize( + ofLong: PrimitiveIterator.OfLong, int: int + ) -> Spliterator.OfLong: ... + class AbstractDoubleSpliterator(Spliterator.OfDouble): + def characteristics(self) -> int: ... + def estimateSize(self) -> int: ... + def trySplit(self) -> Spliterator.OfDouble: ... + + class AbstractIntSpliterator(Spliterator.OfInt): + def characteristics(self) -> int: ... + def estimateSize(self) -> int: ... + def trySplit(self) -> Spliterator.OfInt: ... + + class AbstractLongSpliterator(Spliterator.OfLong): + def characteristics(self) -> int: ... + def estimateSize(self) -> int: ... + def trySplit(self) -> Spliterator.OfLong: ... + + class AbstractSpliterator( + Spliterator[_Spliterators__AbstractSpliterator__T], + typing.Generic[_Spliterators__AbstractSpliterator__T], + ): + def characteristics(self) -> int: ... + def estimateSize(self) -> int: ... + def trySplit(self) -> Spliterator[_Spliterators__AbstractSpliterator__T]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util")``. + + AbstractCollection: type[AbstractCollection] + AbstractList: type[AbstractList] + AbstractMap: type[AbstractMap] + AbstractQueue: type[AbstractQueue] + AbstractSequentialList: type[AbstractSequentialList] + AbstractSet: type[AbstractSet] + ArrayDeque: type[ArrayDeque] + ArrayList: type[ArrayList] + Arrays: type[Arrays] + Base64: type[Base64] + BitSet: type[BitSet] + Calendar: type[Calendar] + Collection: type[Collection] + Collections: type[Collections] + Comparator: type[Comparator] + ConcurrentModificationException: type[ConcurrentModificationException] + Currency: type[Currency] + Date: type[Date] + Deque: type[Deque] + Dictionary: type[Dictionary] + DoubleSummaryStatistics: type[DoubleSummaryStatistics] + DuplicateFormatFlagsException: type[DuplicateFormatFlagsException] + EmptyStackException: type[EmptyStackException] + EnumMap: type[EnumMap] + EnumSet: type[EnumSet] + Enumeration: type[Enumeration] + EventListener: type[EventListener] + EventListenerProxy: type[EventListenerProxy] + EventObject: type[EventObject] + FormatFlagsConversionMismatchException: type[FormatFlagsConversionMismatchException] + Formattable: type[Formattable] + FormattableFlags: type[FormattableFlags] + Formatter: type[Formatter] + FormatterClosedException: type[FormatterClosedException] + GregorianCalendar: type[GregorianCalendar] + HashMap: type[HashMap] + HashSet: type[HashSet] + Hashtable: type[Hashtable] + HexFormat: type[HexFormat] + IdentityHashMap: type[IdentityHashMap] + IllegalFormatCodePointException: type[IllegalFormatCodePointException] + IllegalFormatConversionException: type[IllegalFormatConversionException] + IllegalFormatException: type[IllegalFormatException] + IllegalFormatFlagsException: type[IllegalFormatFlagsException] + IllegalFormatPrecisionException: type[IllegalFormatPrecisionException] + IllegalFormatWidthException: type[IllegalFormatWidthException] + IllformedLocaleException: type[IllformedLocaleException] + InputMismatchException: type[InputMismatchException] + IntSummaryStatistics: type[IntSummaryStatistics] + InvalidPropertiesFormatException: type[InvalidPropertiesFormatException] + Iterator: type[Iterator] + LinkedHashMap: type[LinkedHashMap] + LinkedHashSet: type[LinkedHashSet] + LinkedList: type[LinkedList] + List: type[List] + ListIterator: type[ListIterator] + ListResourceBundle: type[ListResourceBundle] + Locale: type[Locale] + LongSummaryStatistics: type[LongSummaryStatistics] + Map: type[Map] + MissingFormatArgumentException: type[MissingFormatArgumentException] + MissingFormatWidthException: type[MissingFormatWidthException] + MissingResourceException: type[MissingResourceException] + NavigableMap: type[NavigableMap] + NavigableSet: type[NavigableSet] + NoSuchElementException: type[NoSuchElementException] + Objects: type[Objects] + Observable: type[Observable] + Observer: type[Observer] + Optional: type[Optional] + OptionalDouble: type[OptionalDouble] + OptionalInt: type[OptionalInt] + OptionalLong: type[OptionalLong] + PrimitiveIterator: type[PrimitiveIterator] + PriorityQueue: type[PriorityQueue] + Properties: type[Properties] + PropertyPermission: type[PropertyPermission] + PropertyResourceBundle: type[PropertyResourceBundle] + Queue: type[Queue] + Random: type[Random] + RandomAccess: type[RandomAccess] + ResourceBundle: type[ResourceBundle] + Scanner: type[Scanner] + SequencedCollection: type[SequencedCollection] + SequencedMap: type[SequencedMap] + SequencedSet: type[SequencedSet] + ServiceConfigurationError: type[ServiceConfigurationError] + ServiceLoader: type[ServiceLoader] + Set: type[Set] + SimpleTimeZone: type[SimpleTimeZone] + SortedMap: type[SortedMap] + SortedSet: type[SortedSet] + Spliterator: type[Spliterator] + Spliterators: type[Spliterators] + SplittableRandom: type[SplittableRandom] + Stack: type[Stack] + StringJoiner: type[StringJoiner] + StringTokenizer: type[StringTokenizer] + TimeZone: type[TimeZone] + Timer: type[Timer] + TimerTask: type[TimerTask] + TooManyListenersException: type[TooManyListenersException] + TreeMap: type[TreeMap] + TreeSet: type[TreeSet] + UUID: type[UUID] + UnknownFormatConversionException: type[UnknownFormatConversionException] + UnknownFormatFlagsException: type[UnknownFormatFlagsException] + Vector: type[Vector] + WeakHashMap: type[WeakHashMap] + concurrent: java.util.concurrent.__module_protocol__ + function: java.util.function.__module_protocol__ + jar: java.util.jar.__module_protocol__ + logging: java.util.logging.__module_protocol__ + prefs: java.util.prefs.__module_protocol__ + random: java.util.random.__module_protocol__ + regex: java.util.regex.__module_protocol__ + spi: java.util.spi.__module_protocol__ + stream: java.util.stream.__module_protocol__ + zip: java.util.zip.__module_protocol__ diff --git a/typings/java/util/concurrent/__init__.pyi b/typings/java/util/concurrent/__init__.pyi new file mode 100644 index 0000000..762fad6 --- /dev/null +++ b/typings/java/util/concurrent/__init__.pyi @@ -0,0 +1,4430 @@ +import builtins +import typing +from typing import Protocol + +import java +import java.io +import java.lang +import java.security +import java.time +import java.time.temporal +import java.util +import java.util.concurrent.atomic +import java.util.concurrent.locks +import java.util.function +import java.util.stream +import jpype + +_BlockingQueue__E = typing.TypeVar("_BlockingQueue__E") # + +class BlockingQueue( + java.util.Queue[_BlockingQueue__E], typing.Generic[_BlockingQueue__E] +): + def add(self, e: _BlockingQueue__E) -> bool: ... + def contains(self, object: typing.Any) -> bool: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_BlockingQueue__E] + | typing.Sequence[_BlockingQueue__E] + | set[_BlockingQueue__E], + ) -> int: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_BlockingQueue__E] + | typing.Sequence[_BlockingQueue__E] + | set[_BlockingQueue__E], + int: int, + ) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + @typing.overload + def offer(self, e: _BlockingQueue__E) -> bool: ... + @typing.overload + def offer(self, e: _BlockingQueue__E, long: int, timeUnit: TimeUnit) -> bool: ... + @typing.overload + def poll(self) -> _BlockingQueue__E: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> _BlockingQueue__E: ... + def put(self, e: _BlockingQueue__E) -> None: ... + def remainingCapacity(self) -> int: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _BlockingQueue__E: ... + def take(self) -> _BlockingQueue__E: ... + +class BrokenBarrierException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +_Callable__V = typing.TypeVar("_Callable__V") # + +class Callable(typing.Generic[_Callable__V]): + def call(self) -> _Callable__V: ... + +class CancellationException(java.lang.IllegalStateException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class CompletionException(java.lang.RuntimeException): + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +_CompletionService__V = typing.TypeVar("_CompletionService__V") # + +class CompletionService(typing.Generic[_CompletionService__V]): + @typing.overload + def poll(self) -> Future[_CompletionService__V]: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> Future[_CompletionService__V]: ... + @typing.overload + def submit( + self, runnable: java.lang.Runnable | typing.Callable, v: _CompletionService__V + ) -> Future[_CompletionService__V]: ... + @typing.overload + def submit( + self, + callable: Callable[_CompletionService__V] + | typing.Callable[[], _CompletionService__V], + ) -> Future[_CompletionService__V]: ... + def take(self) -> Future[_CompletionService__V]: ... + +_CompletionStage__T = typing.TypeVar("_CompletionStage__T") # + +class CompletionStage(typing.Generic[_CompletionStage__T]): + def acceptEither( + self, + completionStage: CompletionStage[_CompletionStage__T], + consumer: java.util.function.Consumer[_CompletionStage__T] + | typing.Callable[[_CompletionStage__T], None], + ) -> CompletionStage[None]: ... + @typing.overload + def acceptEitherAsync( + self, + completionStage: CompletionStage[_CompletionStage__T], + consumer: java.util.function.Consumer[_CompletionStage__T] + | typing.Callable[[_CompletionStage__T], None], + ) -> CompletionStage[None]: ... + @typing.overload + def acceptEitherAsync( + self, + completionStage: CompletionStage[_CompletionStage__T], + consumer: java.util.function.Consumer[_CompletionStage__T] + | typing.Callable[[_CompletionStage__T], None], + executor: Executor | typing.Callable, + ) -> CompletionStage[None]: ... + _applyToEither__U = typing.TypeVar("_applyToEither__U") # + def applyToEither( + self, + completionStage: CompletionStage[_CompletionStage__T], + function: java.util.function.Function[_CompletionStage__T, _applyToEither__U] + | typing.Callable[[_CompletionStage__T], _applyToEither__U], + ) -> CompletionStage[_applyToEither__U]: ... + _applyToEitherAsync_0__U = typing.TypeVar("_applyToEitherAsync_0__U") # + _applyToEitherAsync_1__U = typing.TypeVar("_applyToEitherAsync_1__U") # + @typing.overload + def applyToEitherAsync( + self, + completionStage: CompletionStage[_CompletionStage__T], + function: java.util.function.Function[ + _CompletionStage__T, _applyToEitherAsync_0__U + ] + | typing.Callable[[_CompletionStage__T], _applyToEitherAsync_0__U], + ) -> CompletionStage[_applyToEitherAsync_0__U]: ... + @typing.overload + def applyToEitherAsync( + self, + completionStage: CompletionStage[_CompletionStage__T], + function: java.util.function.Function[ + _CompletionStage__T, _applyToEitherAsync_1__U + ] + | typing.Callable[[_CompletionStage__T], _applyToEitherAsync_1__U], + executor: Executor | typing.Callable, + ) -> CompletionStage[_applyToEitherAsync_1__U]: ... + def exceptionally( + self, + function: java.util.function.Function[java.lang.Throwable, _CompletionStage__T] + | typing.Callable[[java.lang.Throwable], _CompletionStage__T], + ) -> CompletionStage[_CompletionStage__T]: ... + @typing.overload + def exceptionallyAsync( + self, + function: java.util.function.Function[java.lang.Throwable, _CompletionStage__T] + | typing.Callable[[java.lang.Throwable], _CompletionStage__T], + ) -> CompletionStage[_CompletionStage__T]: ... + @typing.overload + def exceptionallyAsync( + self, + function: java.util.function.Function[java.lang.Throwable, _CompletionStage__T] + | typing.Callable[[java.lang.Throwable], _CompletionStage__T], + executor: Executor | typing.Callable, + ) -> CompletionStage[_CompletionStage__T]: ... + def exceptionallyCompose( + self, + function: java.util.function.Function[ + java.lang.Throwable, CompletionStage[_CompletionStage__T] + ] + | typing.Callable[[java.lang.Throwable], CompletionStage[_CompletionStage__T]], + ) -> CompletionStage[_CompletionStage__T]: ... + @typing.overload + def exceptionallyComposeAsync( + self, + function: java.util.function.Function[ + java.lang.Throwable, CompletionStage[_CompletionStage__T] + ] + | typing.Callable[[java.lang.Throwable], CompletionStage[_CompletionStage__T]], + ) -> CompletionStage[_CompletionStage__T]: ... + @typing.overload + def exceptionallyComposeAsync( + self, + function: java.util.function.Function[ + java.lang.Throwable, CompletionStage[_CompletionStage__T] + ] + | typing.Callable[[java.lang.Throwable], CompletionStage[_CompletionStage__T]], + executor: Executor | typing.Callable, + ) -> CompletionStage[_CompletionStage__T]: ... + _handle__U = typing.TypeVar("_handle__U") # + def handle( + self, + biFunction: java.util.function.BiFunction[ + _CompletionStage__T, java.lang.Throwable, _handle__U + ] + | typing.Callable[[_CompletionStage__T, java.lang.Throwable], _handle__U], + ) -> CompletionStage[_handle__U]: ... + _handleAsync_0__U = typing.TypeVar("_handleAsync_0__U") # + _handleAsync_1__U = typing.TypeVar("_handleAsync_1__U") # + @typing.overload + def handleAsync( + self, + biFunction: java.util.function.BiFunction[ + _CompletionStage__T, java.lang.Throwable, _handleAsync_0__U + ] + | typing.Callable[ + [_CompletionStage__T, java.lang.Throwable], _handleAsync_0__U + ], + ) -> CompletionStage[_handleAsync_0__U]: ... + @typing.overload + def handleAsync( + self, + biFunction: java.util.function.BiFunction[ + _CompletionStage__T, java.lang.Throwable, _handleAsync_1__U + ] + | typing.Callable[ + [_CompletionStage__T, java.lang.Throwable], _handleAsync_1__U + ], + executor: Executor | typing.Callable, + ) -> CompletionStage[_handleAsync_1__U]: ... + def runAfterBoth( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + ) -> CompletionStage[None]: ... + @typing.overload + def runAfterBothAsync( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + ) -> CompletionStage[None]: ... + @typing.overload + def runAfterBothAsync( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + executor: Executor | typing.Callable, + ) -> CompletionStage[None]: ... + def runAfterEither( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + ) -> CompletionStage[None]: ... + @typing.overload + def runAfterEitherAsync( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + ) -> CompletionStage[None]: ... + @typing.overload + def runAfterEitherAsync( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + executor: Executor | typing.Callable, + ) -> CompletionStage[None]: ... + def thenAccept( + self, + consumer: java.util.function.Consumer[_CompletionStage__T] + | typing.Callable[[_CompletionStage__T], None], + ) -> CompletionStage[None]: ... + @typing.overload + def thenAcceptAsync( + self, + consumer: java.util.function.Consumer[_CompletionStage__T] + | typing.Callable[[_CompletionStage__T], None], + ) -> CompletionStage[None]: ... + @typing.overload + def thenAcceptAsync( + self, + consumer: java.util.function.Consumer[_CompletionStage__T] + | typing.Callable[[_CompletionStage__T], None], + executor: Executor | typing.Callable, + ) -> CompletionStage[None]: ... + _thenAcceptBoth__U = typing.TypeVar("_thenAcceptBoth__U") # + def thenAcceptBoth( + self, + completionStage: CompletionStage[_thenAcceptBoth__U], + biConsumer: java.util.function.BiConsumer[ + _CompletionStage__T, _thenAcceptBoth__U + ] + | typing.Callable[[_CompletionStage__T, _thenAcceptBoth__U], None], + ) -> CompletionStage[None]: ... + _thenAcceptBothAsync_0__U = typing.TypeVar("_thenAcceptBothAsync_0__U") # + _thenAcceptBothAsync_1__U = typing.TypeVar("_thenAcceptBothAsync_1__U") # + @typing.overload + def thenAcceptBothAsync( + self, + completionStage: CompletionStage[_thenAcceptBothAsync_0__U], + biConsumer: java.util.function.BiConsumer[ + _CompletionStage__T, _thenAcceptBothAsync_0__U + ] + | typing.Callable[[_CompletionStage__T, _thenAcceptBothAsync_0__U], None], + ) -> CompletionStage[None]: ... + @typing.overload + def thenAcceptBothAsync( + self, + completionStage: CompletionStage[_thenAcceptBothAsync_1__U], + biConsumer: java.util.function.BiConsumer[ + _CompletionStage__T, _thenAcceptBothAsync_1__U + ] + | typing.Callable[[_CompletionStage__T, _thenAcceptBothAsync_1__U], None], + executor: Executor | typing.Callable, + ) -> CompletionStage[None]: ... + _thenApply__U = typing.TypeVar("_thenApply__U") # + def thenApply( + self, + function: java.util.function.Function[_CompletionStage__T, _thenApply__U] + | typing.Callable[[_CompletionStage__T], _thenApply__U], + ) -> CompletionStage[_thenApply__U]: ... + _thenApplyAsync_0__U = typing.TypeVar("_thenApplyAsync_0__U") # + _thenApplyAsync_1__U = typing.TypeVar("_thenApplyAsync_1__U") # + @typing.overload + def thenApplyAsync( + self, + function: java.util.function.Function[_CompletionStage__T, _thenApplyAsync_0__U] + | typing.Callable[[_CompletionStage__T], _thenApplyAsync_0__U], + ) -> CompletionStage[_thenApplyAsync_0__U]: ... + @typing.overload + def thenApplyAsync( + self, + function: java.util.function.Function[_CompletionStage__T, _thenApplyAsync_1__U] + | typing.Callable[[_CompletionStage__T], _thenApplyAsync_1__U], + executor: Executor | typing.Callable, + ) -> CompletionStage[_thenApplyAsync_1__U]: ... + _thenCombine__U = typing.TypeVar("_thenCombine__U") # + _thenCombine__V = typing.TypeVar("_thenCombine__V") # + def thenCombine( + self, + completionStage: CompletionStage[_thenCombine__U], + biFunction: java.util.function.BiFunction[ + _CompletionStage__T, _thenCombine__U, _thenCombine__V + ] + | typing.Callable[[_CompletionStage__T, _thenCombine__U], _thenCombine__V], + ) -> CompletionStage[_thenCombine__V]: ... + _thenCombineAsync_0__U = typing.TypeVar("_thenCombineAsync_0__U") # + _thenCombineAsync_0__V = typing.TypeVar("_thenCombineAsync_0__V") # + _thenCombineAsync_1__U = typing.TypeVar("_thenCombineAsync_1__U") # + _thenCombineAsync_1__V = typing.TypeVar("_thenCombineAsync_1__V") # + @typing.overload + def thenCombineAsync( + self, + completionStage: CompletionStage[_thenCombineAsync_0__U], + biFunction: java.util.function.BiFunction[ + _CompletionStage__T, _thenCombineAsync_0__U, _thenCombineAsync_0__V + ] + | typing.Callable[ + [_CompletionStage__T, _thenCombineAsync_0__U], _thenCombineAsync_0__V + ], + ) -> CompletionStage[_thenCombineAsync_0__V]: ... + @typing.overload + def thenCombineAsync( + self, + completionStage: CompletionStage[_thenCombineAsync_1__U], + biFunction: java.util.function.BiFunction[ + _CompletionStage__T, _thenCombineAsync_1__U, _thenCombineAsync_1__V + ] + | typing.Callable[ + [_CompletionStage__T, _thenCombineAsync_1__U], _thenCombineAsync_1__V + ], + executor: Executor | typing.Callable, + ) -> CompletionStage[_thenCombineAsync_1__V]: ... + _thenCompose__U = typing.TypeVar("_thenCompose__U") # + def thenCompose( + self, + function: java.util.function.Function[ + _CompletionStage__T, CompletionStage[_thenCompose__U] + ] + | typing.Callable[[_CompletionStage__T], CompletionStage[_thenCompose__U]], + ) -> CompletionStage[_thenCompose__U]: ... + _thenComposeAsync_0__U = typing.TypeVar("_thenComposeAsync_0__U") # + _thenComposeAsync_1__U = typing.TypeVar("_thenComposeAsync_1__U") # + @typing.overload + def thenComposeAsync( + self, + function: java.util.function.Function[ + _CompletionStage__T, CompletionStage[_thenComposeAsync_0__U] + ] + | typing.Callable[ + [_CompletionStage__T], CompletionStage[_thenComposeAsync_0__U] + ], + ) -> CompletionStage[_thenComposeAsync_0__U]: ... + @typing.overload + def thenComposeAsync( + self, + function: java.util.function.Function[ + _CompletionStage__T, CompletionStage[_thenComposeAsync_1__U] + ] + | typing.Callable[ + [_CompletionStage__T], CompletionStage[_thenComposeAsync_1__U] + ], + executor: Executor | typing.Callable, + ) -> CompletionStage[_thenComposeAsync_1__U]: ... + def thenRun( + self, runnable: java.lang.Runnable | typing.Callable + ) -> CompletionStage[None]: ... + @typing.overload + def thenRunAsync( + self, runnable: java.lang.Runnable | typing.Callable + ) -> CompletionStage[None]: ... + @typing.overload + def thenRunAsync( + self, + runnable: java.lang.Runnable | typing.Callable, + executor: Executor | typing.Callable, + ) -> CompletionStage[None]: ... + def toCompletableFuture(self) -> CompletableFuture[_CompletionStage__T]: ... + def whenComplete( + self, + biConsumer: java.util.function.BiConsumer[ + _CompletionStage__T, java.lang.Throwable + ] + | typing.Callable[[_CompletionStage__T, java.lang.Throwable], None], + ) -> CompletionStage[_CompletionStage__T]: ... + @typing.overload + def whenCompleteAsync( + self, + biConsumer: java.util.function.BiConsumer[ + _CompletionStage__T, java.lang.Throwable + ] + | typing.Callable[[_CompletionStage__T, java.lang.Throwable], None], + ) -> CompletionStage[_CompletionStage__T]: ... + @typing.overload + def whenCompleteAsync( + self, + biConsumer: java.util.function.BiConsumer[ + _CompletionStage__T, java.lang.Throwable + ] + | typing.Callable[[_CompletionStage__T, java.lang.Throwable], None], + executor: Executor | typing.Callable, + ) -> CompletionStage[_CompletionStage__T]: ... + +_ConcurrentLinkedDeque__E = typing.TypeVar("_ConcurrentLinkedDeque__E") # + +class ConcurrentLinkedDeque( + java.util.AbstractCollection[_ConcurrentLinkedDeque__E], + java.util.Deque[_ConcurrentLinkedDeque__E], + java.io.Serializable, + typing.Generic[_ConcurrentLinkedDeque__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_ConcurrentLinkedDeque__E] + | typing.Sequence[_ConcurrentLinkedDeque__E] + | set[_ConcurrentLinkedDeque__E], + ): ... + def add(self, e: _ConcurrentLinkedDeque__E) -> bool: ... + def addAll( + self, + collection: java.util.Collection[_ConcurrentLinkedDeque__E] + | typing.Sequence[_ConcurrentLinkedDeque__E] + | set[_ConcurrentLinkedDeque__E], + ) -> bool: ... + def addFirst(self, e: _ConcurrentLinkedDeque__E) -> None: ... + def addLast(self, e: _ConcurrentLinkedDeque__E) -> None: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def descendingIterator(self) -> java.util.Iterator[_ConcurrentLinkedDeque__E]: ... + def element(self) -> _ConcurrentLinkedDeque__E: ... + def forEach( + self, + consumer: java.util.function.Consumer[_ConcurrentLinkedDeque__E] + | typing.Callable[[_ConcurrentLinkedDeque__E], None], + ) -> None: ... + def getFirst(self) -> _ConcurrentLinkedDeque__E: ... + def getLast(self) -> _ConcurrentLinkedDeque__E: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> java.util.Iterator[_ConcurrentLinkedDeque__E]: ... + def offer(self, e: _ConcurrentLinkedDeque__E) -> bool: ... + def offerFirst(self, e: _ConcurrentLinkedDeque__E) -> bool: ... + def offerLast(self, e: _ConcurrentLinkedDeque__E) -> bool: ... + def peek(self) -> _ConcurrentLinkedDeque__E: ... + def peekFirst(self) -> _ConcurrentLinkedDeque__E: ... + def peekLast(self) -> _ConcurrentLinkedDeque__E: ... + def poll(self) -> _ConcurrentLinkedDeque__E: ... + def pollFirst(self) -> _ConcurrentLinkedDeque__E: ... + def pollLast(self) -> _ConcurrentLinkedDeque__E: ... + def pop(self) -> _ConcurrentLinkedDeque__E: ... + def push(self, e: _ConcurrentLinkedDeque__E) -> None: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _ConcurrentLinkedDeque__E: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeFirst(self) -> _ConcurrentLinkedDeque__E: ... + def removeFirstOccurrence(self, object: typing.Any) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_ConcurrentLinkedDeque__E] + | typing.Callable[[_ConcurrentLinkedDeque__E], bool], + ) -> bool: ... + def removeLast(self) -> _ConcurrentLinkedDeque__E: ... + def removeLastOccurrence(self, object: typing.Any) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_ConcurrentLinkedDeque__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + +_ConcurrentLinkedQueue__E = typing.TypeVar("_ConcurrentLinkedQueue__E") # + +class ConcurrentLinkedQueue( + java.util.AbstractQueue[_ConcurrentLinkedQueue__E], + java.util.Queue[_ConcurrentLinkedQueue__E], + java.io.Serializable, + typing.Generic[_ConcurrentLinkedQueue__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_ConcurrentLinkedQueue__E] + | typing.Sequence[_ConcurrentLinkedQueue__E] + | set[_ConcurrentLinkedQueue__E], + ): ... + def add(self, e: _ConcurrentLinkedQueue__E) -> bool: ... + def addAll( + self, + collection: java.util.Collection[_ConcurrentLinkedQueue__E] + | typing.Sequence[_ConcurrentLinkedQueue__E] + | set[_ConcurrentLinkedQueue__E], + ) -> bool: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def forEach( + self, + consumer: java.util.function.Consumer[_ConcurrentLinkedQueue__E] + | typing.Callable[[_ConcurrentLinkedQueue__E], None], + ) -> None: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> java.util.Iterator[_ConcurrentLinkedQueue__E]: ... + def offer(self, e: _ConcurrentLinkedQueue__E) -> bool: ... + def peek(self) -> _ConcurrentLinkedQueue__E: ... + def poll(self) -> _ConcurrentLinkedQueue__E: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _ConcurrentLinkedQueue__E: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_ConcurrentLinkedQueue__E] + | typing.Callable[[_ConcurrentLinkedQueue__E], bool], + ) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_ConcurrentLinkedQueue__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + +_ConcurrentMap__K = typing.TypeVar("_ConcurrentMap__K") # +_ConcurrentMap__V = typing.TypeVar("_ConcurrentMap__V") # + +class ConcurrentMap( + java.util.Map[_ConcurrentMap__K, _ConcurrentMap__V], + typing.Generic[_ConcurrentMap__K, _ConcurrentMap__V], +): + def compute( + self, + k: _ConcurrentMap__K, + biFunction: java.util.function.BiFunction[ + _ConcurrentMap__K, _ConcurrentMap__V, _ConcurrentMap__V + ] + | typing.Callable[[_ConcurrentMap__K, _ConcurrentMap__V], _ConcurrentMap__V], + ) -> _ConcurrentMap__V: ... + def computeIfAbsent( + self, + k: _ConcurrentMap__K, + function: java.util.function.Function[_ConcurrentMap__K, _ConcurrentMap__V] + | typing.Callable[[_ConcurrentMap__K], _ConcurrentMap__V], + ) -> _ConcurrentMap__V: ... + def computeIfPresent( + self, + k: _ConcurrentMap__K, + biFunction: java.util.function.BiFunction[ + _ConcurrentMap__K, _ConcurrentMap__V, _ConcurrentMap__V + ] + | typing.Callable[[_ConcurrentMap__K, _ConcurrentMap__V], _ConcurrentMap__V], + ) -> _ConcurrentMap__V: ... + def equals(self, object: typing.Any) -> bool: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[_ConcurrentMap__K, _ConcurrentMap__V] + | typing.Callable[[_ConcurrentMap__K, _ConcurrentMap__V], None], + ) -> None: ... + def getOrDefault( + self, object: typing.Any, v: _ConcurrentMap__V + ) -> _ConcurrentMap__V: ... + def hashCode(self) -> int: ... + def merge( + self, + k: _ConcurrentMap__K, + v: _ConcurrentMap__V, + biFunction: java.util.function.BiFunction[ + _ConcurrentMap__V, _ConcurrentMap__V, _ConcurrentMap__V + ] + | typing.Callable[[_ConcurrentMap__V, _ConcurrentMap__V], _ConcurrentMap__V], + ) -> _ConcurrentMap__V: ... + def putIfAbsent( + self, k: _ConcurrentMap__K, v: _ConcurrentMap__V + ) -> _ConcurrentMap__V: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _ConcurrentMap__V: ... + @typing.overload + def replace( + self, k: _ConcurrentMap__K, v: _ConcurrentMap__V, v2: _ConcurrentMap__V + ) -> bool: ... + @typing.overload + def replace( + self, k: _ConcurrentMap__K, v: _ConcurrentMap__V + ) -> _ConcurrentMap__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[ + _ConcurrentMap__K, _ConcurrentMap__V, _ConcurrentMap__V + ] + | typing.Callable[[_ConcurrentMap__K, _ConcurrentMap__V], _ConcurrentMap__V], + ) -> None: ... + +_ConcurrentSkipListSet__E = typing.TypeVar("_ConcurrentSkipListSet__E") # + +class ConcurrentSkipListSet( + java.util.AbstractSet[_ConcurrentSkipListSet__E], + java.util.NavigableSet[_ConcurrentSkipListSet__E], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_ConcurrentSkipListSet__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_ConcurrentSkipListSet__E] + | typing.Sequence[_ConcurrentSkipListSet__E] + | set[_ConcurrentSkipListSet__E], + ): ... + @typing.overload + def __init__( + self, + comparator: java.util.Comparator[_ConcurrentSkipListSet__E] + | typing.Callable[[_ConcurrentSkipListSet__E, _ConcurrentSkipListSet__E], int], + ): ... + @typing.overload + def __init__(self, sortedSet: java.util.SortedSet[_ConcurrentSkipListSet__E]): ... + def add(self, e: _ConcurrentSkipListSet__E) -> bool: ... + def addFirst(self, e: _ConcurrentSkipListSet__E) -> None: ... + def addLast(self, e: _ConcurrentSkipListSet__E) -> None: ... + def ceiling(self, e: _ConcurrentSkipListSet__E) -> _ConcurrentSkipListSet__E: ... + def clear(self) -> None: ... + def clone(self) -> ConcurrentSkipListSet[_ConcurrentSkipListSet__E]: ... + def comparator(self) -> java.util.Comparator[_ConcurrentSkipListSet__E]: ... + def contains(self, object: typing.Any) -> bool: ... + def descendingIterator(self) -> java.util.Iterator[_ConcurrentSkipListSet__E]: ... + def descendingSet(self) -> java.util.NavigableSet[_ConcurrentSkipListSet__E]: ... + def equals(self, object: typing.Any) -> bool: ... + def first(self) -> _ConcurrentSkipListSet__E: ... + def floor(self, e: _ConcurrentSkipListSet__E) -> _ConcurrentSkipListSet__E: ... + @typing.overload + def headSet( + self, e: _ConcurrentSkipListSet__E + ) -> java.util.NavigableSet[_ConcurrentSkipListSet__E]: ... + @typing.overload + def headSet( + self, e: _ConcurrentSkipListSet__E, boolean: bool + ) -> java.util.NavigableSet[_ConcurrentSkipListSet__E]: ... + def higher(self, e: _ConcurrentSkipListSet__E) -> _ConcurrentSkipListSet__E: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> java.util.Iterator[_ConcurrentSkipListSet__E]: ... + def last(self) -> _ConcurrentSkipListSet__E: ... + def lower(self, e: _ConcurrentSkipListSet__E) -> _ConcurrentSkipListSet__E: ... + def pollFirst(self) -> _ConcurrentSkipListSet__E: ... + def pollLast(self) -> _ConcurrentSkipListSet__E: ... + def remove(self, object: typing.Any) -> bool: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_ConcurrentSkipListSet__E]: ... + @typing.overload + def subSet( + self, + e: _ConcurrentSkipListSet__E, + boolean: bool, + e2: _ConcurrentSkipListSet__E, + boolean2: bool, + ) -> java.util.NavigableSet[_ConcurrentSkipListSet__E]: ... + @typing.overload + def subSet( + self, e: _ConcurrentSkipListSet__E, e2: _ConcurrentSkipListSet__E + ) -> java.util.NavigableSet[_ConcurrentSkipListSet__E]: ... + @typing.overload + def tailSet( + self, e: _ConcurrentSkipListSet__E + ) -> java.util.NavigableSet[_ConcurrentSkipListSet__E]: ... + @typing.overload + def tailSet( + self, e: _ConcurrentSkipListSet__E, boolean: bool + ) -> java.util.NavigableSet[_ConcurrentSkipListSet__E]: ... + +_CopyOnWriteArrayList__E = typing.TypeVar("_CopyOnWriteArrayList__E") # + +class CopyOnWriteArrayList( + java.util.List[_CopyOnWriteArrayList__E], + java.util.RandomAccess, + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_CopyOnWriteArrayList__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, eArray: list[_CopyOnWriteArrayList__E] | jpype.JArray): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_CopyOnWriteArrayList__E] + | typing.Sequence[_CopyOnWriteArrayList__E] + | builtins.set[_CopyOnWriteArrayList__E], + ): ... + @typing.overload + def add(self, e: _CopyOnWriteArrayList__E) -> bool: ... + @typing.overload + def add(self, int: int, e: _CopyOnWriteArrayList__E) -> None: ... + @typing.overload + def addAll( + self, + int: int, + collection: java.util.Collection[_CopyOnWriteArrayList__E] + | typing.Sequence[_CopyOnWriteArrayList__E] + | builtins.set[_CopyOnWriteArrayList__E], + ) -> bool: ... + @typing.overload + def addAll( + self, + collection: java.util.Collection[_CopyOnWriteArrayList__E] + | typing.Sequence[_CopyOnWriteArrayList__E] + | builtins.set[_CopyOnWriteArrayList__E], + ) -> bool: ... + def addAllAbsent( + self, + collection: java.util.Collection[_CopyOnWriteArrayList__E] + | typing.Sequence[_CopyOnWriteArrayList__E] + | builtins.set[_CopyOnWriteArrayList__E], + ) -> int: ... + def addFirst(self, e: _CopyOnWriteArrayList__E) -> None: ... + def addIfAbsent(self, e: _CopyOnWriteArrayList__E) -> bool: ... + def addLast(self, e: _CopyOnWriteArrayList__E) -> None: ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def forEach( + self, + consumer: java.util.function.Consumer[_CopyOnWriteArrayList__E] + | typing.Callable[[_CopyOnWriteArrayList__E], None], + ) -> None: ... + def get(self, int: int) -> _CopyOnWriteArrayList__E: ... + def getFirst(self) -> _CopyOnWriteArrayList__E: ... + def getLast(self) -> _CopyOnWriteArrayList__E: ... + def hashCode(self) -> int: ... + @typing.overload + def indexOf(self, object: typing.Any) -> int: ... + @typing.overload + def indexOf(self, e: _CopyOnWriteArrayList__E, int: int) -> int: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> java.util.Iterator[_CopyOnWriteArrayList__E]: ... + @typing.overload + def lastIndexOf(self, object: typing.Any) -> int: ... + @typing.overload + def lastIndexOf(self, e: _CopyOnWriteArrayList__E, int: int) -> int: ... + @typing.overload + def listIterator(self) -> java.util.ListIterator[_CopyOnWriteArrayList__E]: ... + @typing.overload + def listIterator( + self, int: int + ) -> java.util.ListIterator[_CopyOnWriteArrayList__E]: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def removeFirst(self) -> _CopyOnWriteArrayList__E: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_CopyOnWriteArrayList__E] + | typing.Callable[[_CopyOnWriteArrayList__E], bool], + ) -> bool: ... + def removeLast(self) -> _CopyOnWriteArrayList__E: ... + def replaceAll( + self, + unaryOperator: java.util.function.UnaryOperator[_CopyOnWriteArrayList__E] + | typing.Callable, + ) -> None: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def reversed(self) -> java.util.List[_CopyOnWriteArrayList__E]: ... + def set( + self, int: int, e: _CopyOnWriteArrayList__E + ) -> _CopyOnWriteArrayList__E: ... + def size(self) -> int: ... + def sort( + self, + comparator: java.util.Comparator[_CopyOnWriteArrayList__E] + | typing.Callable[[_CopyOnWriteArrayList__E, _CopyOnWriteArrayList__E], int], + ) -> None: ... + def spliterator(self) -> java.util.Spliterator[_CopyOnWriteArrayList__E]: ... + def subList( + self, int: int, int2: int + ) -> java.util.List[_CopyOnWriteArrayList__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + +_CopyOnWriteArraySet__E = typing.TypeVar("_CopyOnWriteArraySet__E") # + +class CopyOnWriteArraySet( + java.util.AbstractSet[_CopyOnWriteArraySet__E], + java.io.Serializable, + typing.Generic[_CopyOnWriteArraySet__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_CopyOnWriteArraySet__E] + | typing.Sequence[_CopyOnWriteArraySet__E] + | set[_CopyOnWriteArraySet__E], + ): ... + def add(self, e: _CopyOnWriteArraySet__E) -> bool: ... + def addAll( + self, + collection: java.util.Collection[_CopyOnWriteArraySet__E] + | typing.Sequence[_CopyOnWriteArraySet__E] + | set[_CopyOnWriteArraySet__E], + ) -> bool: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def forEach( + self, + consumer: java.util.function.Consumer[_CopyOnWriteArraySet__E] + | typing.Callable[[_CopyOnWriteArraySet__E], None], + ) -> None: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> java.util.Iterator[_CopyOnWriteArraySet__E]: ... + def remove(self, object: typing.Any) -> bool: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_CopyOnWriteArraySet__E] + | typing.Callable[[_CopyOnWriteArraySet__E], bool], + ) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_CopyOnWriteArraySet__E]: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + +class CountDownLatch: + def __init__(self, int: int): ... + @typing.overload + def await_(self, long: int, timeUnit: TimeUnit) -> bool: ... + @typing.overload + def await_(self) -> None: ... + def countDown(self) -> None: ... + def getCount(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class CyclicBarrier: + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, runnable: java.lang.Runnable | typing.Callable): ... + @typing.overload + def await_(self) -> int: ... + @typing.overload + def await_(self, long: int, timeUnit: TimeUnit) -> int: ... + def getNumberWaiting(self) -> int: ... + def getParties(self) -> int: ... + def isBroken(self) -> bool: ... + def reset(self) -> None: ... + +class Delayed(java.lang.Comparable["Delayed"]): + def getDelay(self, timeUnit: TimeUnit) -> int: ... + +_Exchanger__V = typing.TypeVar("_Exchanger__V") # + +class Exchanger(typing.Generic[_Exchanger__V]): + def __init__(self): ... + @typing.overload + def exchange(self, v: _Exchanger__V) -> _Exchanger__V: ... + @typing.overload + def exchange( + self, v: _Exchanger__V, long: int, timeUnit: TimeUnit + ) -> _Exchanger__V: ... + +class ExecutionException(java.lang.Exception): + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class Executor: + def execute(self, runnable: java.lang.Runnable | typing.Callable) -> None: ... + +class Executors: + _callable_1__T = typing.TypeVar("_callable_1__T") # + @typing.overload + @staticmethod + def callable( + runnable: java.lang.Runnable | typing.Callable, + ) -> Callable[typing.Any]: ... + @typing.overload + @staticmethod + def callable( + runnable: java.lang.Runnable | typing.Callable, t: _callable_1__T + ) -> Callable[_callable_1__T]: ... + @typing.overload + @staticmethod + def callable( + privilegedAction: java.security.PrivilegedAction[typing.Any] + | typing.Callable[[], typing.Any], + ) -> Callable[typing.Any]: ... + @typing.overload + @staticmethod + def callable( + privilegedExceptionAction: java.security.PrivilegedExceptionAction[typing.Any] + | typing.Callable[[], typing.Any], + ) -> Callable[typing.Any]: ... + @staticmethod + def defaultThreadFactory() -> ThreadFactory: ... + @typing.overload + @staticmethod + def newCachedThreadPool() -> ExecutorService: ... + @typing.overload + @staticmethod + def newCachedThreadPool( + threadFactory: ThreadFactory | typing.Callable, + ) -> ExecutorService: ... + @typing.overload + @staticmethod + def newFixedThreadPool(int: int) -> ExecutorService: ... + @typing.overload + @staticmethod + def newFixedThreadPool( + int: int, threadFactory: ThreadFactory | typing.Callable + ) -> ExecutorService: ... + @typing.overload + @staticmethod + def newScheduledThreadPool(int: int) -> ScheduledExecutorService: ... + @typing.overload + @staticmethod + def newScheduledThreadPool( + int: int, threadFactory: ThreadFactory | typing.Callable + ) -> ScheduledExecutorService: ... + @typing.overload + @staticmethod + def newSingleThreadExecutor() -> ExecutorService: ... + @typing.overload + @staticmethod + def newSingleThreadExecutor( + threadFactory: ThreadFactory | typing.Callable, + ) -> ExecutorService: ... + @typing.overload + @staticmethod + def newSingleThreadScheduledExecutor() -> ScheduledExecutorService: ... + @typing.overload + @staticmethod + def newSingleThreadScheduledExecutor( + threadFactory: ThreadFactory | typing.Callable, + ) -> ScheduledExecutorService: ... + @staticmethod + def newThreadPerTaskExecutor( + threadFactory: ThreadFactory | typing.Callable, + ) -> ExecutorService: ... + @staticmethod + def newVirtualThreadPerTaskExecutor() -> ExecutorService: ... + @typing.overload + @staticmethod + def newWorkStealingPool() -> ExecutorService: ... + @typing.overload + @staticmethod + def newWorkStealingPool(int: int) -> ExecutorService: ... + _privilegedCallable__T = typing.TypeVar("_privilegedCallable__T") # + @staticmethod + def privilegedCallable( + callable: Callable[_privilegedCallable__T] + | typing.Callable[[], _privilegedCallable__T], + ) -> Callable[_privilegedCallable__T]: ... + _privilegedCallableUsingCurrentClassLoader__T = typing.TypeVar( + "_privilegedCallableUsingCurrentClassLoader__T" + ) # + @staticmethod + def privilegedCallableUsingCurrentClassLoader( + callable: Callable[_privilegedCallableUsingCurrentClassLoader__T] + | typing.Callable[[], _privilegedCallableUsingCurrentClassLoader__T], + ) -> Callable[_privilegedCallableUsingCurrentClassLoader__T]: ... + @staticmethod + def privilegedThreadFactory() -> ThreadFactory: ... + @staticmethod + def unconfigurableExecutorService( + executorService: ExecutorService, + ) -> ExecutorService: ... + @staticmethod + def unconfigurableScheduledExecutorService( + scheduledExecutorService: ScheduledExecutorService, + ) -> ScheduledExecutorService: ... + +class ForkJoinWorkerThread(java.lang.Thread): + def getPool(self) -> ForkJoinPool: ... + def getPoolIndex(self) -> int: ... + def getQueuedTaskCount(self) -> int: ... + def run(self) -> None: ... + +_Future__V = typing.TypeVar("_Future__V") # + +class Future(typing.Generic[_Future__V]): + def cancel(self, boolean: bool) -> bool: ... + def exceptionNow(self) -> java.lang.Throwable: ... + @typing.overload + def get(self) -> _Future__V: ... + @typing.overload + def get(self, long: int, timeUnit: TimeUnit) -> _Future__V: ... + def isCancelled(self) -> bool: ... + def isDone(self) -> bool: ... + def resultNow(self) -> _Future__V: ... + def state(self) -> Future.State: ... + class State(java.lang.Enum["Future.State"]): + RUNNING: typing.ClassVar[Future.State] = ... + SUCCESS: typing.ClassVar[Future.State] = ... + FAILED: typing.ClassVar[Future.State] = ... + CANCELLED: typing.ClassVar[Future.State] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Future.State: ... + @staticmethod + def values() -> typing.MutableSequence[Future.State]: ... + +class Phaser: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, phaser: Phaser): ... + @typing.overload + def __init__(self, phaser: Phaser, int: int): ... + def arrive(self) -> int: ... + def arriveAndAwaitAdvance(self) -> int: ... + def arriveAndDeregister(self) -> int: ... + def awaitAdvance(self, int: int) -> int: ... + @typing.overload + def awaitAdvanceInterruptibly(self, int: int) -> int: ... + @typing.overload + def awaitAdvanceInterruptibly( + self, int: int, long: int, timeUnit: TimeUnit + ) -> int: ... + def bulkRegister(self, int: int) -> int: ... + def forceTermination(self) -> None: ... + def getArrivedParties(self) -> int: ... + def getParent(self) -> Phaser: ... + def getPhase(self) -> int: ... + def getRegisteredParties(self) -> int: ... + def getRoot(self) -> Phaser: ... + def getUnarrivedParties(self) -> int: ... + def isTerminated(self) -> bool: ... + def register(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class RejectedExecutionException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class RejectedExecutionHandler: + def rejectedExecution( + self, + runnable: java.lang.Runnable | typing.Callable, + threadPoolExecutor: ThreadPoolExecutor, + ) -> None: ... + +class Semaphore(java.io.Serializable): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, boolean: bool): ... + @typing.overload + def acquire(self) -> None: ... + @typing.overload + def acquire(self, int: int) -> None: ... + @typing.overload + def acquireUninterruptibly(self) -> None: ... + @typing.overload + def acquireUninterruptibly(self, int: int) -> None: ... + def availablePermits(self) -> int: ... + def drainPermits(self) -> int: ... + def getQueueLength(self) -> int: ... + def hasQueuedThreads(self) -> bool: ... + def isFair(self) -> bool: ... + @typing.overload + def release(self) -> None: ... + @typing.overload + def release(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def tryAcquire(self) -> bool: ... + @typing.overload + def tryAcquire(self, int: int) -> bool: ... + @typing.overload + def tryAcquire(self, int: int, long: int, timeUnit: TimeUnit) -> bool: ... + @typing.overload + def tryAcquire(self, long: int, timeUnit: TimeUnit) -> bool: ... + +class StructureViolationException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +_StructuredTaskScope__Joiner__T = typing.TypeVar( + "_StructuredTaskScope__Joiner__T" +) # +_StructuredTaskScope__Joiner__R = typing.TypeVar( + "_StructuredTaskScope__Joiner__R" +) # +_StructuredTaskScope__Subtask__T = typing.TypeVar( + "_StructuredTaskScope__Subtask__T" +) # +_StructuredTaskScope__T = typing.TypeVar("_StructuredTaskScope__T") # +_StructuredTaskScope__R = typing.TypeVar("_StructuredTaskScope__R") # + +class StructuredTaskScope( + java.lang.AutoCloseable, + typing.Generic[_StructuredTaskScope__T, _StructuredTaskScope__R], +): + def close(self) -> None: ... + _fork_0__U = typing.TypeVar("_fork_0__U") # + _fork_1__U = typing.TypeVar("_fork_1__U") # + @typing.overload + def fork( + self, runnable: java.lang.Runnable | typing.Callable + ) -> StructuredTaskScope.Subtask[_fork_0__U]: ... + @typing.overload + def fork( + self, callable: Callable[_fork_1__U] | typing.Callable[[], _fork_1__U] + ) -> StructuredTaskScope.Subtask[_fork_1__U]: ... + def isCancelled(self) -> bool: ... + def join(self) -> _StructuredTaskScope__R: ... + _open_0__T = typing.TypeVar("_open_0__T") # + _open_1__T = typing.TypeVar("_open_1__T") # + _open_1__R = typing.TypeVar("_open_1__R") # + _open_2__T = typing.TypeVar("_open_2__T") # + _open_2__R = typing.TypeVar("_open_2__R") # + @typing.overload + @staticmethod + def open() -> StructuredTaskScope[_open_0__T, None]: ... + @typing.overload + @staticmethod + def open( + joiner: StructuredTaskScope.Joiner[_open_1__T, _open_1__R] + | typing.Callable[[], _open_1__R], + ) -> StructuredTaskScope[_open_1__T, _open_1__R]: ... + @typing.overload + @staticmethod + def open( + joiner: StructuredTaskScope.Joiner[_open_2__T, _open_2__R] + | typing.Callable[[], _open_2__R], + function: java.util.function.Function[ + StructuredTaskScope.Configuration, StructuredTaskScope.Configuration + ] + | typing.Callable[ + [StructuredTaskScope.Configuration], StructuredTaskScope.Configuration + ], + ) -> StructuredTaskScope[_open_2__T, _open_2__R]: ... + class Configuration: + def withName( + self, string: java.lang.String | str + ) -> StructuredTaskScope.Configuration: ... + def withThreadFactory( + self, threadFactory: ThreadFactory | typing.Callable + ) -> StructuredTaskScope.Configuration: ... + def withTimeout( + self, duration: java.time.Duration + ) -> StructuredTaskScope.Configuration: ... + + class FailedException(java.lang.RuntimeException): ... + + class Joiner( + typing.Generic[_StructuredTaskScope__Joiner__T, _StructuredTaskScope__Joiner__R] + ): + _allSuccessfulOrThrow__T = typing.TypeVar("_allSuccessfulOrThrow__T") # + @staticmethod + def allSuccessfulOrThrow() -> StructuredTaskScope.Joiner[ + _allSuccessfulOrThrow__T, + java.util.stream.Stream[ + StructuredTaskScope.Subtask[_allSuccessfulOrThrow__T] + ], + ]: ... + _allUntil__T = typing.TypeVar("_allUntil__T") # + @staticmethod + def allUntil( + predicate: java.util.function.Predicate[ + StructuredTaskScope.Subtask[_allUntil__T] + ] + | typing.Callable[[StructuredTaskScope.Subtask[_allUntil__T]], bool], + ) -> StructuredTaskScope.Joiner[ + _allUntil__T, + java.util.stream.Stream[StructuredTaskScope.Subtask[_allUntil__T]], + ]: ... + _anySuccessfulResultOrThrow__T = typing.TypeVar( + "_anySuccessfulResultOrThrow__T" + ) # + @staticmethod + def anySuccessfulResultOrThrow() -> StructuredTaskScope.Joiner[ + _anySuccessfulResultOrThrow__T, _anySuccessfulResultOrThrow__T + ]: ... + _awaitAll__T = typing.TypeVar("_awaitAll__T") # + @staticmethod + def awaitAll() -> StructuredTaskScope.Joiner[_awaitAll__T, None]: ... + _awaitAllSuccessfulOrThrow__T = typing.TypeVar( + "_awaitAllSuccessfulOrThrow__T" + ) # + @staticmethod + def awaitAllSuccessfulOrThrow() -> StructuredTaskScope.Joiner[ + _awaitAllSuccessfulOrThrow__T, None + ]: ... + def onComplete( + self, subtask: StructuredTaskScope.Subtask[_StructuredTaskScope__Joiner__T] + ) -> bool: ... + def onFork( + self, subtask: StructuredTaskScope.Subtask[_StructuredTaskScope__Joiner__T] + ) -> bool: ... + def result(self) -> _StructuredTaskScope__Joiner__R: ... + + class Subtask( + java.util.function.Supplier[_StructuredTaskScope__Subtask__T], + typing.Generic[_StructuredTaskScope__Subtask__T], + ): + def exception(self) -> java.lang.Throwable: ... + def get(self) -> _StructuredTaskScope__Subtask__T: ... + def state(self) -> StructuredTaskScope.Subtask.State: ... + class State(java.lang.Enum["StructuredTaskScope.Subtask.State"]): + UNAVAILABLE: typing.ClassVar[StructuredTaskScope.Subtask.State] = ... + SUCCESS: typing.ClassVar[StructuredTaskScope.Subtask.State] = ... + FAILED: typing.ClassVar[StructuredTaskScope.Subtask.State] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf( + string: java.lang.String | str, + ) -> StructuredTaskScope.Subtask.State: ... + @staticmethod + def values() -> typing.MutableSequence[ + StructuredTaskScope.Subtask.State + ]: ... + + class TimeoutException(java.lang.RuntimeException): ... + +class ThreadFactory: + def newThread( + self, runnable: java.lang.Runnable | typing.Callable + ) -> java.lang.Thread: ... + +class ThreadLocalRandom(java.util.Random): + @staticmethod + def current() -> ThreadLocalRandom: ... + @typing.overload + def doubles(self) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles( + self, double: float, double2: float + ) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles(self, long: int) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles( + self, long: int, double: float, double2: float + ) -> java.util.stream.DoubleStream: ... + @typing.overload + def ints(self) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, int: int, int2: int) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, long: int) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, long: int, int: int, int2: int) -> java.util.stream.IntStream: ... + @typing.overload + def longs(self) -> java.util.stream.LongStream: ... + @typing.overload + def longs(self, long: int) -> java.util.stream.LongStream: ... + @typing.overload + def longs(self, long: int, long2: int) -> java.util.stream.LongStream: ... + @typing.overload + def longs( + self, long: int, long2: int, long3: int + ) -> java.util.stream.LongStream: ... + def nextBoolean(self) -> bool: ... + @typing.overload + def nextDouble(self) -> float: ... + @typing.overload + def nextDouble(self, double: float) -> float: ... + @typing.overload + def nextDouble(self, double: float, double2: float) -> float: ... + @typing.overload + def nextFloat(self) -> float: ... + @typing.overload + def nextFloat(self, float: float) -> float: ... + @typing.overload + def nextFloat(self, float: float, float2: float) -> float: ... + @typing.overload + def nextInt(self) -> int: ... + @typing.overload + def nextInt(self, int: int) -> int: ... + @typing.overload + def nextInt(self, int: int, int2: int) -> int: ... + @typing.overload + def nextLong(self) -> int: ... + @typing.overload + def nextLong(self, long: int) -> int: ... + @typing.overload + def nextLong(self, long: int, long2: int) -> int: ... + def setSeed(self, long: int) -> None: ... + +class TimeUnit(java.lang.Enum["TimeUnit"]): + NANOSECONDS: typing.ClassVar[TimeUnit] = ... + MICROSECONDS: typing.ClassVar[TimeUnit] = ... + MILLISECONDS: typing.ClassVar[TimeUnit] = ... + SECONDS: typing.ClassVar[TimeUnit] = ... + MINUTES: typing.ClassVar[TimeUnit] = ... + HOURS: typing.ClassVar[TimeUnit] = ... + DAYS: typing.ClassVar[TimeUnit] = ... + @typing.overload + def convert(self, duration: java.time.Duration) -> int: ... + @typing.overload + def convert(self, long: int, timeUnit: TimeUnit) -> int: ... + @staticmethod + def of(chronoUnit: java.time.temporal.ChronoUnit) -> TimeUnit: ... + def sleep(self, long: int) -> None: ... + def timedJoin(self, thread: java.lang.Thread, long: int) -> None: ... + def timedWait(self, object: typing.Any, long: int) -> None: ... + def toChronoUnit(self) -> java.time.temporal.ChronoUnit: ... + def toDays(self, long: int) -> int: ... + def toHours(self, long: int) -> int: ... + def toMicros(self, long: int) -> int: ... + def toMillis(self, long: int) -> int: ... + def toMinutes(self, long: int) -> int: ... + def toNanos(self, long: int) -> int: ... + def toSeconds(self, long: int) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> TimeUnit: ... + @staticmethod + def values() -> typing.MutableSequence[TimeUnit]: ... + +class TimeoutException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +_ArrayBlockingQueue__E = typing.TypeVar("_ArrayBlockingQueue__E") # + +class ArrayBlockingQueue( + java.util.AbstractQueue[_ArrayBlockingQueue__E], + BlockingQueue[_ArrayBlockingQueue__E], + java.io.Serializable, + typing.Generic[_ArrayBlockingQueue__E], +): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, boolean: bool): ... + @typing.overload + def __init__( + self, + int: int, + boolean: bool, + collection: java.util.Collection[_ArrayBlockingQueue__E] + | typing.Sequence[_ArrayBlockingQueue__E] + | set[_ArrayBlockingQueue__E], + ): ... + def add(self, e: _ArrayBlockingQueue__E) -> bool: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_ArrayBlockingQueue__E] + | typing.Sequence[_ArrayBlockingQueue__E] + | set[_ArrayBlockingQueue__E], + ) -> int: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_ArrayBlockingQueue__E] + | typing.Sequence[_ArrayBlockingQueue__E] + | set[_ArrayBlockingQueue__E], + int: int, + ) -> int: ... + def forEach( + self, + consumer: java.util.function.Consumer[_ArrayBlockingQueue__E] + | typing.Callable[[_ArrayBlockingQueue__E], None], + ) -> None: ... + def iterator(self) -> java.util.Iterator[_ArrayBlockingQueue__E]: ... + @typing.overload + def offer(self, e: _ArrayBlockingQueue__E) -> bool: ... + @typing.overload + def offer( + self, e: _ArrayBlockingQueue__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + def peek(self) -> _ArrayBlockingQueue__E: ... + @typing.overload + def poll(self) -> _ArrayBlockingQueue__E: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> _ArrayBlockingQueue__E: ... + def put(self, e: _ArrayBlockingQueue__E) -> None: ... + def remainingCapacity(self) -> int: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _ArrayBlockingQueue__E: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_ArrayBlockingQueue__E] + | typing.Callable[[_ArrayBlockingQueue__E], bool], + ) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_ArrayBlockingQueue__E]: ... + def take(self) -> _ArrayBlockingQueue__E: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + +_BlockingDeque__E = typing.TypeVar("_BlockingDeque__E") # + +class BlockingDeque( + BlockingQueue[_BlockingDeque__E], + java.util.Deque[_BlockingDeque__E], + typing.Generic[_BlockingDeque__E], +): + def add(self, e: _BlockingDeque__E) -> bool: ... + def addFirst(self, e: _BlockingDeque__E) -> None: ... + def addLast(self, e: _BlockingDeque__E) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def element(self) -> _BlockingDeque__E: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def iterator(self) -> java.util.Iterator[_BlockingDeque__E]: ... + @typing.overload + def offer(self, e: _BlockingDeque__E) -> bool: ... + @typing.overload + def offer(self, e: _BlockingDeque__E, long: int, timeUnit: TimeUnit) -> bool: ... + @typing.overload + def offerFirst(self, e: _BlockingDeque__E) -> bool: ... + @typing.overload + def offerFirst( + self, e: _BlockingDeque__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + @typing.overload + def offerLast(self, e: _BlockingDeque__E) -> bool: ... + @typing.overload + def offerLast( + self, e: _BlockingDeque__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + def peek(self) -> _BlockingDeque__E: ... + @typing.overload + def poll(self) -> _BlockingDeque__E: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> _BlockingDeque__E: ... + @typing.overload + def pollFirst(self) -> _BlockingDeque__E: ... + @typing.overload + def pollFirst(self, long: int, timeUnit: TimeUnit) -> _BlockingDeque__E: ... + @typing.overload + def pollLast(self) -> _BlockingDeque__E: ... + @typing.overload + def pollLast(self, long: int, timeUnit: TimeUnit) -> _BlockingDeque__E: ... + def push(self, e: _BlockingDeque__E) -> None: ... + def put(self, e: _BlockingDeque__E) -> None: ... + def putFirst(self, e: _BlockingDeque__E) -> None: ... + def putLast(self, e: _BlockingDeque__E) -> None: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _BlockingDeque__E: ... + def removeFirstOccurrence(self, object: typing.Any) -> bool: ... + def removeLastOccurrence(self, object: typing.Any) -> bool: ... + def size(self) -> int: ... + def take(self) -> _BlockingDeque__E: ... + def takeFirst(self) -> _BlockingDeque__E: ... + def takeLast(self) -> _BlockingDeque__E: ... + +_CompletableFuture__T = typing.TypeVar("_CompletableFuture__T") # + +class CompletableFuture( + Future[_CompletableFuture__T], + CompletionStage[_CompletableFuture__T], + typing.Generic[_CompletableFuture__T], +): + def __init__(self): ... + def acceptEither( + self, + completionStage: CompletionStage[_CompletableFuture__T], + consumer: java.util.function.Consumer[_CompletableFuture__T] + | typing.Callable[[_CompletableFuture__T], None], + ) -> CompletableFuture[None]: ... + @typing.overload + def acceptEitherAsync( + self, + completionStage: CompletionStage[_CompletableFuture__T], + consumer: java.util.function.Consumer[_CompletableFuture__T] + | typing.Callable[[_CompletableFuture__T], None], + ) -> CompletableFuture[None]: ... + @typing.overload + def acceptEitherAsync( + self, + completionStage: CompletionStage[_CompletableFuture__T], + consumer: java.util.function.Consumer[_CompletableFuture__T] + | typing.Callable[[_CompletableFuture__T], None], + executor: Executor | typing.Callable, + ) -> CompletableFuture[None]: ... + @staticmethod + def allOf( + *completableFuture: CompletableFuture[typing.Any], + ) -> CompletableFuture[None]: ... + @staticmethod + def anyOf( + *completableFuture: CompletableFuture[typing.Any], + ) -> CompletableFuture[typing.Any]: ... + _applyToEither__U = typing.TypeVar("_applyToEither__U") # + def applyToEither( + self, + completionStage: CompletionStage[_CompletableFuture__T], + function: java.util.function.Function[_CompletableFuture__T, _applyToEither__U] + | typing.Callable[[_CompletableFuture__T], _applyToEither__U], + ) -> CompletableFuture[_applyToEither__U]: ... + _applyToEitherAsync_0__U = typing.TypeVar("_applyToEitherAsync_0__U") # + _applyToEitherAsync_1__U = typing.TypeVar("_applyToEitherAsync_1__U") # + @typing.overload + def applyToEitherAsync( + self, + completionStage: CompletionStage[_CompletableFuture__T], + function: java.util.function.Function[ + _CompletableFuture__T, _applyToEitherAsync_0__U + ] + | typing.Callable[[_CompletableFuture__T], _applyToEitherAsync_0__U], + ) -> CompletableFuture[_applyToEitherAsync_0__U]: ... + @typing.overload + def applyToEitherAsync( + self, + completionStage: CompletionStage[_CompletableFuture__T], + function: java.util.function.Function[ + _CompletableFuture__T, _applyToEitherAsync_1__U + ] + | typing.Callable[[_CompletableFuture__T], _applyToEitherAsync_1__U], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_applyToEitherAsync_1__U]: ... + def cancel(self, boolean: bool) -> bool: ... + def complete(self, t: _CompletableFuture__T) -> bool: ... + @typing.overload + def completeAsync( + self, + supplier: java.util.function.Supplier[_CompletableFuture__T] + | typing.Callable[[], _CompletableFuture__T], + ) -> CompletableFuture[_CompletableFuture__T]: ... + @typing.overload + def completeAsync( + self, + supplier: java.util.function.Supplier[_CompletableFuture__T] + | typing.Callable[[], _CompletableFuture__T], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_CompletableFuture__T]: ... + def completeExceptionally(self, throwable: java.lang.Throwable) -> bool: ... + def completeOnTimeout( + self, t: _CompletableFuture__T, long: int, timeUnit: TimeUnit + ) -> CompletableFuture[_CompletableFuture__T]: ... + _completedFuture__U = typing.TypeVar("_completedFuture__U") # + @staticmethod + def completedFuture( + u: _completedFuture__U, + ) -> CompletableFuture[_completedFuture__U]: ... + _completedStage__U = typing.TypeVar("_completedStage__U") # + @staticmethod + def completedStage( + u: _completedStage__U, + ) -> CompletionStage[_completedStage__U]: ... + def copy(self) -> CompletableFuture[_CompletableFuture__T]: ... + def defaultExecutor(self) -> Executor: ... + @typing.overload + @staticmethod + def delayedExecutor(long: int, timeUnit: TimeUnit) -> Executor: ... + @typing.overload + @staticmethod + def delayedExecutor( + long: int, timeUnit: TimeUnit, executor: Executor | typing.Callable + ) -> Executor: ... + def exceptionNow(self) -> java.lang.Throwable: ... + def exceptionally( + self, + function: java.util.function.Function[ + java.lang.Throwable, _CompletableFuture__T + ] + | typing.Callable[[java.lang.Throwable], _CompletableFuture__T], + ) -> CompletableFuture[_CompletableFuture__T]: ... + @typing.overload + def exceptionallyAsync( + self, + function: java.util.function.Function[ + java.lang.Throwable, _CompletableFuture__T + ] + | typing.Callable[[java.lang.Throwable], _CompletableFuture__T], + ) -> CompletableFuture[_CompletableFuture__T]: ... + @typing.overload + def exceptionallyAsync( + self, + function: java.util.function.Function[ + java.lang.Throwable, _CompletableFuture__T + ] + | typing.Callable[[java.lang.Throwable], _CompletableFuture__T], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_CompletableFuture__T]: ... + def exceptionallyCompose( + self, + function: java.util.function.Function[ + java.lang.Throwable, CompletionStage[_CompletableFuture__T] + ] + | typing.Callable[ + [java.lang.Throwable], CompletionStage[_CompletableFuture__T] + ], + ) -> CompletableFuture[_CompletableFuture__T]: ... + @typing.overload + def exceptionallyComposeAsync( + self, + function: java.util.function.Function[ + java.lang.Throwable, CompletionStage[_CompletableFuture__T] + ] + | typing.Callable[ + [java.lang.Throwable], CompletionStage[_CompletableFuture__T] + ], + ) -> CompletableFuture[_CompletableFuture__T]: ... + @typing.overload + def exceptionallyComposeAsync( + self, + function: java.util.function.Function[ + java.lang.Throwable, CompletionStage[_CompletableFuture__T] + ] + | typing.Callable[ + [java.lang.Throwable], CompletionStage[_CompletableFuture__T] + ], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_CompletableFuture__T]: ... + _failedFuture__U = typing.TypeVar("_failedFuture__U") # + @staticmethod + def failedFuture( + throwable: java.lang.Throwable, + ) -> CompletableFuture[_failedFuture__U]: ... + _failedStage__U = typing.TypeVar("_failedStage__U") # + @staticmethod + def failedStage( + throwable: java.lang.Throwable, + ) -> CompletionStage[_failedStage__U]: ... + @typing.overload + def get(self) -> _CompletableFuture__T: ... + @typing.overload + def get(self, long: int, timeUnit: TimeUnit) -> _CompletableFuture__T: ... + def getNow(self, t: _CompletableFuture__T) -> _CompletableFuture__T: ... + def getNumberOfDependents(self) -> int: ... + _handle__U = typing.TypeVar("_handle__U") # + def handle( + self, + biFunction: java.util.function.BiFunction[ + _CompletableFuture__T, java.lang.Throwable, _handle__U + ] + | typing.Callable[[_CompletableFuture__T, java.lang.Throwable], _handle__U], + ) -> CompletableFuture[_handle__U]: ... + _handleAsync_0__U = typing.TypeVar("_handleAsync_0__U") # + _handleAsync_1__U = typing.TypeVar("_handleAsync_1__U") # + @typing.overload + def handleAsync( + self, + biFunction: java.util.function.BiFunction[ + _CompletableFuture__T, java.lang.Throwable, _handleAsync_0__U + ] + | typing.Callable[ + [_CompletableFuture__T, java.lang.Throwable], _handleAsync_0__U + ], + ) -> CompletableFuture[_handleAsync_0__U]: ... + @typing.overload + def handleAsync( + self, + biFunction: java.util.function.BiFunction[ + _CompletableFuture__T, java.lang.Throwable, _handleAsync_1__U + ] + | typing.Callable[ + [_CompletableFuture__T, java.lang.Throwable], _handleAsync_1__U + ], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_handleAsync_1__U]: ... + def isCancelled(self) -> bool: ... + def isCompletedExceptionally(self) -> bool: ... + def isDone(self) -> bool: ... + def join(self) -> _CompletableFuture__T: ... + def minimalCompletionStage(self) -> CompletionStage[_CompletableFuture__T]: ... + _newIncompleteFuture__U = typing.TypeVar("_newIncompleteFuture__U") # + def newIncompleteFuture(self) -> CompletableFuture[_newIncompleteFuture__U]: ... + def obtrudeException(self, throwable: java.lang.Throwable) -> None: ... + def obtrudeValue(self, t: _CompletableFuture__T) -> None: ... + def orTimeout( + self, long: int, timeUnit: TimeUnit + ) -> CompletableFuture[_CompletableFuture__T]: ... + def resultNow(self) -> _CompletableFuture__T: ... + def runAfterBoth( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + ) -> CompletableFuture[None]: ... + @typing.overload + def runAfterBothAsync( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + ) -> CompletableFuture[None]: ... + @typing.overload + def runAfterBothAsync( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + executor: Executor | typing.Callable, + ) -> CompletableFuture[None]: ... + def runAfterEither( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + ) -> CompletableFuture[None]: ... + @typing.overload + def runAfterEitherAsync( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + ) -> CompletableFuture[None]: ... + @typing.overload + def runAfterEitherAsync( + self, + completionStage: CompletionStage[typing.Any], + runnable: java.lang.Runnable | typing.Callable, + executor: Executor | typing.Callable, + ) -> CompletableFuture[None]: ... + @typing.overload + @staticmethod + def runAsync( + runnable: java.lang.Runnable | typing.Callable, + ) -> CompletableFuture[None]: ... + @typing.overload + @staticmethod + def runAsync( + runnable: java.lang.Runnable | typing.Callable, + executor: Executor | typing.Callable, + ) -> CompletableFuture[None]: ... + def state(self) -> Future.State: ... + _supplyAsync_0__U = typing.TypeVar("_supplyAsync_0__U") # + _supplyAsync_1__U = typing.TypeVar("_supplyAsync_1__U") # + @typing.overload + @staticmethod + def supplyAsync( + supplier: java.util.function.Supplier[_supplyAsync_0__U] + | typing.Callable[[], _supplyAsync_0__U], + ) -> CompletableFuture[_supplyAsync_0__U]: ... + @typing.overload + @staticmethod + def supplyAsync( + supplier: java.util.function.Supplier[_supplyAsync_1__U] + | typing.Callable[[], _supplyAsync_1__U], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_supplyAsync_1__U]: ... + def thenAccept( + self, + consumer: java.util.function.Consumer[_CompletableFuture__T] + | typing.Callable[[_CompletableFuture__T], None], + ) -> CompletableFuture[None]: ... + @typing.overload + def thenAcceptAsync( + self, + consumer: java.util.function.Consumer[_CompletableFuture__T] + | typing.Callable[[_CompletableFuture__T], None], + ) -> CompletableFuture[None]: ... + @typing.overload + def thenAcceptAsync( + self, + consumer: java.util.function.Consumer[_CompletableFuture__T] + | typing.Callable[[_CompletableFuture__T], None], + executor: Executor | typing.Callable, + ) -> CompletableFuture[None]: ... + _thenAcceptBoth__U = typing.TypeVar("_thenAcceptBoth__U") # + def thenAcceptBoth( + self, + completionStage: CompletionStage[_thenAcceptBoth__U], + biConsumer: java.util.function.BiConsumer[ + _CompletableFuture__T, _thenAcceptBoth__U + ] + | typing.Callable[[_CompletableFuture__T, _thenAcceptBoth__U], None], + ) -> CompletableFuture[None]: ... + _thenAcceptBothAsync_0__U = typing.TypeVar("_thenAcceptBothAsync_0__U") # + _thenAcceptBothAsync_1__U = typing.TypeVar("_thenAcceptBothAsync_1__U") # + @typing.overload + def thenAcceptBothAsync( + self, + completionStage: CompletionStage[_thenAcceptBothAsync_0__U], + biConsumer: java.util.function.BiConsumer[ + _CompletableFuture__T, _thenAcceptBothAsync_0__U + ] + | typing.Callable[[_CompletableFuture__T, _thenAcceptBothAsync_0__U], None], + ) -> CompletableFuture[None]: ... + @typing.overload + def thenAcceptBothAsync( + self, + completionStage: CompletionStage[_thenAcceptBothAsync_1__U], + biConsumer: java.util.function.BiConsumer[ + _CompletableFuture__T, _thenAcceptBothAsync_1__U + ] + | typing.Callable[[_CompletableFuture__T, _thenAcceptBothAsync_1__U], None], + executor: Executor | typing.Callable, + ) -> CompletableFuture[None]: ... + _thenApply__U = typing.TypeVar("_thenApply__U") # + def thenApply( + self, + function: java.util.function.Function[_CompletableFuture__T, _thenApply__U] + | typing.Callable[[_CompletableFuture__T], _thenApply__U], + ) -> CompletableFuture[_thenApply__U]: ... + _thenApplyAsync_0__U = typing.TypeVar("_thenApplyAsync_0__U") # + _thenApplyAsync_1__U = typing.TypeVar("_thenApplyAsync_1__U") # + @typing.overload + def thenApplyAsync( + self, + function: java.util.function.Function[ + _CompletableFuture__T, _thenApplyAsync_0__U + ] + | typing.Callable[[_CompletableFuture__T], _thenApplyAsync_0__U], + ) -> CompletableFuture[_thenApplyAsync_0__U]: ... + @typing.overload + def thenApplyAsync( + self, + function: java.util.function.Function[ + _CompletableFuture__T, _thenApplyAsync_1__U + ] + | typing.Callable[[_CompletableFuture__T], _thenApplyAsync_1__U], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_thenApplyAsync_1__U]: ... + _thenCombine__U = typing.TypeVar("_thenCombine__U") # + _thenCombine__V = typing.TypeVar("_thenCombine__V") # + def thenCombine( + self, + completionStage: CompletionStage[_thenCombine__U], + biFunction: java.util.function.BiFunction[ + _CompletableFuture__T, _thenCombine__U, _thenCombine__V + ] + | typing.Callable[[_CompletableFuture__T, _thenCombine__U], _thenCombine__V], + ) -> CompletableFuture[_thenCombine__V]: ... + _thenCombineAsync_0__U = typing.TypeVar("_thenCombineAsync_0__U") # + _thenCombineAsync_0__V = typing.TypeVar("_thenCombineAsync_0__V") # + _thenCombineAsync_1__U = typing.TypeVar("_thenCombineAsync_1__U") # + _thenCombineAsync_1__V = typing.TypeVar("_thenCombineAsync_1__V") # + @typing.overload + def thenCombineAsync( + self, + completionStage: CompletionStage[_thenCombineAsync_0__U], + biFunction: java.util.function.BiFunction[ + _CompletableFuture__T, _thenCombineAsync_0__U, _thenCombineAsync_0__V + ] + | typing.Callable[ + [_CompletableFuture__T, _thenCombineAsync_0__U], _thenCombineAsync_0__V + ], + ) -> CompletableFuture[_thenCombineAsync_0__V]: ... + @typing.overload + def thenCombineAsync( + self, + completionStage: CompletionStage[_thenCombineAsync_1__U], + biFunction: java.util.function.BiFunction[ + _CompletableFuture__T, _thenCombineAsync_1__U, _thenCombineAsync_1__V + ] + | typing.Callable[ + [_CompletableFuture__T, _thenCombineAsync_1__U], _thenCombineAsync_1__V + ], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_thenCombineAsync_1__V]: ... + _thenCompose__U = typing.TypeVar("_thenCompose__U") # + def thenCompose( + self, + function: java.util.function.Function[ + _CompletableFuture__T, CompletionStage[_thenCompose__U] + ] + | typing.Callable[[_CompletableFuture__T], CompletionStage[_thenCompose__U]], + ) -> CompletableFuture[_thenCompose__U]: ... + _thenComposeAsync_0__U = typing.TypeVar("_thenComposeAsync_0__U") # + _thenComposeAsync_1__U = typing.TypeVar("_thenComposeAsync_1__U") # + @typing.overload + def thenComposeAsync( + self, + function: java.util.function.Function[ + _CompletableFuture__T, CompletionStage[_thenComposeAsync_0__U] + ] + | typing.Callable[ + [_CompletableFuture__T], CompletionStage[_thenComposeAsync_0__U] + ], + ) -> CompletableFuture[_thenComposeAsync_0__U]: ... + @typing.overload + def thenComposeAsync( + self, + function: java.util.function.Function[ + _CompletableFuture__T, CompletionStage[_thenComposeAsync_1__U] + ] + | typing.Callable[ + [_CompletableFuture__T], CompletionStage[_thenComposeAsync_1__U] + ], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_thenComposeAsync_1__U]: ... + def thenRun( + self, runnable: java.lang.Runnable | typing.Callable + ) -> CompletableFuture[None]: ... + @typing.overload + def thenRunAsync( + self, runnable: java.lang.Runnable | typing.Callable + ) -> CompletableFuture[None]: ... + @typing.overload + def thenRunAsync( + self, + runnable: java.lang.Runnable | typing.Callable, + executor: Executor | typing.Callable, + ) -> CompletableFuture[None]: ... + def toCompletableFuture(self) -> CompletableFuture[_CompletableFuture__T]: ... + def toString(self) -> java.lang.String: ... + def whenComplete( + self, + biConsumer: java.util.function.BiConsumer[ + _CompletableFuture__T, java.lang.Throwable + ] + | typing.Callable[[_CompletableFuture__T, java.lang.Throwable], None], + ) -> CompletableFuture[_CompletableFuture__T]: ... + @typing.overload + def whenCompleteAsync( + self, + biConsumer: java.util.function.BiConsumer[ + _CompletableFuture__T, java.lang.Throwable + ] + | typing.Callable[[_CompletableFuture__T, java.lang.Throwable], None], + ) -> CompletableFuture[_CompletableFuture__T]: ... + @typing.overload + def whenCompleteAsync( + self, + biConsumer: java.util.function.BiConsumer[ + _CompletableFuture__T, java.lang.Throwable + ] + | typing.Callable[[_CompletableFuture__T, java.lang.Throwable], None], + executor: Executor | typing.Callable, + ) -> CompletableFuture[_CompletableFuture__T]: ... + class AsynchronousCompletionTask: ... + +_ConcurrentNavigableMap__K = typing.TypeVar("_ConcurrentNavigableMap__K") # +_ConcurrentNavigableMap__V = typing.TypeVar("_ConcurrentNavigableMap__V") # + +class ConcurrentNavigableMap( + ConcurrentMap[_ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V], + java.util.NavigableMap[_ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V], + typing.Generic[_ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V], +): + def descendingKeySet( + self, + ) -> java.util.NavigableSet[_ConcurrentNavigableMap__K]: ... + def descendingMap( + self, + ) -> ConcurrentNavigableMap[ + _ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V + ]: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + @typing.overload + def headMap( + self, k: _ConcurrentNavigableMap__K + ) -> ConcurrentNavigableMap[ + _ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V + ]: ... + @typing.overload + def headMap( + self, k: _ConcurrentNavigableMap__K, boolean: bool + ) -> ConcurrentNavigableMap[ + _ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V + ]: ... + def keySet(self) -> java.util.NavigableSet[_ConcurrentNavigableMap__K]: ... + def navigableKeySet(self) -> java.util.NavigableSet[_ConcurrentNavigableMap__K]: ... + @typing.overload + def subMap( + self, + k: _ConcurrentNavigableMap__K, + boolean: bool, + k2: _ConcurrentNavigableMap__K, + boolean2: bool, + ) -> ConcurrentNavigableMap[ + _ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V + ]: ... + @typing.overload + def subMap( + self, k: _ConcurrentNavigableMap__K, k2: _ConcurrentNavigableMap__K + ) -> ConcurrentNavigableMap[ + _ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V + ]: ... + @typing.overload + def tailMap( + self, k: _ConcurrentNavigableMap__K + ) -> ConcurrentNavigableMap[ + _ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V + ]: ... + @typing.overload + def tailMap( + self, k: _ConcurrentNavigableMap__K, boolean: bool + ) -> ConcurrentNavigableMap[ + _ConcurrentNavigableMap__K, _ConcurrentNavigableMap__V + ]: ... + +_DelayQueue__E = typing.TypeVar("_DelayQueue__E", bound=Delayed) # + +class DelayQueue( + java.util.AbstractQueue[_DelayQueue__E], + BlockingQueue[_DelayQueue__E], + typing.Generic[_DelayQueue__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_DelayQueue__E] + | typing.Sequence[_DelayQueue__E] + | set[_DelayQueue__E], + ): ... + def add(self, e: _DelayQueue__E) -> bool: ... + def clear(self) -> None: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_DelayQueue__E] + | typing.Sequence[_DelayQueue__E] + | set[_DelayQueue__E], + ) -> int: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_DelayQueue__E] + | typing.Sequence[_DelayQueue__E] + | set[_DelayQueue__E], + int: int, + ) -> int: ... + def iterator(self) -> java.util.Iterator[_DelayQueue__E]: ... + @typing.overload + def offer(self, e: _DelayQueue__E) -> bool: ... + @typing.overload + def offer(self, e: _DelayQueue__E, long: int, timeUnit: TimeUnit) -> bool: ... + def peek(self) -> _DelayQueue__E: ... + @typing.overload + def poll(self) -> _DelayQueue__E: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> _DelayQueue__E: ... + def put(self, e: _DelayQueue__E) -> None: ... + def remainingCapacity(self) -> int: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _DelayQueue__E: ... + def size(self) -> int: ... + def take(self) -> _DelayQueue__E: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + +_ExecutorCompletionService__V = typing.TypeVar("_ExecutorCompletionService__V") # + +class ExecutorCompletionService( + CompletionService[_ExecutorCompletionService__V], + typing.Generic[_ExecutorCompletionService__V], +): + @typing.overload + def __init__(self, executor: Executor | typing.Callable): ... + @typing.overload + def __init__( + self, + executor: Executor | typing.Callable, + blockingQueue: BlockingQueue[Future[_ExecutorCompletionService__V]], + ): ... + @typing.overload + def poll(self) -> Future[_ExecutorCompletionService__V]: ... + @typing.overload + def poll( + self, long: int, timeUnit: TimeUnit + ) -> Future[_ExecutorCompletionService__V]: ... + @typing.overload + def submit( + self, + runnable: java.lang.Runnable | typing.Callable, + v: _ExecutorCompletionService__V, + ) -> Future[_ExecutorCompletionService__V]: ... + @typing.overload + def submit( + self, + callable: Callable[_ExecutorCompletionService__V] + | typing.Callable[[], _ExecutorCompletionService__V], + ) -> Future[_ExecutorCompletionService__V]: ... + def take(self) -> Future[_ExecutorCompletionService__V]: ... + +class ExecutorService(Executor, java.lang.AutoCloseable): + def awaitTermination(self, long: int, timeUnit: TimeUnit) -> bool: ... + def close(self) -> None: ... + _invokeAll_0__T = typing.TypeVar("_invokeAll_0__T") # + _invokeAll_1__T = typing.TypeVar("_invokeAll_1__T") # + @typing.overload + def invokeAll( + self, + collection: java.util.Collection[Callable[_invokeAll_0__T]] + | typing.Sequence[Callable[_invokeAll_0__T]] + | set[Callable[_invokeAll_0__T]], + ) -> java.util.List[Future[_invokeAll_0__T]]: ... + @typing.overload + def invokeAll( + self, + collection: java.util.Collection[Callable[_invokeAll_1__T]] + | typing.Sequence[Callable[_invokeAll_1__T]] + | set[Callable[_invokeAll_1__T]], + long: int, + timeUnit: TimeUnit, + ) -> java.util.List[Future[_invokeAll_1__T]]: ... + _invokeAny_0__T = typing.TypeVar("_invokeAny_0__T") # + _invokeAny_1__T = typing.TypeVar("_invokeAny_1__T") # + @typing.overload + def invokeAny( + self, + collection: java.util.Collection[Callable[_invokeAny_0__T]] + | typing.Sequence[Callable[_invokeAny_0__T]] + | set[Callable[_invokeAny_0__T]], + ) -> _invokeAny_0__T: ... + @typing.overload + def invokeAny( + self, + collection: java.util.Collection[Callable[_invokeAny_1__T]] + | typing.Sequence[Callable[_invokeAny_1__T]] + | set[Callable[_invokeAny_1__T]], + long: int, + timeUnit: TimeUnit, + ) -> _invokeAny_1__T: ... + def isShutdown(self) -> bool: ... + def isTerminated(self) -> bool: ... + def shutdown(self) -> None: ... + def shutdownNow(self) -> java.util.List[java.lang.Runnable]: ... + _submit_1__T = typing.TypeVar("_submit_1__T") # + _submit_2__T = typing.TypeVar("_submit_2__T") # + @typing.overload + def submit( + self, runnable: java.lang.Runnable | typing.Callable + ) -> Future[typing.Any]: ... + @typing.overload + def submit( + self, runnable: java.lang.Runnable | typing.Callable, t: _submit_1__T + ) -> Future[_submit_1__T]: ... + @typing.overload + def submit( + self, callable: Callable[_submit_2__T] | typing.Callable[[], _submit_2__T] + ) -> Future[_submit_2__T]: ... + +_ForkJoinTask__V = typing.TypeVar("_ForkJoinTask__V") # + +class ForkJoinTask( + Future[_ForkJoinTask__V], java.io.Serializable, typing.Generic[_ForkJoinTask__V] +): + def __init__(self): ... + _adapt_1__T = typing.TypeVar("_adapt_1__T") # + _adapt_2__T = typing.TypeVar("_adapt_2__T") # + @typing.overload + @staticmethod + def adapt( + runnable: java.lang.Runnable | typing.Callable, + ) -> ForkJoinTask[typing.Any]: ... + @typing.overload + @staticmethod + def adapt( + runnable: java.lang.Runnable | typing.Callable, t: _adapt_1__T + ) -> ForkJoinTask[_adapt_1__T]: ... + @typing.overload + @staticmethod + def adapt( + callable: Callable[_adapt_2__T] | typing.Callable[[], _adapt_2__T], + ) -> ForkJoinTask[_adapt_2__T]: ... + _adaptInterruptible_1__T = typing.TypeVar("_adaptInterruptible_1__T") # + _adaptInterruptible_2__T = typing.TypeVar("_adaptInterruptible_2__T") # + @typing.overload + @staticmethod + def adaptInterruptible( + runnable: java.lang.Runnable | typing.Callable, + ) -> ForkJoinTask[typing.Any]: ... + @typing.overload + @staticmethod + def adaptInterruptible( + runnable: java.lang.Runnable | typing.Callable, t: _adaptInterruptible_1__T + ) -> ForkJoinTask[_adaptInterruptible_1__T]: ... + @typing.overload + @staticmethod + def adaptInterruptible( + callable: Callable[_adaptInterruptible_2__T] + | typing.Callable[[], _adaptInterruptible_2__T], + ) -> ForkJoinTask[_adaptInterruptible_2__T]: ... + def cancel(self, boolean: bool) -> bool: ... + def compareAndSetForkJoinTaskTag(self, short: int, short2: int) -> bool: ... + def complete(self, v: _ForkJoinTask__V) -> None: ... + def completeExceptionally(self, throwable: java.lang.Throwable) -> None: ... + def exceptionNow(self) -> java.lang.Throwable: ... + def fork(self) -> ForkJoinTask[_ForkJoinTask__V]: ... + @typing.overload + def get(self) -> _ForkJoinTask__V: ... + @typing.overload + def get(self, long: int, timeUnit: TimeUnit) -> _ForkJoinTask__V: ... + def getException(self) -> java.lang.Throwable: ... + def getForkJoinTaskTag(self) -> int: ... + @staticmethod + def getPool() -> ForkJoinPool: ... + @staticmethod + def getQueuedTaskCount() -> int: ... + def getRawResult(self) -> _ForkJoinTask__V: ... + @staticmethod + def getSurplusQueuedTaskCount() -> int: ... + @staticmethod + def helpQuiesce() -> None: ... + @staticmethod + def inForkJoinPool() -> bool: ... + def invoke(self) -> _ForkJoinTask__V: ... + _invokeAll_0__T = typing.TypeVar("_invokeAll_0__T", bound="ForkJoinTask") # + @typing.overload + @staticmethod + def invokeAll( + collection: java.util.Collection[_invokeAll_0__T] + | typing.Sequence[_invokeAll_0__T] + | set[_invokeAll_0__T], + ) -> java.util.Collection[_invokeAll_0__T]: ... + @typing.overload + @staticmethod + def invokeAll( + forkJoinTask: ForkJoinTask[typing.Any], forkJoinTask2: ForkJoinTask[typing.Any] + ) -> None: ... + @typing.overload + @staticmethod + def invokeAll(*forkJoinTask: ForkJoinTask[typing.Any]) -> None: ... + def isCancelled(self) -> bool: ... + def isCompletedAbnormally(self) -> bool: ... + def isCompletedNormally(self) -> bool: ... + def isDone(self) -> bool: ... + def join(self) -> _ForkJoinTask__V: ... + def quietlyComplete(self) -> None: ... + def quietlyInvoke(self) -> None: ... + @typing.overload + def quietlyJoin(self, long: int, timeUnit: TimeUnit) -> bool: ... + @typing.overload + def quietlyJoin(self) -> None: ... + def quietlyJoinUninterruptibly(self, long: int, timeUnit: TimeUnit) -> bool: ... + def reinitialize(self) -> None: ... + def resultNow(self) -> _ForkJoinTask__V: ... + def setForkJoinTaskTag(self, short: int) -> int: ... + def state(self) -> Future.State: ... + def tryUnfork(self) -> bool: ... + +_LinkedBlockingQueue__E = typing.TypeVar("_LinkedBlockingQueue__E") # + +class LinkedBlockingQueue( + java.util.AbstractQueue[_LinkedBlockingQueue__E], + BlockingQueue[_LinkedBlockingQueue__E], + java.io.Serializable, + typing.Generic[_LinkedBlockingQueue__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_LinkedBlockingQueue__E] + | typing.Sequence[_LinkedBlockingQueue__E] + | set[_LinkedBlockingQueue__E], + ): ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_LinkedBlockingQueue__E] + | typing.Sequence[_LinkedBlockingQueue__E] + | set[_LinkedBlockingQueue__E], + ) -> int: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_LinkedBlockingQueue__E] + | typing.Sequence[_LinkedBlockingQueue__E] + | set[_LinkedBlockingQueue__E], + int: int, + ) -> int: ... + def forEach( + self, + consumer: java.util.function.Consumer[_LinkedBlockingQueue__E] + | typing.Callable[[_LinkedBlockingQueue__E], None], + ) -> None: ... + def iterator(self) -> java.util.Iterator[_LinkedBlockingQueue__E]: ... + @typing.overload + def offer(self, e: _LinkedBlockingQueue__E) -> bool: ... + @typing.overload + def offer( + self, e: _LinkedBlockingQueue__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + def peek(self) -> _LinkedBlockingQueue__E: ... + @typing.overload + def poll(self) -> _LinkedBlockingQueue__E: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> _LinkedBlockingQueue__E: ... + def put(self, e: _LinkedBlockingQueue__E) -> None: ... + def remainingCapacity(self) -> int: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _LinkedBlockingQueue__E: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_LinkedBlockingQueue__E] + | typing.Callable[[_LinkedBlockingQueue__E], bool], + ) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_LinkedBlockingQueue__E]: ... + def take(self) -> _LinkedBlockingQueue__E: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + +_PriorityBlockingQueue__E = typing.TypeVar("_PriorityBlockingQueue__E") # + +class PriorityBlockingQueue( + java.util.AbstractQueue[_PriorityBlockingQueue__E], + BlockingQueue[_PriorityBlockingQueue__E], + java.io.Serializable, + typing.Generic[_PriorityBlockingQueue__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + int: int, + comparator: java.util.Comparator[_PriorityBlockingQueue__E] + | typing.Callable[[_PriorityBlockingQueue__E, _PriorityBlockingQueue__E], int], + ): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_PriorityBlockingQueue__E] + | typing.Sequence[_PriorityBlockingQueue__E] + | set[_PriorityBlockingQueue__E], + ): ... + def add(self, e: _PriorityBlockingQueue__E) -> bool: ... + def clear(self) -> None: ... + def comparator(self) -> java.util.Comparator[_PriorityBlockingQueue__E]: ... + def contains(self, object: typing.Any) -> bool: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_PriorityBlockingQueue__E] + | typing.Sequence[_PriorityBlockingQueue__E] + | set[_PriorityBlockingQueue__E], + ) -> int: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_PriorityBlockingQueue__E] + | typing.Sequence[_PriorityBlockingQueue__E] + | set[_PriorityBlockingQueue__E], + int: int, + ) -> int: ... + def forEach( + self, + consumer: java.util.function.Consumer[_PriorityBlockingQueue__E] + | typing.Callable[[_PriorityBlockingQueue__E], None], + ) -> None: ... + def iterator(self) -> java.util.Iterator[_PriorityBlockingQueue__E]: ... + @typing.overload + def offer(self, e: _PriorityBlockingQueue__E) -> bool: ... + @typing.overload + def offer( + self, e: _PriorityBlockingQueue__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + def peek(self) -> _PriorityBlockingQueue__E: ... + @typing.overload + def poll(self) -> _PriorityBlockingQueue__E: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> _PriorityBlockingQueue__E: ... + def put(self, e: _PriorityBlockingQueue__E) -> None: ... + def remainingCapacity(self) -> int: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _PriorityBlockingQueue__E: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_PriorityBlockingQueue__E] + | typing.Callable[[_PriorityBlockingQueue__E], bool], + ) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_PriorityBlockingQueue__E]: ... + def take(self) -> _PriorityBlockingQueue__E: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + +_RunnableFuture__V = typing.TypeVar("_RunnableFuture__V") # + +class RunnableFuture( + java.lang.Runnable, Future[_RunnableFuture__V], typing.Generic[_RunnableFuture__V] +): + def run(self) -> None: ... + +_ScheduledFuture__V = typing.TypeVar("_ScheduledFuture__V") # + +class ScheduledFuture( + Delayed, Future[_ScheduledFuture__V], typing.Generic[_ScheduledFuture__V] +): ... + +_SynchronousQueue__E = typing.TypeVar("_SynchronousQueue__E") # + +class SynchronousQueue( + java.util.AbstractQueue[_SynchronousQueue__E], + BlockingQueue[_SynchronousQueue__E], + java.io.Serializable, + typing.Generic[_SynchronousQueue__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_SynchronousQueue__E] + | typing.Sequence[_SynchronousQueue__E] + | set[_SynchronousQueue__E], + ) -> int: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_SynchronousQueue__E] + | typing.Sequence[_SynchronousQueue__E] + | set[_SynchronousQueue__E], + int: int, + ) -> int: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> java.util.Iterator[_SynchronousQueue__E]: ... + @typing.overload + def offer(self, e: _SynchronousQueue__E) -> bool: ... + @typing.overload + def offer(self, e: _SynchronousQueue__E, long: int, timeUnit: TimeUnit) -> bool: ... + def peek(self) -> _SynchronousQueue__E: ... + @typing.overload + def poll(self) -> _SynchronousQueue__E: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> _SynchronousQueue__E: ... + def put(self, e: _SynchronousQueue__E) -> None: ... + def remainingCapacity(self) -> int: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _SynchronousQueue__E: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_SynchronousQueue__E]: ... + def take(self) -> _SynchronousQueue__E: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + +_TransferQueue__E = typing.TypeVar("_TransferQueue__E") # + +class TransferQueue( + BlockingQueue[_TransferQueue__E], typing.Generic[_TransferQueue__E] +): + def equals(self, object: typing.Any) -> bool: ... + def getWaitingConsumerCount(self) -> int: ... + def hasWaitingConsumer(self) -> bool: ... + def hashCode(self) -> int: ... + def transfer(self, e: _TransferQueue__E) -> None: ... + @typing.overload + def tryTransfer(self, e: _TransferQueue__E) -> bool: ... + @typing.overload + def tryTransfer( + self, e: _TransferQueue__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + +class AbstractExecutorService(ExecutorService): + def __init__(self): ... + _invokeAll_0__T = typing.TypeVar("_invokeAll_0__T") # + _invokeAll_1__T = typing.TypeVar("_invokeAll_1__T") # + @typing.overload + def invokeAll( + self, + collection: java.util.Collection[Callable[_invokeAll_0__T]] + | typing.Sequence[Callable[_invokeAll_0__T]] + | set[Callable[_invokeAll_0__T]], + ) -> java.util.List[Future[_invokeAll_0__T]]: ... + @typing.overload + def invokeAll( + self, + collection: java.util.Collection[Callable[_invokeAll_1__T]] + | typing.Sequence[Callable[_invokeAll_1__T]] + | set[Callable[_invokeAll_1__T]], + long: int, + timeUnit: TimeUnit, + ) -> java.util.List[Future[_invokeAll_1__T]]: ... + _invokeAny_0__T = typing.TypeVar("_invokeAny_0__T") # + _invokeAny_1__T = typing.TypeVar("_invokeAny_1__T") # + @typing.overload + def invokeAny( + self, + collection: java.util.Collection[Callable[_invokeAny_0__T]] + | typing.Sequence[Callable[_invokeAny_0__T]] + | set[Callable[_invokeAny_0__T]], + ) -> _invokeAny_0__T: ... + @typing.overload + def invokeAny( + self, + collection: java.util.Collection[Callable[_invokeAny_1__T]] + | typing.Sequence[Callable[_invokeAny_1__T]] + | set[Callable[_invokeAny_1__T]], + long: int, + timeUnit: TimeUnit, + ) -> _invokeAny_1__T: ... + _submit_1__T = typing.TypeVar("_submit_1__T") # + _submit_2__T = typing.TypeVar("_submit_2__T") # + @typing.overload + def submit( + self, runnable: java.lang.Runnable | typing.Callable + ) -> Future[typing.Any]: ... + @typing.overload + def submit( + self, runnable: java.lang.Runnable | typing.Callable, t: _submit_1__T + ) -> Future[_submit_1__T]: ... + @typing.overload + def submit( + self, callable: Callable[_submit_2__T] | typing.Callable[[], _submit_2__T] + ) -> Future[_submit_2__T]: ... + +_ConcurrentSkipListMap__K = typing.TypeVar("_ConcurrentSkipListMap__K") # +_ConcurrentSkipListMap__V = typing.TypeVar("_ConcurrentSkipListMap__V") # + +class ConcurrentSkipListMap( + java.util.AbstractMap[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V], + ConcurrentNavigableMap[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V], + java.lang.Cloneable, + java.io.Serializable, + typing.Generic[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + comparator: java.util.Comparator[_ConcurrentSkipListMap__K] + | typing.Callable[[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__K], int], + ): ... + @typing.overload + def __init__( + self, + map: java.util.Map[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V] + | typing.Mapping[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V], + ): ... + @typing.overload + def __init__( + self, + sortedMap: java.util.SortedMap[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ], + ): ... + def ceilingEntry( + self, k: _ConcurrentSkipListMap__K + ) -> java.util.Map.Entry[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V]: ... + def ceilingKey(self, k: _ConcurrentSkipListMap__K) -> _ConcurrentSkipListMap__K: ... + def clear(self) -> None: ... + def clone( + self, + ) -> ConcurrentSkipListMap[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ]: ... + def comparator(self) -> java.util.Comparator[_ConcurrentSkipListMap__K]: ... + def compute( + self, + k: _ConcurrentSkipListMap__K, + biFunction: java.util.function.BiFunction[ + _ConcurrentSkipListMap__K, + _ConcurrentSkipListMap__V, + _ConcurrentSkipListMap__V, + ] + | typing.Callable[ + [_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V], + _ConcurrentSkipListMap__V, + ], + ) -> _ConcurrentSkipListMap__V: ... + def computeIfAbsent( + self, + k: _ConcurrentSkipListMap__K, + function: java.util.function.Function[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ] + | typing.Callable[[_ConcurrentSkipListMap__K], _ConcurrentSkipListMap__V], + ) -> _ConcurrentSkipListMap__V: ... + def computeIfPresent( + self, + k: _ConcurrentSkipListMap__K, + biFunction: java.util.function.BiFunction[ + _ConcurrentSkipListMap__K, + _ConcurrentSkipListMap__V, + _ConcurrentSkipListMap__V, + ] + | typing.Callable[ + [_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V], + _ConcurrentSkipListMap__V, + ], + ) -> _ConcurrentSkipListMap__V: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def descendingKeySet(self) -> java.util.NavigableSet[_ConcurrentSkipListMap__K]: ... + def descendingMap( + self, + ) -> ConcurrentNavigableMap[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ]: ... + def entrySet( + self, + ) -> java.util.Set[ + java.util.Map.Entry[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V] + ]: ... + def equals(self, object: typing.Any) -> bool: ... + def firstEntry( + self, + ) -> java.util.Map.Entry[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V]: ... + def firstKey(self) -> _ConcurrentSkipListMap__K: ... + def floorEntry( + self, k: _ConcurrentSkipListMap__K + ) -> java.util.Map.Entry[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V]: ... + def floorKey(self, k: _ConcurrentSkipListMap__K) -> _ConcurrentSkipListMap__K: ... + def forEach( + self, + biConsumer: java.util.function.BiConsumer[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ] + | typing.Callable[[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V], None], + ) -> None: ... + def get(self, object: typing.Any) -> _ConcurrentSkipListMap__V: ... + def getOrDefault( + self, object: typing.Any, v: _ConcurrentSkipListMap__V + ) -> _ConcurrentSkipListMap__V: ... + @typing.overload + def headMap( + self, k: _ConcurrentSkipListMap__K + ) -> ConcurrentNavigableMap[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ]: ... + @typing.overload + def headMap( + self, k: _ConcurrentSkipListMap__K, boolean: bool + ) -> ConcurrentNavigableMap[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ]: ... + def higherEntry( + self, k: _ConcurrentSkipListMap__K + ) -> java.util.Map.Entry[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V]: ... + def higherKey(self, k: _ConcurrentSkipListMap__K) -> _ConcurrentSkipListMap__K: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> java.util.NavigableSet[_ConcurrentSkipListMap__K]: ... + def lastEntry( + self, + ) -> java.util.Map.Entry[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V]: ... + def lastKey(self) -> _ConcurrentSkipListMap__K: ... + def lowerEntry( + self, k: _ConcurrentSkipListMap__K + ) -> java.util.Map.Entry[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V]: ... + def lowerKey(self, k: _ConcurrentSkipListMap__K) -> _ConcurrentSkipListMap__K: ... + def merge( + self, + k: _ConcurrentSkipListMap__K, + v: _ConcurrentSkipListMap__V, + biFunction: java.util.function.BiFunction[ + _ConcurrentSkipListMap__V, + _ConcurrentSkipListMap__V, + _ConcurrentSkipListMap__V, + ] + | typing.Callable[ + [_ConcurrentSkipListMap__V, _ConcurrentSkipListMap__V], + _ConcurrentSkipListMap__V, + ], + ) -> _ConcurrentSkipListMap__V: ... + def navigableKeySet(self) -> java.util.NavigableSet[_ConcurrentSkipListMap__K]: ... + def pollFirstEntry( + self, + ) -> java.util.Map.Entry[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V]: ... + def pollLastEntry( + self, + ) -> java.util.Map.Entry[_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V]: ... + def put( + self, k: _ConcurrentSkipListMap__K, v: _ConcurrentSkipListMap__V + ) -> _ConcurrentSkipListMap__V: ... + def putFirst( + self, k: _ConcurrentSkipListMap__K, v: _ConcurrentSkipListMap__V + ) -> _ConcurrentSkipListMap__V: ... + def putIfAbsent( + self, k: _ConcurrentSkipListMap__K, v: _ConcurrentSkipListMap__V + ) -> _ConcurrentSkipListMap__V: ... + def putLast( + self, k: _ConcurrentSkipListMap__K, v: _ConcurrentSkipListMap__V + ) -> _ConcurrentSkipListMap__V: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _ConcurrentSkipListMap__V: ... + @typing.overload + def replace( + self, + k: _ConcurrentSkipListMap__K, + v: _ConcurrentSkipListMap__V, + v2: _ConcurrentSkipListMap__V, + ) -> bool: ... + @typing.overload + def replace( + self, k: _ConcurrentSkipListMap__K, v: _ConcurrentSkipListMap__V + ) -> _ConcurrentSkipListMap__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[ + _ConcurrentSkipListMap__K, + _ConcurrentSkipListMap__V, + _ConcurrentSkipListMap__V, + ] + | typing.Callable[ + [_ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V], + _ConcurrentSkipListMap__V, + ], + ) -> None: ... + def size(self) -> int: ... + @typing.overload + def subMap( + self, + k: _ConcurrentSkipListMap__K, + boolean: bool, + k2: _ConcurrentSkipListMap__K, + boolean2: bool, + ) -> ConcurrentNavigableMap[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ]: ... + @typing.overload + def subMap( + self, k: _ConcurrentSkipListMap__K, k2: _ConcurrentSkipListMap__K + ) -> ConcurrentNavigableMap[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ]: ... + @typing.overload + def tailMap( + self, k: _ConcurrentSkipListMap__K + ) -> ConcurrentNavigableMap[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ]: ... + @typing.overload + def tailMap( + self, k: _ConcurrentSkipListMap__K, boolean: bool + ) -> ConcurrentNavigableMap[ + _ConcurrentSkipListMap__K, _ConcurrentSkipListMap__V + ]: ... + def values(self) -> java.util.Collection[_ConcurrentSkipListMap__V]: ... + +_CountedCompleter__T = typing.TypeVar("_CountedCompleter__T") # + +class CountedCompleter( + ForkJoinTask[_CountedCompleter__T], typing.Generic[_CountedCompleter__T] +): + def addToPendingCount(self, int: int) -> None: ... + def compareAndSetPendingCount(self, int: int, int2: int) -> bool: ... + def complete(self, t: _CountedCompleter__T) -> None: ... + def compute(self) -> None: ... + def decrementPendingCountUnlessZero(self) -> int: ... + def firstComplete(self) -> CountedCompleter[typing.Any]: ... + def getCompleter(self) -> CountedCompleter[typing.Any]: ... + def getPendingCount(self) -> int: ... + def getRawResult(self) -> _CountedCompleter__T: ... + def getRoot(self) -> CountedCompleter[typing.Any]: ... + def helpComplete(self, int: int) -> None: ... + def nextComplete(self) -> CountedCompleter[typing.Any]: ... + def onCompletion(self, countedCompleter: CountedCompleter[typing.Any]) -> None: ... + def onExceptionalCompletion( + self, + throwable: java.lang.Throwable, + countedCompleter: CountedCompleter[typing.Any], + ) -> bool: ... + def propagateCompletion(self) -> None: ... + def quietlyCompleteRoot(self) -> None: ... + def setPendingCount(self, int: int) -> None: ... + def tryComplete(self) -> None: ... + +_FutureTask__V = typing.TypeVar("_FutureTask__V") # + +class FutureTask(RunnableFuture[_FutureTask__V], typing.Generic[_FutureTask__V]): + @typing.overload + def __init__( + self, runnable: java.lang.Runnable | typing.Callable, v: _FutureTask__V + ): ... + @typing.overload + def __init__( + self, callable: Callable[_FutureTask__V] | typing.Callable[[], _FutureTask__V] + ): ... + def cancel(self, boolean: bool) -> bool: ... + def exceptionNow(self) -> java.lang.Throwable: ... + @typing.overload + def get(self) -> _FutureTask__V: ... + @typing.overload + def get(self, long: int, timeUnit: TimeUnit) -> _FutureTask__V: ... + def isCancelled(self) -> bool: ... + def isDone(self) -> bool: ... + def resultNow(self) -> _FutureTask__V: ... + def run(self) -> None: ... + def state(self) -> Future.State: ... + def toString(self) -> java.lang.String: ... + +_LinkedBlockingDeque__E = typing.TypeVar("_LinkedBlockingDeque__E") # + +class LinkedBlockingDeque( + java.util.AbstractQueue[_LinkedBlockingDeque__E], + BlockingDeque[_LinkedBlockingDeque__E], + java.io.Serializable, + typing.Generic[_LinkedBlockingDeque__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_LinkedBlockingDeque__E] + | typing.Sequence[_LinkedBlockingDeque__E] + | set[_LinkedBlockingDeque__E], + ): ... + def add(self, e: _LinkedBlockingDeque__E) -> bool: ... + def addAll( + self, + collection: java.util.Collection[_LinkedBlockingDeque__E] + | typing.Sequence[_LinkedBlockingDeque__E] + | set[_LinkedBlockingDeque__E], + ) -> bool: ... + def addFirst(self, e: _LinkedBlockingDeque__E) -> None: ... + def addLast(self, e: _LinkedBlockingDeque__E) -> None: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def descendingIterator(self) -> java.util.Iterator[_LinkedBlockingDeque__E]: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_LinkedBlockingDeque__E] + | typing.Sequence[_LinkedBlockingDeque__E] + | set[_LinkedBlockingDeque__E], + ) -> int: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_LinkedBlockingDeque__E] + | typing.Sequence[_LinkedBlockingDeque__E] + | set[_LinkedBlockingDeque__E], + int: int, + ) -> int: ... + def element(self) -> _LinkedBlockingDeque__E: ... + def forEach( + self, + consumer: java.util.function.Consumer[_LinkedBlockingDeque__E] + | typing.Callable[[_LinkedBlockingDeque__E], None], + ) -> None: ... + def getFirst(self) -> _LinkedBlockingDeque__E: ... + def getLast(self) -> _LinkedBlockingDeque__E: ... + def iterator(self) -> java.util.Iterator[_LinkedBlockingDeque__E]: ... + @typing.overload + def offer(self, e: _LinkedBlockingDeque__E) -> bool: ... + @typing.overload + def offer( + self, e: _LinkedBlockingDeque__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + @typing.overload + def offerFirst(self, e: _LinkedBlockingDeque__E) -> bool: ... + @typing.overload + def offerFirst( + self, e: _LinkedBlockingDeque__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + @typing.overload + def offerLast(self, e: _LinkedBlockingDeque__E) -> bool: ... + @typing.overload + def offerLast( + self, e: _LinkedBlockingDeque__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + def peek(self) -> _LinkedBlockingDeque__E: ... + def peekFirst(self) -> _LinkedBlockingDeque__E: ... + def peekLast(self) -> _LinkedBlockingDeque__E: ... + @typing.overload + def poll(self) -> _LinkedBlockingDeque__E: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> _LinkedBlockingDeque__E: ... + @typing.overload + def pollFirst(self) -> _LinkedBlockingDeque__E: ... + @typing.overload + def pollFirst(self, long: int, timeUnit: TimeUnit) -> _LinkedBlockingDeque__E: ... + @typing.overload + def pollLast(self) -> _LinkedBlockingDeque__E: ... + @typing.overload + def pollLast(self, long: int, timeUnit: TimeUnit) -> _LinkedBlockingDeque__E: ... + def pop(self) -> _LinkedBlockingDeque__E: ... + def push(self, e: _LinkedBlockingDeque__E) -> None: ... + def put(self, e: _LinkedBlockingDeque__E) -> None: ... + def putFirst(self, e: _LinkedBlockingDeque__E) -> None: ... + def putLast(self, e: _LinkedBlockingDeque__E) -> None: ... + def remainingCapacity(self) -> int: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _LinkedBlockingDeque__E: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeFirst(self) -> _LinkedBlockingDeque__E: ... + def removeFirstOccurrence(self, object: typing.Any) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_LinkedBlockingDeque__E] + | typing.Callable[[_LinkedBlockingDeque__E], bool], + ) -> bool: ... + def removeLast(self) -> _LinkedBlockingDeque__E: ... + def removeLastOccurrence(self, object: typing.Any) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_LinkedBlockingDeque__E]: ... + def take(self) -> _LinkedBlockingDeque__E: ... + def takeFirst(self) -> _LinkedBlockingDeque__E: ... + def takeLast(self) -> _LinkedBlockingDeque__E: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + +_LinkedTransferQueue__E = typing.TypeVar("_LinkedTransferQueue__E") # + +class LinkedTransferQueue( + java.util.AbstractQueue[_LinkedTransferQueue__E], + TransferQueue[_LinkedTransferQueue__E], + java.io.Serializable, + typing.Generic[_LinkedTransferQueue__E], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_LinkedTransferQueue__E] + | typing.Sequence[_LinkedTransferQueue__E] + | set[_LinkedTransferQueue__E], + ): ... + def add(self, e: _LinkedTransferQueue__E) -> bool: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_LinkedTransferQueue__E] + | typing.Sequence[_LinkedTransferQueue__E] + | set[_LinkedTransferQueue__E], + ) -> int: ... + @typing.overload + def drainTo( + self, + collection: java.util.Collection[_LinkedTransferQueue__E] + | typing.Sequence[_LinkedTransferQueue__E] + | set[_LinkedTransferQueue__E], + int: int, + ) -> int: ... + def forEach( + self, + consumer: java.util.function.Consumer[_LinkedTransferQueue__E] + | typing.Callable[[_LinkedTransferQueue__E], None], + ) -> None: ... + def getWaitingConsumerCount(self) -> int: ... + def hasWaitingConsumer(self) -> bool: ... + def isEmpty(self) -> bool: ... + def iterator(self) -> java.util.Iterator[_LinkedTransferQueue__E]: ... + @typing.overload + def offer(self, e: _LinkedTransferQueue__E) -> bool: ... + @typing.overload + def offer( + self, e: _LinkedTransferQueue__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + def peek(self) -> _LinkedTransferQueue__E: ... + @typing.overload + def poll(self) -> _LinkedTransferQueue__E: ... + @typing.overload + def poll(self, long: int, timeUnit: TimeUnit) -> _LinkedTransferQueue__E: ... + def put(self, e: _LinkedTransferQueue__E) -> None: ... + def remainingCapacity(self) -> int: ... + @typing.overload + def remove(self, object: typing.Any) -> bool: ... + @typing.overload + def remove(self) -> _LinkedTransferQueue__E: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def removeIf( + self, + predicate: java.util.function.Predicate[_LinkedTransferQueue__E] + | typing.Callable[[_LinkedTransferQueue__E], bool], + ) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | set[typing.Any], + ) -> bool: ... + def size(self) -> int: ... + def spliterator(self) -> java.util.Spliterator[_LinkedTransferQueue__E]: ... + def take(self) -> _LinkedTransferQueue__E: ... + _toArray_0__T = typing.TypeVar("_toArray_0__T") # + _toArray_2__T = typing.TypeVar("_toArray_2__T") # + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_0__T] | jpype.JArray] + | typing.Callable[[int], list[_toArray_0__T] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_0__T]: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, tArray: list[_toArray_2__T] | jpype.JArray + ) -> typing.MutableSequence[_toArray_2__T]: ... + def toString(self) -> java.lang.String: ... + def transfer(self, e: _LinkedTransferQueue__E) -> None: ... + @typing.overload + def tryTransfer(self, e: _LinkedTransferQueue__E) -> bool: ... + @typing.overload + def tryTransfer( + self, e: _LinkedTransferQueue__E, long: int, timeUnit: TimeUnit + ) -> bool: ... + +class RecursiveAction(ForkJoinTask[None]): + def __init__(self): ... + def getRawResult(self) -> None: ... + +_RecursiveTask__V = typing.TypeVar("_RecursiveTask__V") # + +class RecursiveTask(ForkJoinTask[_RecursiveTask__V], typing.Generic[_RecursiveTask__V]): + def __init__(self): ... + def getRawResult(self) -> _RecursiveTask__V: ... + +_RunnableScheduledFuture__V = typing.TypeVar("_RunnableScheduledFuture__V") # + +class RunnableScheduledFuture( + RunnableFuture[_RunnableScheduledFuture__V], + ScheduledFuture[_RunnableScheduledFuture__V], + typing.Generic[_RunnableScheduledFuture__V], +): + def isPeriodic(self) -> bool: ... + +class ScheduledExecutorService(ExecutorService): + _schedule_1__V = typing.TypeVar("_schedule_1__V") # + @typing.overload + def schedule( + self, + runnable: java.lang.Runnable | typing.Callable, + long: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[typing.Any]: ... + @typing.overload + def schedule( + self, + callable: Callable[_schedule_1__V] | typing.Callable[[], _schedule_1__V], + long: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[_schedule_1__V]: ... + def scheduleAtFixedRate( + self, + runnable: java.lang.Runnable | typing.Callable, + long: int, + long2: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[typing.Any]: ... + def scheduleWithFixedDelay( + self, + runnable: java.lang.Runnable | typing.Callable, + long: int, + long2: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[typing.Any]: ... + +class ForkJoinPool(AbstractExecutorService, ScheduledExecutorService): + defaultForkJoinWorkerThreadFactory: typing.ClassVar[ + ForkJoinPool.ForkJoinWorkerThreadFactory + ] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + int: int, + forkJoinWorkerThreadFactory: ForkJoinPool.ForkJoinWorkerThreadFactory + | typing.Callable, + uncaughtExceptionHandler: java.lang.Thread.UncaughtExceptionHandler + | typing.Callable, + boolean: bool, + ): ... + @typing.overload + def __init__( + self, + int: int, + forkJoinWorkerThreadFactory: ForkJoinPool.ForkJoinWorkerThreadFactory + | typing.Callable, + uncaughtExceptionHandler: java.lang.Thread.UncaughtExceptionHandler + | typing.Callable, + boolean: bool, + int2: int, + int3: int, + int4: int, + predicate: java.util.function.Predicate[ForkJoinPool] + | typing.Callable[[ForkJoinPool], bool], + long: int, + timeUnit: TimeUnit, + ): ... + def awaitQuiescence(self, long: int, timeUnit: TimeUnit) -> bool: ... + def awaitTermination(self, long: int, timeUnit: TimeUnit) -> bool: ... + def cancelDelayedTasksOnShutdown(self) -> None: ... + def close(self) -> None: ... + @staticmethod + def commonPool() -> ForkJoinPool: ... + @typing.overload + def execute(self, runnable: java.lang.Runnable | typing.Callable) -> None: ... + @typing.overload + def execute(self, forkJoinTask: ForkJoinTask[typing.Any]) -> None: ... + _externalSubmit__T = typing.TypeVar("_externalSubmit__T") # + def externalSubmit( + self, forkJoinTask: ForkJoinTask[_externalSubmit__T] + ) -> ForkJoinTask[_externalSubmit__T]: ... + def getActiveThreadCount(self) -> int: ... + def getAsyncMode(self) -> bool: ... + @staticmethod + def getCommonPoolParallelism() -> int: ... + def getDelayedTaskCount(self) -> int: ... + def getFactory(self) -> ForkJoinPool.ForkJoinWorkerThreadFactory: ... + def getParallelism(self) -> int: ... + def getPoolSize(self) -> int: ... + def getQueuedSubmissionCount(self) -> int: ... + def getQueuedTaskCount(self) -> int: ... + def getRunningThreadCount(self) -> int: ... + def getStealCount(self) -> int: ... + def getUncaughtExceptionHandler( + self, + ) -> java.lang.Thread.UncaughtExceptionHandler: ... + def hasQueuedSubmissions(self) -> bool: ... + _invoke__T = typing.TypeVar("_invoke__T") # + def invoke(self, forkJoinTask: ForkJoinTask[_invoke__T]) -> _invoke__T: ... + _invokeAll_0__T = typing.TypeVar("_invokeAll_0__T") # + _invokeAll_1__T = typing.TypeVar("_invokeAll_1__T") # + @typing.overload + def invokeAll( + self, + collection: java.util.Collection[Callable[_invokeAll_0__T]] + | typing.Sequence[Callable[_invokeAll_0__T]] + | set[Callable[_invokeAll_0__T]], + ) -> java.util.List[Future[_invokeAll_0__T]]: ... + @typing.overload + def invokeAll( + self, + collection: java.util.Collection[Callable[_invokeAll_1__T]] + | typing.Sequence[Callable[_invokeAll_1__T]] + | set[Callable[_invokeAll_1__T]], + long: int, + timeUnit: TimeUnit, + ) -> java.util.List[Future[_invokeAll_1__T]]: ... + _invokeAllUninterruptibly__T = typing.TypeVar("_invokeAllUninterruptibly__T") # + def invokeAllUninterruptibly( + self, + collection: java.util.Collection[Callable[_invokeAllUninterruptibly__T]] + | typing.Sequence[Callable[_invokeAllUninterruptibly__T]] + | set[Callable[_invokeAllUninterruptibly__T]], + ) -> java.util.List[Future[_invokeAllUninterruptibly__T]]: ... + _invokeAny_0__T = typing.TypeVar("_invokeAny_0__T") # + _invokeAny_1__T = typing.TypeVar("_invokeAny_1__T") # + @typing.overload + def invokeAny( + self, + collection: java.util.Collection[Callable[_invokeAny_0__T]] + | typing.Sequence[Callable[_invokeAny_0__T]] + | set[Callable[_invokeAny_0__T]], + ) -> _invokeAny_0__T: ... + @typing.overload + def invokeAny( + self, + collection: java.util.Collection[Callable[_invokeAny_1__T]] + | typing.Sequence[Callable[_invokeAny_1__T]] + | set[Callable[_invokeAny_1__T]], + long: int, + timeUnit: TimeUnit, + ) -> _invokeAny_1__T: ... + def isQuiescent(self) -> bool: ... + def isShutdown(self) -> bool: ... + def isTerminated(self) -> bool: ... + def isTerminating(self) -> bool: ... + _lazySubmit__T = typing.TypeVar("_lazySubmit__T") # + def lazySubmit( + self, forkJoinTask: ForkJoinTask[_lazySubmit__T] + ) -> ForkJoinTask[_lazySubmit__T]: ... + @staticmethod + def managedBlock(managedBlocker: ForkJoinPool.ManagedBlocker) -> None: ... + _schedule_1__V = typing.TypeVar("_schedule_1__V") # + @typing.overload + def schedule( + self, + runnable: java.lang.Runnable | typing.Callable, + long: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[typing.Any]: ... + @typing.overload + def schedule( + self, + callable: Callable[_schedule_1__V] | typing.Callable[[], _schedule_1__V], + long: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[_schedule_1__V]: ... + def scheduleAtFixedRate( + self, + runnable: java.lang.Runnable | typing.Callable, + long: int, + long2: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[typing.Any]: ... + def scheduleWithFixedDelay( + self, + runnable: java.lang.Runnable | typing.Callable, + long: int, + long2: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[typing.Any]: ... + def setParallelism(self, int: int) -> int: ... + def shutdown(self) -> None: ... + def shutdownNow(self) -> java.util.List[java.lang.Runnable]: ... + _submit_1__T = typing.TypeVar("_submit_1__T") # + _submit_2__T = typing.TypeVar("_submit_2__T") # + _submit_3__T = typing.TypeVar("_submit_3__T") # + @typing.overload + def submit( + self, runnable: java.lang.Runnable | typing.Callable + ) -> ForkJoinTask[typing.Any]: ... + @typing.overload + def submit( + self, runnable: java.lang.Runnable | typing.Callable, t: _submit_1__T + ) -> ForkJoinTask[_submit_1__T]: ... + @typing.overload + def submit( + self, callable: Callable[_submit_2__T] | typing.Callable[[], _submit_2__T] + ) -> ForkJoinTask[_submit_2__T]: ... + @typing.overload + def submit( + self, forkJoinTask: ForkJoinTask[_submit_3__T] + ) -> ForkJoinTask[_submit_3__T]: ... + _submitWithTimeout__V = typing.TypeVar("_submitWithTimeout__V") # + def submitWithTimeout( + self, + callable: Callable[_submitWithTimeout__V] + | typing.Callable[[], _submitWithTimeout__V], + long: int, + timeUnit: TimeUnit, + consumer: java.util.function.Consumer[ForkJoinTask[_submitWithTimeout__V]] + | typing.Callable[[ForkJoinTask[_submitWithTimeout__V]], None], + ) -> ForkJoinTask[_submitWithTimeout__V]: ... + def toString(self) -> java.lang.String: ... + class ForkJoinWorkerThreadFactory: + def newThread(self, forkJoinPool: ForkJoinPool) -> ForkJoinWorkerThread: ... + + class ManagedBlocker: + def block(self) -> bool: ... + def isReleasable(self) -> bool: ... + +class ThreadPoolExecutor(AbstractExecutorService): + @typing.overload + def __init__( + self, + int: int, + int2: int, + long: int, + timeUnit: TimeUnit, + blockingQueue: BlockingQueue[java.lang.Runnable | typing.Callable], + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + long: int, + timeUnit: TimeUnit, + blockingQueue: BlockingQueue[java.lang.Runnable | typing.Callable], + rejectedExecutionHandler: RejectedExecutionHandler | typing.Callable, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + long: int, + timeUnit: TimeUnit, + blockingQueue: BlockingQueue[java.lang.Runnable | typing.Callable], + threadFactory: ThreadFactory | typing.Callable, + ): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + long: int, + timeUnit: TimeUnit, + blockingQueue: BlockingQueue[java.lang.Runnable | typing.Callable], + threadFactory: ThreadFactory | typing.Callable, + rejectedExecutionHandler: RejectedExecutionHandler | typing.Callable, + ): ... + def allowCoreThreadTimeOut(self, boolean: bool) -> None: ... + def allowsCoreThreadTimeOut(self) -> bool: ... + def awaitTermination(self, long: int, timeUnit: TimeUnit) -> bool: ... + def execute(self, runnable: java.lang.Runnable | typing.Callable) -> None: ... + def getActiveCount(self) -> int: ... + def getCompletedTaskCount(self) -> int: ... + def getCorePoolSize(self) -> int: ... + def getKeepAliveTime(self, timeUnit: TimeUnit) -> int: ... + def getLargestPoolSize(self) -> int: ... + def getMaximumPoolSize(self) -> int: ... + def getPoolSize(self) -> int: ... + def getQueue(self) -> BlockingQueue[java.lang.Runnable]: ... + def getRejectedExecutionHandler(self) -> RejectedExecutionHandler: ... + def getTaskCount(self) -> int: ... + def getThreadFactory(self) -> ThreadFactory: ... + def isShutdown(self) -> bool: ... + def isTerminated(self) -> bool: ... + def isTerminating(self) -> bool: ... + def prestartAllCoreThreads(self) -> int: ... + def prestartCoreThread(self) -> bool: ... + def purge(self) -> None: ... + def remove(self, runnable: java.lang.Runnable | typing.Callable) -> bool: ... + def setCorePoolSize(self, int: int) -> None: ... + def setKeepAliveTime(self, long: int, timeUnit: TimeUnit) -> None: ... + def setMaximumPoolSize(self, int: int) -> None: ... + def setRejectedExecutionHandler( + self, rejectedExecutionHandler: RejectedExecutionHandler | typing.Callable + ) -> None: ... + def setThreadFactory( + self, threadFactory: ThreadFactory | typing.Callable + ) -> None: ... + def shutdown(self) -> None: ... + def shutdownNow(self) -> java.util.List[java.lang.Runnable]: ... + def toString(self) -> java.lang.String: ... + class AbortPolicy(RejectedExecutionHandler): + def __init__(self): ... + def rejectedExecution( + self, + runnable: java.lang.Runnable | typing.Callable, + threadPoolExecutor: ThreadPoolExecutor, + ) -> None: ... + + class CallerRunsPolicy(RejectedExecutionHandler): + def __init__(self): ... + def rejectedExecution( + self, + runnable: java.lang.Runnable | typing.Callable, + threadPoolExecutor: ThreadPoolExecutor, + ) -> None: ... + + class DiscardOldestPolicy(RejectedExecutionHandler): + def __init__(self): ... + def rejectedExecution( + self, + runnable: java.lang.Runnable | typing.Callable, + threadPoolExecutor: ThreadPoolExecutor, + ) -> None: ... + + class DiscardPolicy(RejectedExecutionHandler): + def __init__(self): ... + def rejectedExecution( + self, + runnable: java.lang.Runnable | typing.Callable, + threadPoolExecutor: ThreadPoolExecutor, + ) -> None: ... + +class ScheduledThreadPoolExecutor(ThreadPoolExecutor, ScheduledExecutorService): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__( + self, + int: int, + rejectedExecutionHandler: RejectedExecutionHandler | typing.Callable, + ): ... + @typing.overload + def __init__(self, int: int, threadFactory: ThreadFactory | typing.Callable): ... + @typing.overload + def __init__( + self, + int: int, + threadFactory: ThreadFactory | typing.Callable, + rejectedExecutionHandler: RejectedExecutionHandler | typing.Callable, + ): ... + def execute(self, runnable: java.lang.Runnable | typing.Callable) -> None: ... + def getContinueExistingPeriodicTasksAfterShutdownPolicy(self) -> bool: ... + def getExecuteExistingDelayedTasksAfterShutdownPolicy(self) -> bool: ... + def getQueue(self) -> BlockingQueue[java.lang.Runnable]: ... + def getRemoveOnCancelPolicy(self) -> bool: ... + _schedule_1__V = typing.TypeVar("_schedule_1__V") # + @typing.overload + def schedule( + self, + runnable: java.lang.Runnable | typing.Callable, + long: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[typing.Any]: ... + @typing.overload + def schedule( + self, + callable: Callable[_schedule_1__V] | typing.Callable[[], _schedule_1__V], + long: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[_schedule_1__V]: ... + def scheduleAtFixedRate( + self, + runnable: java.lang.Runnable | typing.Callable, + long: int, + long2: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[typing.Any]: ... + def scheduleWithFixedDelay( + self, + runnable: java.lang.Runnable | typing.Callable, + long: int, + long2: int, + timeUnit: TimeUnit, + ) -> ScheduledFuture[typing.Any]: ... + def setContinueExistingPeriodicTasksAfterShutdownPolicy( + self, boolean: bool + ) -> None: ... + def setExecuteExistingDelayedTasksAfterShutdownPolicy( + self, boolean: bool + ) -> None: ... + def setRemoveOnCancelPolicy(self, boolean: bool) -> None: ... + def shutdown(self) -> None: ... + def shutdownNow(self) -> java.util.List[java.lang.Runnable]: ... + _submit_1__T = typing.TypeVar("_submit_1__T") # + _submit_2__T = typing.TypeVar("_submit_2__T") # + @typing.overload + def submit( + self, runnable: java.lang.Runnable | typing.Callable + ) -> Future[typing.Any]: ... + @typing.overload + def submit( + self, runnable: java.lang.Runnable | typing.Callable, t: _submit_1__T + ) -> Future[_submit_1__T]: ... + @typing.overload + def submit( + self, callable: Callable[_submit_2__T] | typing.Callable[[], _submit_2__T] + ) -> Future[_submit_2__T]: ... + +_ConcurrentHashMap__KeySetView__K = typing.TypeVar( + "_ConcurrentHashMap__KeySetView__K" +) # +_ConcurrentHashMap__KeySetView__V = typing.TypeVar( + "_ConcurrentHashMap__KeySetView__V" +) # +_ConcurrentHashMap__K = typing.TypeVar("_ConcurrentHashMap__K") # +_ConcurrentHashMap__V = typing.TypeVar("_ConcurrentHashMap__V") # + +class ConcurrentHashMap( + java.util.AbstractMap[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + ConcurrentMap[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + java.io.Serializable, + typing.Generic[_ConcurrentHashMap__K, _ConcurrentHashMap__V], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, float: float): ... + @typing.overload + def __init__(self, int: int, float: float, int2: int): ... + @typing.overload + def __init__( + self, + map: java.util.Map[_ConcurrentHashMap__K, _ConcurrentHashMap__V] + | typing.Mapping[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + ): ... + def clear(self) -> None: ... + def compute( + self, + k: _ConcurrentHashMap__K, + biFunction: java.util.function.BiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V, _ConcurrentHashMap__V + ] + | typing.Callable[ + [_ConcurrentHashMap__K, _ConcurrentHashMap__V], _ConcurrentHashMap__V + ], + ) -> _ConcurrentHashMap__V: ... + def computeIfAbsent( + self, + k: _ConcurrentHashMap__K, + function: java.util.function.Function[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V + ] + | typing.Callable[[_ConcurrentHashMap__K], _ConcurrentHashMap__V], + ) -> _ConcurrentHashMap__V: ... + def computeIfPresent( + self, + k: _ConcurrentHashMap__K, + biFunction: java.util.function.BiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V, _ConcurrentHashMap__V + ] + | typing.Callable[ + [_ConcurrentHashMap__K, _ConcurrentHashMap__V], _ConcurrentHashMap__V + ], + ) -> _ConcurrentHashMap__V: ... + def contains(self, object: typing.Any) -> bool: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def elements(self) -> java.util.Enumeration[_ConcurrentHashMap__V]: ... + def entrySet( + self, + ) -> java.util.Set[ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V] + ]: ... + def equals(self, object: typing.Any) -> bool: ... + _forEach_2__U = typing.TypeVar("_forEach_2__U") # + @typing.overload + def forEach( + self, + biConsumer: java.util.function.BiConsumer[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V + ] + | typing.Callable[[_ConcurrentHashMap__K, _ConcurrentHashMap__V], None], + ) -> None: ... + @typing.overload + def forEach( + self, + long: int, + biConsumer: java.util.function.BiConsumer[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V + ] + | typing.Callable[[_ConcurrentHashMap__K, _ConcurrentHashMap__V], None], + ) -> None: ... + @typing.overload + def forEach( + self, + long: int, + biFunction: java.util.function.BiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V, _forEach_2__U + ] + | typing.Callable[ + [_ConcurrentHashMap__K, _ConcurrentHashMap__V], _forEach_2__U + ], + consumer: java.util.function.Consumer[_forEach_2__U] + | typing.Callable[[_forEach_2__U], None], + ) -> None: ... + _forEachEntry_1__U = typing.TypeVar("_forEachEntry_1__U") # + @typing.overload + def forEachEntry( + self, + long: int, + consumer: java.util.function.Consumer[ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V] + ] + | typing.Callable[ + [java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V]], None + ], + ) -> None: ... + @typing.overload + def forEachEntry( + self, + long: int, + function: java.util.function.Function[ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + _forEachEntry_1__U, + ] + | typing.Callable[ + [java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V]], + _forEachEntry_1__U, + ], + consumer: java.util.function.Consumer[_forEachEntry_1__U] + | typing.Callable[[_forEachEntry_1__U], None], + ) -> None: ... + _forEachKey_1__U = typing.TypeVar("_forEachKey_1__U") # + @typing.overload + def forEachKey( + self, + long: int, + consumer: java.util.function.Consumer[_ConcurrentHashMap__K] + | typing.Callable[[_ConcurrentHashMap__K], None], + ) -> None: ... + @typing.overload + def forEachKey( + self, + long: int, + function: java.util.function.Function[_ConcurrentHashMap__K, _forEachKey_1__U] + | typing.Callable[[_ConcurrentHashMap__K], _forEachKey_1__U], + consumer: java.util.function.Consumer[_forEachKey_1__U] + | typing.Callable[[_forEachKey_1__U], None], + ) -> None: ... + _forEachValue_1__U = typing.TypeVar("_forEachValue_1__U") # + @typing.overload + def forEachValue( + self, + long: int, + consumer: java.util.function.Consumer[_ConcurrentHashMap__V] + | typing.Callable[[_ConcurrentHashMap__V], None], + ) -> None: ... + @typing.overload + def forEachValue( + self, + long: int, + function: java.util.function.Function[_ConcurrentHashMap__V, _forEachValue_1__U] + | typing.Callable[[_ConcurrentHashMap__V], _forEachValue_1__U], + consumer: java.util.function.Consumer[_forEachValue_1__U] + | typing.Callable[[_forEachValue_1__U], None], + ) -> None: ... + def get(self, object: typing.Any) -> _ConcurrentHashMap__V: ... + def getOrDefault( + self, object: typing.Any, v: _ConcurrentHashMap__V + ) -> _ConcurrentHashMap__V: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + @typing.overload + def keySet( + self, + ) -> ConcurrentHashMap.KeySetView[_ConcurrentHashMap__K, _ConcurrentHashMap__V]: ... + @typing.overload + def keySet( + self, v: _ConcurrentHashMap__V + ) -> ConcurrentHashMap.KeySetView[_ConcurrentHashMap__K, _ConcurrentHashMap__V]: ... + def keys(self) -> java.util.Enumeration[_ConcurrentHashMap__K]: ... + def mappingCount(self) -> int: ... + def merge( + self, + k: _ConcurrentHashMap__K, + v: _ConcurrentHashMap__V, + biFunction: java.util.function.BiFunction[ + _ConcurrentHashMap__V, _ConcurrentHashMap__V, _ConcurrentHashMap__V + ] + | typing.Callable[ + [_ConcurrentHashMap__V, _ConcurrentHashMap__V], _ConcurrentHashMap__V + ], + ) -> _ConcurrentHashMap__V: ... + _newKeySet_0__K = typing.TypeVar("_newKeySet_0__K") # + _newKeySet_1__K = typing.TypeVar("_newKeySet_1__K") # + @typing.overload + @staticmethod + def newKeySet() -> ConcurrentHashMap.KeySetView[_newKeySet_0__K, bool]: ... + @typing.overload + @staticmethod + def newKeySet(int: int) -> ConcurrentHashMap.KeySetView[_newKeySet_1__K, bool]: ... + def put( + self, k: _ConcurrentHashMap__K, v: _ConcurrentHashMap__V + ) -> _ConcurrentHashMap__V: ... + def putAll( + self, + map: java.util.Map[_ConcurrentHashMap__K, _ConcurrentHashMap__V] + | typing.Mapping[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + ) -> None: ... + def putIfAbsent( + self, k: _ConcurrentHashMap__K, v: _ConcurrentHashMap__V + ) -> _ConcurrentHashMap__V: ... + _reduce__U = typing.TypeVar("_reduce__U") # + def reduce( + self, + long: int, + biFunction: java.util.function.BiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V, _reduce__U + ] + | typing.Callable[[_ConcurrentHashMap__K, _ConcurrentHashMap__V], _reduce__U], + biFunction2: java.util.function.BiFunction[_reduce__U, _reduce__U, _reduce__U] + | typing.Callable[[_reduce__U, _reduce__U], _reduce__U], + ) -> _reduce__U: ... + _reduceEntries_0__U = typing.TypeVar("_reduceEntries_0__U") # + @typing.overload + def reduceEntries( + self, + long: int, + function: java.util.function.Function[ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + _reduceEntries_0__U, + ] + | typing.Callable[ + [java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V]], + _reduceEntries_0__U, + ], + biFunction: java.util.function.BiFunction[ + _reduceEntries_0__U, _reduceEntries_0__U, _reduceEntries_0__U + ] + | typing.Callable[ + [_reduceEntries_0__U, _reduceEntries_0__U], _reduceEntries_0__U + ], + ) -> _reduceEntries_0__U: ... + @typing.overload + def reduceEntries( + self, + long: int, + biFunction: java.util.function.BiFunction[ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + ] + | typing.Callable[ + [ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + ], + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + ], + ) -> java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V]: ... + def reduceEntriesToDouble( + self, + long: int, + toDoubleFunction: java.util.function.ToDoubleFunction[ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V] + ] + | typing.Callable[ + [java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V]], float + ], + double: float, + doubleBinaryOperator: java.util.function.DoubleBinaryOperator | typing.Callable, + ) -> float: ... + def reduceEntriesToInt( + self, + long: int, + toIntFunction: java.util.function.ToIntFunction[ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V] + ] + | typing.Callable[ + [java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V]], int + ], + int: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def reduceEntriesToLong( + self, + long: int, + toLongFunction: java.util.function.ToLongFunction[ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V] + ] + | typing.Callable[ + [java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V]], int + ], + long2: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + _reduceKeys_1__U = typing.TypeVar("_reduceKeys_1__U") # + @typing.overload + def reduceKeys( + self, + long: int, + biFunction: java.util.function.BiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__K, _ConcurrentHashMap__K + ] + | typing.Callable[ + [_ConcurrentHashMap__K, _ConcurrentHashMap__K], _ConcurrentHashMap__K + ], + ) -> _ConcurrentHashMap__K: ... + @typing.overload + def reduceKeys( + self, + long: int, + function: java.util.function.Function[_ConcurrentHashMap__K, _reduceKeys_1__U] + | typing.Callable[[_ConcurrentHashMap__K], _reduceKeys_1__U], + biFunction: java.util.function.BiFunction[ + _reduceKeys_1__U, _reduceKeys_1__U, _reduceKeys_1__U + ] + | typing.Callable[[_reduceKeys_1__U, _reduceKeys_1__U], _reduceKeys_1__U], + ) -> _reduceKeys_1__U: ... + def reduceKeysToDouble( + self, + long: int, + toDoubleFunction: java.util.function.ToDoubleFunction[_ConcurrentHashMap__K] + | typing.Callable[[_ConcurrentHashMap__K], float], + double: float, + doubleBinaryOperator: java.util.function.DoubleBinaryOperator | typing.Callable, + ) -> float: ... + def reduceKeysToInt( + self, + long: int, + toIntFunction: java.util.function.ToIntFunction[_ConcurrentHashMap__K] + | typing.Callable[[_ConcurrentHashMap__K], int], + int: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def reduceKeysToLong( + self, + long: int, + toLongFunction: java.util.function.ToLongFunction[_ConcurrentHashMap__K] + | typing.Callable[[_ConcurrentHashMap__K], int], + long2: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + def reduceToDouble( + self, + long: int, + toDoubleBiFunction: java.util.function.ToDoubleBiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V + ] + | typing.Callable[[_ConcurrentHashMap__K, _ConcurrentHashMap__V], float], + double: float, + doubleBinaryOperator: java.util.function.DoubleBinaryOperator | typing.Callable, + ) -> float: ... + def reduceToInt( + self, + long: int, + toIntBiFunction: java.util.function.ToIntBiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V + ] + | typing.Callable[[_ConcurrentHashMap__K, _ConcurrentHashMap__V], int], + int: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def reduceToLong( + self, + long: int, + toLongBiFunction: java.util.function.ToLongBiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V + ] + | typing.Callable[[_ConcurrentHashMap__K, _ConcurrentHashMap__V], int], + long2: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + _reduceValues_1__U = typing.TypeVar("_reduceValues_1__U") # + @typing.overload + def reduceValues( + self, + long: int, + biFunction: java.util.function.BiFunction[ + _ConcurrentHashMap__V, _ConcurrentHashMap__V, _ConcurrentHashMap__V + ] + | typing.Callable[ + [_ConcurrentHashMap__V, _ConcurrentHashMap__V], _ConcurrentHashMap__V + ], + ) -> _ConcurrentHashMap__V: ... + @typing.overload + def reduceValues( + self, + long: int, + function: java.util.function.Function[_ConcurrentHashMap__V, _reduceValues_1__U] + | typing.Callable[[_ConcurrentHashMap__V], _reduceValues_1__U], + biFunction: java.util.function.BiFunction[ + _reduceValues_1__U, _reduceValues_1__U, _reduceValues_1__U + ] + | typing.Callable[[_reduceValues_1__U, _reduceValues_1__U], _reduceValues_1__U], + ) -> _reduceValues_1__U: ... + def reduceValuesToDouble( + self, + long: int, + toDoubleFunction: java.util.function.ToDoubleFunction[_ConcurrentHashMap__V] + | typing.Callable[[_ConcurrentHashMap__V], float], + double: float, + doubleBinaryOperator: java.util.function.DoubleBinaryOperator | typing.Callable, + ) -> float: ... + def reduceValuesToInt( + self, + long: int, + toIntFunction: java.util.function.ToIntFunction[_ConcurrentHashMap__V] + | typing.Callable[[_ConcurrentHashMap__V], int], + int: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def reduceValuesToLong( + self, + long: int, + toLongFunction: java.util.function.ToLongFunction[_ConcurrentHashMap__V] + | typing.Callable[[_ConcurrentHashMap__V], int], + long2: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> _ConcurrentHashMap__V: ... + @typing.overload + def replace( + self, + k: _ConcurrentHashMap__K, + v: _ConcurrentHashMap__V, + v2: _ConcurrentHashMap__V, + ) -> bool: ... + @typing.overload + def replace( + self, k: _ConcurrentHashMap__K, v: _ConcurrentHashMap__V + ) -> _ConcurrentHashMap__V: ... + def replaceAll( + self, + biFunction: java.util.function.BiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V, _ConcurrentHashMap__V + ] + | typing.Callable[ + [_ConcurrentHashMap__K, _ConcurrentHashMap__V], _ConcurrentHashMap__V + ], + ) -> None: ... + _search__U = typing.TypeVar("_search__U") # + def search( + self, + long: int, + biFunction: java.util.function.BiFunction[ + _ConcurrentHashMap__K, _ConcurrentHashMap__V, _search__U + ] + | typing.Callable[[_ConcurrentHashMap__K, _ConcurrentHashMap__V], _search__U], + ) -> _search__U: ... + _searchEntries__U = typing.TypeVar("_searchEntries__U") # + def searchEntries( + self, + long: int, + function: java.util.function.Function[ + java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V], + _searchEntries__U, + ] + | typing.Callable[ + [java.util.Map.Entry[_ConcurrentHashMap__K, _ConcurrentHashMap__V]], + _searchEntries__U, + ], + ) -> _searchEntries__U: ... + _searchKeys__U = typing.TypeVar("_searchKeys__U") # + def searchKeys( + self, + long: int, + function: java.util.function.Function[_ConcurrentHashMap__K, _searchKeys__U] + | typing.Callable[[_ConcurrentHashMap__K], _searchKeys__U], + ) -> _searchKeys__U: ... + _searchValues__U = typing.TypeVar("_searchValues__U") # + def searchValues( + self, + long: int, + function: java.util.function.Function[_ConcurrentHashMap__V, _searchValues__U] + | typing.Callable[[_ConcurrentHashMap__V], _searchValues__U], + ) -> _searchValues__U: ... + def size(self) -> int: ... + def toString(self) -> java.lang.String: ... + def values(self) -> java.util.Collection[_ConcurrentHashMap__V]: ... + class KeySetView( + java.util.concurrent.ConcurrentHashMap.CollectionView[ + _ConcurrentHashMap__KeySetView__K, + _ConcurrentHashMap__KeySetView__V, + _ConcurrentHashMap__KeySetView__K, + ], + java.util.Set[_ConcurrentHashMap__KeySetView__K], + java.io.Serializable, + typing.Generic[ + _ConcurrentHashMap__KeySetView__K, _ConcurrentHashMap__KeySetView__V + ], + ): + def add(self, k: _ConcurrentHashMap__KeySetView__K) -> bool: ... + def addAll( + self, + collection: java.util.Collection[_ConcurrentHashMap__KeySetView__K] + | typing.Sequence[_ConcurrentHashMap__KeySetView__K] + | set[_ConcurrentHashMap__KeySetView__K], + ) -> bool: ... + def contains(self, object: typing.Any) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def forEach( + self, + consumer: java.util.function.Consumer[_ConcurrentHashMap__KeySetView__K] + | typing.Callable[[_ConcurrentHashMap__KeySetView__K], None], + ) -> None: ... + def getMappedValue(self) -> _ConcurrentHashMap__KeySetView__V: ... + def hashCode(self) -> int: ... + def iterator(self) -> java.util.Iterator[_ConcurrentHashMap__KeySetView__K]: ... + def remove(self, object: typing.Any) -> bool: ... + def spliterator( + self, + ) -> java.util.Spliterator[_ConcurrentHashMap__KeySetView__K]: ... + + class CollectionView: ... + +_Flow__Processor__T = typing.TypeVar("_Flow__Processor__T") # +_Flow__Processor__R = typing.TypeVar("_Flow__Processor__R") # +_Flow__Publisher__T = typing.TypeVar("_Flow__Publisher__T") # +_Flow__Subscriber__T = typing.TypeVar("_Flow__Subscriber__T") # + +class Flow: + @staticmethod + def defaultBufferSize() -> int: ... + class Processor( + java.util.concurrent.Flow.Subscriber[_Flow__Processor__T], + java.util.concurrent.Flow.Publisher[_Flow__Processor__R], + typing.Generic[_Flow__Processor__T, _Flow__Processor__R], + ): ... + + class Publisher(typing.Generic[_Flow__Publisher__T]): + def subscribe( + self, subscriber: Flow.Subscriber[_Flow__Publisher__T] + ) -> None: ... + + class Subscriber(typing.Generic[_Flow__Subscriber__T]): + def onComplete(self) -> None: ... + def onError(self, throwable: java.lang.Throwable) -> None: ... + def onNext(self, t: _Flow__Subscriber__T) -> None: ... + def onSubscribe(self, subscription: Flow.Subscription) -> None: ... + + class Subscription: + def cancel(self) -> None: ... + def request(self, long: int) -> None: ... + +_SubmissionPublisher__T = typing.TypeVar("_SubmissionPublisher__T") # + +class SubmissionPublisher( + Flow.Publisher[_SubmissionPublisher__T], + java.lang.AutoCloseable, + typing.Generic[_SubmissionPublisher__T], +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, executor: Executor | typing.Callable, int: int): ... + @typing.overload + def __init__( + self, + executor: Executor | typing.Callable, + int: int, + biConsumer: java.util.function.BiConsumer[ + Flow.Subscriber[_SubmissionPublisher__T], java.lang.Throwable + ] + | typing.Callable[ + [Flow.Subscriber[_SubmissionPublisher__T], java.lang.Throwable], None + ], + ): ... + def close(self) -> None: ... + def closeExceptionally(self, throwable: java.lang.Throwable) -> None: ... + def consume( + self, + consumer: java.util.function.Consumer[_SubmissionPublisher__T] + | typing.Callable[[_SubmissionPublisher__T], None], + ) -> CompletableFuture[None]: ... + def estimateMaximumLag(self) -> int: ... + def estimateMinimumDemand(self) -> int: ... + def getClosedException(self) -> java.lang.Throwable: ... + def getExecutor(self) -> Executor: ... + def getMaxBufferCapacity(self) -> int: ... + def getNumberOfSubscribers(self) -> int: ... + def getSubscribers( + self, + ) -> java.util.List[Flow.Subscriber[_SubmissionPublisher__T]]: ... + def hasSubscribers(self) -> bool: ... + def isClosed(self) -> bool: ... + def isSubscribed( + self, subscriber: Flow.Subscriber[_SubmissionPublisher__T] + ) -> bool: ... + @typing.overload + def offer( + self, + t: _SubmissionPublisher__T, + biPredicate: java.util.function.BiPredicate[ + Flow.Subscriber[_SubmissionPublisher__T], _SubmissionPublisher__T + ] + | typing.Callable[ + [Flow.Subscriber[_SubmissionPublisher__T], _SubmissionPublisher__T], bool + ], + ) -> int: ... + @typing.overload + def offer( + self, + t: _SubmissionPublisher__T, + long: int, + timeUnit: TimeUnit, + biPredicate: java.util.function.BiPredicate[ + Flow.Subscriber[_SubmissionPublisher__T], _SubmissionPublisher__T + ] + | typing.Callable[ + [Flow.Subscriber[_SubmissionPublisher__T], _SubmissionPublisher__T], bool + ], + ) -> int: ... + def submit(self, t: _SubmissionPublisher__T) -> int: ... + def subscribe( + self, subscriber: Flow.Subscriber[_SubmissionPublisher__T] + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.concurrent")``. + + AbstractExecutorService: type[AbstractExecutorService] + ArrayBlockingQueue: type[ArrayBlockingQueue] + BlockingDeque: type[BlockingDeque] + BlockingQueue: type[BlockingQueue] + BrokenBarrierException: type[BrokenBarrierException] + Callable: type[Callable] + CancellationException: type[CancellationException] + CompletableFuture: type[CompletableFuture] + CompletionException: type[CompletionException] + CompletionService: type[CompletionService] + CompletionStage: type[CompletionStage] + ConcurrentHashMap: type[ConcurrentHashMap] + ConcurrentLinkedDeque: type[ConcurrentLinkedDeque] + ConcurrentLinkedQueue: type[ConcurrentLinkedQueue] + ConcurrentMap: type[ConcurrentMap] + ConcurrentNavigableMap: type[ConcurrentNavigableMap] + ConcurrentSkipListMap: type[ConcurrentSkipListMap] + ConcurrentSkipListSet: type[ConcurrentSkipListSet] + CopyOnWriteArrayList: type[CopyOnWriteArrayList] + CopyOnWriteArraySet: type[CopyOnWriteArraySet] + CountDownLatch: type[CountDownLatch] + CountedCompleter: type[CountedCompleter] + CyclicBarrier: type[CyclicBarrier] + DelayQueue: type[DelayQueue] + Delayed: type[Delayed] + Exchanger: type[Exchanger] + ExecutionException: type[ExecutionException] + Executor: type[Executor] + ExecutorCompletionService: type[ExecutorCompletionService] + ExecutorService: type[ExecutorService] + Executors: type[Executors] + Flow: type[Flow] + ForkJoinPool: type[ForkJoinPool] + ForkJoinTask: type[ForkJoinTask] + ForkJoinWorkerThread: type[ForkJoinWorkerThread] + Future: type[Future] + FutureTask: type[FutureTask] + LinkedBlockingDeque: type[LinkedBlockingDeque] + LinkedBlockingQueue: type[LinkedBlockingQueue] + LinkedTransferQueue: type[LinkedTransferQueue] + Phaser: type[Phaser] + PriorityBlockingQueue: type[PriorityBlockingQueue] + RecursiveAction: type[RecursiveAction] + RecursiveTask: type[RecursiveTask] + RejectedExecutionException: type[RejectedExecutionException] + RejectedExecutionHandler: type[RejectedExecutionHandler] + RunnableFuture: type[RunnableFuture] + RunnableScheduledFuture: type[RunnableScheduledFuture] + ScheduledExecutorService: type[ScheduledExecutorService] + ScheduledFuture: type[ScheduledFuture] + ScheduledThreadPoolExecutor: type[ScheduledThreadPoolExecutor] + Semaphore: type[Semaphore] + StructureViolationException: type[StructureViolationException] + StructuredTaskScope: type[StructuredTaskScope] + SubmissionPublisher: type[SubmissionPublisher] + SynchronousQueue: type[SynchronousQueue] + ThreadFactory: type[ThreadFactory] + ThreadLocalRandom: type[ThreadLocalRandom] + ThreadPoolExecutor: type[ThreadPoolExecutor] + TimeUnit: type[TimeUnit] + TimeoutException: type[TimeoutException] + TransferQueue: type[TransferQueue] + atomic: java.util.concurrent.atomic.__module_protocol__ + locks: java.util.concurrent.locks.__module_protocol__ diff --git a/typings/java/util/concurrent/atomic/__init__.pyi b/typings/java/util/concurrent/atomic/__init__.pyi new file mode 100644 index 0000000..a32a5bb --- /dev/null +++ b/typings/java/util/concurrent/atomic/__init__.pyi @@ -0,0 +1,691 @@ +import typing +from typing import Protocol + +import java +import java.io +import java.lang +import java.util.function +import jpype + +class AtomicBoolean(java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + def compareAndExchange(self, boolean: bool, boolean2: bool) -> bool: ... + def compareAndExchangeAcquire(self, boolean: bool, boolean2: bool) -> bool: ... + def compareAndExchangeRelease(self, boolean: bool, boolean2: bool) -> bool: ... + def compareAndSet(self, boolean: bool, boolean2: bool) -> bool: ... + def get(self) -> bool: ... + def getAcquire(self) -> bool: ... + def getAndSet(self, boolean: bool) -> bool: ... + def getOpaque(self) -> bool: ... + def getPlain(self) -> bool: ... + def lazySet(self, boolean: bool) -> None: ... + def set(self, boolean: bool) -> None: ... + def setOpaque(self, boolean: bool) -> None: ... + def setPlain(self, boolean: bool) -> None: ... + def setRelease(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + def weakCompareAndSet(self, boolean: bool, boolean2: bool) -> bool: ... + def weakCompareAndSetAcquire(self, boolean: bool, boolean2: bool) -> bool: ... + def weakCompareAndSetPlain(self, boolean: bool, boolean2: bool) -> bool: ... + def weakCompareAndSetRelease(self, boolean: bool, boolean2: bool) -> bool: ... + def weakCompareAndSetVolatile(self, boolean: bool, boolean2: bool) -> bool: ... + +class AtomicInteger(java.lang.Number, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + def accumulateAndGet( + self, + int: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def addAndGet(self, int: int) -> int: ... + def compareAndExchange(self, int: int, int2: int) -> int: ... + def compareAndExchangeAcquire(self, int: int, int2: int) -> int: ... + def compareAndExchangeRelease(self, int: int, int2: int) -> int: ... + def compareAndSet(self, int: int, int2: int) -> bool: ... + def decrementAndGet(self) -> int: ... + def doubleValue(self) -> float: ... + def floatValue(self) -> float: ... + def get(self) -> int: ... + def getAcquire(self) -> int: ... + def getAndAccumulate( + self, + int: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def getAndAdd(self, int: int) -> int: ... + def getAndDecrement(self) -> int: ... + def getAndIncrement(self) -> int: ... + def getAndSet(self, int: int) -> int: ... + def getAndUpdate( + self, intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable + ) -> int: ... + def getOpaque(self) -> int: ... + def getPlain(self) -> int: ... + def incrementAndGet(self) -> int: ... + def intValue(self) -> int: ... + def lazySet(self, int: int) -> None: ... + def longValue(self) -> int: ... + def set(self, int: int) -> None: ... + def setOpaque(self, int: int) -> None: ... + def setPlain(self, int: int) -> None: ... + def setRelease(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + def updateAndGet( + self, intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable + ) -> int: ... + def weakCompareAndSet(self, int: int, int2: int) -> bool: ... + def weakCompareAndSetAcquire(self, int: int, int2: int) -> bool: ... + def weakCompareAndSetPlain(self, int: int, int2: int) -> bool: ... + def weakCompareAndSetRelease(self, int: int, int2: int) -> bool: ... + def weakCompareAndSetVolatile(self, int: int, int2: int) -> bool: ... + +class AtomicIntegerArray(java.io.Serializable): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, intArray: list[int] | jpype.JArray): ... + def accumulateAndGet( + self, + int: int, + int2: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def addAndGet(self, int: int, int2: int) -> int: ... + def compareAndExchange(self, int: int, int2: int, int3: int) -> int: ... + def compareAndExchangeAcquire(self, int: int, int2: int, int3: int) -> int: ... + def compareAndExchangeRelease(self, int: int, int2: int, int3: int) -> int: ... + def compareAndSet(self, int: int, int2: int, int3: int) -> bool: ... + def decrementAndGet(self, int: int) -> int: ... + def get(self, int: int) -> int: ... + def getAcquire(self, int: int) -> int: ... + def getAndAccumulate( + self, + int: int, + int2: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def getAndAdd(self, int: int, int2: int) -> int: ... + def getAndDecrement(self, int: int) -> int: ... + def getAndIncrement(self, int: int) -> int: ... + def getAndSet(self, int: int, int2: int) -> int: ... + def getAndUpdate( + self, + int: int, + intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable, + ) -> int: ... + def getOpaque(self, int: int) -> int: ... + def getPlain(self, int: int) -> int: ... + def incrementAndGet(self, int: int) -> int: ... + def lazySet(self, int: int, int2: int) -> None: ... + def length(self) -> int: ... + def set(self, int: int, int2: int) -> None: ... + def setOpaque(self, int: int, int2: int) -> None: ... + def setPlain(self, int: int, int2: int) -> None: ... + def setRelease(self, int: int, int2: int) -> None: ... + def toString(self) -> java.lang.String: ... + def updateAndGet( + self, + int: int, + intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable, + ) -> int: ... + def weakCompareAndSet(self, int: int, int2: int, int3: int) -> bool: ... + def weakCompareAndSetAcquire(self, int: int, int2: int, int3: int) -> bool: ... + def weakCompareAndSetPlain(self, int: int, int2: int, int3: int) -> bool: ... + def weakCompareAndSetRelease(self, int: int, int2: int, int3: int) -> bool: ... + def weakCompareAndSetVolatile(self, int: int, int2: int, int3: int) -> bool: ... + +_AtomicIntegerFieldUpdater__T = typing.TypeVar("_AtomicIntegerFieldUpdater__T") # + +class AtomicIntegerFieldUpdater(typing.Generic[_AtomicIntegerFieldUpdater__T]): + def accumulateAndGet( + self, + t: _AtomicIntegerFieldUpdater__T, + int: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def addAndGet(self, t: _AtomicIntegerFieldUpdater__T, int: int) -> int: ... + def compareAndSet( + self, t: _AtomicIntegerFieldUpdater__T, int: int, int2: int + ) -> bool: ... + def decrementAndGet(self, t: _AtomicIntegerFieldUpdater__T) -> int: ... + def get(self, t: _AtomicIntegerFieldUpdater__T) -> int: ... + def getAndAccumulate( + self, + t: _AtomicIntegerFieldUpdater__T, + int: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + def getAndAdd(self, t: _AtomicIntegerFieldUpdater__T, int: int) -> int: ... + def getAndDecrement(self, t: _AtomicIntegerFieldUpdater__T) -> int: ... + def getAndIncrement(self, t: _AtomicIntegerFieldUpdater__T) -> int: ... + def getAndSet(self, t: _AtomicIntegerFieldUpdater__T, int: int) -> int: ... + def getAndUpdate( + self, + t: _AtomicIntegerFieldUpdater__T, + intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable, + ) -> int: ... + def incrementAndGet(self, t: _AtomicIntegerFieldUpdater__T) -> int: ... + def lazySet(self, t: _AtomicIntegerFieldUpdater__T, int: int) -> None: ... + _newUpdater__U = typing.TypeVar("_newUpdater__U") # + @staticmethod + def newUpdater( + class_: type[_newUpdater__U], string: java.lang.String | str + ) -> AtomicIntegerFieldUpdater[_newUpdater__U]: ... + def set(self, t: _AtomicIntegerFieldUpdater__T, int: int) -> None: ... + def updateAndGet( + self, + t: _AtomicIntegerFieldUpdater__T, + intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable, + ) -> int: ... + def weakCompareAndSet( + self, t: _AtomicIntegerFieldUpdater__T, int: int, int2: int + ) -> bool: ... + +class AtomicLong(java.lang.Number, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, long: int): ... + def accumulateAndGet( + self, + long: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + def addAndGet(self, long: int) -> int: ... + def compareAndExchange(self, long: int, long2: int) -> int: ... + def compareAndExchangeAcquire(self, long: int, long2: int) -> int: ... + def compareAndExchangeRelease(self, long: int, long2: int) -> int: ... + def compareAndSet(self, long: int, long2: int) -> bool: ... + def decrementAndGet(self) -> int: ... + def doubleValue(self) -> float: ... + def floatValue(self) -> float: ... + def get(self) -> int: ... + def getAcquire(self) -> int: ... + def getAndAccumulate( + self, + long: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + def getAndAdd(self, long: int) -> int: ... + def getAndDecrement(self) -> int: ... + def getAndIncrement(self) -> int: ... + def getAndSet(self, long: int) -> int: ... + def getAndUpdate( + self, longUnaryOperator: java.util.function.LongUnaryOperator | typing.Callable + ) -> int: ... + def getOpaque(self) -> int: ... + def getPlain(self) -> int: ... + def incrementAndGet(self) -> int: ... + def intValue(self) -> int: ... + def lazySet(self, long: int) -> None: ... + def longValue(self) -> int: ... + def set(self, long: int) -> None: ... + def setOpaque(self, long: int) -> None: ... + def setPlain(self, long: int) -> None: ... + def setRelease(self, long: int) -> None: ... + def toString(self) -> java.lang.String: ... + def updateAndGet( + self, longUnaryOperator: java.util.function.LongUnaryOperator | typing.Callable + ) -> int: ... + def weakCompareAndSet(self, long: int, long2: int) -> bool: ... + def weakCompareAndSetAcquire(self, long: int, long2: int) -> bool: ... + def weakCompareAndSetPlain(self, long: int, long2: int) -> bool: ... + def weakCompareAndSetRelease(self, long: int, long2: int) -> bool: ... + def weakCompareAndSetVolatile(self, long: int, long2: int) -> bool: ... + +class AtomicLongArray(java.io.Serializable): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, longArray: list[int] | jpype.JArray): ... + def accumulateAndGet( + self, + int: int, + long: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + def addAndGet(self, int: int, long: int) -> int: ... + def compareAndExchange(self, int: int, long: int, long2: int) -> int: ... + def compareAndExchangeAcquire(self, int: int, long: int, long2: int) -> int: ... + def compareAndExchangeRelease(self, int: int, long: int, long2: int) -> int: ... + def compareAndSet(self, int: int, long: int, long2: int) -> bool: ... + def decrementAndGet(self, int: int) -> int: ... + def get(self, int: int) -> int: ... + def getAcquire(self, int: int) -> int: ... + def getAndAccumulate( + self, + int: int, + long: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + def getAndAdd(self, int: int, long: int) -> int: ... + def getAndDecrement(self, int: int) -> int: ... + def getAndIncrement(self, int: int) -> int: ... + def getAndSet(self, int: int, long: int) -> int: ... + def getAndUpdate( + self, + int: int, + longUnaryOperator: java.util.function.LongUnaryOperator | typing.Callable, + ) -> int: ... + def getOpaque(self, int: int) -> int: ... + def getPlain(self, int: int) -> int: ... + def incrementAndGet(self, int: int) -> int: ... + def lazySet(self, int: int, long: int) -> None: ... + def length(self) -> int: ... + def set(self, int: int, long: int) -> None: ... + def setOpaque(self, int: int, long: int) -> None: ... + def setPlain(self, int: int, long: int) -> None: ... + def setRelease(self, int: int, long: int) -> None: ... + def toString(self) -> java.lang.String: ... + def updateAndGet( + self, + int: int, + longUnaryOperator: java.util.function.LongUnaryOperator | typing.Callable, + ) -> int: ... + def weakCompareAndSet(self, int: int, long: int, long2: int) -> bool: ... + def weakCompareAndSetAcquire(self, int: int, long: int, long2: int) -> bool: ... + def weakCompareAndSetPlain(self, int: int, long: int, long2: int) -> bool: ... + def weakCompareAndSetRelease(self, int: int, long: int, long2: int) -> bool: ... + def weakCompareAndSetVolatile(self, int: int, long: int, long2: int) -> bool: ... + +_AtomicLongFieldUpdater__T = typing.TypeVar("_AtomicLongFieldUpdater__T") # + +class AtomicLongFieldUpdater(typing.Generic[_AtomicLongFieldUpdater__T]): + def accumulateAndGet( + self, + t: _AtomicLongFieldUpdater__T, + long: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + def addAndGet(self, t: _AtomicLongFieldUpdater__T, long: int) -> int: ... + def compareAndSet( + self, t: _AtomicLongFieldUpdater__T, long: int, long2: int + ) -> bool: ... + def decrementAndGet(self, t: _AtomicLongFieldUpdater__T) -> int: ... + def get(self, t: _AtomicLongFieldUpdater__T) -> int: ... + def getAndAccumulate( + self, + t: _AtomicLongFieldUpdater__T, + long: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + def getAndAdd(self, t: _AtomicLongFieldUpdater__T, long: int) -> int: ... + def getAndDecrement(self, t: _AtomicLongFieldUpdater__T) -> int: ... + def getAndIncrement(self, t: _AtomicLongFieldUpdater__T) -> int: ... + def getAndSet(self, t: _AtomicLongFieldUpdater__T, long: int) -> int: ... + def getAndUpdate( + self, + t: _AtomicLongFieldUpdater__T, + longUnaryOperator: java.util.function.LongUnaryOperator | typing.Callable, + ) -> int: ... + def incrementAndGet(self, t: _AtomicLongFieldUpdater__T) -> int: ... + def lazySet(self, t: _AtomicLongFieldUpdater__T, long: int) -> None: ... + _newUpdater__U = typing.TypeVar("_newUpdater__U") # + @staticmethod + def newUpdater( + class_: type[_newUpdater__U], string: java.lang.String | str + ) -> AtomicLongFieldUpdater[_newUpdater__U]: ... + def set(self, t: _AtomicLongFieldUpdater__T, long: int) -> None: ... + def updateAndGet( + self, + t: _AtomicLongFieldUpdater__T, + longUnaryOperator: java.util.function.LongUnaryOperator | typing.Callable, + ) -> int: ... + def weakCompareAndSet( + self, t: _AtomicLongFieldUpdater__T, long: int, long2: int + ) -> bool: ... + +_AtomicMarkableReference__V = typing.TypeVar("_AtomicMarkableReference__V") # + +class AtomicMarkableReference(typing.Generic[_AtomicMarkableReference__V]): + def __init__(self, v: _AtomicMarkableReference__V, boolean: bool): ... + def attemptMark(self, v: _AtomicMarkableReference__V, boolean: bool) -> bool: ... + def compareAndSet( + self, + v: _AtomicMarkableReference__V, + v2: _AtomicMarkableReference__V, + boolean: bool, + boolean2: bool, + ) -> bool: ... + def get( + self, booleanArray: list[bool] | jpype.JArray + ) -> _AtomicMarkableReference__V: ... + def getReference(self) -> _AtomicMarkableReference__V: ... + def isMarked(self) -> bool: ... + def set(self, v: _AtomicMarkableReference__V, boolean: bool) -> None: ... + def weakCompareAndSet( + self, + v: _AtomicMarkableReference__V, + v2: _AtomicMarkableReference__V, + boolean: bool, + boolean2: bool, + ) -> bool: ... + +_AtomicReference__V = typing.TypeVar("_AtomicReference__V") # + +class AtomicReference(java.io.Serializable, typing.Generic[_AtomicReference__V]): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, v: _AtomicReference__V): ... + def accumulateAndGet( + self, + v: _AtomicReference__V, + binaryOperator: java.util.function.BinaryOperator[_AtomicReference__V] + | typing.Callable, + ) -> _AtomicReference__V: ... + def compareAndExchange( + self, v: _AtomicReference__V, v2: _AtomicReference__V + ) -> _AtomicReference__V: ... + def compareAndExchangeAcquire( + self, v: _AtomicReference__V, v2: _AtomicReference__V + ) -> _AtomicReference__V: ... + def compareAndExchangeRelease( + self, v: _AtomicReference__V, v2: _AtomicReference__V + ) -> _AtomicReference__V: ... + def compareAndSet( + self, v: _AtomicReference__V, v2: _AtomicReference__V + ) -> bool: ... + def get(self) -> _AtomicReference__V: ... + def getAcquire(self) -> _AtomicReference__V: ... + def getAndAccumulate( + self, + v: _AtomicReference__V, + binaryOperator: java.util.function.BinaryOperator[_AtomicReference__V] + | typing.Callable, + ) -> _AtomicReference__V: ... + def getAndSet(self, v: _AtomicReference__V) -> _AtomicReference__V: ... + def getAndUpdate( + self, + unaryOperator: java.util.function.UnaryOperator[_AtomicReference__V] + | typing.Callable, + ) -> _AtomicReference__V: ... + def getOpaque(self) -> _AtomicReference__V: ... + def getPlain(self) -> _AtomicReference__V: ... + def lazySet(self, v: _AtomicReference__V) -> None: ... + def set(self, v: _AtomicReference__V) -> None: ... + def setOpaque(self, v: _AtomicReference__V) -> None: ... + def setPlain(self, v: _AtomicReference__V) -> None: ... + def setRelease(self, v: _AtomicReference__V) -> None: ... + def toString(self) -> java.lang.String: ... + def updateAndGet( + self, + unaryOperator: java.util.function.UnaryOperator[_AtomicReference__V] + | typing.Callable, + ) -> _AtomicReference__V: ... + def weakCompareAndSet( + self, v: _AtomicReference__V, v2: _AtomicReference__V + ) -> bool: ... + def weakCompareAndSetAcquire( + self, v: _AtomicReference__V, v2: _AtomicReference__V + ) -> bool: ... + def weakCompareAndSetPlain( + self, v: _AtomicReference__V, v2: _AtomicReference__V + ) -> bool: ... + def weakCompareAndSetRelease( + self, v: _AtomicReference__V, v2: _AtomicReference__V + ) -> bool: ... + def weakCompareAndSetVolatile( + self, v: _AtomicReference__V, v2: _AtomicReference__V + ) -> bool: ... + +_AtomicReferenceArray__E = typing.TypeVar("_AtomicReferenceArray__E") # + +class AtomicReferenceArray( + java.io.Serializable, typing.Generic[_AtomicReferenceArray__E] +): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, eArray: list[_AtomicReferenceArray__E] | jpype.JArray): ... + def accumulateAndGet( + self, + int: int, + e: _AtomicReferenceArray__E, + binaryOperator: java.util.function.BinaryOperator[_AtomicReferenceArray__E] + | typing.Callable, + ) -> _AtomicReferenceArray__E: ... + def compareAndExchange( + self, int: int, e: _AtomicReferenceArray__E, e2: _AtomicReferenceArray__E + ) -> _AtomicReferenceArray__E: ... + def compareAndExchangeAcquire( + self, int: int, e: _AtomicReferenceArray__E, e2: _AtomicReferenceArray__E + ) -> _AtomicReferenceArray__E: ... + def compareAndExchangeRelease( + self, int: int, e: _AtomicReferenceArray__E, e2: _AtomicReferenceArray__E + ) -> _AtomicReferenceArray__E: ... + def compareAndSet( + self, int: int, e: _AtomicReferenceArray__E, e2: _AtomicReferenceArray__E + ) -> bool: ... + def get(self, int: int) -> _AtomicReferenceArray__E: ... + def getAcquire(self, int: int) -> _AtomicReferenceArray__E: ... + def getAndAccumulate( + self, + int: int, + e: _AtomicReferenceArray__E, + binaryOperator: java.util.function.BinaryOperator[_AtomicReferenceArray__E] + | typing.Callable, + ) -> _AtomicReferenceArray__E: ... + def getAndSet( + self, int: int, e: _AtomicReferenceArray__E + ) -> _AtomicReferenceArray__E: ... + def getAndUpdate( + self, + int: int, + unaryOperator: java.util.function.UnaryOperator[_AtomicReferenceArray__E] + | typing.Callable, + ) -> _AtomicReferenceArray__E: ... + def getOpaque(self, int: int) -> _AtomicReferenceArray__E: ... + def getPlain(self, int: int) -> _AtomicReferenceArray__E: ... + def lazySet(self, int: int, e: _AtomicReferenceArray__E) -> None: ... + def length(self) -> int: ... + def set(self, int: int, e: _AtomicReferenceArray__E) -> None: ... + def setOpaque(self, int: int, e: _AtomicReferenceArray__E) -> None: ... + def setPlain(self, int: int, e: _AtomicReferenceArray__E) -> None: ... + def setRelease(self, int: int, e: _AtomicReferenceArray__E) -> None: ... + def toString(self) -> java.lang.String: ... + def updateAndGet( + self, + int: int, + unaryOperator: java.util.function.UnaryOperator[_AtomicReferenceArray__E] + | typing.Callable, + ) -> _AtomicReferenceArray__E: ... + def weakCompareAndSet( + self, int: int, e: _AtomicReferenceArray__E, e2: _AtomicReferenceArray__E + ) -> bool: ... + def weakCompareAndSetAcquire( + self, int: int, e: _AtomicReferenceArray__E, e2: _AtomicReferenceArray__E + ) -> bool: ... + def weakCompareAndSetPlain( + self, int: int, e: _AtomicReferenceArray__E, e2: _AtomicReferenceArray__E + ) -> bool: ... + def weakCompareAndSetRelease( + self, int: int, e: _AtomicReferenceArray__E, e2: _AtomicReferenceArray__E + ) -> bool: ... + def weakCompareAndSetVolatile( + self, int: int, e: _AtomicReferenceArray__E, e2: _AtomicReferenceArray__E + ) -> bool: ... + +_AtomicReferenceFieldUpdater__T = typing.TypeVar( + "_AtomicReferenceFieldUpdater__T" +) # +_AtomicReferenceFieldUpdater__V = typing.TypeVar( + "_AtomicReferenceFieldUpdater__V" +) # + +class AtomicReferenceFieldUpdater( + typing.Generic[_AtomicReferenceFieldUpdater__T, _AtomicReferenceFieldUpdater__V] +): + def accumulateAndGet( + self, + t: _AtomicReferenceFieldUpdater__T, + v: _AtomicReferenceFieldUpdater__V, + binaryOperator: java.util.function.BinaryOperator[ + _AtomicReferenceFieldUpdater__V + ] + | typing.Callable, + ) -> _AtomicReferenceFieldUpdater__V: ... + def compareAndSet( + self, + t: _AtomicReferenceFieldUpdater__T, + v: _AtomicReferenceFieldUpdater__V, + v2: _AtomicReferenceFieldUpdater__V, + ) -> bool: ... + def get( + self, t: _AtomicReferenceFieldUpdater__T + ) -> _AtomicReferenceFieldUpdater__V: ... + def getAndAccumulate( + self, + t: _AtomicReferenceFieldUpdater__T, + v: _AtomicReferenceFieldUpdater__V, + binaryOperator: java.util.function.BinaryOperator[ + _AtomicReferenceFieldUpdater__V + ] + | typing.Callable, + ) -> _AtomicReferenceFieldUpdater__V: ... + def getAndSet( + self, t: _AtomicReferenceFieldUpdater__T, v: _AtomicReferenceFieldUpdater__V + ) -> _AtomicReferenceFieldUpdater__V: ... + def getAndUpdate( + self, + t: _AtomicReferenceFieldUpdater__T, + unaryOperator: java.util.function.UnaryOperator[_AtomicReferenceFieldUpdater__V] + | typing.Callable, + ) -> _AtomicReferenceFieldUpdater__V: ... + def lazySet( + self, t: _AtomicReferenceFieldUpdater__T, v: _AtomicReferenceFieldUpdater__V + ) -> None: ... + _newUpdater__U = typing.TypeVar("_newUpdater__U") # + _newUpdater__W = typing.TypeVar("_newUpdater__W") # + @staticmethod + def newUpdater( + class_: type[_newUpdater__U], + class2: type[_newUpdater__W], + string: java.lang.String | str, + ) -> AtomicReferenceFieldUpdater[_newUpdater__U, _newUpdater__W]: ... + def set( + self, t: _AtomicReferenceFieldUpdater__T, v: _AtomicReferenceFieldUpdater__V + ) -> None: ... + def updateAndGet( + self, + t: _AtomicReferenceFieldUpdater__T, + unaryOperator: java.util.function.UnaryOperator[_AtomicReferenceFieldUpdater__V] + | typing.Callable, + ) -> _AtomicReferenceFieldUpdater__V: ... + def weakCompareAndSet( + self, + t: _AtomicReferenceFieldUpdater__T, + v: _AtomicReferenceFieldUpdater__V, + v2: _AtomicReferenceFieldUpdater__V, + ) -> bool: ... + +_AtomicStampedReference__V = typing.TypeVar("_AtomicStampedReference__V") # + +class AtomicStampedReference(typing.Generic[_AtomicStampedReference__V]): + def __init__(self, v: _AtomicStampedReference__V, int: int): ... + def attemptStamp(self, v: _AtomicStampedReference__V, int: int) -> bool: ... + def compareAndSet( + self, + v: _AtomicStampedReference__V, + v2: _AtomicStampedReference__V, + int: int, + int2: int, + ) -> bool: ... + def get(self, intArray: list[int] | jpype.JArray) -> _AtomicStampedReference__V: ... + def getReference(self) -> _AtomicStampedReference__V: ... + def getStamp(self) -> int: ... + def set(self, v: _AtomicStampedReference__V, int: int) -> None: ... + def weakCompareAndSet( + self, + v: _AtomicStampedReference__V, + v2: _AtomicStampedReference__V, + int: int, + int2: int, + ) -> bool: ... + +class DoubleAccumulator(java.util.concurrent.atomic.Striped64, java.io.Serializable): + def __init__( + self, + doubleBinaryOperator: java.util.function.DoubleBinaryOperator | typing.Callable, + double2: float, + ): ... + def accumulate(self, double: float) -> None: ... + def doubleValue(self) -> float: ... + def floatValue(self) -> float: ... + def get(self) -> float: ... + def getThenReset(self) -> float: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + def reset(self) -> None: ... + def toString(self) -> java.lang.String: ... + +class DoubleAdder(java.util.concurrent.atomic.Striped64, java.io.Serializable): + def __init__(self): ... + def add(self, double: float) -> None: ... + def doubleValue(self) -> float: ... + def floatValue(self) -> float: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + def reset(self) -> None: ... + def sum(self) -> float: ... + def sumThenReset(self) -> float: ... + def toString(self) -> java.lang.String: ... + +class LongAccumulator(java.util.concurrent.atomic.Striped64, java.io.Serializable): + def __init__( + self, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + long2: int, + ): ... + def accumulate(self, long: int) -> None: ... + def doubleValue(self) -> float: ... + def floatValue(self) -> float: ... + def get(self) -> int: ... + def getThenReset(self) -> int: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + def reset(self) -> None: ... + def toString(self) -> java.lang.String: ... + +class LongAdder(java.util.concurrent.atomic.Striped64, java.io.Serializable): + def __init__(self): ... + def add(self, long: int) -> None: ... + def decrement(self) -> None: ... + def doubleValue(self) -> float: ... + def floatValue(self) -> float: ... + def increment(self) -> None: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + def reset(self) -> None: ... + def sum(self) -> int: ... + def sumThenReset(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class Striped64: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.concurrent.atomic")``. + + AtomicBoolean: type[AtomicBoolean] + AtomicInteger: type[AtomicInteger] + AtomicIntegerArray: type[AtomicIntegerArray] + AtomicIntegerFieldUpdater: type[AtomicIntegerFieldUpdater] + AtomicLong: type[AtomicLong] + AtomicLongArray: type[AtomicLongArray] + AtomicLongFieldUpdater: type[AtomicLongFieldUpdater] + AtomicMarkableReference: type[AtomicMarkableReference] + AtomicReference: type[AtomicReference] + AtomicReferenceArray: type[AtomicReferenceArray] + AtomicReferenceFieldUpdater: type[AtomicReferenceFieldUpdater] + AtomicStampedReference: type[AtomicStampedReference] + DoubleAccumulator: type[DoubleAccumulator] + DoubleAdder: type[DoubleAdder] + LongAccumulator: type[LongAccumulator] + LongAdder: type[LongAdder] + Striped64: type[Striped64] diff --git a/typings/java/util/concurrent/locks/__init__.pyi b/typings/java/util/concurrent/locks/__init__.pyi new file mode 100644 index 0000000..ca3c36f --- /dev/null +++ b/typings/java/util/concurrent/locks/__init__.pyi @@ -0,0 +1,282 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import java.util.concurrent + +class AbstractOwnableSynchronizer(java.io.Serializable): ... + +class Condition: + def awaitNanos(self, long: int) -> int: ... + def awaitUninterruptibly(self) -> None: ... + def awaitUntil(self, date: java.util.Date) -> bool: ... + @typing.overload + def await_(self, long: int, timeUnit: java.util.concurrent.TimeUnit) -> bool: ... + @typing.overload + def await_(self) -> None: ... + def signal(self) -> None: ... + def signalAll(self) -> None: ... + +class Lock: + def lock(self) -> None: ... + def lockInterruptibly(self) -> None: ... + def newCondition(self) -> Condition: ... + @typing.overload + def tryLock(self) -> bool: ... + @typing.overload + def tryLock(self, long: int, timeUnit: java.util.concurrent.TimeUnit) -> bool: ... + def unlock(self) -> None: ... + +class LockSupport: + @staticmethod + def getBlocker(thread: java.lang.Thread) -> typing.Any: ... + @typing.overload + @staticmethod + def park() -> None: ... + @typing.overload + @staticmethod + def park(object: typing.Any) -> None: ... + @typing.overload + @staticmethod + def parkNanos(object: typing.Any, long: int) -> None: ... + @typing.overload + @staticmethod + def parkNanos(long: int) -> None: ... + @typing.overload + @staticmethod + def parkUntil(object: typing.Any, long: int) -> None: ... + @typing.overload + @staticmethod + def parkUntil(long: int) -> None: ... + @staticmethod + def setCurrentBlocker(object: typing.Any) -> None: ... + @staticmethod + def unpark(thread: java.lang.Thread) -> None: ... + +class ReadWriteLock: + def readLock(self) -> Lock: ... + def writeLock(self) -> Lock: ... + +class StampedLock(java.io.Serializable): + def __init__(self): ... + def asReadLock(self) -> Lock: ... + def asReadWriteLock(self) -> ReadWriteLock: ... + def asWriteLock(self) -> Lock: ... + def getReadLockCount(self) -> int: ... + @staticmethod + def isLockStamp(long: int) -> bool: ... + @staticmethod + def isOptimisticReadStamp(long: int) -> bool: ... + @staticmethod + def isReadLockStamp(long: int) -> bool: ... + def isReadLocked(self) -> bool: ... + @staticmethod + def isWriteLockStamp(long: int) -> bool: ... + def isWriteLocked(self) -> bool: ... + def readLock(self) -> int: ... + def readLockInterruptibly(self) -> int: ... + def toString(self) -> java.lang.String: ... + def tryConvertToOptimisticRead(self, long: int) -> int: ... + def tryConvertToReadLock(self, long: int) -> int: ... + def tryConvertToWriteLock(self, long: int) -> int: ... + def tryOptimisticRead(self) -> int: ... + @typing.overload + def tryReadLock(self) -> int: ... + @typing.overload + def tryReadLock( + self, long: int, timeUnit: java.util.concurrent.TimeUnit + ) -> int: ... + def tryUnlockRead(self) -> bool: ... + def tryUnlockWrite(self) -> bool: ... + @typing.overload + def tryWriteLock(self) -> int: ... + @typing.overload + def tryWriteLock( + self, long: int, timeUnit: java.util.concurrent.TimeUnit + ) -> int: ... + def unlock(self, long: int) -> None: ... + def unlockRead(self, long: int) -> None: ... + def unlockWrite(self, long: int) -> None: ... + def validate(self, long: int) -> bool: ... + def writeLock(self) -> int: ... + def writeLockInterruptibly(self) -> int: ... + +class AbstractQueuedLongSynchronizer(AbstractOwnableSynchronizer, java.io.Serializable): + def __init__(self): ... + def acquire(self, long: int) -> None: ... + def acquireInterruptibly(self, long: int) -> None: ... + def acquireShared(self, long: int) -> None: ... + def acquireSharedInterruptibly(self, long: int) -> None: ... + def getExclusiveQueuedThreads(self) -> java.util.Collection[java.lang.Thread]: ... + def getFirstQueuedThread(self) -> java.lang.Thread: ... + def getQueueLength(self) -> int: ... + def getQueuedThreads(self) -> java.util.Collection[java.lang.Thread]: ... + def getSharedQueuedThreads(self) -> java.util.Collection[java.lang.Thread]: ... + def getWaitQueueLength( + self, conditionObject: AbstractQueuedLongSynchronizer.ConditionObject + ) -> int: ... + def getWaitingThreads( + self, conditionObject: AbstractQueuedLongSynchronizer.ConditionObject + ) -> java.util.Collection[java.lang.Thread]: ... + def hasContended(self) -> bool: ... + def hasQueuedPredecessors(self) -> bool: ... + def hasQueuedThreads(self) -> bool: ... + def hasWaiters( + self, conditionObject: AbstractQueuedLongSynchronizer.ConditionObject + ) -> bool: ... + def isQueued(self, thread: java.lang.Thread) -> bool: ... + def owns( + self, conditionObject: AbstractQueuedLongSynchronizer.ConditionObject + ) -> bool: ... + def release(self, long: int) -> bool: ... + def releaseShared(self, long: int) -> bool: ... + def toString(self) -> java.lang.String: ... + def tryAcquireNanos(self, long: int, long2: int) -> bool: ... + def tryAcquireSharedNanos(self, long: int, long2: int) -> bool: ... + class ConditionObject(Condition, java.io.Serializable): + def __init__( + self, abstractQueuedLongSynchronizer: AbstractQueuedLongSynchronizer + ): ... + def awaitNanos(self, long: int) -> int: ... + def awaitUninterruptibly(self) -> None: ... + def awaitUntil(self, date: java.util.Date) -> bool: ... + @typing.overload + def await_( + self, long: int, timeUnit: java.util.concurrent.TimeUnit + ) -> bool: ... + @typing.overload + def await_(self) -> None: ... + def signal(self) -> None: ... + def signalAll(self) -> None: ... + +class AbstractQueuedSynchronizer(AbstractOwnableSynchronizer, java.io.Serializable): + def acquire(self, int: int) -> None: ... + def acquireInterruptibly(self, int: int) -> None: ... + def acquireShared(self, int: int) -> None: ... + def acquireSharedInterruptibly(self, int: int) -> None: ... + def getExclusiveQueuedThreads(self) -> java.util.Collection[java.lang.Thread]: ... + def getFirstQueuedThread(self) -> java.lang.Thread: ... + def getQueueLength(self) -> int: ... + def getQueuedThreads(self) -> java.util.Collection[java.lang.Thread]: ... + def getSharedQueuedThreads(self) -> java.util.Collection[java.lang.Thread]: ... + def getWaitQueueLength( + self, conditionObject: AbstractQueuedSynchronizer.ConditionObject + ) -> int: ... + def getWaitingThreads( + self, conditionObject: AbstractQueuedSynchronizer.ConditionObject + ) -> java.util.Collection[java.lang.Thread]: ... + def hasContended(self) -> bool: ... + def hasQueuedPredecessors(self) -> bool: ... + def hasQueuedThreads(self) -> bool: ... + def hasWaiters( + self, conditionObject: AbstractQueuedSynchronizer.ConditionObject + ) -> bool: ... + def isQueued(self, thread: java.lang.Thread) -> bool: ... + def owns( + self, conditionObject: AbstractQueuedSynchronizer.ConditionObject + ) -> bool: ... + def release(self, int: int) -> bool: ... + def releaseShared(self, int: int) -> bool: ... + def toString(self) -> java.lang.String: ... + def tryAcquireNanos(self, int: int, long: int) -> bool: ... + def tryAcquireSharedNanos(self, int: int, long: int) -> bool: ... + class ConditionObject(Condition, java.io.Serializable): + def __init__(self, abstractQueuedSynchronizer: AbstractQueuedSynchronizer): ... + def awaitNanos(self, long: int) -> int: ... + def awaitUninterruptibly(self) -> None: ... + def awaitUntil(self, date: java.util.Date) -> bool: ... + @typing.overload + def await_( + self, long: int, timeUnit: java.util.concurrent.TimeUnit + ) -> bool: ... + @typing.overload + def await_(self) -> None: ... + def signal(self) -> None: ... + def signalAll(self) -> None: ... + +class ReentrantLock(Lock, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + def getHoldCount(self) -> int: ... + def getQueueLength(self) -> int: ... + def getWaitQueueLength(self, condition: Condition) -> int: ... + def hasQueuedThread(self, thread: java.lang.Thread) -> bool: ... + def hasQueuedThreads(self) -> bool: ... + def hasWaiters(self, condition: Condition) -> bool: ... + def isFair(self) -> bool: ... + def isHeldByCurrentThread(self) -> bool: ... + def isLocked(self) -> bool: ... + def lock(self) -> None: ... + def lockInterruptibly(self) -> None: ... + def newCondition(self) -> Condition: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def tryLock(self) -> bool: ... + @typing.overload + def tryLock(self, long: int, timeUnit: java.util.concurrent.TimeUnit) -> bool: ... + def unlock(self) -> None: ... + +class ReentrantReadWriteLock(ReadWriteLock, java.io.Serializable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + def getQueueLength(self) -> int: ... + def getReadHoldCount(self) -> int: ... + def getReadLockCount(self) -> int: ... + def getWaitQueueLength(self, condition: Condition) -> int: ... + def getWriteHoldCount(self) -> int: ... + def hasQueuedThread(self, thread: java.lang.Thread) -> bool: ... + def hasQueuedThreads(self) -> bool: ... + def hasWaiters(self, condition: Condition) -> bool: ... + def isFair(self) -> bool: ... + def isWriteLocked(self) -> bool: ... + def isWriteLockedByCurrentThread(self) -> bool: ... + def readLock(self) -> ReentrantReadWriteLock.ReadLock: ... + def toString(self) -> java.lang.String: ... + def writeLock(self) -> ReentrantReadWriteLock.WriteLock: ... + class ReadLock(Lock, java.io.Serializable): + def lock(self) -> None: ... + def lockInterruptibly(self) -> None: ... + def newCondition(self) -> Condition: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def tryLock(self) -> bool: ... + @typing.overload + def tryLock( + self, long: int, timeUnit: java.util.concurrent.TimeUnit + ) -> bool: ... + def unlock(self) -> None: ... + + class WriteLock(Lock, java.io.Serializable): + def getHoldCount(self) -> int: ... + def isHeldByCurrentThread(self) -> bool: ... + def lock(self) -> None: ... + def lockInterruptibly(self) -> None: ... + def newCondition(self) -> Condition: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def tryLock(self) -> bool: ... + @typing.overload + def tryLock( + self, long: int, timeUnit: java.util.concurrent.TimeUnit + ) -> bool: ... + def unlock(self) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.concurrent.locks")``. + + AbstractOwnableSynchronizer: type[AbstractOwnableSynchronizer] + AbstractQueuedLongSynchronizer: type[AbstractQueuedLongSynchronizer] + AbstractQueuedSynchronizer: type[AbstractQueuedSynchronizer] + Condition: type[Condition] + Lock: type[Lock] + LockSupport: type[LockSupport] + ReadWriteLock: type[ReadWriteLock] + ReentrantLock: type[ReentrantLock] + ReentrantReadWriteLock: type[ReentrantReadWriteLock] + StampedLock: type[StampedLock] diff --git a/typings/java/util/function/__init__.pyi b/typings/java/util/function/__init__.pyi new file mode 100644 index 0000000..cf244b9 --- /dev/null +++ b/typings/java/util/function/__init__.pyi @@ -0,0 +1,351 @@ +import typing +from typing import Protocol + +import java.util + +_BiConsumer__T = typing.TypeVar("_BiConsumer__T") # +_BiConsumer__U = typing.TypeVar("_BiConsumer__U") # + +class BiConsumer(typing.Generic[_BiConsumer__T, _BiConsumer__U]): + def accept(self, t: _BiConsumer__T, u: _BiConsumer__U) -> None: ... + def andThen( + self, + biConsumer: BiConsumer[_BiConsumer__T, _BiConsumer__U] + | typing.Callable[[_BiConsumer__T, _BiConsumer__U], None], + ) -> BiConsumer[_BiConsumer__T, _BiConsumer__U]: ... + +_BiFunction__T = typing.TypeVar("_BiFunction__T") # +_BiFunction__U = typing.TypeVar("_BiFunction__U") # +_BiFunction__R = typing.TypeVar("_BiFunction__R") # + +class BiFunction(typing.Generic[_BiFunction__T, _BiFunction__U, _BiFunction__R]): + _andThen__V = typing.TypeVar("_andThen__V") # + def andThen( + self, + function: Function[_BiFunction__R, _andThen__V] + | typing.Callable[[_BiFunction__R], _andThen__V], + ) -> BiFunction[_BiFunction__T, _BiFunction__U, _andThen__V]: ... + def apply(self, t: _BiFunction__T, u: _BiFunction__U) -> _BiFunction__R: ... + +_BiPredicate__T = typing.TypeVar("_BiPredicate__T") # +_BiPredicate__U = typing.TypeVar("_BiPredicate__U") # + +class BiPredicate(typing.Generic[_BiPredicate__T, _BiPredicate__U]): + def and_( + self, + biPredicate: BiPredicate[_BiPredicate__T, _BiPredicate__U] + | typing.Callable[[_BiPredicate__T, _BiPredicate__U], bool], + ) -> BiPredicate[_BiPredicate__T, _BiPredicate__U]: ... + def negate(self) -> BiPredicate[_BiPredicate__T, _BiPredicate__U]: ... + def or_( + self, + biPredicate: BiPredicate[_BiPredicate__T, _BiPredicate__U] + | typing.Callable[[_BiPredicate__T, _BiPredicate__U], bool], + ) -> BiPredicate[_BiPredicate__T, _BiPredicate__U]: ... + def test(self, t: _BiPredicate__T, u: _BiPredicate__U) -> bool: ... + +class BooleanSupplier: + def getAsBoolean(self) -> bool: ... + +_Consumer__T = typing.TypeVar("_Consumer__T") # + +class Consumer(typing.Generic[_Consumer__T]): + def accept(self, t: _Consumer__T) -> None: ... + def andThen( + self, consumer: Consumer[_Consumer__T] | typing.Callable[[_Consumer__T], None] + ) -> Consumer[_Consumer__T]: ... + +class DoubleBinaryOperator: + def applyAsDouble(self, double: float, double2: float) -> float: ... + +class DoubleConsumer: + def accept(self, double: float) -> None: ... + def andThen( + self, doubleConsumer: DoubleConsumer | typing.Callable + ) -> DoubleConsumer: ... + +_DoubleFunction__R = typing.TypeVar("_DoubleFunction__R") # + +class DoubleFunction(typing.Generic[_DoubleFunction__R]): + def apply(self, double: float) -> _DoubleFunction__R: ... + +class DoublePredicate: + def and_( + self, doublePredicate: DoublePredicate | typing.Callable + ) -> DoublePredicate: ... + def negate(self) -> DoublePredicate: ... + def or_( + self, doublePredicate: DoublePredicate | typing.Callable + ) -> DoublePredicate: ... + def test(self, double: float) -> bool: ... + +class DoubleSupplier: + def getAsDouble(self) -> float: ... + +class DoubleToIntFunction: + def applyAsInt(self, double: float) -> int: ... + +class DoubleToLongFunction: + def applyAsLong(self, double: float) -> int: ... + +class DoubleUnaryOperator: + def andThen( + self, doubleUnaryOperator: DoubleUnaryOperator | typing.Callable + ) -> DoubleUnaryOperator: ... + def applyAsDouble(self, double: float) -> float: ... + def compose( + self, doubleUnaryOperator: DoubleUnaryOperator | typing.Callable + ) -> DoubleUnaryOperator: ... + @staticmethod + def identity() -> DoubleUnaryOperator: ... + +_Function__T = typing.TypeVar("_Function__T") # +_Function__R = typing.TypeVar("_Function__R") # + +class Function(typing.Generic[_Function__T, _Function__R]): + _andThen__V = typing.TypeVar("_andThen__V") # + def andThen( + self, + function: Function[_Function__R, _andThen__V] + | typing.Callable[[_Function__R], _andThen__V], + ) -> Function[_Function__T, _andThen__V]: ... + def apply(self, t: _Function__T) -> _Function__R: ... + _compose__V = typing.TypeVar("_compose__V") # + def compose( + self, + function: Function[_compose__V, _Function__T] + | typing.Callable[[_compose__V], _Function__T], + ) -> Function[_compose__V, _Function__R]: ... + _identity__T = typing.TypeVar("_identity__T") # + @staticmethod + def identity() -> Function[_identity__T, _identity__T]: ... + +class IntBinaryOperator: + def applyAsInt(self, int: int, int2: int) -> int: ... + +class IntConsumer: + def accept(self, int: int) -> None: ... + def andThen(self, intConsumer: IntConsumer | typing.Callable) -> IntConsumer: ... + +_IntFunction__R = typing.TypeVar("_IntFunction__R") # + +class IntFunction(typing.Generic[_IntFunction__R]): + def apply(self, int: int) -> _IntFunction__R: ... + +class IntPredicate: + def and_(self, intPredicate: IntPredicate | typing.Callable) -> IntPredicate: ... + def negate(self) -> IntPredicate: ... + def or_(self, intPredicate: IntPredicate | typing.Callable) -> IntPredicate: ... + def test(self, int: int) -> bool: ... + +class IntSupplier: + def getAsInt(self) -> int: ... + +class IntToDoubleFunction: + def applyAsDouble(self, int: int) -> float: ... + +class IntToLongFunction: + def applyAsLong(self, int: int) -> int: ... + +class IntUnaryOperator: + def andThen( + self, intUnaryOperator: IntUnaryOperator | typing.Callable + ) -> IntUnaryOperator: ... + def applyAsInt(self, int: int) -> int: ... + def compose( + self, intUnaryOperator: IntUnaryOperator | typing.Callable + ) -> IntUnaryOperator: ... + @staticmethod + def identity() -> IntUnaryOperator: ... + +class LongBinaryOperator: + def applyAsLong(self, long: int, long2: int) -> int: ... + +class LongConsumer: + def accept(self, long: int) -> None: ... + def andThen(self, longConsumer: LongConsumer | typing.Callable) -> LongConsumer: ... + +_LongFunction__R = typing.TypeVar("_LongFunction__R") # + +class LongFunction(typing.Generic[_LongFunction__R]): + def apply(self, long: int) -> _LongFunction__R: ... + +class LongPredicate: + def and_(self, longPredicate: LongPredicate | typing.Callable) -> LongPredicate: ... + def negate(self) -> LongPredicate: ... + def or_(self, longPredicate: LongPredicate | typing.Callable) -> LongPredicate: ... + def test(self, long: int) -> bool: ... + +class LongSupplier: + def getAsLong(self) -> int: ... + +class LongToDoubleFunction: + def applyAsDouble(self, long: int) -> float: ... + +class LongToIntFunction: + def applyAsInt(self, long: int) -> int: ... + +class LongUnaryOperator: + def andThen( + self, longUnaryOperator: LongUnaryOperator | typing.Callable + ) -> LongUnaryOperator: ... + def applyAsLong(self, long: int) -> int: ... + def compose( + self, longUnaryOperator: LongUnaryOperator | typing.Callable + ) -> LongUnaryOperator: ... + @staticmethod + def identity() -> LongUnaryOperator: ... + +_ObjDoubleConsumer__T = typing.TypeVar("_ObjDoubleConsumer__T") # + +class ObjDoubleConsumer(typing.Generic[_ObjDoubleConsumer__T]): + def accept(self, t: _ObjDoubleConsumer__T, double: float) -> None: ... + +_ObjIntConsumer__T = typing.TypeVar("_ObjIntConsumer__T") # + +class ObjIntConsumer(typing.Generic[_ObjIntConsumer__T]): + def accept(self, t: _ObjIntConsumer__T, int: int) -> None: ... + +_ObjLongConsumer__T = typing.TypeVar("_ObjLongConsumer__T") # + +class ObjLongConsumer(typing.Generic[_ObjLongConsumer__T]): + def accept(self, t: _ObjLongConsumer__T, long: int) -> None: ... + +_Predicate__T = typing.TypeVar("_Predicate__T") # + +class Predicate(typing.Generic[_Predicate__T]): + def and_( + self, + predicate: Predicate[_Predicate__T] | typing.Callable[[_Predicate__T], bool], + ) -> Predicate[_Predicate__T]: ... + _isEqual__T = typing.TypeVar("_isEqual__T") # + @staticmethod + def isEqual(object: typing.Any) -> Predicate[_isEqual__T]: ... + def negate(self) -> Predicate[_Predicate__T]: ... + _not___T = typing.TypeVar("_not___T") # + @staticmethod + def not_( + predicate: Predicate[_not___T] | typing.Callable[[_not___T], bool], + ) -> Predicate[_not___T]: ... + def or_( + self, + predicate: Predicate[_Predicate__T] | typing.Callable[[_Predicate__T], bool], + ) -> Predicate[_Predicate__T]: ... + def test(self, t: _Predicate__T) -> bool: ... + +_Supplier__T = typing.TypeVar("_Supplier__T") # + +class Supplier(typing.Generic[_Supplier__T]): + def get(self) -> _Supplier__T: ... + +_ToDoubleBiFunction__T = typing.TypeVar("_ToDoubleBiFunction__T") # +_ToDoubleBiFunction__U = typing.TypeVar("_ToDoubleBiFunction__U") # + +class ToDoubleBiFunction( + typing.Generic[_ToDoubleBiFunction__T, _ToDoubleBiFunction__U] +): + def applyAsDouble( + self, t: _ToDoubleBiFunction__T, u: _ToDoubleBiFunction__U + ) -> float: ... + +_ToDoubleFunction__T = typing.TypeVar("_ToDoubleFunction__T") # + +class ToDoubleFunction(typing.Generic[_ToDoubleFunction__T]): + def applyAsDouble(self, t: _ToDoubleFunction__T) -> float: ... + +_ToIntBiFunction__T = typing.TypeVar("_ToIntBiFunction__T") # +_ToIntBiFunction__U = typing.TypeVar("_ToIntBiFunction__U") # + +class ToIntBiFunction(typing.Generic[_ToIntBiFunction__T, _ToIntBiFunction__U]): + def applyAsInt(self, t: _ToIntBiFunction__T, u: _ToIntBiFunction__U) -> int: ... + +_ToIntFunction__T = typing.TypeVar("_ToIntFunction__T") # + +class ToIntFunction(typing.Generic[_ToIntFunction__T]): + def applyAsInt(self, t: _ToIntFunction__T) -> int: ... + +_ToLongBiFunction__T = typing.TypeVar("_ToLongBiFunction__T") # +_ToLongBiFunction__U = typing.TypeVar("_ToLongBiFunction__U") # + +class ToLongBiFunction(typing.Generic[_ToLongBiFunction__T, _ToLongBiFunction__U]): + def applyAsLong(self, t: _ToLongBiFunction__T, u: _ToLongBiFunction__U) -> int: ... + +_ToLongFunction__T = typing.TypeVar("_ToLongFunction__T") # + +class ToLongFunction(typing.Generic[_ToLongFunction__T]): + def applyAsLong(self, t: _ToLongFunction__T) -> int: ... + +_BinaryOperator__T = typing.TypeVar("_BinaryOperator__T") # + +class BinaryOperator( + BiFunction[_BinaryOperator__T, _BinaryOperator__T, _BinaryOperator__T], + typing.Generic[_BinaryOperator__T], +): + _maxBy__T = typing.TypeVar("_maxBy__T") # + @staticmethod + def maxBy( + comparator: java.util.Comparator[_maxBy__T] + | typing.Callable[[_maxBy__T, _maxBy__T], int], + ) -> BinaryOperator[_maxBy__T]: ... + _minBy__T = typing.TypeVar("_minBy__T") # + @staticmethod + def minBy( + comparator: java.util.Comparator[_minBy__T] + | typing.Callable[[_minBy__T, _minBy__T], int], + ) -> BinaryOperator[_minBy__T]: ... + +_UnaryOperator__T = typing.TypeVar("_UnaryOperator__T") # + +class UnaryOperator( + Function[_UnaryOperator__T, _UnaryOperator__T], typing.Generic[_UnaryOperator__T] +): + _identity__T = typing.TypeVar("_identity__T") # + @staticmethod + def identity() -> UnaryOperator[_identity__T]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.function")``. + + BiConsumer: type[BiConsumer] + BiFunction: type[BiFunction] + BiPredicate: type[BiPredicate] + BinaryOperator: type[BinaryOperator] + BooleanSupplier: type[BooleanSupplier] + Consumer: type[Consumer] + DoubleBinaryOperator: type[DoubleBinaryOperator] + DoubleConsumer: type[DoubleConsumer] + DoubleFunction: type[DoubleFunction] + DoublePredicate: type[DoublePredicate] + DoubleSupplier: type[DoubleSupplier] + DoubleToIntFunction: type[DoubleToIntFunction] + DoubleToLongFunction: type[DoubleToLongFunction] + DoubleUnaryOperator: type[DoubleUnaryOperator] + Function: type[Function] + IntBinaryOperator: type[IntBinaryOperator] + IntConsumer: type[IntConsumer] + IntFunction: type[IntFunction] + IntPredicate: type[IntPredicate] + IntSupplier: type[IntSupplier] + IntToDoubleFunction: type[IntToDoubleFunction] + IntToLongFunction: type[IntToLongFunction] + IntUnaryOperator: type[IntUnaryOperator] + LongBinaryOperator: type[LongBinaryOperator] + LongConsumer: type[LongConsumer] + LongFunction: type[LongFunction] + LongPredicate: type[LongPredicate] + LongSupplier: type[LongSupplier] + LongToDoubleFunction: type[LongToDoubleFunction] + LongToIntFunction: type[LongToIntFunction] + LongUnaryOperator: type[LongUnaryOperator] + ObjDoubleConsumer: type[ObjDoubleConsumer] + ObjIntConsumer: type[ObjIntConsumer] + ObjLongConsumer: type[ObjLongConsumer] + Predicate: type[Predicate] + Supplier: type[Supplier] + ToDoubleBiFunction: type[ToDoubleBiFunction] + ToDoubleFunction: type[ToDoubleFunction] + ToIntBiFunction: type[ToIntBiFunction] + ToIntFunction: type[ToIntFunction] + ToLongBiFunction: type[ToLongBiFunction] + ToLongFunction: type[ToLongFunction] + UnaryOperator: type[UnaryOperator] diff --git a/typings/java/util/jar/__init__.pyi b/typings/java/util/jar/__init__.pyi new file mode 100644 index 0000000..42e943c --- /dev/null +++ b/typings/java/util/jar/__init__.pyi @@ -0,0 +1,186 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.security +import java.security.cert +import java.util +import java.util.stream +import java.util.zip +import jpype +import jpype.protocol + +class Attributes(java.util.Map[typing.Any, typing.Any], java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, attributes: Attributes): ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def entrySet( + self, + ) -> java.util.Set[java.util.Map.Entry[typing.Any, typing.Any]]: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, object: typing.Any) -> typing.Any: ... + @typing.overload + def getValue(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def getValue(self, name: Attributes.Name) -> java.lang.String: ... + def hashCode(self) -> int: ... + def isEmpty(self) -> bool: ... + def keySet(self) -> java.util.Set[typing.Any]: ... + def put(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + def putAll( + self, + map: java.util.Map[typing.Any, typing.Any] + | typing.Mapping[typing.Any, typing.Any], + ) -> None: ... + def putValue( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> typing.Any: ... + def size(self) -> int: ... + def values(self) -> java.util.Collection[typing.Any]: ... + class Name: + MANIFEST_VERSION: typing.ClassVar[Attributes.Name] = ... + SIGNATURE_VERSION: typing.ClassVar[Attributes.Name] = ... + CONTENT_TYPE: typing.ClassVar[Attributes.Name] = ... + CLASS_PATH: typing.ClassVar[Attributes.Name] = ... + MAIN_CLASS: typing.ClassVar[Attributes.Name] = ... + SEALED: typing.ClassVar[Attributes.Name] = ... + EXTENSION_LIST: typing.ClassVar[Attributes.Name] = ... + EXTENSION_NAME: typing.ClassVar[Attributes.Name] = ... + EXTENSION_INSTALLATION: typing.ClassVar[Attributes.Name] = ... + IMPLEMENTATION_TITLE: typing.ClassVar[Attributes.Name] = ... + IMPLEMENTATION_VERSION: typing.ClassVar[Attributes.Name] = ... + IMPLEMENTATION_VENDOR: typing.ClassVar[Attributes.Name] = ... + IMPLEMENTATION_VENDOR_ID: typing.ClassVar[Attributes.Name] = ... + IMPLEMENTATION_URL: typing.ClassVar[Attributes.Name] = ... + SPECIFICATION_TITLE: typing.ClassVar[Attributes.Name] = ... + SPECIFICATION_VERSION: typing.ClassVar[Attributes.Name] = ... + SPECIFICATION_VENDOR: typing.ClassVar[Attributes.Name] = ... + MULTI_RELEASE: typing.ClassVar[Attributes.Name] = ... + def __init__(self, string: java.lang.String | str): ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class JarEntry(java.util.zip.ZipEntry): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, jarEntry: JarEntry): ... + @typing.overload + def __init__(self, zipEntry: java.util.zip.ZipEntry): ... + def getAttributes(self) -> Attributes: ... + def getCertificates( + self, + ) -> typing.MutableSequence[java.security.cert.Certificate]: ... + def getCodeSigners(self) -> typing.MutableSequence[java.security.CodeSigner]: ... + def getRealName(self) -> java.lang.String: ... + +class JarException(java.util.zip.ZipException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class JarFile(java.util.zip.ZipFile): + MANIFEST_NAME: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self, file: java.io.File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__( + self, file: java.io.File | jpype.protocol.SupportsPath, boolean: bool + ): ... + @typing.overload + def __init__( + self, file: java.io.File | jpype.protocol.SupportsPath, boolean: bool, int: int + ): ... + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + boolean: bool, + int: int, + version: java.lang.Runtime.Version, + ): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + @staticmethod + def baseVersion() -> java.lang.Runtime.Version: ... + def entries(self) -> java.util.Enumeration[JarEntry]: ... + def getEntry(self, string: java.lang.String | str) -> java.util.zip.ZipEntry: ... + def getInputStream( + self, zipEntry: java.util.zip.ZipEntry + ) -> java.io.InputStream: ... + def getJarEntry(self, string: java.lang.String | str) -> JarEntry: ... + def getManifest(self) -> Manifest: ... + def getVersion(self) -> java.lang.Runtime.Version: ... + def isMultiRelease(self) -> bool: ... + @staticmethod + def runtimeVersion() -> java.lang.Runtime.Version: ... + def stream(self) -> java.util.stream.Stream[JarEntry]: ... + def versionedStream(self) -> java.util.stream.Stream[JarEntry]: ... + +class JarInputStream(java.util.zip.ZipInputStream): + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + @typing.overload + def __init__(self, inputStream: java.io.InputStream, boolean: bool): ... + def getManifest(self) -> Manifest: ... + def getNextEntry(self) -> java.util.zip.ZipEntry: ... + def getNextJarEntry(self) -> JarEntry: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self) -> int: ... + +class JarOutputStream(java.util.zip.ZipOutputStream): + @typing.overload + def __init__(self, outputStream: java.io.OutputStream): ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream, manifest: Manifest): ... + def putNextEntry(self, zipEntry: java.util.zip.ZipEntry) -> None: ... + +class Manifest(java.lang.Cloneable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + @typing.overload + def __init__(self, manifest: Manifest): ... + def clear(self) -> None: ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + def getAttributes(self, string: java.lang.String | str) -> Attributes: ... + def getEntries(self) -> java.util.Map[java.lang.String, Attributes]: ... + def getMainAttributes(self) -> Attributes: ... + def hashCode(self) -> int: ... + def read(self, inputStream: java.io.InputStream) -> None: ... + def write(self, outputStream: java.io.OutputStream) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.jar")``. + + Attributes: type[Attributes] + JarEntry: type[JarEntry] + JarException: type[JarException] + JarFile: type[JarFile] + JarInputStream: type[JarInputStream] + JarOutputStream: type[JarOutputStream] + Manifest: type[Manifest] diff --git a/typings/java/util/logging/__init__.pyi b/typings/java/util/logging/__init__.pyi new file mode 100644 index 0000000..608de2d --- /dev/null +++ b/typings/java/util/logging/__init__.pyi @@ -0,0 +1,563 @@ +import datetime +import typing +from typing import Protocol + +import java.io +import java.lang +import java.security +import java.time +import java.util +import java.util.function +import jpype + +class ErrorManager: + GENERIC_FAILURE: typing.ClassVar[int] = ... + WRITE_FAILURE: typing.ClassVar[int] = ... + FLUSH_FAILURE: typing.ClassVar[int] = ... + CLOSE_FAILURE: typing.ClassVar[int] = ... + OPEN_FAILURE: typing.ClassVar[int] = ... + FORMAT_FAILURE: typing.ClassVar[int] = ... + def __init__(self): ... + def error( + self, string: java.lang.String | str, exception: java.lang.Exception, int: int + ) -> None: ... + +class Filter: + def isLoggable(self, logRecord: LogRecord) -> bool: ... + +class Formatter: + def format(self, logRecord: LogRecord) -> java.lang.String: ... + def formatMessage(self, logRecord: LogRecord) -> java.lang.String: ... + def getHead(self, handler: Handler) -> java.lang.String: ... + def getTail(self, handler: Handler) -> java.lang.String: ... + +class Handler: + def close(self) -> None: ... + def flush(self) -> None: ... + def getEncoding(self) -> java.lang.String: ... + def getErrorManager(self) -> ErrorManager: ... + def getFilter(self) -> Filter: ... + def getFormatter(self) -> Formatter: ... + def getLevel(self) -> Level: ... + def isLoggable(self, logRecord: LogRecord) -> bool: ... + def publish(self, logRecord: LogRecord) -> None: ... + def setEncoding(self, string: java.lang.String | str) -> None: ... + def setErrorManager(self, errorManager: ErrorManager) -> None: ... + def setFilter(self, filter: Filter | typing.Callable) -> None: ... + def setFormatter(self, formatter: Formatter) -> None: ... + def setLevel(self, level: Level) -> None: ... + +class Level(java.io.Serializable): + OFF: typing.ClassVar[Level] = ... + SEVERE: typing.ClassVar[Level] = ... + WARNING: typing.ClassVar[Level] = ... + INFO: typing.ClassVar[Level] = ... + CONFIG: typing.ClassVar[Level] = ... + FINE: typing.ClassVar[Level] = ... + FINER: typing.ClassVar[Level] = ... + FINEST: typing.ClassVar[Level] = ... + ALL: typing.ClassVar[Level] = ... + def equals(self, object: typing.Any) -> bool: ... + def getLocalizedName(self) -> java.lang.String: ... + def getName(self) -> java.lang.String: ... + def getResourceBundleName(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def intValue(self) -> int: ... + @staticmethod + def parse(string: java.lang.String | str) -> Level: ... + def toString(self) -> java.lang.String: ... + +class LogManager: + LOGGING_MXBEAN_NAME: typing.ClassVar[java.lang.String] = ... + def addConfigurationListener( + self, runnable: java.lang.Runnable | typing.Callable + ) -> LogManager: ... + def addLogger(self, logger: Logger) -> bool: ... + def checkAccess(self) -> None: ... + @staticmethod + def getLogManager() -> LogManager: ... + def getLogger(self, string: java.lang.String | str) -> Logger: ... + def getLoggerNames(self) -> java.util.Enumeration[java.lang.String]: ... + @staticmethod + def getLoggingMXBean() -> LoggingMXBean: ... + def getProperty(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def readConfiguration(self) -> None: ... + @typing.overload + def readConfiguration(self, inputStream: java.io.InputStream) -> None: ... + def removeConfigurationListener( + self, runnable: java.lang.Runnable | typing.Callable + ) -> None: ... + def reset(self) -> None: ... + @typing.overload + def updateConfiguration( + self, + inputStream: java.io.InputStream, + function: java.util.function.Function[ + java.lang.String | str, + java.util.function.BiFunction[ + java.lang.String | str, java.lang.String | str, java.lang.String | str + ] + | typing.Callable[ + [java.lang.String | str, java.lang.String | str], java.lang.String | str + ], + ] + | typing.Callable[ + [java.lang.String | str], + java.util.function.BiFunction[ + java.lang.String | str, java.lang.String | str, java.lang.String | str + ] + | typing.Callable[ + [java.lang.String | str, java.lang.String | str], java.lang.String | str + ], + ], + ) -> None: ... + @typing.overload + def updateConfiguration( + self, + function: java.util.function.Function[ + java.lang.String | str, + java.util.function.BiFunction[ + java.lang.String | str, java.lang.String | str, java.lang.String | str + ] + | typing.Callable[ + [java.lang.String | str, java.lang.String | str], java.lang.String | str + ], + ] + | typing.Callable[ + [java.lang.String | str], + java.util.function.BiFunction[ + java.lang.String | str, java.lang.String | str, java.lang.String | str + ] + | typing.Callable[ + [java.lang.String | str, java.lang.String | str], java.lang.String | str + ], + ], + ) -> None: ... + +class LogRecord(java.io.Serializable): + def __init__(self, level: Level, string: java.lang.String | str): ... + def getInstant(self) -> java.time.Instant: ... + def getLevel(self) -> Level: ... + def getLoggerName(self) -> java.lang.String: ... + def getLongThreadID(self) -> int: ... + def getMessage(self) -> java.lang.String: ... + def getMillis(self) -> int: ... + def getParameters(self) -> typing.MutableSequence[typing.Any]: ... + def getResourceBundle(self) -> java.util.ResourceBundle: ... + def getResourceBundleName(self) -> java.lang.String: ... + def getSequenceNumber(self) -> int: ... + def getSourceClassName(self) -> java.lang.String: ... + def getSourceMethodName(self) -> java.lang.String: ... + def getThreadID(self) -> int: ... + def getThrown(self) -> java.lang.Throwable: ... + def setInstant(self, instant: java.time.Instant | datetime.datetime) -> None: ... + def setLevel(self, level: Level) -> None: ... + def setLoggerName(self, string: java.lang.String | str) -> None: ... + def setLongThreadID(self, long: int) -> LogRecord: ... + def setMessage(self, string: java.lang.String | str) -> None: ... + def setMillis(self, long: int) -> None: ... + def setParameters(self, objectArray: list[typing.Any] | jpype.JArray) -> None: ... + def setResourceBundle(self, resourceBundle: java.util.ResourceBundle) -> None: ... + def setResourceBundleName(self, string: java.lang.String | str) -> None: ... + def setSequenceNumber(self, long: int) -> None: ... + def setSourceClassName(self, string: java.lang.String | str) -> None: ... + def setSourceMethodName(self, string: java.lang.String | str) -> None: ... + def setThreadID(self, int: int) -> None: ... + def setThrown(self, throwable: java.lang.Throwable) -> None: ... + +class Logger: + GLOBAL_LOGGER_NAME: typing.ClassVar[java.lang.String] = ... + global_: typing.ClassVar[Logger] = ... + def addHandler(self, handler: Handler) -> None: ... + @typing.overload + def config(self, string: java.lang.String | str) -> None: ... + @typing.overload + def config( + self, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + @typing.overload + def entering( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def entering( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + object: typing.Any, + ) -> None: ... + @typing.overload + def entering( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ) -> None: ... + @typing.overload + def exiting( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def exiting( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + object: typing.Any, + ) -> None: ... + @typing.overload + def fine(self, string: java.lang.String | str) -> None: ... + @typing.overload + def fine( + self, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + @typing.overload + def finer(self, string: java.lang.String | str) -> None: ... + @typing.overload + def finer( + self, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + @typing.overload + def finest(self, string: java.lang.String | str) -> None: ... + @typing.overload + def finest( + self, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + @typing.overload + @staticmethod + def getAnonymousLogger() -> Logger: ... + @typing.overload + @staticmethod + def getAnonymousLogger(string: java.lang.String | str) -> Logger: ... + def getFilter(self) -> Filter: ... + @staticmethod + def getGlobal() -> Logger: ... + def getHandlers(self) -> typing.MutableSequence[Handler]: ... + def getLevel(self) -> Level: ... + @typing.overload + @staticmethod + def getLogger(string: java.lang.String | str) -> Logger: ... + @typing.overload + @staticmethod + def getLogger( + string: java.lang.String | str, string2: java.lang.String | str + ) -> Logger: ... + def getName(self) -> java.lang.String: ... + def getParent(self) -> Logger: ... + def getResourceBundle(self) -> java.util.ResourceBundle: ... + def getResourceBundleName(self) -> java.lang.String: ... + def getUseParentHandlers(self) -> bool: ... + @typing.overload + def info(self, string: java.lang.String | str) -> None: ... + @typing.overload + def info( + self, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + def isLoggable(self, level: Level) -> bool: ... + @typing.overload + def log(self, level: Level, string: java.lang.String | str) -> None: ... + @typing.overload + def log( + self, level: Level, string: java.lang.String | str, object: typing.Any + ) -> None: ... + @typing.overload + def log( + self, + level: Level, + string: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ) -> None: ... + @typing.overload + def log( + self, + level: Level, + string: java.lang.String | str, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + level: Level, + throwable: java.lang.Throwable, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + @typing.overload + def log( + self, + level: Level, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + @typing.overload + def log(self, logRecord: LogRecord) -> None: ... + @typing.overload + def logp( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> None: ... + @typing.overload + def logp( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + object: typing.Any, + ) -> None: ... + @typing.overload + def logp( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ) -> None: ... + @typing.overload + def logp( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def logp( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + @typing.overload + def logp( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + @typing.overload + def logrb( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + ) -> None: ... + @typing.overload + def logrb( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + object: typing.Any, + ) -> None: ... + @typing.overload + def logrb( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + objectArray: list[typing.Any] | jpype.JArray, + ) -> None: ... + @typing.overload + def logrb( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def logrb( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + resourceBundle: java.util.ResourceBundle, + string3: java.lang.String | str, + *object: typing.Any, + ) -> None: ... + @typing.overload + def logrb( + self, + level: Level, + string: java.lang.String | str, + string2: java.lang.String | str, + resourceBundle: java.util.ResourceBundle, + string3: java.lang.String | str, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def logrb( + self, + level: Level, + resourceBundle: java.util.ResourceBundle, + string: java.lang.String | str, + *object: typing.Any, + ) -> None: ... + @typing.overload + def logrb( + self, + level: Level, + resourceBundle: java.util.ResourceBundle, + string: java.lang.String | str, + throwable: java.lang.Throwable, + ) -> None: ... + def removeHandler(self, handler: Handler) -> None: ... + def setFilter(self, filter: Filter | typing.Callable) -> None: ... + def setLevel(self, level: Level) -> None: ... + def setParent(self, logger: Logger) -> None: ... + def setResourceBundle(self, resourceBundle: java.util.ResourceBundle) -> None: ... + def setUseParentHandlers(self, boolean: bool) -> None: ... + @typing.overload + def severe(self, string: java.lang.String | str) -> None: ... + @typing.overload + def severe( + self, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + def throwing( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def warning(self, string: java.lang.String | str) -> None: ... + @typing.overload + def warning( + self, + supplier: java.util.function.Supplier[java.lang.String | str] + | typing.Callable[[], java.lang.String | str], + ) -> None: ... + +class LoggingMXBean: + def getLoggerLevel(self, string: java.lang.String | str) -> java.lang.String: ... + def getLoggerNames(self) -> java.util.List[java.lang.String]: ... + def getParentLoggerName( + self, string: java.lang.String | str + ) -> java.lang.String: ... + def setLoggerLevel( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + +class LoggingPermission(java.security.BasicPermission): + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + +class MemoryHandler(Handler): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, handler: Handler, int: int, level: Level): ... + def close(self) -> None: ... + def flush(self) -> None: ... + def getPushLevel(self) -> Level: ... + def isLoggable(self, logRecord: LogRecord) -> bool: ... + def publish(self, logRecord: LogRecord) -> None: ... + def push(self) -> None: ... + def setPushLevel(self, level: Level) -> None: ... + +class SimpleFormatter(Formatter): + def __init__(self): ... + def format(self, logRecord: LogRecord) -> java.lang.String: ... + +class StreamHandler(Handler): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream, formatter: Formatter): ... + def close(self) -> None: ... + def flush(self) -> None: ... + def isLoggable(self, logRecord: LogRecord) -> bool: ... + def publish(self, logRecord: LogRecord) -> None: ... + def setEncoding(self, string: java.lang.String | str) -> None: ... + +class XMLFormatter(Formatter): + def __init__(self): ... + def format(self, logRecord: LogRecord) -> java.lang.String: ... + def getHead(self, handler: Handler) -> java.lang.String: ... + def getTail(self, handler: Handler) -> java.lang.String: ... + +class ConsoleHandler(StreamHandler): + def __init__(self): ... + def close(self) -> None: ... + def publish(self, logRecord: LogRecord) -> None: ... + +class FileHandler(StreamHandler): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int, int2: int): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, int: int, int2: int, boolean: bool + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, long: int, int: int, boolean: bool + ): ... + def close(self) -> None: ... + def publish(self, logRecord: LogRecord) -> None: ... + +class SocketHandler(StreamHandler): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + def close(self) -> None: ... + def publish(self, logRecord: LogRecord) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.logging")``. + + ConsoleHandler: type[ConsoleHandler] + ErrorManager: type[ErrorManager] + FileHandler: type[FileHandler] + Filter: type[Filter] + Formatter: type[Formatter] + Handler: type[Handler] + Level: type[Level] + LogManager: type[LogManager] + LogRecord: type[LogRecord] + Logger: type[Logger] + LoggingMXBean: type[LoggingMXBean] + LoggingPermission: type[LoggingPermission] + MemoryHandler: type[MemoryHandler] + SimpleFormatter: type[SimpleFormatter] + SocketHandler: type[SocketHandler] + StreamHandler: type[StreamHandler] + XMLFormatter: type[XMLFormatter] diff --git a/typings/java/util/prefs/__init__.pyi b/typings/java/util/prefs/__init__.pyi new file mode 100644 index 0000000..17df666 --- /dev/null +++ b/typings/java/util/prefs/__init__.pyi @@ -0,0 +1,186 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import jpype + +class BackingStoreException(java.lang.Exception): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class InvalidPreferencesFormatException(java.lang.Exception): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class NodeChangeEvent(java.util.EventObject): + def __init__(self, preferences: Preferences, preferences2: Preferences): ... + def getChild(self) -> Preferences: ... + def getParent(self) -> Preferences: ... + +class NodeChangeListener(java.util.EventListener): + def childAdded(self, nodeChangeEvent: NodeChangeEvent) -> None: ... + def childRemoved(self, nodeChangeEvent: NodeChangeEvent) -> None: ... + +class PreferenceChangeEvent(java.util.EventObject): + def __init__( + self, + preferences: Preferences, + string: java.lang.String | str, + string2: java.lang.String | str, + ): ... + def getKey(self) -> java.lang.String: ... + def getNewValue(self) -> java.lang.String: ... + def getNode(self) -> Preferences: ... + +class PreferenceChangeListener(java.util.EventListener): + def preferenceChange( + self, preferenceChangeEvent: PreferenceChangeEvent + ) -> None: ... + +class Preferences: + MAX_KEY_LENGTH: typing.ClassVar[int] = ... + MAX_VALUE_LENGTH: typing.ClassVar[int] = ... + MAX_NAME_LENGTH: typing.ClassVar[int] = ... + def absolutePath(self) -> java.lang.String: ... + def addNodeChangeListener(self, nodeChangeListener: NodeChangeListener) -> None: ... + def addPreferenceChangeListener( + self, preferenceChangeListener: PreferenceChangeListener | typing.Callable + ) -> None: ... + def childrenNames(self) -> typing.MutableSequence[java.lang.String]: ... + def clear(self) -> None: ... + def exportNode(self, outputStream: java.io.OutputStream) -> None: ... + def exportSubtree(self, outputStream: java.io.OutputStream) -> None: ... + def flush(self) -> None: ... + def get( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + def getBoolean(self, string: java.lang.String | str, boolean: bool) -> bool: ... + def getByteArray( + self, + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[int]: ... + def getDouble(self, string: java.lang.String | str, double: float) -> float: ... + def getFloat(self, string: java.lang.String | str, float: float) -> float: ... + def getInt(self, string: java.lang.String | str, int: int) -> int: ... + def getLong(self, string: java.lang.String | str, long: int) -> int: ... + @staticmethod + def importPreferences(inputStream: java.io.InputStream) -> None: ... + def isUserNode(self) -> bool: ... + def keys(self) -> typing.MutableSequence[java.lang.String]: ... + def name(self) -> java.lang.String: ... + def node(self, string: java.lang.String | str) -> Preferences: ... + def nodeExists(self, string: java.lang.String | str) -> bool: ... + def parent(self) -> Preferences: ... + def put( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + def putBoolean(self, string: java.lang.String | str, boolean: bool) -> None: ... + def putByteArray( + self, + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + ) -> None: ... + def putDouble(self, string: java.lang.String | str, double: float) -> None: ... + def putFloat(self, string: java.lang.String | str, float: float) -> None: ... + def putInt(self, string: java.lang.String | str, int: int) -> None: ... + def putLong(self, string: java.lang.String | str, long: int) -> None: ... + def remove(self, string: java.lang.String | str) -> None: ... + def removeNode(self) -> None: ... + def removeNodeChangeListener( + self, nodeChangeListener: NodeChangeListener + ) -> None: ... + def removePreferenceChangeListener( + self, preferenceChangeListener: PreferenceChangeListener | typing.Callable + ) -> None: ... + def sync(self) -> None: ... + @staticmethod + def systemNodeForPackage(class_: type[typing.Any]) -> Preferences: ... + @staticmethod + def systemRoot() -> Preferences: ... + def toString(self) -> java.lang.String: ... + @staticmethod + def userNodeForPackage(class_: type[typing.Any]) -> Preferences: ... + @staticmethod + def userRoot() -> Preferences: ... + +class PreferencesFactory: + def systemRoot(self) -> Preferences: ... + def userRoot(self) -> Preferences: ... + +class AbstractPreferences(Preferences): + def absolutePath(self) -> java.lang.String: ... + def addNodeChangeListener(self, nodeChangeListener: NodeChangeListener) -> None: ... + def addPreferenceChangeListener( + self, preferenceChangeListener: PreferenceChangeListener | typing.Callable + ) -> None: ... + def childrenNames(self) -> typing.MutableSequence[java.lang.String]: ... + def clear(self) -> None: ... + def exportNode(self, outputStream: java.io.OutputStream) -> None: ... + def exportSubtree(self, outputStream: java.io.OutputStream) -> None: ... + def flush(self) -> None: ... + def get( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + def getBoolean(self, string: java.lang.String | str, boolean: bool) -> bool: ... + def getByteArray( + self, + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[int]: ... + def getDouble(self, string: java.lang.String | str, double: float) -> float: ... + def getFloat(self, string: java.lang.String | str, float: float) -> float: ... + def getInt(self, string: java.lang.String | str, int: int) -> int: ... + def getLong(self, string: java.lang.String | str, long: int) -> int: ... + def isUserNode(self) -> bool: ... + def keys(self) -> typing.MutableSequence[java.lang.String]: ... + def name(self) -> java.lang.String: ... + def node(self, string: java.lang.String | str) -> Preferences: ... + def nodeExists(self, string: java.lang.String | str) -> bool: ... + def parent(self) -> Preferences: ... + def put( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + def putBoolean(self, string: java.lang.String | str, boolean: bool) -> None: ... + def putByteArray( + self, + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + ) -> None: ... + def putDouble(self, string: java.lang.String | str, double: float) -> None: ... + def putFloat(self, string: java.lang.String | str, float: float) -> None: ... + def putInt(self, string: java.lang.String | str, int: int) -> None: ... + def putLong(self, string: java.lang.String | str, long: int) -> None: ... + def remove(self, string: java.lang.String | str) -> None: ... + def removeNode(self) -> None: ... + def removeNodeChangeListener( + self, nodeChangeListener: NodeChangeListener + ) -> None: ... + def removePreferenceChangeListener( + self, preferenceChangeListener: PreferenceChangeListener | typing.Callable + ) -> None: ... + def sync(self) -> None: ... + def toString(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.prefs")``. + + AbstractPreferences: type[AbstractPreferences] + BackingStoreException: type[BackingStoreException] + InvalidPreferencesFormatException: type[InvalidPreferencesFormatException] + NodeChangeEvent: type[NodeChangeEvent] + NodeChangeListener: type[NodeChangeListener] + PreferenceChangeEvent: type[PreferenceChangeEvent] + PreferenceChangeListener: type[PreferenceChangeListener] + Preferences: type[Preferences] + PreferencesFactory: type[PreferencesFactory] diff --git a/typings/java/util/random/__init__.pyi b/typings/java/util/random/__init__.pyi new file mode 100644 index 0000000..17aaa29 --- /dev/null +++ b/typings/java/util/random/__init__.pyi @@ -0,0 +1,226 @@ +import typing +from typing import Protocol + +import java +import java.lang +import java.math +import java.util.stream +import jpype + +_RandomGeneratorFactory__T = typing.TypeVar( + "_RandomGeneratorFactory__T", bound="RandomGenerator" +) # + +class RandomGeneratorFactory(typing.Generic[_RandomGeneratorFactory__T]): + @staticmethod + def all() -> java.util.stream.Stream[RandomGeneratorFactory[RandomGenerator]]: ... + @typing.overload + def create(self) -> _RandomGeneratorFactory__T: ... + @typing.overload + def create( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> _RandomGeneratorFactory__T: ... + @typing.overload + def create(self, long: int) -> _RandomGeneratorFactory__T: ... + def equidistribution(self) -> int: ... + @staticmethod + def getDefault() -> RandomGeneratorFactory[RandomGenerator]: ... + def group(self) -> java.lang.String: ... + def isArbitrarilyJumpable(self) -> bool: ... + def isDeprecated(self) -> bool: ... + def isHardware(self) -> bool: ... + def isJumpable(self) -> bool: ... + def isLeapable(self) -> bool: ... + def isSplittable(self) -> bool: ... + def isStatistical(self) -> bool: ... + def isStochastic(self) -> bool: ... + def isStreamable(self) -> bool: ... + def name(self) -> java.lang.String: ... + _of__T = typing.TypeVar("_of__T", bound="RandomGenerator") # + @staticmethod + def of(string: java.lang.String | str) -> RandomGeneratorFactory[_of__T]: ... + def period(self) -> java.math.BigInteger: ... + def stateBits(self) -> int: ... + +class RandomGenerator: + @typing.overload + def doubles(self) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles( + self, double: float, double2: float + ) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles(self, long: int) -> java.util.stream.DoubleStream: ... + @typing.overload + def doubles( + self, long: int, double: float, double2: float + ) -> java.util.stream.DoubleStream: ... + def equiDoubles( + self, double: float, double2: float, boolean: bool, boolean2: bool + ) -> java.util.stream.DoubleStream: ... + @staticmethod + def getDefault() -> RandomGenerator: ... + @typing.overload + def ints(self) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, int: int, int2: int) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, long: int) -> java.util.stream.IntStream: ... + @typing.overload + def ints(self, long: int, int: int, int2: int) -> java.util.stream.IntStream: ... + def isDeprecated(self) -> bool: ... + @typing.overload + def longs(self) -> java.util.stream.LongStream: ... + @typing.overload + def longs(self, long: int) -> java.util.stream.LongStream: ... + @typing.overload + def longs(self, long: int, long2: int) -> java.util.stream.LongStream: ... + @typing.overload + def longs( + self, long: int, long2: int, long3: int + ) -> java.util.stream.LongStream: ... + def nextBoolean(self) -> bool: ... + def nextBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def nextDouble(self) -> float: ... + @typing.overload + def nextDouble(self, double: float) -> float: ... + @typing.overload + def nextDouble(self, double: float, double2: float) -> float: ... + def nextExponential(self) -> float: ... + @typing.overload + def nextFloat(self) -> float: ... + @typing.overload + def nextFloat(self, float: float) -> float: ... + @typing.overload + def nextFloat(self, float: float, float2: float) -> float: ... + @typing.overload + def nextGaussian(self) -> float: ... + @typing.overload + def nextGaussian(self, double: float, double2: float) -> float: ... + @typing.overload + def nextInt(self) -> int: ... + @typing.overload + def nextInt(self, int: int) -> int: ... + @typing.overload + def nextInt(self, int: int, int2: int) -> int: ... + @typing.overload + def nextLong(self) -> int: ... + @typing.overload + def nextLong(self, long: int) -> int: ... + @typing.overload + def nextLong(self, long: int, long2: int) -> int: ... + @staticmethod + def of(string: java.lang.String | str) -> RandomGenerator: ... + class ArbitrarilyJumpableGenerator( + java.util.random.RandomGenerator.LeapableGenerator + ): + def copy(self) -> RandomGenerator.ArbitrarilyJumpableGenerator: ... + @typing.overload + def copyAndJump(self) -> RandomGenerator: ... + @typing.overload + def copyAndJump( + self, double: float + ) -> RandomGenerator.ArbitrarilyJumpableGenerator: ... + @typing.overload + def jump(self, double: float) -> None: ... + @typing.overload + def jump(self) -> None: ... + def jumpPowerOfTwo(self, int: int) -> None: ... + @typing.overload + def jumps( + self, double: float + ) -> java.util.stream.Stream[RandomGenerator.ArbitrarilyJumpableGenerator]: ... + @typing.overload + def jumps( + self, long: int, double: float + ) -> java.util.stream.Stream[RandomGenerator.ArbitrarilyJumpableGenerator]: ... + @typing.overload + def jumps(self) -> java.util.stream.Stream[RandomGenerator]: ... + @typing.overload + def jumps(self, long: int) -> java.util.stream.Stream[RandomGenerator]: ... + def leap(self) -> None: ... + @staticmethod + def of( + string: java.lang.String | str, + ) -> RandomGenerator.ArbitrarilyJumpableGenerator: ... + + class JumpableGenerator(java.util.random.RandomGenerator.StreamableGenerator): + def copy(self) -> RandomGenerator.JumpableGenerator: ... + def copyAndJump(self) -> RandomGenerator: ... + def jump(self) -> None: ... + def jumpDistance(self) -> float: ... + @typing.overload + def jumps(self) -> java.util.stream.Stream[RandomGenerator]: ... + @typing.overload + def jumps(self, long: int) -> java.util.stream.Stream[RandomGenerator]: ... + @staticmethod + def of(string: java.lang.String | str) -> RandomGenerator.JumpableGenerator: ... + @typing.overload + def rngs(self) -> java.util.stream.Stream[RandomGenerator]: ... + @typing.overload + def rngs(self, long: int) -> java.util.stream.Stream[RandomGenerator]: ... + + class LeapableGenerator(java.util.random.RandomGenerator.JumpableGenerator): + def copy(self) -> RandomGenerator.LeapableGenerator: ... + def copyAndLeap(self) -> RandomGenerator.JumpableGenerator: ... + def leap(self) -> None: ... + def leapDistance(self) -> float: ... + @typing.overload + def leaps( + self, + ) -> java.util.stream.Stream[RandomGenerator.JumpableGenerator]: ... + @typing.overload + def leaps( + self, long: int + ) -> java.util.stream.Stream[RandomGenerator.JumpableGenerator]: ... + @staticmethod + def of(string: java.lang.String | str) -> RandomGenerator.LeapableGenerator: ... + + class SplittableGenerator(java.util.random.RandomGenerator.StreamableGenerator): + @staticmethod + def of( + string: java.lang.String | str, + ) -> RandomGenerator.SplittableGenerator: ... + @typing.overload + def rngs(self) -> java.util.stream.Stream[RandomGenerator]: ... + @typing.overload + def rngs(self, long: int) -> java.util.stream.Stream[RandomGenerator]: ... + @typing.overload + def split(self) -> RandomGenerator.SplittableGenerator: ... + @typing.overload + def split( + self, splittableGenerator: RandomGenerator.SplittableGenerator + ) -> RandomGenerator.SplittableGenerator: ... + @typing.overload + def splits( + self, splittableGenerator: RandomGenerator.SplittableGenerator + ) -> java.util.stream.Stream[RandomGenerator.SplittableGenerator]: ... + @typing.overload + def splits( + self, long: int + ) -> java.util.stream.Stream[RandomGenerator.SplittableGenerator]: ... + @typing.overload + def splits( + self, long: int, splittableGenerator: RandomGenerator.SplittableGenerator + ) -> java.util.stream.Stream[RandomGenerator.SplittableGenerator]: ... + @typing.overload + def splits( + self, + ) -> java.util.stream.Stream[RandomGenerator.SplittableGenerator]: ... + + class StreamableGenerator(java.util.random.RandomGenerator): + @staticmethod + def of( + string: java.lang.String | str, + ) -> RandomGenerator.StreamableGenerator: ... + @typing.overload + def rngs(self) -> java.util.stream.Stream[RandomGenerator]: ... + @typing.overload + def rngs(self, long: int) -> java.util.stream.Stream[RandomGenerator]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.random")``. + + RandomGenerator: type[RandomGenerator] + RandomGeneratorFactory: type[RandomGeneratorFactory] diff --git a/typings/java/util/regex/__init__.pyi b/typings/java/util/regex/__init__.pyi new file mode 100644 index 0000000..d170044 --- /dev/null +++ b/typings/java/util/regex/__init__.pyi @@ -0,0 +1,173 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import java.util.function +import java.util.stream + +class MatchResult: + @typing.overload + def end(self) -> int: ... + @typing.overload + def end(self, int: int) -> int: ... + @typing.overload + def end(self, string: java.lang.String | str) -> int: ... + @typing.overload + def group(self) -> java.lang.String: ... + @typing.overload + def group(self, int: int) -> java.lang.String: ... + @typing.overload + def group(self, string: java.lang.String | str) -> java.lang.String: ... + def groupCount(self) -> int: ... + def hasMatch(self) -> bool: ... + def namedGroups(self) -> java.util.Map[java.lang.String, int]: ... + @typing.overload + def start(self) -> int: ... + @typing.overload + def start(self, int: int) -> int: ... + @typing.overload + def start(self, string: java.lang.String | str) -> int: ... + +class Pattern(java.io.Serializable): + UNIX_LINES: typing.ClassVar[int] = ... + CASE_INSENSITIVE: typing.ClassVar[int] = ... + COMMENTS: typing.ClassVar[int] = ... + MULTILINE: typing.ClassVar[int] = ... + LITERAL: typing.ClassVar[int] = ... + DOTALL: typing.ClassVar[int] = ... + UNICODE_CASE: typing.ClassVar[int] = ... + CANON_EQ: typing.ClassVar[int] = ... + UNICODE_CHARACTER_CLASS: typing.ClassVar[int] = ... + def asMatchPredicate(self) -> java.util.function.Predicate[java.lang.String]: ... + def asPredicate(self) -> java.util.function.Predicate[java.lang.String]: ... + @typing.overload + @staticmethod + def compile(string: java.lang.String | str) -> Pattern: ... + @typing.overload + @staticmethod + def compile(string: java.lang.String | str, int: int) -> Pattern: ... + def flags(self) -> int: ... + def matcher(self, charSequence: java.lang.CharSequence | str) -> Matcher: ... + @staticmethod + def matches( + string: java.lang.String | str, charSequence: java.lang.CharSequence | str + ) -> bool: ... + def namedGroups(self) -> java.util.Map[java.lang.String, int]: ... + def pattern(self) -> java.lang.String: ... + @staticmethod + def quote(string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def split( + self, charSequence: java.lang.CharSequence | str + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def split( + self, charSequence: java.lang.CharSequence | str, int: int + ) -> typing.MutableSequence[java.lang.String]: ... + def splitAsStream( + self, charSequence: java.lang.CharSequence | str + ) -> java.util.stream.Stream[java.lang.String]: ... + def splitWithDelimiters( + self, charSequence: java.lang.CharSequence | str, int: int + ) -> typing.MutableSequence[java.lang.String]: ... + def toString(self) -> java.lang.String: ... + +class PatternSyntaxException(java.lang.IllegalArgumentException): + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str, int: int + ): ... + def getDescription(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getMessage(self) -> java.lang.String: ... + def getPattern(self) -> java.lang.String: ... + +class Matcher(MatchResult): + @typing.overload + def appendReplacement( + self, stringBuffer: java.lang.StringBuffer, string2: java.lang.String | str + ) -> Matcher: ... + @typing.overload + def appendReplacement( + self, stringBuilder: java.lang.StringBuilder, string2: java.lang.String | str + ) -> Matcher: ... + @typing.overload + def appendTail( + self, stringBuffer: java.lang.StringBuffer + ) -> java.lang.StringBuffer: ... + @typing.overload + def appendTail( + self, stringBuilder: java.lang.StringBuilder + ) -> java.lang.StringBuilder: ... + @typing.overload + def end(self) -> int: ... + @typing.overload + def end(self, int: int) -> int: ... + @typing.overload + def end(self, string: java.lang.String | str) -> int: ... + @typing.overload + def find(self) -> bool: ... + @typing.overload + def find(self, int: int) -> bool: ... + @typing.overload + def group(self) -> java.lang.String: ... + @typing.overload + def group(self, int: int) -> java.lang.String: ... + @typing.overload + def group(self, string: java.lang.String | str) -> java.lang.String: ... + def groupCount(self) -> int: ... + def hasAnchoringBounds(self) -> bool: ... + def hasMatch(self) -> bool: ... + def hasTransparentBounds(self) -> bool: ... + def hitEnd(self) -> bool: ... + def lookingAt(self) -> bool: ... + def matches(self) -> bool: ... + def namedGroups(self) -> java.util.Map[java.lang.String, int]: ... + def pattern(self) -> Pattern: ... + @staticmethod + def quoteReplacement(string: java.lang.String | str) -> java.lang.String: ... + def region(self, int: int, int2: int) -> Matcher: ... + def regionEnd(self) -> int: ... + def regionStart(self) -> int: ... + @typing.overload + def replaceAll(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def replaceAll( + self, + function: java.util.function.Function[MatchResult, java.lang.String | str] + | typing.Callable[[MatchResult], java.lang.String | str], + ) -> java.lang.String: ... + @typing.overload + def replaceFirst(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def replaceFirst( + self, + function: java.util.function.Function[MatchResult, java.lang.String | str] + | typing.Callable[[MatchResult], java.lang.String | str], + ) -> java.lang.String: ... + def requireEnd(self) -> bool: ... + @typing.overload + def reset(self) -> Matcher: ... + @typing.overload + def reset(self, charSequence: java.lang.CharSequence | str) -> Matcher: ... + def results(self) -> java.util.stream.Stream[MatchResult]: ... + @typing.overload + def start(self) -> int: ... + @typing.overload + def start(self, int: int) -> int: ... + @typing.overload + def start(self, string: java.lang.String | str) -> int: ... + def toMatchResult(self) -> MatchResult: ... + def toString(self) -> java.lang.String: ... + def useAnchoringBounds(self, boolean: bool) -> Matcher: ... + def usePattern(self, pattern: Pattern) -> Matcher: ... + def useTransparentBounds(self, boolean: bool) -> Matcher: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.regex")``. + + MatchResult: type[MatchResult] + Matcher: type[Matcher] + Pattern: type[Pattern] + PatternSyntaxException: type[PatternSyntaxException] diff --git a/typings/java/util/spi/__init__.pyi b/typings/java/util/spi/__init__.pyi new file mode 100644 index 0000000..d38d8ee --- /dev/null +++ b/typings/java/util/spi/__init__.pyi @@ -0,0 +1,125 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util + +class LocaleServiceProvider: + def getAvailableLocales(self) -> typing.MutableSequence[java.util.Locale]: ... + def isSupportedLocale(self, locale: java.util.Locale) -> bool: ... + +class ResourceBundleControlProvider: + def getControl( + self, string: java.lang.String | str + ) -> java.util.ResourceBundle.Control: ... + +class ResourceBundleProvider: + def getBundle( + self, string: java.lang.String | str, locale: java.util.Locale + ) -> java.util.ResourceBundle: ... + +class ToolProvider: + def description(self) -> java.util.Optional[java.lang.String]: ... + @staticmethod + def findFirst( + string: java.lang.String | str, + ) -> java.util.Optional[ToolProvider]: ... + def name(self) -> java.lang.String: ... + @typing.overload + def run( + self, + printWriter: java.io.PrintWriter, + printWriter2: java.io.PrintWriter, + *string: java.lang.String | str, + ) -> int: ... + @typing.overload + def run( + self, + printStream: java.io.PrintStream, + printStream2: java.io.PrintStream, + *string: java.lang.String | str, + ) -> int: ... + +class AbstractResourceBundleProvider(ResourceBundleProvider): + def getBundle( + self, string: java.lang.String | str, locale: java.util.Locale + ) -> java.util.ResourceBundle: ... + +class CalendarDataProvider(LocaleServiceProvider): + def getFirstDayOfWeek(self, locale: java.util.Locale) -> int: ... + def getMinimalDaysInFirstWeek(self, locale: java.util.Locale) -> int: ... + +class CalendarNameProvider(LocaleServiceProvider): + def getDisplayName( + self, + string: java.lang.String | str, + int: int, + int2: int, + int3: int, + locale: java.util.Locale, + ) -> java.lang.String: ... + def getDisplayNames( + self, + string: java.lang.String | str, + int: int, + int2: int, + locale: java.util.Locale, + ) -> java.util.Map[java.lang.String, int]: ... + +class CurrencyNameProvider(LocaleServiceProvider): + def getDisplayName( + self, string: java.lang.String | str, locale: java.util.Locale + ) -> java.lang.String: ... + def getSymbol( + self, string: java.lang.String | str, locale: java.util.Locale + ) -> java.lang.String: ... + +class LocaleNameProvider(LocaleServiceProvider): + def getDisplayCountry( + self, string: java.lang.String | str, locale: java.util.Locale + ) -> java.lang.String: ... + def getDisplayLanguage( + self, string: java.lang.String | str, locale: java.util.Locale + ) -> java.lang.String: ... + def getDisplayScript( + self, string: java.lang.String | str, locale: java.util.Locale + ) -> java.lang.String: ... + def getDisplayUnicodeExtensionKey( + self, string: java.lang.String | str, locale: java.util.Locale + ) -> java.lang.String: ... + def getDisplayUnicodeExtensionType( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + locale: java.util.Locale, + ) -> java.lang.String: ... + def getDisplayVariant( + self, string: java.lang.String | str, locale: java.util.Locale + ) -> java.lang.String: ... + +class TimeZoneNameProvider(LocaleServiceProvider): + def getDisplayName( + self, + string: java.lang.String | str, + boolean: bool, + int: int, + locale: java.util.Locale, + ) -> java.lang.String: ... + def getGenericDisplayName( + self, string: java.lang.String | str, int: int, locale: java.util.Locale + ) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.spi")``. + + AbstractResourceBundleProvider: type[AbstractResourceBundleProvider] + CalendarDataProvider: type[CalendarDataProvider] + CalendarNameProvider: type[CalendarNameProvider] + CurrencyNameProvider: type[CurrencyNameProvider] + LocaleNameProvider: type[LocaleNameProvider] + LocaleServiceProvider: type[LocaleServiceProvider] + ResourceBundleControlProvider: type[ResourceBundleControlProvider] + ResourceBundleProvider: type[ResourceBundleProvider] + TimeZoneNameProvider: type[TimeZoneNameProvider] + ToolProvider: type[ToolProvider] diff --git a/typings/java/util/stream/__init__.pyi b/typings/java/util/stream/__init__.pyi new file mode 100644 index 0000000..71d1b97 --- /dev/null +++ b/typings/java/util/stream/__init__.pyi @@ -0,0 +1,1543 @@ +import typing +from typing import Protocol + +import java +import java.lang +import java.util +import java.util.concurrent +import java.util.function +import jpype + +_BaseStream__T = typing.TypeVar("_BaseStream__T") # +_BaseStream__S = typing.TypeVar("_BaseStream__S", bound="BaseStream") # + +class BaseStream( + java.lang.AutoCloseable, typing.Generic[_BaseStream__T, _BaseStream__S] +): + def close(self) -> None: ... + def isParallel(self) -> bool: ... + def iterator(self) -> java.util.Iterator[_BaseStream__T]: ... + def onClose( + self, runnable: java.lang.Runnable | typing.Callable + ) -> _BaseStream__S: ... + def parallel(self) -> _BaseStream__S: ... + def sequential(self) -> _BaseStream__S: ... + def spliterator(self) -> java.util.Spliterator[_BaseStream__T]: ... + def unordered(self) -> _BaseStream__S: ... + +_Collector__T = typing.TypeVar("_Collector__T") # +_Collector__A = typing.TypeVar("_Collector__A") # +_Collector__R = typing.TypeVar("_Collector__R") # + +class Collector(typing.Generic[_Collector__T, _Collector__A, _Collector__R]): + def accumulator( + self, + ) -> java.util.function.BiConsumer[_Collector__A, _Collector__T]: ... + def characteristics(self) -> java.util.Set[Collector.Characteristics]: ... + def combiner(self) -> java.util.function.BinaryOperator[_Collector__A]: ... + def finisher(self) -> java.util.function.Function[_Collector__A, _Collector__R]: ... + _of_0__T = typing.TypeVar("_of_0__T") # + _of_0__A = typing.TypeVar("_of_0__A") # + _of_0__R = typing.TypeVar("_of_0__R") # + _of_1__T = typing.TypeVar("_of_1__T") # + _of_1__R = typing.TypeVar("_of_1__R") # + @typing.overload + @staticmethod + def of( + supplier: java.util.function.Supplier[_of_0__A] | typing.Callable[[], _of_0__A], + biConsumer: java.util.function.BiConsumer[_of_0__A, _of_0__T] + | typing.Callable[[_of_0__A, _of_0__T], None], + binaryOperator: java.util.function.BinaryOperator[_of_0__A] | typing.Callable, + function: java.util.function.Function[_of_0__A, _of_0__R] + | typing.Callable[[_of_0__A], _of_0__R], + *characteristics: Collector.Characteristics, + ) -> Collector[_of_0__T, _of_0__A, _of_0__R]: ... + @typing.overload + @staticmethod + def of( + supplier: java.util.function.Supplier[_of_1__R] | typing.Callable[[], _of_1__R], + biConsumer: java.util.function.BiConsumer[_of_1__R, _of_1__T] + | typing.Callable[[_of_1__R, _of_1__T], None], + binaryOperator: java.util.function.BinaryOperator[_of_1__R] | typing.Callable, + *characteristics: Collector.Characteristics, + ) -> Collector[_of_1__T, _of_1__R, _of_1__R]: ... + def supplier(self) -> java.util.function.Supplier[_Collector__A]: ... + class Characteristics(java.lang.Enum["Collector.Characteristics"]): + CONCURRENT: typing.ClassVar[Collector.Characteristics] = ... + UNORDERED: typing.ClassVar[Collector.Characteristics] = ... + IDENTITY_FINISH: typing.ClassVar[Collector.Characteristics] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Collector.Characteristics: ... + @staticmethod + def values() -> typing.MutableSequence[Collector.Characteristics]: ... + +class Collectors: + _averagingDouble__T = typing.TypeVar("_averagingDouble__T") # + @staticmethod + def averagingDouble( + toDoubleFunction: java.util.function.ToDoubleFunction[_averagingDouble__T] + | typing.Callable[[_averagingDouble__T], float], + ) -> Collector[_averagingDouble__T, typing.Any, float]: ... + _averagingInt__T = typing.TypeVar("_averagingInt__T") # + @staticmethod + def averagingInt( + toIntFunction: java.util.function.ToIntFunction[_averagingInt__T] + | typing.Callable[[_averagingInt__T], int], + ) -> Collector[_averagingInt__T, typing.Any, float]: ... + _averagingLong__T = typing.TypeVar("_averagingLong__T") # + @staticmethod + def averagingLong( + toLongFunction: java.util.function.ToLongFunction[_averagingLong__T] + | typing.Callable[[_averagingLong__T], int], + ) -> Collector[_averagingLong__T, typing.Any, float]: ... + _collectingAndThen__T = typing.TypeVar("_collectingAndThen__T") # + _collectingAndThen__A = typing.TypeVar("_collectingAndThen__A") # + _collectingAndThen__R = typing.TypeVar("_collectingAndThen__R") # + _collectingAndThen__RR = typing.TypeVar("_collectingAndThen__RR") # + @staticmethod + def collectingAndThen( + collector: Collector[ + _collectingAndThen__T, _collectingAndThen__A, _collectingAndThen__R + ], + function: java.util.function.Function[ + _collectingAndThen__R, _collectingAndThen__RR + ] + | typing.Callable[[_collectingAndThen__R], _collectingAndThen__RR], + ) -> Collector[ + _collectingAndThen__T, _collectingAndThen__A, _collectingAndThen__RR + ]: ... + _counting__T = typing.TypeVar("_counting__T") # + @staticmethod + def counting() -> Collector[_counting__T, typing.Any, int]: ... + _filtering__T = typing.TypeVar("_filtering__T") # + _filtering__A = typing.TypeVar("_filtering__A") # + _filtering__R = typing.TypeVar("_filtering__R") # + @staticmethod + def filtering( + predicate: java.util.function.Predicate[_filtering__T] + | typing.Callable[[_filtering__T], bool], + collector: Collector[_filtering__T, _filtering__A, _filtering__R], + ) -> Collector[_filtering__T, typing.Any, _filtering__R]: ... + _flatMapping__T = typing.TypeVar("_flatMapping__T") # + _flatMapping__U = typing.TypeVar("_flatMapping__U") # + _flatMapping__A = typing.TypeVar("_flatMapping__A") # + _flatMapping__R = typing.TypeVar("_flatMapping__R") # + @staticmethod + def flatMapping( + function: java.util.function.Function[_flatMapping__T, Stream[_flatMapping__U]] + | typing.Callable[[_flatMapping__T], Stream[_flatMapping__U]], + collector: Collector[_flatMapping__U, _flatMapping__A, _flatMapping__R], + ) -> Collector[_flatMapping__T, typing.Any, _flatMapping__R]: ... + _groupingBy_0__T = typing.TypeVar("_groupingBy_0__T") # + _groupingBy_0__K = typing.TypeVar("_groupingBy_0__K") # + _groupingBy_1__T = typing.TypeVar("_groupingBy_1__T") # + _groupingBy_1__K = typing.TypeVar("_groupingBy_1__K") # + _groupingBy_1__D = typing.TypeVar("_groupingBy_1__D") # + _groupingBy_1__A = typing.TypeVar("_groupingBy_1__A") # + _groupingBy_1__M = typing.TypeVar("_groupingBy_1__M", bound=java.util.Map) # + _groupingBy_2__T = typing.TypeVar("_groupingBy_2__T") # + _groupingBy_2__K = typing.TypeVar("_groupingBy_2__K") # + _groupingBy_2__A = typing.TypeVar("_groupingBy_2__A") # + _groupingBy_2__D = typing.TypeVar("_groupingBy_2__D") # + @typing.overload + @staticmethod + def groupingBy( + function: java.util.function.Function[_groupingBy_0__T, _groupingBy_0__K] + | typing.Callable[[_groupingBy_0__T], _groupingBy_0__K], + ) -> Collector[ + _groupingBy_0__T, + typing.Any, + java.util.Map[_groupingBy_0__K, java.util.List[_groupingBy_0__T]], + ]: ... + @typing.overload + @staticmethod + def groupingBy( + function: java.util.function.Function[_groupingBy_1__T, _groupingBy_1__K] + | typing.Callable[[_groupingBy_1__T], _groupingBy_1__K], + supplier: java.util.function.Supplier[_groupingBy_1__M] + | typing.Callable[[], _groupingBy_1__M], + collector: Collector[_groupingBy_1__T, _groupingBy_1__A, _groupingBy_1__D], + ) -> Collector[_groupingBy_1__T, typing.Any, _groupingBy_1__M]: ... + @typing.overload + @staticmethod + def groupingBy( + function: java.util.function.Function[_groupingBy_2__T, _groupingBy_2__K] + | typing.Callable[[_groupingBy_2__T], _groupingBy_2__K], + collector: Collector[_groupingBy_2__T, _groupingBy_2__A, _groupingBy_2__D], + ) -> Collector[ + _groupingBy_2__T, typing.Any, java.util.Map[_groupingBy_2__K, _groupingBy_2__D] + ]: ... + _groupingByConcurrent_0__T = typing.TypeVar("_groupingByConcurrent_0__T") # + _groupingByConcurrent_0__K = typing.TypeVar("_groupingByConcurrent_0__K") # + _groupingByConcurrent_1__T = typing.TypeVar("_groupingByConcurrent_1__T") # + _groupingByConcurrent_1__K = typing.TypeVar("_groupingByConcurrent_1__K") # + _groupingByConcurrent_1__A = typing.TypeVar("_groupingByConcurrent_1__A") # + _groupingByConcurrent_1__D = typing.TypeVar("_groupingByConcurrent_1__D") # + _groupingByConcurrent_1__M = typing.TypeVar( + "_groupingByConcurrent_1__M", bound=java.util.concurrent.ConcurrentMap + ) # + _groupingByConcurrent_2__T = typing.TypeVar("_groupingByConcurrent_2__T") # + _groupingByConcurrent_2__K = typing.TypeVar("_groupingByConcurrent_2__K") # + _groupingByConcurrent_2__A = typing.TypeVar("_groupingByConcurrent_2__A") # + _groupingByConcurrent_2__D = typing.TypeVar("_groupingByConcurrent_2__D") # + @typing.overload + @staticmethod + def groupingByConcurrent( + function: java.util.function.Function[ + _groupingByConcurrent_0__T, _groupingByConcurrent_0__K + ] + | typing.Callable[[_groupingByConcurrent_0__T], _groupingByConcurrent_0__K], + ) -> Collector[ + _groupingByConcurrent_0__T, + typing.Any, + java.util.concurrent.ConcurrentMap[ + _groupingByConcurrent_0__K, java.util.List[_groupingByConcurrent_0__T] + ], + ]: ... + @typing.overload + @staticmethod + def groupingByConcurrent( + function: java.util.function.Function[ + _groupingByConcurrent_1__T, _groupingByConcurrent_1__K + ] + | typing.Callable[[_groupingByConcurrent_1__T], _groupingByConcurrent_1__K], + supplier: java.util.function.Supplier[_groupingByConcurrent_1__M] + | typing.Callable[[], _groupingByConcurrent_1__M], + collector: Collector[ + _groupingByConcurrent_1__T, + _groupingByConcurrent_1__A, + _groupingByConcurrent_1__D, + ], + ) -> Collector[ + _groupingByConcurrent_1__T, typing.Any, _groupingByConcurrent_1__M + ]: ... + @typing.overload + @staticmethod + def groupingByConcurrent( + function: java.util.function.Function[ + _groupingByConcurrent_2__T, _groupingByConcurrent_2__K + ] + | typing.Callable[[_groupingByConcurrent_2__T], _groupingByConcurrent_2__K], + collector: Collector[ + _groupingByConcurrent_2__T, + _groupingByConcurrent_2__A, + _groupingByConcurrent_2__D, + ], + ) -> Collector[ + _groupingByConcurrent_2__T, + typing.Any, + java.util.concurrent.ConcurrentMap[ + _groupingByConcurrent_2__K, _groupingByConcurrent_2__D + ], + ]: ... + @typing.overload + @staticmethod + def joining() -> Collector[ + java.lang.CharSequence, typing.Any, java.lang.String + ]: ... + @typing.overload + @staticmethod + def joining( + charSequence: java.lang.CharSequence | str, + ) -> Collector[java.lang.CharSequence, typing.Any, java.lang.String]: ... + @typing.overload + @staticmethod + def joining( + charSequence: java.lang.CharSequence | str, + charSequence2: java.lang.CharSequence | str, + charSequence3: java.lang.CharSequence | str, + ) -> Collector[java.lang.CharSequence, typing.Any, java.lang.String]: ... + _mapping__T = typing.TypeVar("_mapping__T") # + _mapping__U = typing.TypeVar("_mapping__U") # + _mapping__A = typing.TypeVar("_mapping__A") # + _mapping__R = typing.TypeVar("_mapping__R") # + @staticmethod + def mapping( + function: java.util.function.Function[_mapping__T, _mapping__U] + | typing.Callable[[_mapping__T], _mapping__U], + collector: Collector[_mapping__U, _mapping__A, _mapping__R], + ) -> Collector[_mapping__T, typing.Any, _mapping__R]: ... + _maxBy__T = typing.TypeVar("_maxBy__T") # + @staticmethod + def maxBy( + comparator: java.util.Comparator[_maxBy__T] + | typing.Callable[[_maxBy__T, _maxBy__T], int], + ) -> Collector[_maxBy__T, typing.Any, java.util.Optional[_maxBy__T]]: ... + _minBy__T = typing.TypeVar("_minBy__T") # + @staticmethod + def minBy( + comparator: java.util.Comparator[_minBy__T] + | typing.Callable[[_minBy__T, _minBy__T], int], + ) -> Collector[_minBy__T, typing.Any, java.util.Optional[_minBy__T]]: ... + _partitioningBy_0__T = typing.TypeVar("_partitioningBy_0__T") # + _partitioningBy_1__T = typing.TypeVar("_partitioningBy_1__T") # + _partitioningBy_1__D = typing.TypeVar("_partitioningBy_1__D") # + _partitioningBy_1__A = typing.TypeVar("_partitioningBy_1__A") # + @typing.overload + @staticmethod + def partitioningBy( + predicate: java.util.function.Predicate[_partitioningBy_0__T] + | typing.Callable[[_partitioningBy_0__T], bool], + ) -> Collector[ + _partitioningBy_0__T, + typing.Any, + java.util.Map[bool, java.util.List[_partitioningBy_0__T]], + ]: ... + @typing.overload + @staticmethod + def partitioningBy( + predicate: java.util.function.Predicate[_partitioningBy_1__T] + | typing.Callable[[_partitioningBy_1__T], bool], + collector: Collector[ + _partitioningBy_1__T, _partitioningBy_1__A, _partitioningBy_1__D + ], + ) -> Collector[ + _partitioningBy_1__T, typing.Any, java.util.Map[bool, _partitioningBy_1__D] + ]: ... + _reducing_0__T = typing.TypeVar("_reducing_0__T") # + _reducing_1__T = typing.TypeVar("_reducing_1__T") # + _reducing_1__U = typing.TypeVar("_reducing_1__U") # + _reducing_2__T = typing.TypeVar("_reducing_2__T") # + @typing.overload + @staticmethod + def reducing( + t: _reducing_0__T, + binaryOperator: java.util.function.BinaryOperator[_reducing_0__T] + | typing.Callable, + ) -> Collector[_reducing_0__T, typing.Any, _reducing_0__T]: ... + @typing.overload + @staticmethod + def reducing( + u: _reducing_1__U, + function: java.util.function.Function[_reducing_1__T, _reducing_1__U] + | typing.Callable[[_reducing_1__T], _reducing_1__U], + binaryOperator: java.util.function.BinaryOperator[_reducing_1__U] + | typing.Callable, + ) -> Collector[_reducing_1__T, typing.Any, _reducing_1__U]: ... + @typing.overload + @staticmethod + def reducing( + binaryOperator: java.util.function.BinaryOperator[_reducing_2__T] + | typing.Callable, + ) -> Collector[_reducing_2__T, typing.Any, java.util.Optional[_reducing_2__T]]: ... + _summarizingDouble__T = typing.TypeVar("_summarizingDouble__T") # + @staticmethod + def summarizingDouble( + toDoubleFunction: java.util.function.ToDoubleFunction[_summarizingDouble__T] + | typing.Callable[[_summarizingDouble__T], float], + ) -> Collector[ + _summarizingDouble__T, typing.Any, java.util.DoubleSummaryStatistics + ]: ... + _summarizingInt__T = typing.TypeVar("_summarizingInt__T") # + @staticmethod + def summarizingInt( + toIntFunction: java.util.function.ToIntFunction[_summarizingInt__T] + | typing.Callable[[_summarizingInt__T], int], + ) -> Collector[_summarizingInt__T, typing.Any, java.util.IntSummaryStatistics]: ... + _summarizingLong__T = typing.TypeVar("_summarizingLong__T") # + @staticmethod + def summarizingLong( + toLongFunction: java.util.function.ToLongFunction[_summarizingLong__T] + | typing.Callable[[_summarizingLong__T], int], + ) -> Collector[ + _summarizingLong__T, typing.Any, java.util.LongSummaryStatistics + ]: ... + _summingDouble__T = typing.TypeVar("_summingDouble__T") # + @staticmethod + def summingDouble( + toDoubleFunction: java.util.function.ToDoubleFunction[_summingDouble__T] + | typing.Callable[[_summingDouble__T], float], + ) -> Collector[_summingDouble__T, typing.Any, float]: ... + _summingInt__T = typing.TypeVar("_summingInt__T") # + @staticmethod + def summingInt( + toIntFunction: java.util.function.ToIntFunction[_summingInt__T] + | typing.Callable[[_summingInt__T], int], + ) -> Collector[_summingInt__T, typing.Any, int]: ... + _summingLong__T = typing.TypeVar("_summingLong__T") # + @staticmethod + def summingLong( + toLongFunction: java.util.function.ToLongFunction[_summingLong__T] + | typing.Callable[[_summingLong__T], int], + ) -> Collector[_summingLong__T, typing.Any, int]: ... + _teeing__T = typing.TypeVar("_teeing__T") # + _teeing__R1 = typing.TypeVar("_teeing__R1") # + _teeing__R2 = typing.TypeVar("_teeing__R2") # + _teeing__R = typing.TypeVar("_teeing__R") # + @staticmethod + def teeing( + collector: Collector[_teeing__T, typing.Any, _teeing__R1], + collector2: Collector[_teeing__T, typing.Any, _teeing__R2], + biFunction: java.util.function.BiFunction[_teeing__R1, _teeing__R2, _teeing__R] + | typing.Callable[[_teeing__R1, _teeing__R2], _teeing__R], + ) -> Collector[_teeing__T, typing.Any, _teeing__R]: ... + _toCollection__T = typing.TypeVar("_toCollection__T") # + _toCollection__C = typing.TypeVar( + "_toCollection__C", bound=java.util.Collection + ) # + @staticmethod + def toCollection( + supplier: java.util.function.Supplier[_toCollection__C] + | typing.Callable[[], _toCollection__C], + ) -> Collector[_toCollection__T, typing.Any, _toCollection__C]: ... + _toConcurrentMap_0__T = typing.TypeVar("_toConcurrentMap_0__T") # + _toConcurrentMap_0__K = typing.TypeVar("_toConcurrentMap_0__K") # + _toConcurrentMap_0__U = typing.TypeVar("_toConcurrentMap_0__U") # + _toConcurrentMap_1__T = typing.TypeVar("_toConcurrentMap_1__T") # + _toConcurrentMap_1__K = typing.TypeVar("_toConcurrentMap_1__K") # + _toConcurrentMap_1__U = typing.TypeVar("_toConcurrentMap_1__U") # + _toConcurrentMap_2__T = typing.TypeVar("_toConcurrentMap_2__T") # + _toConcurrentMap_2__K = typing.TypeVar("_toConcurrentMap_2__K") # + _toConcurrentMap_2__U = typing.TypeVar("_toConcurrentMap_2__U") # + _toConcurrentMap_2__M = typing.TypeVar( + "_toConcurrentMap_2__M", bound=java.util.concurrent.ConcurrentMap + ) # + @typing.overload + @staticmethod + def toConcurrentMap( + function: java.util.function.Function[ + _toConcurrentMap_0__T, _toConcurrentMap_0__K + ] + | typing.Callable[[_toConcurrentMap_0__T], _toConcurrentMap_0__K], + function2: java.util.function.Function[ + _toConcurrentMap_0__T, _toConcurrentMap_0__U + ] + | typing.Callable[[_toConcurrentMap_0__T], _toConcurrentMap_0__U], + ) -> Collector[ + _toConcurrentMap_0__T, + typing.Any, + java.util.concurrent.ConcurrentMap[ + _toConcurrentMap_0__K, _toConcurrentMap_0__U + ], + ]: ... + @typing.overload + @staticmethod + def toConcurrentMap( + function: java.util.function.Function[ + _toConcurrentMap_1__T, _toConcurrentMap_1__K + ] + | typing.Callable[[_toConcurrentMap_1__T], _toConcurrentMap_1__K], + function2: java.util.function.Function[ + _toConcurrentMap_1__T, _toConcurrentMap_1__U + ] + | typing.Callable[[_toConcurrentMap_1__T], _toConcurrentMap_1__U], + binaryOperator: java.util.function.BinaryOperator[_toConcurrentMap_1__U] + | typing.Callable, + ) -> Collector[ + _toConcurrentMap_1__T, + typing.Any, + java.util.concurrent.ConcurrentMap[ + _toConcurrentMap_1__K, _toConcurrentMap_1__U + ], + ]: ... + @typing.overload + @staticmethod + def toConcurrentMap( + function: java.util.function.Function[ + _toConcurrentMap_2__T, _toConcurrentMap_2__K + ] + | typing.Callable[[_toConcurrentMap_2__T], _toConcurrentMap_2__K], + function2: java.util.function.Function[ + _toConcurrentMap_2__T, _toConcurrentMap_2__U + ] + | typing.Callable[[_toConcurrentMap_2__T], _toConcurrentMap_2__U], + binaryOperator: java.util.function.BinaryOperator[_toConcurrentMap_2__U] + | typing.Callable, + supplier: java.util.function.Supplier[_toConcurrentMap_2__M] + | typing.Callable[[], _toConcurrentMap_2__M], + ) -> Collector[_toConcurrentMap_2__T, typing.Any, _toConcurrentMap_2__M]: ... + _toList__T = typing.TypeVar("_toList__T") # + @staticmethod + def toList() -> Collector[_toList__T, typing.Any, java.util.List[_toList__T]]: ... + _toMap_0__T = typing.TypeVar("_toMap_0__T") # + _toMap_0__K = typing.TypeVar("_toMap_0__K") # + _toMap_0__U = typing.TypeVar("_toMap_0__U") # + _toMap_1__T = typing.TypeVar("_toMap_1__T") # + _toMap_1__K = typing.TypeVar("_toMap_1__K") # + _toMap_1__U = typing.TypeVar("_toMap_1__U") # + _toMap_2__T = typing.TypeVar("_toMap_2__T") # + _toMap_2__K = typing.TypeVar("_toMap_2__K") # + _toMap_2__U = typing.TypeVar("_toMap_2__U") # + _toMap_2__M = typing.TypeVar("_toMap_2__M", bound=java.util.Map) # + @typing.overload + @staticmethod + def toMap( + function: java.util.function.Function[_toMap_0__T, _toMap_0__K] + | typing.Callable[[_toMap_0__T], _toMap_0__K], + function2: java.util.function.Function[_toMap_0__T, _toMap_0__U] + | typing.Callable[[_toMap_0__T], _toMap_0__U], + ) -> Collector[ + _toMap_0__T, typing.Any, java.util.Map[_toMap_0__K, _toMap_0__U] + ]: ... + @typing.overload + @staticmethod + def toMap( + function: java.util.function.Function[_toMap_1__T, _toMap_1__K] + | typing.Callable[[_toMap_1__T], _toMap_1__K], + function2: java.util.function.Function[_toMap_1__T, _toMap_1__U] + | typing.Callable[[_toMap_1__T], _toMap_1__U], + binaryOperator: java.util.function.BinaryOperator[_toMap_1__U] + | typing.Callable, + ) -> Collector[ + _toMap_1__T, typing.Any, java.util.Map[_toMap_1__K, _toMap_1__U] + ]: ... + @typing.overload + @staticmethod + def toMap( + function: java.util.function.Function[_toMap_2__T, _toMap_2__K] + | typing.Callable[[_toMap_2__T], _toMap_2__K], + function2: java.util.function.Function[_toMap_2__T, _toMap_2__U] + | typing.Callable[[_toMap_2__T], _toMap_2__U], + binaryOperator: java.util.function.BinaryOperator[_toMap_2__U] + | typing.Callable, + supplier: java.util.function.Supplier[_toMap_2__M] + | typing.Callable[[], _toMap_2__M], + ) -> Collector[_toMap_2__T, typing.Any, _toMap_2__M]: ... + _toSet__T = typing.TypeVar("_toSet__T") # + @staticmethod + def toSet() -> Collector[_toSet__T, typing.Any, java.util.Set[_toSet__T]]: ... + _toUnmodifiableList__T = typing.TypeVar("_toUnmodifiableList__T") # + @staticmethod + def toUnmodifiableList() -> Collector[ + _toUnmodifiableList__T, typing.Any, java.util.List[_toUnmodifiableList__T] + ]: ... + _toUnmodifiableMap_0__T = typing.TypeVar("_toUnmodifiableMap_0__T") # + _toUnmodifiableMap_0__K = typing.TypeVar("_toUnmodifiableMap_0__K") # + _toUnmodifiableMap_0__U = typing.TypeVar("_toUnmodifiableMap_0__U") # + _toUnmodifiableMap_1__T = typing.TypeVar("_toUnmodifiableMap_1__T") # + _toUnmodifiableMap_1__K = typing.TypeVar("_toUnmodifiableMap_1__K") # + _toUnmodifiableMap_1__U = typing.TypeVar("_toUnmodifiableMap_1__U") # + @typing.overload + @staticmethod + def toUnmodifiableMap( + function: java.util.function.Function[ + _toUnmodifiableMap_0__T, _toUnmodifiableMap_0__K + ] + | typing.Callable[[_toUnmodifiableMap_0__T], _toUnmodifiableMap_0__K], + function2: java.util.function.Function[ + _toUnmodifiableMap_0__T, _toUnmodifiableMap_0__U + ] + | typing.Callable[[_toUnmodifiableMap_0__T], _toUnmodifiableMap_0__U], + ) -> Collector[ + _toUnmodifiableMap_0__T, + typing.Any, + java.util.Map[_toUnmodifiableMap_0__K, _toUnmodifiableMap_0__U], + ]: ... + @typing.overload + @staticmethod + def toUnmodifiableMap( + function: java.util.function.Function[ + _toUnmodifiableMap_1__T, _toUnmodifiableMap_1__K + ] + | typing.Callable[[_toUnmodifiableMap_1__T], _toUnmodifiableMap_1__K], + function2: java.util.function.Function[ + _toUnmodifiableMap_1__T, _toUnmodifiableMap_1__U + ] + | typing.Callable[[_toUnmodifiableMap_1__T], _toUnmodifiableMap_1__U], + binaryOperator: java.util.function.BinaryOperator[_toUnmodifiableMap_1__U] + | typing.Callable, + ) -> Collector[ + _toUnmodifiableMap_1__T, + typing.Any, + java.util.Map[_toUnmodifiableMap_1__K, _toUnmodifiableMap_1__U], + ]: ... + _toUnmodifiableSet__T = typing.TypeVar("_toUnmodifiableSet__T") # + @staticmethod + def toUnmodifiableSet() -> Collector[ + _toUnmodifiableSet__T, typing.Any, java.util.Set[_toUnmodifiableSet__T] + ]: ... + +class Gatherers: + _fold__T = typing.TypeVar("_fold__T") # + _fold__R = typing.TypeVar("_fold__R") # + @staticmethod + def fold( + supplier: java.util.function.Supplier[_fold__R] | typing.Callable[[], _fold__R], + biFunction: java.util.function.BiFunction[_fold__R, _fold__T, _fold__R] + | typing.Callable[[_fold__R, _fold__T], _fold__R], + ) -> Gatherer[_fold__T, typing.Any, _fold__R]: ... + _mapConcurrent__T = typing.TypeVar("_mapConcurrent__T") # + _mapConcurrent__R = typing.TypeVar("_mapConcurrent__R") # + @staticmethod + def mapConcurrent( + int: int, + function: java.util.function.Function[_mapConcurrent__T, _mapConcurrent__R] + | typing.Callable[[_mapConcurrent__T], _mapConcurrent__R], + ) -> Gatherer[_mapConcurrent__T, typing.Any, _mapConcurrent__R]: ... + _scan__T = typing.TypeVar("_scan__T") # + _scan__R = typing.TypeVar("_scan__R") # + @staticmethod + def scan( + supplier: java.util.function.Supplier[_scan__R] | typing.Callable[[], _scan__R], + biFunction: java.util.function.BiFunction[_scan__R, _scan__T, _scan__R] + | typing.Callable[[_scan__R, _scan__T], _scan__R], + ) -> Gatherer[_scan__T, typing.Any, _scan__R]: ... + _windowFixed__TR = typing.TypeVar("_windowFixed__TR") # + @staticmethod + def windowFixed( + int: int, + ) -> Gatherer[_windowFixed__TR, typing.Any, java.util.List[_windowFixed__TR]]: ... + _windowSliding__TR = typing.TypeVar("_windowSliding__TR") # + @staticmethod + def windowSliding( + int: int, + ) -> Gatherer[ + _windowSliding__TR, typing.Any, java.util.List[_windowSliding__TR] + ]: ... + +class StreamSupport: + @typing.overload + @staticmethod + def doubleStream( + ofDouble: java.util.Spliterator.OfDouble, boolean: bool + ) -> DoubleStream: ... + @typing.overload + @staticmethod + def doubleStream( + supplier: java.util.function.Supplier[java.util.Spliterator.OfDouble] + | typing.Callable[[], java.util.Spliterator.OfDouble], + int: int, + boolean: bool, + ) -> DoubleStream: ... + @typing.overload + @staticmethod + def intStream(ofInt: java.util.Spliterator.OfInt, boolean: bool) -> IntStream: ... + @typing.overload + @staticmethod + def intStream( + supplier: java.util.function.Supplier[java.util.Spliterator.OfInt] + | typing.Callable[[], java.util.Spliterator.OfInt], + int: int, + boolean: bool, + ) -> IntStream: ... + @typing.overload + @staticmethod + def longStream( + ofLong: java.util.Spliterator.OfLong, boolean: bool + ) -> LongStream: ... + @typing.overload + @staticmethod + def longStream( + supplier: java.util.function.Supplier[java.util.Spliterator.OfLong] + | typing.Callable[[], java.util.Spliterator.OfLong], + int: int, + boolean: bool, + ) -> LongStream: ... + _stream_0__T = typing.TypeVar("_stream_0__T") # + _stream_1__T = typing.TypeVar("_stream_1__T") # + @typing.overload + @staticmethod + def stream( + spliterator: java.util.Spliterator[_stream_0__T], boolean: bool + ) -> Stream[_stream_0__T]: ... + @typing.overload + @staticmethod + def stream( + supplier: java.util.function.Supplier[java.util.Spliterator[_stream_1__T]] + | typing.Callable[[], java.util.Spliterator[_stream_1__T]], + int: int, + boolean: bool, + ) -> Stream[_stream_1__T]: ... + +class DoubleStream(BaseStream[float, "DoubleStream"]): + def allMatch( + self, doublePredicate: java.util.function.DoublePredicate | typing.Callable + ) -> bool: ... + def anyMatch( + self, doublePredicate: java.util.function.DoublePredicate | typing.Callable + ) -> bool: ... + def average(self) -> java.util.OptionalDouble: ... + def boxed(self) -> Stream[float]: ... + @staticmethod + def builder() -> DoubleStream.Builder: ... + _collect__R = typing.TypeVar("_collect__R") # + def collect( + self, + supplier: java.util.function.Supplier[_collect__R] + | typing.Callable[[], _collect__R], + objDoubleConsumer: java.util.function.ObjDoubleConsumer[_collect__R] + | typing.Callable[[_collect__R, float], None], + biConsumer: java.util.function.BiConsumer[_collect__R, _collect__R] + | typing.Callable[[_collect__R, _collect__R], None], + ) -> _collect__R: ... + @staticmethod + def concat( + doubleStream: DoubleStream, doubleStream2: DoubleStream + ) -> DoubleStream: ... + def count(self) -> int: ... + def distinct(self) -> DoubleStream: ... + def dropWhile( + self, doublePredicate: java.util.function.DoublePredicate | typing.Callable + ) -> DoubleStream: ... + @staticmethod + def empty() -> DoubleStream: ... + def filter( + self, doublePredicate: java.util.function.DoublePredicate | typing.Callable + ) -> DoubleStream: ... + def findAny(self) -> java.util.OptionalDouble: ... + def findFirst(self) -> java.util.OptionalDouble: ... + def flatMap( + self, + doubleFunction: java.util.function.DoubleFunction[DoubleStream] + | typing.Callable[[float], DoubleStream], + ) -> DoubleStream: ... + def forEach( + self, doubleConsumer: java.util.function.DoubleConsumer | typing.Callable + ) -> None: ... + def forEachOrdered( + self, doubleConsumer: java.util.function.DoubleConsumer | typing.Callable + ) -> None: ... + @staticmethod + def generate( + doubleSupplier: java.util.function.DoubleSupplier | typing.Callable, + ) -> DoubleStream: ... + @typing.overload + @staticmethod + def iterate( + double: float, + doublePredicate: java.util.function.DoublePredicate | typing.Callable, + doubleUnaryOperator: java.util.function.DoubleUnaryOperator | typing.Callable, + ) -> DoubleStream: ... + @typing.overload + @staticmethod + def iterate( + double: float, + doubleUnaryOperator: java.util.function.DoubleUnaryOperator | typing.Callable, + ) -> DoubleStream: ... + def iterator(self) -> java.util.PrimitiveIterator.OfDouble: ... + def limit(self, long: int) -> DoubleStream: ... + def map( + self, + doubleUnaryOperator: java.util.function.DoubleUnaryOperator | typing.Callable, + ) -> DoubleStream: ... + def mapMulti( + self, + doubleMapMultiConsumer: DoubleStream.DoubleMapMultiConsumer | typing.Callable, + ) -> DoubleStream: ... + def mapToInt( + self, + doubleToIntFunction: java.util.function.DoubleToIntFunction | typing.Callable, + ) -> IntStream: ... + def mapToLong( + self, + doubleToLongFunction: java.util.function.DoubleToLongFunction | typing.Callable, + ) -> LongStream: ... + _mapToObj__U = typing.TypeVar("_mapToObj__U") # + def mapToObj( + self, + doubleFunction: java.util.function.DoubleFunction[_mapToObj__U] + | typing.Callable[[float], _mapToObj__U], + ) -> Stream[_mapToObj__U]: ... + def max(self) -> java.util.OptionalDouble: ... + def min(self) -> java.util.OptionalDouble: ... + def noneMatch( + self, doublePredicate: java.util.function.DoublePredicate | typing.Callable + ) -> bool: ... + @typing.overload + @staticmethod + def of(double: float) -> DoubleStream: ... + @typing.overload + @staticmethod + def of(*double: float) -> DoubleStream: ... + def parallel(self) -> DoubleStream: ... + def peek( + self, doubleConsumer: java.util.function.DoubleConsumer | typing.Callable + ) -> DoubleStream: ... + @typing.overload + def reduce( + self, + double: float, + doubleBinaryOperator: java.util.function.DoubleBinaryOperator | typing.Callable, + ) -> float: ... + @typing.overload + def reduce( + self, + doubleBinaryOperator: java.util.function.DoubleBinaryOperator | typing.Callable, + ) -> java.util.OptionalDouble: ... + def sequential(self) -> DoubleStream: ... + def skip(self, long: int) -> DoubleStream: ... + def sorted(self) -> DoubleStream: ... + def spliterator(self) -> java.util.Spliterator.OfDouble: ... + def sum(self) -> float: ... + def summaryStatistics(self) -> java.util.DoubleSummaryStatistics: ... + def takeWhile( + self, doublePredicate: java.util.function.DoublePredicate | typing.Callable + ) -> DoubleStream: ... + def toArray(self) -> typing.MutableSequence[float]: ... + class Builder(java.util.function.DoubleConsumer): + def accept(self, double: float) -> None: ... + def add(self, double: float) -> DoubleStream.Builder: ... + def build(self) -> DoubleStream: ... + + class DoubleMapMultiConsumer: + def accept( + self, + double: float, + doubleConsumer: java.util.function.DoubleConsumer | typing.Callable, + ) -> None: ... + +class IntStream(BaseStream[int, "IntStream"]): + def allMatch( + self, intPredicate: java.util.function.IntPredicate | typing.Callable + ) -> bool: ... + def anyMatch( + self, intPredicate: java.util.function.IntPredicate | typing.Callable + ) -> bool: ... + def asDoubleStream(self) -> DoubleStream: ... + def asLongStream(self) -> LongStream: ... + def average(self) -> java.util.OptionalDouble: ... + def boxed(self) -> Stream[int]: ... + @staticmethod + def builder() -> IntStream.Builder: ... + _collect__R = typing.TypeVar("_collect__R") # + def collect( + self, + supplier: java.util.function.Supplier[_collect__R] + | typing.Callable[[], _collect__R], + objIntConsumer: java.util.function.ObjIntConsumer[_collect__R] + | typing.Callable[[_collect__R, int], None], + biConsumer: java.util.function.BiConsumer[_collect__R, _collect__R] + | typing.Callable[[_collect__R, _collect__R], None], + ) -> _collect__R: ... + @staticmethod + def concat(intStream: IntStream, intStream2: IntStream) -> IntStream: ... + def count(self) -> int: ... + def distinct(self) -> IntStream: ... + def dropWhile( + self, intPredicate: java.util.function.IntPredicate | typing.Callable + ) -> IntStream: ... + @staticmethod + def empty() -> IntStream: ... + def filter( + self, intPredicate: java.util.function.IntPredicate | typing.Callable + ) -> IntStream: ... + def findAny(self) -> java.util.OptionalInt: ... + def findFirst(self) -> java.util.OptionalInt: ... + def flatMap( + self, + intFunction: java.util.function.IntFunction[IntStream] + | typing.Callable[[int], IntStream], + ) -> IntStream: ... + def forEach( + self, intConsumer: java.util.function.IntConsumer | typing.Callable + ) -> None: ... + def forEachOrdered( + self, intConsumer: java.util.function.IntConsumer | typing.Callable + ) -> None: ... + @staticmethod + def generate( + intSupplier: java.util.function.IntSupplier | typing.Callable, + ) -> IntStream: ... + @typing.overload + @staticmethod + def iterate( + int: int, + intPredicate: java.util.function.IntPredicate | typing.Callable, + intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable, + ) -> IntStream: ... + @typing.overload + @staticmethod + def iterate( + int: int, + intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable, + ) -> IntStream: ... + def iterator(self) -> java.util.PrimitiveIterator.OfInt: ... + def limit(self, long: int) -> IntStream: ... + def map( + self, intUnaryOperator: java.util.function.IntUnaryOperator | typing.Callable + ) -> IntStream: ... + def mapMulti( + self, intMapMultiConsumer: IntStream.IntMapMultiConsumer | typing.Callable + ) -> IntStream: ... + def mapToDouble( + self, + intToDoubleFunction: java.util.function.IntToDoubleFunction | typing.Callable, + ) -> DoubleStream: ... + def mapToLong( + self, intToLongFunction: java.util.function.IntToLongFunction | typing.Callable + ) -> LongStream: ... + _mapToObj__U = typing.TypeVar("_mapToObj__U") # + def mapToObj( + self, + intFunction: java.util.function.IntFunction[_mapToObj__U] + | typing.Callable[[int], _mapToObj__U], + ) -> Stream[_mapToObj__U]: ... + def max(self) -> java.util.OptionalInt: ... + def min(self) -> java.util.OptionalInt: ... + def noneMatch( + self, intPredicate: java.util.function.IntPredicate | typing.Callable + ) -> bool: ... + @typing.overload + @staticmethod + def of(int: int) -> IntStream: ... + @typing.overload + @staticmethod + def of(*int: int) -> IntStream: ... + def parallel(self) -> IntStream: ... + def peek( + self, intConsumer: java.util.function.IntConsumer | typing.Callable + ) -> IntStream: ... + @staticmethod + def range(int: int, int2: int) -> IntStream: ... + @staticmethod + def rangeClosed(int: int, int2: int) -> IntStream: ... + @typing.overload + def reduce( + self, + int: int, + intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable, + ) -> int: ... + @typing.overload + def reduce( + self, intBinaryOperator: java.util.function.IntBinaryOperator | typing.Callable + ) -> java.util.OptionalInt: ... + def sequential(self) -> IntStream: ... + def skip(self, long: int) -> IntStream: ... + def sorted(self) -> IntStream: ... + def spliterator(self) -> java.util.Spliterator.OfInt: ... + def sum(self) -> int: ... + def summaryStatistics(self) -> java.util.IntSummaryStatistics: ... + def takeWhile( + self, intPredicate: java.util.function.IntPredicate | typing.Callable + ) -> IntStream: ... + def toArray(self) -> typing.MutableSequence[int]: ... + class Builder(java.util.function.IntConsumer): + def accept(self, int: int) -> None: ... + def add(self, int: int) -> IntStream.Builder: ... + def build(self) -> IntStream: ... + + class IntMapMultiConsumer: + def accept( + self, + int: int, + intConsumer: java.util.function.IntConsumer | typing.Callable, + ) -> None: ... + +class LongStream(BaseStream[int, "LongStream"]): + def allMatch( + self, longPredicate: java.util.function.LongPredicate | typing.Callable + ) -> bool: ... + def anyMatch( + self, longPredicate: java.util.function.LongPredicate | typing.Callable + ) -> bool: ... + def asDoubleStream(self) -> DoubleStream: ... + def average(self) -> java.util.OptionalDouble: ... + def boxed(self) -> Stream[int]: ... + @staticmethod + def builder() -> LongStream.Builder: ... + _collect__R = typing.TypeVar("_collect__R") # + def collect( + self, + supplier: java.util.function.Supplier[_collect__R] + | typing.Callable[[], _collect__R], + objLongConsumer: java.util.function.ObjLongConsumer[_collect__R] + | typing.Callable[[_collect__R, int], None], + biConsumer: java.util.function.BiConsumer[_collect__R, _collect__R] + | typing.Callable[[_collect__R, _collect__R], None], + ) -> _collect__R: ... + @staticmethod + def concat(longStream: LongStream, longStream2: LongStream) -> LongStream: ... + def count(self) -> int: ... + def distinct(self) -> LongStream: ... + def dropWhile( + self, longPredicate: java.util.function.LongPredicate | typing.Callable + ) -> LongStream: ... + @staticmethod + def empty() -> LongStream: ... + def filter( + self, longPredicate: java.util.function.LongPredicate | typing.Callable + ) -> LongStream: ... + def findAny(self) -> java.util.OptionalLong: ... + def findFirst(self) -> java.util.OptionalLong: ... + def flatMap( + self, + longFunction: java.util.function.LongFunction[LongStream] + | typing.Callable[[int], LongStream], + ) -> LongStream: ... + def forEach( + self, longConsumer: java.util.function.LongConsumer | typing.Callable + ) -> None: ... + def forEachOrdered( + self, longConsumer: java.util.function.LongConsumer | typing.Callable + ) -> None: ... + @staticmethod + def generate( + longSupplier: java.util.function.LongSupplier | typing.Callable, + ) -> LongStream: ... + @typing.overload + @staticmethod + def iterate( + long: int, + longPredicate: java.util.function.LongPredicate | typing.Callable, + longUnaryOperator: java.util.function.LongUnaryOperator | typing.Callable, + ) -> LongStream: ... + @typing.overload + @staticmethod + def iterate( + long: int, + longUnaryOperator: java.util.function.LongUnaryOperator | typing.Callable, + ) -> LongStream: ... + def iterator(self) -> java.util.PrimitiveIterator.OfLong: ... + def limit(self, long: int) -> LongStream: ... + def map( + self, longUnaryOperator: java.util.function.LongUnaryOperator | typing.Callable + ) -> LongStream: ... + def mapMulti( + self, longMapMultiConsumer: LongStream.LongMapMultiConsumer | typing.Callable + ) -> LongStream: ... + def mapToDouble( + self, + longToDoubleFunction: java.util.function.LongToDoubleFunction | typing.Callable, + ) -> DoubleStream: ... + def mapToInt( + self, longToIntFunction: java.util.function.LongToIntFunction | typing.Callable + ) -> IntStream: ... + _mapToObj__U = typing.TypeVar("_mapToObj__U") # + def mapToObj( + self, + longFunction: java.util.function.LongFunction[_mapToObj__U] + | typing.Callable[[int], _mapToObj__U], + ) -> Stream[_mapToObj__U]: ... + def max(self) -> java.util.OptionalLong: ... + def min(self) -> java.util.OptionalLong: ... + def noneMatch( + self, longPredicate: java.util.function.LongPredicate | typing.Callable + ) -> bool: ... + @typing.overload + @staticmethod + def of(long: int) -> LongStream: ... + @typing.overload + @staticmethod + def of(*long: int) -> LongStream: ... + def parallel(self) -> LongStream: ... + def peek( + self, longConsumer: java.util.function.LongConsumer | typing.Callable + ) -> LongStream: ... + @staticmethod + def range(long: int, long2: int) -> LongStream: ... + @staticmethod + def rangeClosed(long: int, long2: int) -> LongStream: ... + @typing.overload + def reduce( + self, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> java.util.OptionalLong: ... + @typing.overload + def reduce( + self, + long: int, + longBinaryOperator: java.util.function.LongBinaryOperator | typing.Callable, + ) -> int: ... + def sequential(self) -> LongStream: ... + def skip(self, long: int) -> LongStream: ... + def sorted(self) -> LongStream: ... + def spliterator(self) -> java.util.Spliterator.OfLong: ... + def sum(self) -> int: ... + def summaryStatistics(self) -> java.util.LongSummaryStatistics: ... + def takeWhile( + self, longPredicate: java.util.function.LongPredicate | typing.Callable + ) -> LongStream: ... + def toArray(self) -> typing.MutableSequence[int]: ... + class Builder(java.util.function.LongConsumer): + def accept(self, long: int) -> None: ... + def add(self, long: int) -> LongStream.Builder: ... + def build(self) -> LongStream: ... + + class LongMapMultiConsumer: + def accept( + self, + long: int, + longConsumer: java.util.function.LongConsumer | typing.Callable, + ) -> None: ... + +_Stream__Builder__T = typing.TypeVar("_Stream__Builder__T") # +_Stream__T = typing.TypeVar("_Stream__T") # + +class Stream(BaseStream[_Stream__T, "Stream"[_Stream__T]], typing.Generic[_Stream__T]): + def allMatch( + self, + predicate: java.util.function.Predicate[_Stream__T] + | typing.Callable[[_Stream__T], bool], + ) -> bool: ... + def anyMatch( + self, + predicate: java.util.function.Predicate[_Stream__T] + | typing.Callable[[_Stream__T], bool], + ) -> bool: ... + _builder__T = typing.TypeVar("_builder__T") # + @staticmethod + def builder() -> Stream.Builder[_builder__T]: ... + _collect_0__R = typing.TypeVar("_collect_0__R") # + _collect_1__R = typing.TypeVar("_collect_1__R") # + _collect_1__A = typing.TypeVar("_collect_1__A") # + @typing.overload + def collect( + self, + supplier: java.util.function.Supplier[_collect_0__R] + | typing.Callable[[], _collect_0__R], + biConsumer: java.util.function.BiConsumer[_collect_0__R, _Stream__T] + | typing.Callable[[_collect_0__R, _Stream__T], None], + biConsumer2: java.util.function.BiConsumer[_collect_0__R, _collect_0__R] + | typing.Callable[[_collect_0__R, _collect_0__R], None], + ) -> _collect_0__R: ... + @typing.overload + def collect( + self, collector: Collector[_Stream__T, _collect_1__A, _collect_1__R] + ) -> _collect_1__R: ... + _concat__T = typing.TypeVar("_concat__T") # + @staticmethod + def concat( + stream: Stream[_concat__T], stream2: Stream[_concat__T] + ) -> Stream[_concat__T]: ... + def count(self) -> int: ... + def distinct(self) -> Stream[_Stream__T]: ... + def dropWhile( + self, + predicate: java.util.function.Predicate[_Stream__T] + | typing.Callable[[_Stream__T], bool], + ) -> Stream[_Stream__T]: ... + _empty__T = typing.TypeVar("_empty__T") # + @staticmethod + def empty() -> Stream[_empty__T]: ... + def filter( + self, + predicate: java.util.function.Predicate[_Stream__T] + | typing.Callable[[_Stream__T], bool], + ) -> Stream[_Stream__T]: ... + def findAny(self) -> java.util.Optional[_Stream__T]: ... + def findFirst(self) -> java.util.Optional[_Stream__T]: ... + _flatMap__R = typing.TypeVar("_flatMap__R") # + def flatMap( + self, + function: java.util.function.Function[_Stream__T, Stream[_flatMap__R]] + | typing.Callable[[_Stream__T], Stream[_flatMap__R]], + ) -> Stream[_flatMap__R]: ... + def flatMapToDouble( + self, + function: java.util.function.Function[_Stream__T, DoubleStream] + | typing.Callable[[_Stream__T], DoubleStream], + ) -> DoubleStream: ... + def flatMapToInt( + self, + function: java.util.function.Function[_Stream__T, IntStream] + | typing.Callable[[_Stream__T], IntStream], + ) -> IntStream: ... + def flatMapToLong( + self, + function: java.util.function.Function[_Stream__T, LongStream] + | typing.Callable[[_Stream__T], LongStream], + ) -> LongStream: ... + def forEach( + self, + consumer: java.util.function.Consumer[_Stream__T] + | typing.Callable[[_Stream__T], None], + ) -> None: ... + def forEachOrdered( + self, + consumer: java.util.function.Consumer[_Stream__T] + | typing.Callable[[_Stream__T], None], + ) -> None: ... + _gather__R = typing.TypeVar("_gather__R") # + def gather( + self, + gatherer: Gatherer[_Stream__T, typing.Any, _gather__R] + | typing.Callable[[], Gatherer.Integrator[typing.Any, typing.Any, typing.Any]], + ) -> Stream[_gather__R]: ... + _generate__T = typing.TypeVar("_generate__T") # + @staticmethod + def generate( + supplier: java.util.function.Supplier[_generate__T] + | typing.Callable[[], _generate__T], + ) -> Stream[_generate__T]: ... + _iterate_0__T = typing.TypeVar("_iterate_0__T") # + _iterate_1__T = typing.TypeVar("_iterate_1__T") # + @typing.overload + @staticmethod + def iterate( + t: _iterate_0__T, + predicate: java.util.function.Predicate[_iterate_0__T] + | typing.Callable[[_iterate_0__T], bool], + unaryOperator: java.util.function.UnaryOperator[_iterate_0__T] + | typing.Callable, + ) -> Stream[_iterate_0__T]: ... + @typing.overload + @staticmethod + def iterate( + t: _iterate_1__T, + unaryOperator: java.util.function.UnaryOperator[_iterate_1__T] + | typing.Callable, + ) -> Stream[_iterate_1__T]: ... + def limit(self, long: int) -> Stream[_Stream__T]: ... + _map__R = typing.TypeVar("_map__R") # + def map( + self, + function: java.util.function.Function[_Stream__T, _map__R] + | typing.Callable[[_Stream__T], _map__R], + ) -> Stream[_map__R]: ... + _mapMulti__R = typing.TypeVar("_mapMulti__R") # + def mapMulti( + self, + biConsumer: java.util.function.BiConsumer[ + _Stream__T, java.util.function.Consumer[_mapMulti__R] + ] + | typing.Callable[ + [_Stream__T, java.util.function.Consumer[_mapMulti__R]], None + ], + ) -> Stream[_mapMulti__R]: ... + def mapMultiToDouble( + self, + biConsumer: java.util.function.BiConsumer[ + _Stream__T, java.util.function.DoubleConsumer + ] + | typing.Callable[[_Stream__T, java.util.function.DoubleConsumer], None], + ) -> DoubleStream: ... + def mapMultiToInt( + self, + biConsumer: java.util.function.BiConsumer[ + _Stream__T, java.util.function.IntConsumer + ] + | typing.Callable[[_Stream__T, java.util.function.IntConsumer], None], + ) -> IntStream: ... + def mapMultiToLong( + self, + biConsumer: java.util.function.BiConsumer[ + _Stream__T, java.util.function.LongConsumer + ] + | typing.Callable[[_Stream__T, java.util.function.LongConsumer], None], + ) -> LongStream: ... + def mapToDouble( + self, + toDoubleFunction: java.util.function.ToDoubleFunction[_Stream__T] + | typing.Callable[[_Stream__T], float], + ) -> DoubleStream: ... + def mapToInt( + self, + toIntFunction: java.util.function.ToIntFunction[_Stream__T] + | typing.Callable[[_Stream__T], int], + ) -> IntStream: ... + def mapToLong( + self, + toLongFunction: java.util.function.ToLongFunction[_Stream__T] + | typing.Callable[[_Stream__T], int], + ) -> LongStream: ... + def max( + self, + comparator: java.util.Comparator[_Stream__T] + | typing.Callable[[_Stream__T, _Stream__T], int], + ) -> java.util.Optional[_Stream__T]: ... + def min( + self, + comparator: java.util.Comparator[_Stream__T] + | typing.Callable[[_Stream__T, _Stream__T], int], + ) -> java.util.Optional[_Stream__T]: ... + def noneMatch( + self, + predicate: java.util.function.Predicate[_Stream__T] + | typing.Callable[[_Stream__T], bool], + ) -> bool: ... + _of_0__T = typing.TypeVar("_of_0__T") # + _of_1__T = typing.TypeVar("_of_1__T") # + @typing.overload + @staticmethod + def of(t: _of_0__T) -> Stream[_of_0__T]: ... + @typing.overload + @staticmethod + def of(*t: _of_1__T) -> Stream[_of_1__T]: ... + _ofNullable__T = typing.TypeVar("_ofNullable__T") # + @staticmethod + def ofNullable(t: _ofNullable__T) -> Stream[_ofNullable__T]: ... + def peek( + self, + consumer: java.util.function.Consumer[_Stream__T] + | typing.Callable[[_Stream__T], None], + ) -> Stream[_Stream__T]: ... + _reduce_0__U = typing.TypeVar("_reduce_0__U") # + @typing.overload + def reduce( + self, + u: _reduce_0__U, + biFunction: java.util.function.BiFunction[ + _reduce_0__U, _Stream__T, _reduce_0__U + ] + | typing.Callable[[_reduce_0__U, _Stream__T], _reduce_0__U], + binaryOperator: java.util.function.BinaryOperator[_reduce_0__U] + | typing.Callable, + ) -> _reduce_0__U: ... + @typing.overload + def reduce( + self, + t: _Stream__T, + binaryOperator: java.util.function.BinaryOperator[_Stream__T] | typing.Callable, + ) -> _Stream__T: ... + @typing.overload + def reduce( + self, + binaryOperator: java.util.function.BinaryOperator[_Stream__T] | typing.Callable, + ) -> java.util.Optional[_Stream__T]: ... + def skip(self, long: int) -> Stream[_Stream__T]: ... + @typing.overload + def sorted(self) -> Stream[_Stream__T]: ... + @typing.overload + def sorted( + self, + comparator: java.util.Comparator[_Stream__T] + | typing.Callable[[_Stream__T, _Stream__T], int], + ) -> Stream[_Stream__T]: ... + def takeWhile( + self, + predicate: java.util.function.Predicate[_Stream__T] + | typing.Callable[[_Stream__T], bool], + ) -> Stream[_Stream__T]: ... + _toArray_1__A = typing.TypeVar("_toArray_1__A") # + @typing.overload + def toArray(self) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def toArray( + self, + intFunction: java.util.function.IntFunction[list[_toArray_1__A] | jpype.JArray] + | typing.Callable[[int], list[_toArray_1__A] | jpype.JArray], + ) -> typing.MutableSequence[_toArray_1__A]: ... + def toList(self) -> java.util.List[_Stream__T]: ... + class Builder( + java.util.function.Consumer[_Stream__Builder__T], + typing.Generic[_Stream__Builder__T], + ): + def accept(self, t: _Stream__Builder__T) -> None: ... + def add( + self, t: _Stream__Builder__T + ) -> Stream.Builder[_Stream__Builder__T]: ... + def build(self) -> Stream[_Stream__Builder__T]: ... + +_Gatherer__Downstream__T = typing.TypeVar("_Gatherer__Downstream__T") # +_Gatherer__Integrator__Greedy__A = typing.TypeVar( + "_Gatherer__Integrator__Greedy__A" +) # +_Gatherer__Integrator__Greedy__T = typing.TypeVar( + "_Gatherer__Integrator__Greedy__T" +) # +_Gatherer__Integrator__Greedy__R = typing.TypeVar( + "_Gatherer__Integrator__Greedy__R" +) # +_Gatherer__Integrator__A = typing.TypeVar("_Gatherer__Integrator__A") # +_Gatherer__Integrator__T = typing.TypeVar("_Gatherer__Integrator__T") # +_Gatherer__Integrator__R = typing.TypeVar("_Gatherer__Integrator__R") # +_Gatherer__T = typing.TypeVar("_Gatherer__T") # +_Gatherer__A = typing.TypeVar("_Gatherer__A") # +_Gatherer__R = typing.TypeVar("_Gatherer__R") # + +class Gatherer(typing.Generic[_Gatherer__T, _Gatherer__A, _Gatherer__R]): + _andThen__RR = typing.TypeVar("_andThen__RR") # + def andThen( + self, + gatherer: Gatherer[_Gatherer__R, typing.Any, _andThen__RR] + | typing.Callable[[], Gatherer.Integrator[typing.Any, typing.Any, typing.Any]], + ) -> Gatherer[_Gatherer__T, typing.Any, _andThen__RR]: ... + def combiner(self) -> java.util.function.BinaryOperator[_Gatherer__A]: ... + _defaultCombiner__A = typing.TypeVar("_defaultCombiner__A") # + @staticmethod + def defaultCombiner() -> java.util.function.BinaryOperator[_defaultCombiner__A]: ... + _defaultFinisher__A = typing.TypeVar("_defaultFinisher__A") # + _defaultFinisher__R = typing.TypeVar("_defaultFinisher__R") # + @staticmethod + def defaultFinisher() -> java.util.function.BiConsumer[ + _defaultFinisher__A, Gatherer.Downstream[_defaultFinisher__R] + ]: ... + _defaultInitializer__A = typing.TypeVar("_defaultInitializer__A") # + @staticmethod + def defaultInitializer() -> java.util.function.Supplier[_defaultInitializer__A]: ... + def finisher( + self, + ) -> java.util.function.BiConsumer[ + _Gatherer__A, Gatherer.Downstream[_Gatherer__R] + ]: ... + def initializer(self) -> java.util.function.Supplier[_Gatherer__A]: ... + def integrator( + self, + ) -> Gatherer.Integrator[_Gatherer__A, _Gatherer__T, _Gatherer__R]: ... + _of_0__T = typing.TypeVar("_of_0__T") # + _of_0__A = typing.TypeVar("_of_0__A") # + _of_0__R = typing.TypeVar("_of_0__R") # + _of_1__T = typing.TypeVar("_of_1__T") # + _of_1__R = typing.TypeVar("_of_1__R") # + _of_2__T = typing.TypeVar("_of_2__T") # + _of_2__R = typing.TypeVar("_of_2__R") # + @typing.overload + @staticmethod + def of( + supplier: java.util.function.Supplier[_of_0__A] | typing.Callable[[], _of_0__A], + integrator: Gatherer.Integrator[_of_0__A, _of_0__T, _of_0__R] + | typing.Callable[[_of_0__A, _of_0__T, Gatherer.Downstream[typing.Any]], bool], + binaryOperator: java.util.function.BinaryOperator[_of_0__A] | typing.Callable, + biConsumer: java.util.function.BiConsumer[ + _of_0__A, Gatherer.Downstream[_of_0__R] | typing.Callable[[_of_0__R], bool] + ] + | typing.Callable[ + [ + _of_0__A, + Gatherer.Downstream[_of_0__R] | typing.Callable[[_of_0__R], bool], + ], + None, + ], + ) -> Gatherer[_of_0__T, _of_0__A, _of_0__R]: ... + @typing.overload + @staticmethod + def of( + integrator: Gatherer.Integrator[None, _of_1__T, _of_1__R] + | typing.Callable[[None, _of_1__T, Gatherer.Downstream[typing.Any]], bool], + ) -> Gatherer[_of_1__T, None, _of_1__R]: ... + @typing.overload + @staticmethod + def of( + integrator: Gatherer.Integrator[None, _of_2__T, _of_2__R] + | typing.Callable[[None, _of_2__T, Gatherer.Downstream[typing.Any]], bool], + biConsumer: java.util.function.BiConsumer[ + None, Gatherer.Downstream[_of_2__R] | typing.Callable[[_of_2__R], bool] + ] + | typing.Callable[ + [None, Gatherer.Downstream[_of_2__R] | typing.Callable[[_of_2__R], bool]], + None, + ], + ) -> Gatherer[_of_2__T, None, _of_2__R]: ... + _ofSequential_0__T = typing.TypeVar("_ofSequential_0__T") # + _ofSequential_0__A = typing.TypeVar("_ofSequential_0__A") # + _ofSequential_0__R = typing.TypeVar("_ofSequential_0__R") # + _ofSequential_1__T = typing.TypeVar("_ofSequential_1__T") # + _ofSequential_1__A = typing.TypeVar("_ofSequential_1__A") # + _ofSequential_1__R = typing.TypeVar("_ofSequential_1__R") # + _ofSequential_2__T = typing.TypeVar("_ofSequential_2__T") # + _ofSequential_2__R = typing.TypeVar("_ofSequential_2__R") # + _ofSequential_3__T = typing.TypeVar("_ofSequential_3__T") # + _ofSequential_3__R = typing.TypeVar("_ofSequential_3__R") # + @typing.overload + @staticmethod + def ofSequential( + supplier: java.util.function.Supplier[_ofSequential_0__A] + | typing.Callable[[], _ofSequential_0__A], + integrator: Gatherer.Integrator[ + _ofSequential_0__A, _ofSequential_0__T, _ofSequential_0__R + ] + | typing.Callable[ + [_ofSequential_0__A, _ofSequential_0__T, Gatherer.Downstream[typing.Any]], + bool, + ], + ) -> Gatherer[_ofSequential_0__T, _ofSequential_0__A, _ofSequential_0__R]: ... + @typing.overload + @staticmethod + def ofSequential( + supplier: java.util.function.Supplier[_ofSequential_1__A] + | typing.Callable[[], _ofSequential_1__A], + integrator: Gatherer.Integrator[ + _ofSequential_1__A, _ofSequential_1__T, _ofSequential_1__R + ] + | typing.Callable[ + [_ofSequential_1__A, _ofSequential_1__T, Gatherer.Downstream[typing.Any]], + bool, + ], + biConsumer: java.util.function.BiConsumer[ + _ofSequential_1__A, + Gatherer.Downstream[_ofSequential_1__R] + | typing.Callable[[_ofSequential_1__R], bool], + ] + | typing.Callable[ + [ + _ofSequential_1__A, + Gatherer.Downstream[_ofSequential_1__R] + | typing.Callable[[_ofSequential_1__R], bool], + ], + None, + ], + ) -> Gatherer[_ofSequential_1__T, _ofSequential_1__A, _ofSequential_1__R]: ... + @typing.overload + @staticmethod + def ofSequential( + integrator: Gatherer.Integrator[None, _ofSequential_2__T, _ofSequential_2__R] + | typing.Callable[ + [None, _ofSequential_2__T, Gatherer.Downstream[typing.Any]], bool + ], + ) -> Gatherer[_ofSequential_2__T, None, _ofSequential_2__R]: ... + @typing.overload + @staticmethod + def ofSequential( + integrator: Gatherer.Integrator[None, _ofSequential_3__T, _ofSequential_3__R] + | typing.Callable[ + [None, _ofSequential_3__T, Gatherer.Downstream[typing.Any]], bool + ], + biConsumer: java.util.function.BiConsumer[ + None, + Gatherer.Downstream[_ofSequential_3__R] + | typing.Callable[[_ofSequential_3__R], bool], + ] + | typing.Callable[ + [ + None, + Gatherer.Downstream[_ofSequential_3__R] + | typing.Callable[[_ofSequential_3__R], bool], + ], + None, + ], + ) -> Gatherer[_ofSequential_3__T, None, _ofSequential_3__R]: ... + class Downstream(typing.Generic[_Gatherer__Downstream__T]): + def isRejecting(self) -> bool: ... + def push(self, t: _Gatherer__Downstream__T) -> bool: ... + + class Integrator( + typing.Generic[ + _Gatherer__Integrator__A, _Gatherer__Integrator__T, _Gatherer__Integrator__R + ] + ): + def integrate( + self, + a: _Gatherer__Integrator__A, + t: _Gatherer__Integrator__T, + downstream: Gatherer.Downstream[_Gatherer__Integrator__R] + | typing.Callable[[_Gatherer__Integrator__R], bool], + ) -> bool: ... + _of__A = typing.TypeVar("_of__A") # + _of__T = typing.TypeVar("_of__T") # + _of__R = typing.TypeVar("_of__R") # + @staticmethod + def of( + integrator: Gatherer.Integrator[_of__A, _of__T, _of__R] + | typing.Callable[[_of__A, _of__T, Gatherer.Downstream[typing.Any]], bool], + ) -> Gatherer.Integrator[_of__A, _of__T, _of__R]: ... + _ofGreedy__A = typing.TypeVar("_ofGreedy__A") # + _ofGreedy__T = typing.TypeVar("_ofGreedy__T") # + _ofGreedy__R = typing.TypeVar("_ofGreedy__R") # + @staticmethod + def ofGreedy( + greedy: Gatherer.Integrator.Greedy[_ofGreedy__A, _ofGreedy__T, _ofGreedy__R] + | typing.Callable, + ) -> Gatherer.Integrator.Greedy[_ofGreedy__A, _ofGreedy__T, _ofGreedy__R]: ... + class Greedy( + java.util.stream.Gatherer.Integrator[ + _Gatherer__Integrator__Greedy__A, + _Gatherer__Integrator__Greedy__T, + _Gatherer__Integrator__Greedy__R, + ], + typing.Generic[ + _Gatherer__Integrator__Greedy__A, + _Gatherer__Integrator__Greedy__T, + _Gatherer__Integrator__Greedy__R, + ], + ): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.stream")``. + + BaseStream: type[BaseStream] + Collector: type[Collector] + Collectors: type[Collectors] + DoubleStream: type[DoubleStream] + Gatherer: type[Gatherer] + Gatherers: type[Gatherers] + IntStream: type[IntStream] + LongStream: type[LongStream] + Stream: type[Stream] + StreamSupport: type[StreamSupport] diff --git a/typings/java/util/zip/__init__.pyi b/typings/java/util/zip/__init__.pyi new file mode 100644 index 0000000..08478fe --- /dev/null +++ b/typings/java/util/zip/__init__.pyi @@ -0,0 +1,520 @@ +import typing +from typing import Protocol + +import java +import java.io +import java.lang +import java.nio +import java.nio.charset +import java.nio.file.attribute +import java.time +import java.util +import java.util.stream +import jpype +import jpype.protocol + +class CheckedInputStream(java.io.FilterInputStream): + def __init__(self, inputStream: java.io.InputStream, checksum: Checksum): ... + def getChecksum(self) -> Checksum: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def skip(self, long: int) -> int: ... + +class CheckedOutputStream(java.io.FilterOutputStream): + def __init__(self, outputStream: java.io.OutputStream, checksum: Checksum): ... + def getChecksum(self) -> Checksum: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class Checksum: + def getValue(self) -> int: ... + def reset(self) -> None: ... + @typing.overload + def update( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def update(self, int: int) -> None: ... + @typing.overload + def update(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def update(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + +class DataFormatException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Deflater(java.lang.AutoCloseable): + DEFLATED: typing.ClassVar[int] = ... + NO_COMPRESSION: typing.ClassVar[int] = ... + BEST_SPEED: typing.ClassVar[int] = ... + BEST_COMPRESSION: typing.ClassVar[int] = ... + DEFAULT_COMPRESSION: typing.ClassVar[int] = ... + FILTERED: typing.ClassVar[int] = ... + HUFFMAN_ONLY: typing.ClassVar[int] = ... + DEFAULT_STRATEGY: typing.ClassVar[int] = ... + NO_FLUSH: typing.ClassVar[int] = ... + SYNC_FLUSH: typing.ClassVar[int] = ... + FULL_FLUSH: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, boolean: bool): ... + def close(self) -> None: ... + @typing.overload + def deflate(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def deflate( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def deflate( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + ) -> int: ... + @typing.overload + def deflate(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def deflate(self, byteBuffer: java.nio.ByteBuffer, int: int) -> int: ... + def end(self) -> None: ... + def finish(self) -> None: ... + def finished(self) -> bool: ... + def getAdler(self) -> int: ... + def getBytesRead(self) -> int: ... + def getBytesWritten(self) -> int: ... + def getTotalIn(self) -> int: ... + def getTotalOut(self) -> int: ... + def needsInput(self) -> bool: ... + def reset(self) -> None: ... + @typing.overload + def setDictionary(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setDictionary( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def setDictionary(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def setInput(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setInput( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def setInput(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + def setLevel(self, int: int) -> None: ... + def setStrategy(self, int: int) -> None: ... + +class DeflaterInputStream(java.io.FilterInputStream): + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + @typing.overload + def __init__(self, inputStream: java.io.InputStream, deflater: Deflater): ... + @typing.overload + def __init__( + self, inputStream: java.io.InputStream, deflater: Deflater, int: int + ): ... + def available(self) -> int: ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class DeflaterOutputStream(java.io.FilterOutputStream): + @typing.overload + def __init__(self, outputStream: java.io.OutputStream): ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream, boolean: bool): ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream, deflater: Deflater): ... + @typing.overload + def __init__( + self, outputStream: java.io.OutputStream, deflater: Deflater, boolean: bool + ): ... + @typing.overload + def __init__( + self, outputStream: java.io.OutputStream, deflater: Deflater, int: int + ): ... + @typing.overload + def __init__( + self, + outputStream: java.io.OutputStream, + deflater: Deflater, + int: int, + boolean: bool, + ): ... + def close(self) -> None: ... + def finish(self) -> None: ... + def flush(self) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class Inflater(java.lang.AutoCloseable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + def close(self) -> None: ... + def end(self) -> None: ... + def finished(self) -> bool: ... + def getAdler(self) -> int: ... + def getBytesRead(self) -> int: ... + def getBytesWritten(self) -> int: ... + def getRemaining(self) -> int: ... + def getTotalIn(self) -> int: ... + def getTotalOut(self) -> int: ... + @typing.overload + def inflate(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def inflate( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def inflate(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + def needsDictionary(self) -> bool: ... + def needsInput(self) -> bool: ... + def reset(self) -> None: ... + @typing.overload + def setDictionary(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setDictionary( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def setDictionary(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def setInput(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setInput( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def setInput(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + +class InflaterInputStream(java.io.FilterInputStream): + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + @typing.overload + def __init__(self, inputStream: java.io.InputStream, inflater: Inflater): ... + @typing.overload + def __init__( + self, inputStream: java.io.InputStream, inflater: Inflater, int: int + ): ... + def available(self) -> int: ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class InflaterOutputStream(java.io.FilterOutputStream): + @typing.overload + def __init__(self, outputStream: java.io.OutputStream): ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream, inflater: Inflater): ... + @typing.overload + def __init__( + self, outputStream: java.io.OutputStream, inflater: Inflater, int: int + ): ... + def close(self) -> None: ... + def finish(self) -> None: ... + def flush(self) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class ZipError(java.lang.InternalError): + def __init__(self, string: java.lang.String | str): ... + +class ZipException(java.io.IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + +class Adler32(Checksum): + def __init__(self): ... + def getValue(self) -> int: ... + def reset(self) -> None: ... + @typing.overload + def update(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def update( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def update(self, int: int) -> None: ... + @typing.overload + def update(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + +class CRC32(Checksum): + def __init__(self): ... + def getValue(self) -> int: ... + def reset(self) -> None: ... + @typing.overload + def update(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def update( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def update(self, int: int) -> None: ... + @typing.overload + def update(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + +class CRC32C(Checksum): + def __init__(self): ... + def getValue(self) -> int: ... + def reset(self) -> None: ... + @typing.overload + def update(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def update( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def update(self, int: int) -> None: ... + @typing.overload + def update(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + +class GZIPInputStream(InflaterInputStream): + GZIP_MAGIC: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + @typing.overload + def __init__(self, inputStream: java.io.InputStream, int: int): ... + def close(self) -> None: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self) -> int: ... + +class GZIPOutputStream(DeflaterOutputStream): + @typing.overload + def __init__(self, outputStream: java.io.OutputStream): ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream, boolean: bool): ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream, int: int): ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream, int: int, boolean: bool): ... + def finish(self) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class ZipEntry(java.util.zip.ZipConstants, java.lang.Cloneable): + STORED: typing.ClassVar[int] = ... + DEFLATED: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, zipEntry: ZipEntry): ... + def clone(self) -> typing.Any: ... + def getComment(self) -> java.lang.String: ... + def getCompressedSize(self) -> int: ... + def getCrc(self) -> int: ... + def getCreationTime(self) -> java.nio.file.attribute.FileTime: ... + def getExtra(self) -> typing.MutableSequence[int]: ... + def getLastAccessTime(self) -> java.nio.file.attribute.FileTime: ... + def getLastModifiedTime(self) -> java.nio.file.attribute.FileTime: ... + def getMethod(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getSize(self) -> int: ... + def getTime(self) -> int: ... + def getTimeLocal(self) -> java.time.LocalDateTime: ... + def hashCode(self) -> int: ... + def isDirectory(self) -> bool: ... + def setComment(self, string: java.lang.String | str) -> None: ... + def setCompressedSize(self, long: int) -> None: ... + def setCrc(self, long: int) -> None: ... + def setCreationTime( + self, fileTime: java.nio.file.attribute.FileTime + ) -> ZipEntry: ... + def setExtra(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setLastAccessTime( + self, fileTime: java.nio.file.attribute.FileTime + ) -> ZipEntry: ... + def setLastModifiedTime( + self, fileTime: java.nio.file.attribute.FileTime + ) -> ZipEntry: ... + def setMethod(self, int: int) -> None: ... + def setSize(self, long: int) -> None: ... + def setTime(self, long: int) -> None: ... + def setTimeLocal(self, localDateTime: java.time.LocalDateTime) -> None: ... + def toString(self) -> java.lang.String: ... + +class ZipFile(java.util.zip.ZipConstants, java.io.Closeable): + OPEN_READ: typing.ClassVar[int] = ... + OPEN_DELETE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, file: java.io.File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__(self, file: java.io.File | jpype.protocol.SupportsPath, int: int): ... + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + int: int, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + charset: java.nio.charset.Charset, + ): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, charset: java.nio.charset.Charset + ): ... + def close(self) -> None: ... + def entries(self) -> java.util.Enumeration[ZipEntry]: ... + def getComment(self) -> java.lang.String: ... + def getEntry(self, string: java.lang.String | str) -> ZipEntry: ... + def getInputStream(self, zipEntry: ZipEntry) -> java.io.InputStream: ... + def getName(self) -> java.lang.String: ... + def size(self) -> int: ... + def stream(self) -> java.util.stream.Stream[ZipEntry]: ... + def toString(self) -> java.lang.String: ... + +class ZipInputStream(InflaterInputStream, java.util.zip.ZipConstants): + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + @typing.overload + def __init__( + self, inputStream: java.io.InputStream, charset: java.nio.charset.Charset + ): ... + def available(self) -> int: ... + def close(self) -> None: ... + def closeEntry(self) -> None: ... + def getNextEntry(self) -> ZipEntry: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def readAllBytes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def readNBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def readNBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def skip(self, long: int) -> int: ... + def skipNBytes(self, long: int) -> None: ... + def transferTo(self, outputStream: java.io.OutputStream) -> int: ... + +class ZipOutputStream(DeflaterOutputStream, java.util.zip.ZipConstants): + STORED: typing.ClassVar[int] = ... + DEFLATED: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, outputStream: java.io.OutputStream): ... + @typing.overload + def __init__( + self, outputStream: java.io.OutputStream, charset: java.nio.charset.Charset + ): ... + def close(self) -> None: ... + def closeEntry(self) -> None: ... + def finish(self) -> None: ... + def putNextEntry(self, zipEntry: ZipEntry) -> None: ... + def setComment(self, string: java.lang.String | str) -> None: ... + def setLevel(self, int: int) -> None: ... + def setMethod(self, int: int) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class ZipConstants: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("java.util.zip")``. + + Adler32: type[Adler32] + CRC32: type[CRC32] + CRC32C: type[CRC32C] + CheckedInputStream: type[CheckedInputStream] + CheckedOutputStream: type[CheckedOutputStream] + Checksum: type[Checksum] + DataFormatException: type[DataFormatException] + Deflater: type[Deflater] + DeflaterInputStream: type[DeflaterInputStream] + DeflaterOutputStream: type[DeflaterOutputStream] + GZIPInputStream: type[GZIPInputStream] + GZIPOutputStream: type[GZIPOutputStream] + Inflater: type[Inflater] + InflaterInputStream: type[InflaterInputStream] + InflaterOutputStream: type[InflaterOutputStream] + ZipConstants: type[ZipConstants] + ZipEntry: type[ZipEntry] + ZipError: type[ZipError] + ZipException: type[ZipException] + ZipFile: type[ZipFile] + ZipInputStream: type[ZipInputStream] + ZipOutputStream: type[ZipOutputStream] diff --git a/typings/loci/__init__.pyi b/typings/loci/__init__.pyi new file mode 100644 index 0000000..8a70008 --- /dev/null +++ b/typings/loci/__init__.pyi @@ -0,0 +1,12 @@ +from typing import Protocol + +import loci.common +import loci.formats +import loci.poi + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci")``. + + common: loci.common.__module_protocol__ + formats: loci.formats.__module_protocol__ + poi: loci.poi.__module_protocol__ diff --git a/typings/loci/common/__init__.pyi b/typings/loci/common/__init__.pyi new file mode 100644 index 0000000..f930f7a --- /dev/null +++ b/typings/loci/common/__init__.pyi @@ -0,0 +1,1381 @@ +import typing +from typing import Protocol + +import com.esotericsoftware.kryo +import com.esotericsoftware.kryo.io +import java.io +import java.lang +import java.net +import java.nio +import java.nio.channels +import java.util +import java.util.zip +import jpype +import jpype.protocol +import loci.common.enumeration +import loci.common.image +import loci.common.services +import loci.common.xml + +class CBZip2InputStream(java.io.InputStream): + def __init__(self, inputStream: java.io.InputStream): ... + def close(self) -> None: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + +class CRC: + CRC_32_TABLE: typing.ClassVar[typing.MutableSequence[int]] = ... + def __init__(self): ... + def getFinalCRC(self) -> int: ... + def getGlobalCRC(self) -> int: ... + def initialiseCRC(self) -> None: ... + def setGlobalCRC(self, int: int) -> None: ... + def updateCRC(self, int: int) -> None: ... + +class Constants: + ENCODING: typing.ClassVar[java.lang.String] = ... + EPSILON: typing.ClassVar[float] = ... + def __init__(self): ... + +class DataTools: + @staticmethod + def allocate(*int: int) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def bytesToDouble( + byteArray: list[int] | jpype.JArray | bytes, boolean: bool + ) -> float: ... + @typing.overload + @staticmethod + def bytesToDouble( + byteArray: list[int] | jpype.JArray | bytes, int: int, boolean: bool + ) -> float: ... + @typing.overload + @staticmethod + def bytesToDouble( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int, boolean: bool + ) -> float: ... + @typing.overload + @staticmethod + def bytesToDouble(shortArray: list[int] | jpype.JArray, boolean: bool) -> float: ... + @typing.overload + @staticmethod + def bytesToDouble( + shortArray: list[int] | jpype.JArray, int: int, boolean: bool + ) -> float: ... + @typing.overload + @staticmethod + def bytesToDouble( + shortArray: list[int] | jpype.JArray, int: int, int2: int, boolean: bool + ) -> float: ... + @typing.overload + @staticmethod + def bytesToFloat( + byteArray: list[int] | jpype.JArray | bytes, boolean: bool + ) -> float: ... + @typing.overload + @staticmethod + def bytesToFloat( + byteArray: list[int] | jpype.JArray | bytes, int: int, boolean: bool + ) -> float: ... + @typing.overload + @staticmethod + def bytesToFloat( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int, boolean: bool + ) -> float: ... + @typing.overload + @staticmethod + def bytesToFloat(shortArray: list[int] | jpype.JArray, boolean: bool) -> float: ... + @typing.overload + @staticmethod + def bytesToFloat( + shortArray: list[int] | jpype.JArray, int: int, boolean: bool + ) -> float: ... + @typing.overload + @staticmethod + def bytesToFloat( + shortArray: list[int] | jpype.JArray, int: int, int2: int, boolean: bool + ) -> float: ... + @staticmethod + def bytesToHex(byteArray: list[int] | jpype.JArray | bytes) -> java.lang.String: ... + @typing.overload + @staticmethod + def bytesToInt( + byteArray: list[int] | jpype.JArray | bytes, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToInt( + byteArray: list[int] | jpype.JArray | bytes, int: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToInt( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToInt(shortArray: list[int] | jpype.JArray, boolean: bool) -> int: ... + @typing.overload + @staticmethod + def bytesToInt( + shortArray: list[int] | jpype.JArray, int: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToInt( + shortArray: list[int] | jpype.JArray, int: int, int2: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToLong( + byteArray: list[int] | jpype.JArray | bytes, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToLong( + byteArray: list[int] | jpype.JArray | bytes, int: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToLong( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToLong(shortArray: list[int] | jpype.JArray, boolean: bool) -> int: ... + @typing.overload + @staticmethod + def bytesToLong( + shortArray: list[int] | jpype.JArray, int: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToLong( + shortArray: list[int] | jpype.JArray, int: int, int2: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToShort( + byteArray: list[int] | jpype.JArray | bytes, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToShort( + byteArray: list[int] | jpype.JArray | bytes, int: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToShort( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToShort(shortArray: list[int] | jpype.JArray, boolean: bool) -> int: ... + @typing.overload + @staticmethod + def bytesToShort( + shortArray: list[int] | jpype.JArray, int: int, boolean: bool + ) -> int: ... + @typing.overload + @staticmethod + def bytesToShort( + shortArray: list[int] | jpype.JArray, int: int, int2: int, boolean: bool + ) -> int: ... + @staticmethod + def containsValue(intArray: list[int] | jpype.JArray, int2: int) -> bool: ... + @staticmethod + def doubleToBytes(double: float, boolean: bool) -> typing.MutableSequence[int]: ... + @staticmethod + def doublesToBytes( + doubleArray: list[float] | jpype.JArray, boolean: bool + ) -> typing.MutableSequence[int]: ... + @staticmethod + def floatToBytes(float: float, boolean: bool) -> typing.MutableSequence[int]: ... + @staticmethod + def floatsToBytes( + floatArray: list[float] | jpype.JArray, boolean: bool + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def indexOf(intArray: list[int] | jpype.JArray, int2: int) -> int: ... + @typing.overload + @staticmethod + def indexOf( + objectArray: list[typing.Any] | jpype.JArray, object2: typing.Any + ) -> int: ... + @staticmethod + def intToBytes(int: int, boolean: bool) -> typing.MutableSequence[int]: ... + @staticmethod + def intsToBytes( + intArray: list[int] | jpype.JArray, boolean: bool + ) -> typing.MutableSequence[int]: ... + @staticmethod + def longToBytes(long: int, boolean: bool) -> typing.MutableSequence[int]: ... + @staticmethod + def longsToBytes( + longArray: list[int] | jpype.JArray, boolean: bool + ) -> typing.MutableSequence[int]: ... + @staticmethod + def makeDataArray( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + boolean: bool, + boolean2: bool, + ) -> typing.Any: ... + @staticmethod + def makeDataArray2D( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + boolean: bool, + boolean2: bool, + int2: int, + ) -> typing.Any: ... + @typing.overload + @staticmethod + def makeSigned( + byteArray: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def makeSigned( + intArray: list[int] | jpype.JArray, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def makeSigned( + shortArray: list[int] | jpype.JArray, + ) -> typing.MutableSequence[int]: ... + @staticmethod + def normalizeDoubles( + doubleArray: list[float] | jpype.JArray, + ) -> typing.MutableSequence[float]: ... + @staticmethod + def normalizeFloats( + floatArray: list[float] | jpype.JArray, + ) -> typing.MutableSequence[float]: ... + @staticmethod + def parseByte(string: java.lang.String | str) -> int: ... + @staticmethod + def parseDouble(string: java.lang.String | str) -> float: ... + @staticmethod + def parseFloat(string: java.lang.String | str) -> float: ... + @staticmethod + def parseInteger(string: java.lang.String | str) -> int: ... + @staticmethod + def parseLong(string: java.lang.String | str) -> int: ... + @staticmethod + def parseShort(string: java.lang.String | str) -> int: ... + @staticmethod + def readFile(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def safeMultiply32(*int: int) -> int: ... + @staticmethod + def safeMultiply64(*long: int) -> int: ... + @staticmethod + def samePrefix( + string: java.lang.String | str, string2: java.lang.String | str + ) -> bool: ... + @staticmethod + def sanitize(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def sanitizeDouble(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def shortToBytes(short: int, boolean: bool) -> typing.MutableSequence[int]: ... + @staticmethod + def shortsToBytes( + shortArray: list[int] | jpype.JArray, boolean: bool + ) -> typing.MutableSequence[int]: ... + @staticmethod + def stripString(string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + @staticmethod + def swap(char: str) -> str: ... + @typing.overload + @staticmethod + def swap(double: float) -> float: ... + @typing.overload + @staticmethod + def swap(float: float) -> float: ... + @typing.overload + @staticmethod + def swap(int: int) -> int: ... + @typing.overload + @staticmethod + def swap(long: int) -> int: ... + @typing.overload + @staticmethod + def swap(short: int) -> int: ... + @staticmethod + def unpackBytes( + long: int, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + boolean: bool, + ) -> None: ... + +class DateTools: + UNIX: typing.ClassVar[int] = ... + COBOL: typing.ClassVar[int] = ... + MICROSOFT: typing.ClassVar[int] = ... + ZVI: typing.ClassVar[int] = ... + ALT_ZVI: typing.ClassVar[int] = ... + UNIX_EPOCH: typing.ClassVar[int] = ... + COBOL_EPOCH: typing.ClassVar[int] = ... + MICROSOFT_EPOCH: typing.ClassVar[int] = ... + ZVI_EPOCH: typing.ClassVar[int] = ... + ALT_ZVI_EPOCH: typing.ClassVar[int] = ... + ISO8601_FORMAT_MS: typing.ClassVar[java.lang.String] = ... + ISO8601_FORMAT: typing.ClassVar[java.lang.String] = ... + TIMESTAMP_FORMAT: typing.ClassVar[java.lang.String] = ... + FILENAME_FORMAT: typing.ClassVar[java.lang.String] = ... + @typing.overload + @staticmethod + def convertDate(long: int, int: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def convertDate( + long: int, int: int, string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def convertDate( + long: int, int: int, string: java.lang.String | str, boolean: bool + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def formatDate( + string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def formatDate( + string: java.lang.String | str, string2: java.lang.String | str, boolean: bool + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def formatDate( + string: java.lang.String | str, + string2: java.lang.String | str, + boolean: bool, + string3: java.lang.String | str, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def formatDate( + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def formatDate( + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def formatDate( + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + boolean: bool, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def formatDate( + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + boolean: bool, + string3: java.lang.String | str, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def formatDate( + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + string3: java.lang.String | str, + ) -> java.lang.String: ... + @staticmethod + def getFileTimestamp() -> java.lang.String: ... + @staticmethod + def getMillisFromTicks(long: int, long2: int) -> int: ... + @typing.overload + @staticmethod + def getTime( + string: java.lang.String | str, string2: java.lang.String | str + ) -> int: ... + @typing.overload + @staticmethod + def getTime( + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> int: ... + @staticmethod + def getTimestamp() -> java.lang.String: ... + +class DebugTools: + @staticmethod + def enableIJLogging(boolean: bool) -> bool: ... + @typing.overload + @staticmethod + def enableLogging() -> bool: ... + @typing.overload + @staticmethod + def enableLogging(string: java.lang.String | str) -> bool: ... + @staticmethod + def getFieldName(class_: type[typing.Any], int: int) -> java.lang.String: ... + @staticmethod + def getStackTrace(throwable: java.lang.Throwable) -> java.lang.String: ... + @staticmethod + def isEnabled() -> bool: ... + @staticmethod + def setRootLevel(string: java.lang.String | str) -> None: ... + +class HandleException(java.io.IOException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class IRandomAccess(java.io.DataInput, java.io.DataOutput): + def close(self) -> None: ... + def exists(self) -> bool: ... + def getFilePointer(self) -> int: ... + def getOrder(self) -> java.nio.ByteOrder: ... + def length(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> int: ... + def seek(self, long: int) -> None: ... + def setOrder(self, byteOrder: java.nio.ByteOrder) -> None: ... + @typing.overload + def skipBytes(self, int: int) -> int: ... + @typing.overload + def skipBytes(self, long: int) -> int: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> None: ... + +class IniList(java.util.ArrayList["IniTable"]): + def __init__(self): ... + def flattenIntoHashMap( + self, + ) -> java.util.HashMap[java.lang.String, java.lang.String]: ... + def getHeaders(self) -> java.util.List[java.lang.String]: ... + def getTable(self, string: java.lang.String | str) -> IniTable: ... + +class IniParser: + def __init__(self): ... + @typing.overload + @staticmethod + def openTextResource(string: java.lang.String | str) -> java.io.BufferedReader: ... + @typing.overload + @staticmethod + def openTextResource( + string: java.lang.String | str, class_: type[typing.Any] + ) -> java.io.BufferedReader: ... + @typing.overload + def parseINI(self, bufferedReader: java.io.BufferedReader) -> IniList: ... + @typing.overload + def parseINI(self, file: java.io.File | jpype.protocol.SupportsPath) -> IniList: ... + @typing.overload + def parseINI(self, string: java.lang.String | str) -> IniList: ... + @typing.overload + def parseINI( + self, string: java.lang.String | str, class_: type[typing.Any] + ) -> IniList: ... + def setBackslashContinuesLine(self, boolean: bool) -> None: ... + def setCommentDelimiter(self, string: java.lang.String | str) -> None: ... + +class IniTable(java.util.HashMap[java.lang.String, java.lang.String]): + HEADER_KEY: typing.ClassVar[java.lang.String] = ... + DEFAULT_HEADER: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + +class IniWriter: + def __init__(self): ... + @typing.overload + def saveINI(self, iniList: IniList, string: java.lang.String | str) -> None: ... + @typing.overload + def saveINI( + self, iniList: IniList, string: java.lang.String | str, boolean: bool + ) -> None: ... + @typing.overload + def saveINI( + self, + iniList: IniList, + string: java.lang.String | str, + boolean: bool, + boolean2: bool, + ) -> None: ... + +class Location: + @typing.overload + def __init__(self, file: java.io.File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__(self, location: Location, string: java.lang.String | str): ... + @staticmethod + def cacheDirectoryListings(boolean: bool) -> None: ... + def canRead(self) -> bool: ... + def canWrite(self) -> bool: ... + @staticmethod + def checkValidId(string: java.lang.String | str) -> None: ... + @staticmethod + def cleanStaleCacheEntries() -> None: ... + @staticmethod + def clearDirectoryListingsCache() -> None: ... + def createNewFile(self) -> bool: ... + def delete(self) -> bool: ... + def deleteOnExit(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def exists(self) -> bool: ... + def getAbsoluteFile(self) -> Location: ... + def getAbsolutePath(self) -> java.lang.String: ... + def getCanonicalFile(self) -> Location: ... + def getCanonicalPath(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getHandle(string: java.lang.String | str) -> IRandomAccess: ... + @typing.overload + @staticmethod + def getHandle(string: java.lang.String | str, boolean: bool) -> IRandomAccess: ... + @typing.overload + @staticmethod + def getHandle( + string: java.lang.String | str, boolean: bool, boolean2: bool + ) -> IRandomAccess: ... + @typing.overload + @staticmethod + def getHandle( + string: java.lang.String | str, boolean: bool, boolean2: bool, int: int + ) -> IRandomAccess: ... + @staticmethod + def getIdMap() -> java.util.HashMap[java.lang.String, typing.Any]: ... + @staticmethod + def getMappedFile(string: java.lang.String | str) -> IRandomAccess: ... + @staticmethod + def getMappedId(string: java.lang.String | str) -> java.lang.String: ... + def getName(self) -> java.lang.String: ... + def getParent(self) -> java.lang.String: ... + def getParentFile(self) -> Location: ... + def getPath(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def isAbsolute(self) -> bool: ... + def isDirectory(self) -> bool: ... + def isFile(self) -> bool: ... + def isHidden(self) -> bool: ... + def lastModified(self) -> int: ... + def length(self) -> int: ... + @typing.overload + def list(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def list(self, boolean: bool) -> typing.MutableSequence[java.lang.String]: ... + def listFiles(self) -> typing.MutableSequence[Location]: ... + @staticmethod + def mapFile( + string: java.lang.String | str, iRandomAccess: IRandomAccess + ) -> None: ... + @staticmethod + def mapId( + string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + def mkdirs(self) -> bool: ... + @staticmethod + def reset() -> None: ... + @staticmethod + def setCacheDirectoryTimeout(double: float) -> None: ... + @staticmethod + def setIdMap( + hashMap: java.util.HashMap[java.lang.String | str, typing.Any], + ) -> None: ... + def toString(self) -> java.lang.String: ... + def toURL(self) -> java.net.URL: ... + +class Log4jTools: + @staticmethod + def enableLogging() -> bool: ... + @staticmethod + def isEnabled() -> bool: ... + @staticmethod + def setRootLevel(string: java.lang.String | str) -> None: ... + +class NIOByteBufferProvider: + MINIMUM_JAVA_VERSION: typing.ClassVar[int] = ... + def __init__( + self, + fileChannel: java.nio.channels.FileChannel, + mapMode: java.nio.channels.FileChannel.MapMode, + ): ... + def allocate(self, long: int, int: int) -> java.nio.ByteBuffer: ... + +class NIOInputStream(java.io.InputStream, java.io.DataInput): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, iRandomAccess: IRandomAccess): ... + def available(self) -> int: ... + def close(self) -> None: ... + @typing.overload + def findString( + self, boolean: bool, int: int, *string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def findString( + self, boolean: bool, *string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def findString( + self, int: int, *string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def findString(self, *string: java.lang.String | str) -> java.lang.String: ... + def getFilePointer(self) -> int: ... + def getInputStream(self) -> java.io.DataInputStream: ... + def isLittleEndian(self) -> bool: ... + def length(self) -> int: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + def order(self, boolean: bool) -> None: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readCString(self) -> java.lang.String: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readShort(self) -> int: ... + @typing.overload + def readString(self, int: int) -> java.lang.String: ... + @typing.overload + def readString(self, string: java.lang.String | str) -> java.lang.String: ... + def readUTF(self) -> java.lang.String: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def reset(self) -> None: ... + def seek(self, long: int) -> None: ... + def setExtend(self, int: int) -> None: ... + def skipBytes(self, int: int) -> int: ... + +class RandomAccessInputStream( + java.io.InputStream, + java.io.DataInput, + java.io.Closeable, + com.esotericsoftware.kryo.KryoSerializable, +): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, int: int): ... + @typing.overload + def __init__(self, iRandomAccess: IRandomAccess): ... + @typing.overload + def __init__( + self, iRandomAccess: IRandomAccess, string: java.lang.String | str + ): ... + def available(self) -> int: ... + def close(self) -> None: ... + @typing.overload + def findString( + self, boolean: bool, int: int, *string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def findString( + self, boolean: bool, *string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def findString( + self, int: int, *string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def findString(self, *string: java.lang.String | str) -> java.lang.String: ... + def getFilePointer(self) -> int: ... + def isBitOnByteBoundary(self) -> bool: ... + def isLittleEndian(self) -> bool: ... + def length(self) -> int: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + def order(self, boolean: bool) -> None: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> int: ... + @typing.overload + def read( + self, + kryo: com.esotericsoftware.kryo.Kryo, + input: com.esotericsoftware.kryo.io.Input, + ) -> None: ... + def readBits(self, int: int) -> int: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readByteToString(self, int: int) -> java.lang.String: ... + def readCString(self) -> java.lang.String: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readShort(self) -> int: ... + @typing.overload + def readString(self, int: int) -> java.lang.String: ... + @typing.overload + def readString(self, string: java.lang.String | str) -> java.lang.String: ... + def readUTF(self) -> java.lang.String: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedInt(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def reset(self) -> None: ... + def seek(self, long: int) -> None: ... + def setEncoding(self, string: java.lang.String | str) -> None: ... + def setLength(self, long: int) -> None: ... + def skipBits(self, long: int) -> None: ... + @typing.overload + def skipBytes(self, int: int) -> int: ... + @typing.overload + def skipBytes(self, long: int) -> int: ... + def write( + self, + kryo: com.esotericsoftware.kryo.Kryo, + output: com.esotericsoftware.kryo.io.Output, + ) -> None: ... + +class RandomAccessOutputStream( + java.io.OutputStream, java.io.DataOutput, java.io.Closeable +): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, iRandomAccess: IRandomAccess): ... + def close(self) -> None: ... + def flush(self) -> None: ... + def getFilePointer(self) -> int: ... + def isLittleEndian(self) -> bool: ... + def length(self) -> int: ... + def order(self, boolean: bool) -> None: ... + def seek(self, long: int) -> None: ... + def skipBytes(self, int: int) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> None: ... + @typing.overload + def writeBits(self, int: int, int2: int) -> None: ... + @typing.overload + def writeBits(self, string: java.lang.String | str) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, int: int) -> None: ... + def writeBytes(self, string: java.lang.String | str) -> None: ... + def writeChar(self, int: int) -> None: ... + def writeChars(self, string: java.lang.String | str) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLine(self, string: java.lang.String | str) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeShort(self, int: int) -> None: ... + def writeUTF(self, string: java.lang.String | str) -> None: ... + +class ReflectException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class ReflectedUniverse: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, classLoader: java.lang.ClassLoader): ... + @typing.overload + def __init__(self, uRLArray: list[java.net.URL] | jpype.JArray): ... + def exec_(self, string: java.lang.String | str) -> typing.Any: ... + def getVar(self, string: java.lang.String | str) -> typing.Any: ... + def isAccessibilityIgnored(self) -> bool: ... + @staticmethod + def isInstance(class_: type[typing.Any], object: typing.Any) -> bool: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def setAccessibilityIgnored(self, boolean: bool) -> None: ... + @typing.overload + def setVar(self, string: java.lang.String | str, boolean: bool) -> None: ... + @typing.overload + def setVar(self, string: java.lang.String | str, byte: int) -> None: ... + @typing.overload + def setVar(self, string: java.lang.String | str, char: str) -> None: ... + @typing.overload + def setVar(self, string: java.lang.String | str, double: float) -> None: ... + @typing.overload + def setVar(self, string: java.lang.String | str, float: float) -> None: ... + @typing.overload + def setVar(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def setVar(self, string: java.lang.String | str, object: typing.Any) -> None: ... + @typing.overload + def setVar(self, string: java.lang.String | str, long: int) -> None: ... + @typing.overload + def setVar(self, string: java.lang.String | str, short: int) -> None: ... + +class Region: + x: int = ... + y: int = ... + width: int = ... + height: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + def containsPoint(self, int: int, int2: int) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def intersection(self, region: Region) -> Region: ... + def intersects(self, region: Region) -> bool: ... + def toString(self) -> java.lang.String: ... + +class StatusEvent: + @typing.overload + def __init__(self, int: int, int2: int, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, int: int, int2: int, string: java.lang.String | str, boolean: bool + ): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + def getProgressMaximum(self) -> int: ... + def getProgressValue(self) -> int: ... + def getStatusMessage(self) -> java.lang.String: ... + def isWarning(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class StatusListener(java.util.EventListener): + def statusUpdated(self, statusEvent: StatusEvent) -> None: ... + +class StatusReporter: + def addStatusListener( + self, statusListener: StatusListener | typing.Callable + ) -> None: ... + def notifyListeners(self, statusEvent: StatusEvent) -> None: ... + def removeStatusListener( + self, statusListener: StatusListener | typing.Callable + ) -> None: ... + +class AbstractNIOHandle(IRandomAccess): + def __init__(self): ... + def exists(self) -> bool: ... + +class CaseInsensitiveLocation(Location): + @typing.overload + def __init__(self, file: java.io.File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + caseInsensitiveLocation: CaseInsensitiveLocation, + string: java.lang.String | str, + ): ... + @typing.overload + def __init__(self, location: Location): ... + @typing.overload + @staticmethod + def invalidateCache() -> None: ... + @typing.overload + @staticmethod + def invalidateCache(file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + +class FileHandle(IRandomAccess): + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + string: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def close(self) -> None: ... + def exists(self) -> bool: ... + def getFilePointer(self) -> int: ... + def getOrder(self) -> java.nio.ByteOrder: ... + def getRandomAccessFile(self) -> java.io.RandomAccessFile: ... + def length(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> int: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readShort(self) -> int: ... + def readUTF(self) -> java.lang.String: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def seek(self, long: int) -> None: ... + def setOrder(self, byteOrder: java.nio.ByteOrder) -> None: ... + @typing.overload + def skipBytes(self, int: int) -> int: ... + @typing.overload + def skipBytes(self, long: int) -> int: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, int: int) -> None: ... + def writeBytes(self, string: java.lang.String | str) -> None: ... + def writeChar(self, int: int) -> None: ... + def writeChars(self, string: java.lang.String | str) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeShort(self, int: int) -> None: ... + def writeUTF(self, string: java.lang.String | str) -> None: ... + +class StreamHandle(IRandomAccess): + def __init__(self): ... + def close(self) -> None: ... + def exists(self) -> bool: ... + def getFilePointer(self) -> int: ... + def getOrder(self) -> java.nio.ByteOrder: ... + def length(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> int: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readShort(self) -> int: ... + def readUTF(self) -> java.lang.String: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def seek(self, long: int) -> None: ... + def setOrder(self, byteOrder: java.nio.ByteOrder) -> None: ... + @typing.overload + def skipBytes(self, int: int) -> int: ... + @typing.overload + def skipBytes(self, long: int) -> int: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, int: int) -> None: ... + def writeBytes(self, string: java.lang.String | str) -> None: ... + def writeChar(self, int: int) -> None: ... + def writeChars(self, string: java.lang.String | str) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeShort(self, int: int) -> None: ... + def writeUTF(self, string: java.lang.String | str) -> None: ... + class Settings: + def __init__(self): ... + def get(self, string: java.lang.String | str) -> java.lang.String: ... + def getRemoteCacheRootDir(self) -> java.lang.String: ... + +class BZip2Handle(StreamHandle): + def __init__(self, string: java.lang.String | str): ... + @staticmethod + def isBZip2File(string: java.lang.String | str) -> bool: ... + +class ByteArrayHandle(AbstractNIOHandle): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, byteBuffer: java.nio.ByteBuffer): ... + def close(self) -> None: ... + def getByteBuffer(self) -> java.nio.ByteBuffer: ... + def getBytes(self) -> typing.MutableSequence[int]: ... + def getFilePointer(self) -> int: ... + def getOrder(self) -> java.nio.ByteOrder: ... + def length(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> int: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readShort(self) -> int: ... + def readUTF(self) -> java.lang.String: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def seek(self, long: int) -> None: ... + def setLength(self, long: int) -> None: ... + def setOrder(self, byteOrder: java.nio.ByteOrder) -> None: ... + @typing.overload + def skipBytes(self, int: int) -> int: ... + @typing.overload + def skipBytes(self, long: int) -> int: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, int: int) -> None: ... + def writeBytes(self, string: java.lang.String | str) -> None: ... + def writeChar(self, int: int) -> None: ... + def writeChars(self, string: java.lang.String | str) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeShort(self, int: int) -> None: ... + def writeUTF(self, string: java.lang.String | str) -> None: ... + +class GZipHandle(StreamHandle): + def __init__(self, string: java.lang.String | str): ... + @staticmethod + def isGZipFile(string: java.lang.String | str) -> bool: ... + +class NIOFileHandle(AbstractNIOHandle): + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + string: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + file: java.io.File | jpype.protocol.SupportsPath, + string: java.lang.String | str, + int: int, + ): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def close(self) -> None: ... + def getBufferSize(self) -> int: ... + def getFileChannel(self) -> java.nio.channels.FileChannel: ... + def getFilePointer(self) -> int: ... + def getOrder(self) -> java.nio.ByteOrder: ... + def getRandomAccessFile(self) -> java.io.RandomAccessFile: ... + def length(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer) -> int: ... + @typing.overload + def read(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> int: ... + def readBoolean(self) -> bool: ... + def readByte(self) -> int: ... + def readChar(self) -> str: ... + def readDouble(self) -> float: ... + def readFloat(self) -> float: ... + @typing.overload + def readFully(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def readFully( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def readInt(self) -> int: ... + def readLine(self) -> java.lang.String: ... + def readLong(self) -> int: ... + def readShort(self) -> int: ... + def readUTF(self) -> java.lang.String: ... + def readUnsignedByte(self) -> int: ... + def readUnsignedShort(self) -> int: ... + def seek(self, long: int) -> None: ... + @staticmethod + def setDefaultBufferSize(int: int) -> None: ... + @staticmethod + def setDefaultReadWriteBufferSize(int: int) -> None: ... + def setLength(self, long: int) -> None: ... + def setOrder(self, byteOrder: java.nio.ByteOrder) -> None: ... + @typing.overload + def skipBytes(self, int: int) -> int: ... + @typing.overload + def skipBytes(self, long: int) -> int: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer) -> None: ... + @typing.overload + def write(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int) -> None: ... + def writeBoolean(self, boolean: bool) -> None: ... + def writeByte(self, int: int) -> None: ... + def writeBytes(self, string: java.lang.String | str) -> None: ... + def writeChar(self, int: int) -> None: ... + def writeChars(self, string: java.lang.String | str) -> None: ... + def writeDouble(self, double: float) -> None: ... + def writeFloat(self, float: float) -> None: ... + def writeInt(self, int: int) -> None: ... + def writeLong(self, long: int) -> None: ... + def writeShort(self, int: int) -> None: ... + def writeUTF(self, string: java.lang.String | str) -> None: ... + +class S3Handle(StreamHandle): + DEFAULT_S3_PROTOCOL: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + boolean: bool, + settings: StreamHandle.Settings, + ): ... + @staticmethod + def cacheObject( + string: java.lang.String | str, settings: StreamHandle.Settings + ) -> java.lang.String: ... + @staticmethod + def canHandleScheme(string: java.lang.String | str) -> bool: ... + def exists(self) -> bool: ... + def getBucket(self) -> java.lang.String: ... + def getCacheKey(self) -> java.lang.String: ... + def getPath(self) -> java.lang.String: ... + def getPort(self) -> int: ... + def getServer(self) -> java.lang.String: ... + def isBucket(self) -> bool: ... + def length(self) -> int: ... + def seek(self, long: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class URLHandle(StreamHandle): + def __init__(self, string: java.lang.String | str): ... + def seek(self, long: int) -> None: ... + +class ZipHandle(StreamHandle): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, zipEntry: java.util.zip.ZipEntry + ): ... + def close(self) -> None: ... + def getEntryCount(self) -> int: ... + def getEntryName(self) -> java.lang.String: ... + def getInputStream(self) -> java.io.DataInputStream: ... + @staticmethod + def isZipFile(string: java.lang.String | str) -> bool: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.common")``. + + AbstractNIOHandle: type[AbstractNIOHandle] + BZip2Handle: type[BZip2Handle] + ByteArrayHandle: type[ByteArrayHandle] + CBZip2InputStream: type[CBZip2InputStream] + CRC: type[CRC] + CaseInsensitiveLocation: type[CaseInsensitiveLocation] + Constants: type[Constants] + DataTools: type[DataTools] + DateTools: type[DateTools] + DebugTools: type[DebugTools] + FileHandle: type[FileHandle] + GZipHandle: type[GZipHandle] + HandleException: type[HandleException] + IRandomAccess: type[IRandomAccess] + IniList: type[IniList] + IniParser: type[IniParser] + IniTable: type[IniTable] + IniWriter: type[IniWriter] + Location: type[Location] + Log4jTools: type[Log4jTools] + NIOByteBufferProvider: type[NIOByteBufferProvider] + NIOFileHandle: type[NIOFileHandle] + NIOInputStream: type[NIOInputStream] + RandomAccessInputStream: type[RandomAccessInputStream] + RandomAccessOutputStream: type[RandomAccessOutputStream] + ReflectException: type[ReflectException] + ReflectedUniverse: type[ReflectedUniverse] + Region: type[Region] + S3Handle: type[S3Handle] + StatusEvent: type[StatusEvent] + StatusListener: type[StatusListener] + StatusReporter: type[StatusReporter] + StreamHandle: type[StreamHandle] + URLHandle: type[URLHandle] + ZipHandle: type[ZipHandle] + enumeration: loci.common.enumeration.__module_protocol__ + image: loci.common.image.__module_protocol__ + services: loci.common.services.__module_protocol__ + xml: loci.common.xml.__module_protocol__ diff --git a/typings/loci/common/enumeration/__init__.pyi b/typings/loci/common/enumeration/__init__.pyi new file mode 100644 index 0000000..b375420 --- /dev/null +++ b/typings/loci/common/enumeration/__init__.pyi @@ -0,0 +1,25 @@ +import typing +from typing import Protocol + +import java.lang + +class CodedEnum: + def getCode(self) -> int: ... + +class EnumException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.common.enumeration")``. + + CodedEnum: type[CodedEnum] + EnumException: type[EnumException] diff --git a/typings/loci/common/image/__init__.pyi b/typings/loci/common/image/__init__.pyi new file mode 100644 index 0000000..457b907 --- /dev/null +++ b/typings/loci/common/image/__init__.pyi @@ -0,0 +1,39 @@ +import typing +from typing import Protocol + +import jpype + +class IImageScaler: + def downsample( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + double: float, + int3: int, + boolean: bool, + boolean2: bool, + int4: int, + boolean3: bool, + ) -> typing.MutableSequence[int]: ... + +class SimpleImageScaler(IImageScaler): + def __init__(self): ... + def downsample( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + double: float, + int3: int, + boolean: bool, + boolean2: bool, + int4: int, + boolean3: bool, + ) -> typing.MutableSequence[int]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.common.image")``. + + IImageScaler: type[IImageScaler] + SimpleImageScaler: type[SimpleImageScaler] diff --git a/typings/loci/common/services/__init__.pyi b/typings/loci/common/services/__init__.pyi new file mode 100644 index 0000000..3013e84 --- /dev/null +++ b/typings/loci/common/services/__init__.pyi @@ -0,0 +1,124 @@ +import typing +from typing import Protocol + +import java.io +import java.lang + +class DependencyException(java.lang.Exception): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, class_: type[Service]): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + class_: type[Service], + throwable: java.lang.Throwable, + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + def getFailureClass(self) -> type[Service]: ... + def toString(self) -> java.lang.String: ... + +class S3ClientStat: + def length(self) -> int: ... + +class Service: ... + +class ServiceException(java.lang.Exception): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class ServiceFactory: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + _getInstance__T = typing.TypeVar("_getInstance__T", bound=Service) # + def getInstance(self, class_: type[_getInstance__T]) -> _getInstance__T: ... + +class AbstractService(Service): + def __init__(self): ... + +class S3ClientService(Service): + def bucketExists(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def getObject( + self, string: java.lang.String | str, string2: java.lang.String | str, long: int + ) -> java.io.InputStream: ... + @typing.overload + def getObject( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> None: ... + def initialize( + self, + string: java.lang.String | str, + int: int, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + string5: java.lang.String | str, + ) -> None: ... + def statObject( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> S3ClientStat: ... + +class S3ClientServiceException(ServiceException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class S3ClientServiceImpl(AbstractService, S3ClientService): + def __init__(self): ... + def bucketExists(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def getObject( + self, string: java.lang.String | str, string2: java.lang.String | str, long: int + ) -> java.io.InputStream: ... + @typing.overload + def getObject( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> None: ... + def initialize( + self, + string: java.lang.String | str, + int: int, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + string5: java.lang.String | str, + ) -> None: ... + def statObject( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> S3ClientStat: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.common.services")``. + + AbstractService: type[AbstractService] + DependencyException: type[DependencyException] + S3ClientService: type[S3ClientService] + S3ClientServiceException: type[S3ClientServiceException] + S3ClientServiceImpl: type[S3ClientServiceImpl] + S3ClientStat: type[S3ClientStat] + Service: type[Service] + ServiceException: type[ServiceException] + ServiceFactory: type[ServiceFactory] diff --git a/typings/loci/common/xml/__init__.pyi b/typings/loci/common/xml/__init__.pyi new file mode 100644 index 0000000..a34aeeb --- /dev/null +++ b/typings/loci/common/xml/__init__.pyi @@ -0,0 +1,202 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import javax.xml.parsers +import javax.xml.transform +import jpype +import jpype.protocol +import loci.common +import org.w3c.dom +import org.w3c.dom.ls +import org.xml.sax +import org.xml.sax.helpers + +class BaseHandler(org.xml.sax.helpers.DefaultHandler): + def __init__(self): ... + def resolveEntity( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> org.xml.sax.InputSource: ... + +class LSInputI(org.w3c.dom.ls.LSInput): + def __init__(self): ... + def getBaseURI(self) -> java.lang.String: ... + def getByteStream(self) -> java.io.InputStream: ... + def getCertifiedText(self) -> bool: ... + def getCharacterStream(self) -> java.io.Reader: ... + def getEncoding(self) -> java.lang.String: ... + def getPublicId(self) -> java.lang.String: ... + def getStringData(self) -> java.lang.String: ... + def getSystemId(self) -> java.lang.String: ... + def setBaseURI(self, string: java.lang.String | str) -> None: ... + def setByteStream(self, inputStream: java.io.InputStream) -> None: ... + def setCertifiedText(self, boolean: bool) -> None: ... + def setCharacterStream(self, reader: java.io.Reader) -> None: ... + def setEncoding(self, string: java.lang.String | str) -> None: ... + def setPublicId(self, string: java.lang.String | str) -> None: ... + def setStringData(self, string: java.lang.String | str) -> None: ... + def setSystemId(self, string: java.lang.String | str) -> None: ... + +class ParserErrorHandler(org.xml.sax.ErrorHandler): + def __init__(self): ... + def error(self, sAXParseException: org.xml.sax.SAXParseException) -> None: ... + def fatalError(self, sAXParseException: org.xml.sax.SAXParseException) -> None: ... + def warning(self, sAXParseException: org.xml.sax.SAXParseException) -> None: ... + +class ValidationErrorHandler(org.xml.sax.ErrorHandler): + def __init__(self): ... + def error(self, sAXParseException: org.xml.sax.SAXParseException) -> None: ... + def fatalError(self, sAXParseException: org.xml.sax.SAXParseException) -> None: ... + def getErrorCount(self) -> int: ... + def ok(self) -> bool: ... + def warning(self, sAXParseException: org.xml.sax.SAXParseException) -> None: ... + +class XMLTools: + @staticmethod + def avoidUndeclaredNamespaces( + string: java.lang.String | str, + ) -> java.lang.String: ... + @staticmethod + def createBuilder() -> javax.xml.parsers.DocumentBuilder: ... + @staticmethod + def createDocument() -> org.w3c.dom.Document: ... + @typing.overload + @staticmethod + def dumpXML( + string: java.lang.String | str, + document: org.w3c.dom.Document, + element: org.w3c.dom.Element, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def dumpXML( + string: java.lang.String | str, + document: org.w3c.dom.Document, + element: org.w3c.dom.Element, + boolean: bool, + ) -> java.lang.String: ... + @staticmethod + def escapeXML(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def getStylesheet( + string: java.lang.String | str, class_: type[typing.Any] + ) -> javax.xml.transform.Templates: ... + @staticmethod + def getXML(document: org.w3c.dom.Document) -> java.lang.String: ... + @typing.overload + @staticmethod + def indentXML(string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + @staticmethod + def indentXML( + string: java.lang.String | str, boolean: bool + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def indentXML(string: java.lang.String | str, int: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def indentXML( + string: java.lang.String | str, int: int, boolean: bool + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def parseDOM( + file: java.io.File | jpype.protocol.SupportsPath, + ) -> org.w3c.dom.Document: ... + @typing.overload + @staticmethod + def parseDOM(inputStream: java.io.InputStream) -> org.w3c.dom.Document: ... + @typing.overload + @staticmethod + def parseDOM(string: java.lang.String | str) -> org.w3c.dom.Document: ... + @typing.overload + @staticmethod + def parseXML( + string: java.lang.String | str, + ) -> java.util.Hashtable[java.lang.String, java.lang.String]: ... + @typing.overload + @staticmethod + def parseXML( + byteArray: list[int] | jpype.JArray | bytes, + defaultHandler: org.xml.sax.helpers.DefaultHandler, + ) -> None: ... + @typing.overload + @staticmethod + def parseXML( + inputStream: java.io.InputStream, + defaultHandler: org.xml.sax.helpers.DefaultHandler, + ) -> None: ... + @typing.overload + @staticmethod + def parseXML( + string: java.lang.String | str, + defaultHandler: org.xml.sax.helpers.DefaultHandler, + ) -> None: ... + @typing.overload + @staticmethod + def parseXML( + randomAccessInputStream: loci.common.RandomAccessInputStream, + defaultHandler: org.xml.sax.helpers.DefaultHandler, + ) -> None: ... + @staticmethod + def sanitizeXML(string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + @staticmethod + def transformXML( + string: java.lang.String | str, templates: javax.xml.transform.Templates + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def transformXML( + source: javax.xml.transform.Source, templates: javax.xml.transform.Templates + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def validateXML(string: java.lang.String | str) -> bool: ... + @typing.overload + @staticmethod + def validateXML( + string: java.lang.String | str, string2: java.lang.String | str + ) -> bool: ... + @typing.overload + @staticmethod + def validateXML( + string: java.lang.String | str, + string2: java.lang.String | str, + schemaReader: XMLTools.SchemaReader | typing.Callable, + ) -> bool: ... + @typing.overload + @staticmethod + def writeXML( + outputStream: java.io.OutputStream, document: org.w3c.dom.Document + ) -> None: ... + @typing.overload + @staticmethod + def writeXML( + outputStream: java.io.OutputStream, + document: org.w3c.dom.Document, + boolean: bool, + ) -> None: ... + @typing.overload + @staticmethod + def writeXML( + result: javax.xml.transform.Result, + document: org.w3c.dom.Document, + boolean: bool, + ) -> None: ... + class SchemaReader: + def getSchemaAsStream( + self, string: java.lang.String | str + ) -> java.io.InputStream: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.common.xml")``. + + BaseHandler: type[BaseHandler] + LSInputI: type[LSInputI] + ParserErrorHandler: type[ParserErrorHandler] + ValidationErrorHandler: type[ValidationErrorHandler] + XMLTools: type[XMLTools] diff --git a/typings/loci/formats/__init__.pyi b/typings/loci/formats/__init__.pyi new file mode 100644 index 0000000..ff3609b --- /dev/null +++ b/typings/loci/formats/__init__.pyi @@ -0,0 +1,3422 @@ +import typing +from typing import Protocol + +import com.esotericsoftware.kryo +import java.awt.image +import java.io +import java.lang +import java.math +import java.util +import jpype +import jpype.protocol +import loci +import loci.common +import loci.formats.cache +import loci.formats.codec +import loci.formats.dicom +import loci.formats.filter +import loci.formats.gui +import loci.formats.in_ +import loci.formats.meta +import loci.formats.ome +import loci.formats.out +import loci.formats.services +import loci.formats.tiff +import loci.formats.tools +import ome.units.quantity +import ome.units.unit +import ome.xml.model.enums +import ome.xml.model.primitives + +class AxisGuesser: + UNKNOWN_AXIS: typing.ClassVar[int] = ... + Z_AXIS: typing.ClassVar[int] = ... + T_AXIS: typing.ClassVar[int] = ... + C_AXIS: typing.ClassVar[int] = ... + S_AXIS: typing.ClassVar[int] = ... + Z_PREFIXES: typing.ClassVar[java.util.Set] = ... + T_PREFIXES: typing.ClassVar[java.util.Set] = ... + C_PREFIXES: typing.ClassVar[java.util.Set] = ... + S_PREFIXES: typing.ClassVar[java.util.Set] = ... + def __init__( + self, + filePattern: FilePattern, + string: java.lang.String | str, + int: int, + int2: int, + int3: int, + boolean: bool, + ): ... + def getAdjustedOrder(self) -> java.lang.String: ... + def getAxisCount(self, int: int) -> int: ... + def getAxisCountC(self) -> int: ... + def getAxisCountS(self) -> int: ... + def getAxisCountT(self) -> int: ... + def getAxisCountZ(self) -> int: ... + @staticmethod + def getAxisType(string: java.lang.String | str) -> int: ... + def getAxisTypes(self) -> typing.MutableSequence[int]: ... + def getFilePattern(self) -> FilePattern: ... + def getOriginalOrder(self) -> java.lang.String: ... + def isCertain(self) -> bool: ... + def setAxisTypes(self, intArray: list[int] | jpype.JArray) -> None: ... + +_ClassList__T = typing.TypeVar("_ClassList__T") # + +class ClassList(typing.Generic[_ClassList__T]): + @typing.overload + def __init__(self, class_: type[_ClassList__T]): ... + @typing.overload + def __init__(self, string: java.lang.String | str, class_: type[_ClassList__T]): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + class_: type[_ClassList__T], + class2: type[typing.Any], + ): ... + @typing.overload + def addClass(self, int: int, class_: type[_ClassList__T]) -> None: ... + @typing.overload + def addClass(self, class_: type[_ClassList__T]) -> None: ... + def addOption( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def append(self, list: java.util.List[type[_ClassList__T]]) -> None: ... + @typing.overload + def append(self, classList: ClassList[_ClassList__T]) -> None: ... + def getClasses(self) -> typing.MutableSequence[type[_ClassList__T]]: ... + def getOptions(self) -> java.util.Map[java.lang.String, java.lang.String]: ... + def isAllowedKey(self, string: java.lang.String | str) -> bool: ... + def isWhitelistedKey(self, string: java.lang.String | str) -> bool: ... + def parseFile( + self, string: java.lang.String | str, class_: type[typing.Any] + ) -> None: ... + def parseLine(self, string: java.lang.String | str) -> None: ... + def parseOptions( + self, string: java.lang.String | str + ) -> java.util.Map[java.lang.String, java.lang.String]: ... + @typing.overload + def prepend(self, list: java.util.List[type[_ClassList__T]]) -> None: ... + @typing.overload + def prepend(self, classList: ClassList[_ClassList__T]) -> None: ... + def removeClass(self, class_: type[_ClassList__T]) -> None: ... + +class CoreMetadata(java.lang.Cloneable): + sizeX: int = ... + sizeY: int = ... + sizeZ: int = ... + sizeC: int = ... + sizeT: int = ... + thumbSizeX: int = ... + thumbSizeY: int = ... + pixelType: int = ... + bitsPerPixel: int = ... + imageCount: int = ... + moduloZ: Modulo = ... + moduloC: Modulo = ... + moduloT: Modulo = ... + dimensionOrder: java.lang.String = ... + orderCertain: bool = ... + rgb: bool = ... + littleEndian: bool = ... + interleaved: bool = ... + indexed: bool = ... + falseColor: bool = ... + metadataComplete: bool = ... + seriesMetadata: java.util.Hashtable = ... + thumbnail: bool = ... + resolutionCount: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, coreMetadata: CoreMetadata): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader, int: int): ... + @typing.overload + def clone(self) -> typing.Any: ... + @typing.overload + def clone(self, iFormatReader: IFormatReader, int: int) -> CoreMetadata: ... + def toString(self) -> java.lang.String: ... + +class FileInfo: + filename: java.lang.String = ... + reader: type = ... + usedToInitialize: bool = ... + def __init__(self): ... + def toString(self) -> java.lang.String: ... + +class FilePattern: + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__(self, location: loci.common.Location): ... + @typing.overload + @staticmethod + def findPattern( + file: java.io.File | jpype.protocol.SupportsPath, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def findPattern(string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + @staticmethod + def findPattern( + string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def findPattern( + string: java.lang.String | str, + string2: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def findPattern( + string: java.lang.String | str, + string2: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + intArray: list[int] | jpype.JArray, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def findPattern( + stringArray: list[java.lang.String] | jpype.JArray, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def findPattern(location: loci.common.Location) -> java.lang.String: ... + @typing.overload + @staticmethod + def findSeriesPatterns( + string: java.lang.String | str, + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + @staticmethod + def findSeriesPatterns( + string: java.lang.String | str, + string2: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> typing.MutableSequence[java.lang.String]: ... + def getBlock(self, int: int) -> java.lang.String: ... + def getBlocks(self) -> typing.MutableSequence[java.lang.String]: ... + def getCount(self) -> typing.MutableSequence[int]: ... + def getElements( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... + def getErrorMessage(self) -> java.lang.String: ... + def getFiles(self) -> typing.MutableSequence[java.lang.String]: ... + def getFirst(self) -> typing.MutableSequence[java.math.BigInteger]: ... + def getLast(self) -> typing.MutableSequence[java.math.BigInteger]: ... + def getPattern(self) -> java.lang.String: ... + @typing.overload + def getPrefix(self) -> java.lang.String: ... + @typing.overload + def getPrefix(self, int: int) -> java.lang.String: ... + def getPrefixes(self) -> typing.MutableSequence[java.lang.String]: ... + def getStep(self) -> typing.MutableSequence[java.math.BigInteger]: ... + def getSuffix(self) -> java.lang.String: ... + def isRegex(self) -> bool: ... + def isValid(self) -> bool: ... + +class FilePatternBlock: + BLOCK_START: typing.ClassVar[java.lang.String] = ... + BLOCK_END: typing.ClassVar[java.lang.String] = ... + def __init__(self, string: java.lang.String | str): ... + def getBlock(self) -> java.lang.String: ... + def getElements(self) -> typing.MutableSequence[java.lang.String]: ... + def getFirst(self) -> java.math.BigInteger: ... + def getLast(self) -> java.math.BigInteger: ... + def getStep(self) -> java.math.BigInteger: ... + def isFixed(self) -> bool: ... + def isNumeric(self) -> bool: ... + +class FormatException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class FormatTools: + INT8: typing.ClassVar[int] = ... + UINT8: typing.ClassVar[int] = ... + INT16: typing.ClassVar[int] = ... + UINT16: typing.ClassVar[int] = ... + INT32: typing.ClassVar[int] = ... + UINT32: typing.ClassVar[int] = ... + FLOAT: typing.ClassVar[int] = ... + DOUBLE: typing.ClassVar[int] = ... + BIT: typing.ClassVar[int] = ... + CHANNEL: typing.ClassVar[java.lang.String] = ... + SPECTRA: typing.ClassVar[java.lang.String] = ... + LIFETIME: typing.ClassVar[java.lang.String] = ... + POLARIZATION: typing.ClassVar[java.lang.String] = ... + PHASE: typing.ClassVar[java.lang.String] = ... + FREQUENCY: typing.ClassVar[java.lang.String] = ... + ROTATION: typing.ClassVar[java.lang.String] = ... + ILLUMINATION: typing.ClassVar[java.lang.String] = ... + MUST_GROUP: typing.ClassVar[int] = ... + CAN_GROUP: typing.ClassVar[int] = ... + CANNOT_GROUP: typing.ClassVar[int] = ... + SERIES_NUM: typing.ClassVar[java.lang.String] = ... + SERIES_NAME: typing.ClassVar[java.lang.String] = ... + CHANNEL_NUM: typing.ClassVar[java.lang.String] = ... + CHANNEL_NAME: typing.ClassVar[java.lang.String] = ... + Z_NUM: typing.ClassVar[java.lang.String] = ... + T_NUM: typing.ClassVar[java.lang.String] = ... + TIMESTAMP: typing.ClassVar[java.lang.String] = ... + TILE_X: typing.ClassVar[java.lang.String] = ... + TILE_Y: typing.ClassVar[java.lang.String] = ... + TILE_NUM: typing.ClassVar[java.lang.String] = ... + VERSION_PROPERTIES: typing.ClassVar[java.util.Properties] = ... + VCS_REVISION: typing.ClassVar[java.lang.String] = ... + VCS_SHORT_REVISION: typing.ClassVar[java.lang.String] = ... + DATE: typing.ClassVar[java.lang.String] = ... + YEAR: typing.ClassVar[java.lang.String] = ... + VERSION: typing.ClassVar[java.lang.String] = ... + CREATOR: typing.ClassVar[java.lang.String] = ... + PROPERTY_FILE: typing.ClassVar[java.lang.String] = ... + HCS_DOMAIN: typing.ClassVar[java.lang.String] = ... + LM_DOMAIN: typing.ClassVar[java.lang.String] = ... + EM_DOMAIN: typing.ClassVar[java.lang.String] = ... + SPM_DOMAIN: typing.ClassVar[java.lang.String] = ... + SEM_DOMAIN: typing.ClassVar[java.lang.String] = ... + FLIM_DOMAIN: typing.ClassVar[java.lang.String] = ... + MEDICAL_DOMAIN: typing.ClassVar[java.lang.String] = ... + HISTOLOGY_DOMAIN: typing.ClassVar[java.lang.String] = ... + GEL_DOMAIN: typing.ClassVar[java.lang.String] = ... + ASTRONOMY_DOMAIN: typing.ClassVar[java.lang.String] = ... + GRAPHICS_DOMAIN: typing.ClassVar[java.lang.String] = ... + UNKNOWN_DOMAIN: typing.ClassVar[java.lang.String] = ... + NON_GRAPHICS_DOMAINS: typing.ClassVar[ + typing.MutableSequence[java.lang.String] + ] = ... + NON_HCS_DOMAINS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + NON_SPECIAL_DOMAINS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + ALL_DOMAINS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + URL_BIO_FORMATS: typing.ClassVar[java.lang.String] = ... + URL_BIO_FORMATS_LIBRARIES: typing.ClassVar[java.lang.String] = ... + URL_OME_TIFF: typing.ClassVar[java.lang.String] = ... + @staticmethod + def assertId(string: java.lang.String | str, boolean: bool, int: int) -> None: ... + @staticmethod + def canUsePrecompressedTiles( + iFormatReader: IFormatReader, iFormatWriter: IFormatWriter, int: int, int2: int + ) -> bool: ... + @typing.overload + @staticmethod + def checkBufferSize(iFormatReader: IFormatReader, int: int) -> None: ... + @typing.overload + @staticmethod + def checkBufferSize( + iFormatReader: IFormatReader, int: int, int2: int, int3: int + ) -> None: ... + @staticmethod + def checkPlaneNumber(iFormatReader: IFormatReader, int: int) -> None: ... + @staticmethod + def checkPlaneParameters( + iFormatReader: IFormatReader, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + ) -> None: ... + @staticmethod + def checkTileSize( + iFormatReader: IFormatReader, int: int, int2: int, int3: int, int4: int + ) -> None: ... + @typing.overload + @staticmethod + def convert( + string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + @staticmethod + def convert( + iFormatReader: IFormatReader, + iFormatWriter: IFormatWriter, + string: java.lang.String | str, + ) -> None: ... + _createAngle_2__T = typing.TypeVar( + "_createAngle_2__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def createAngle( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Angle] + ) -> ome.units.quantity.Angle: ... + @typing.overload + @staticmethod + def createAngle( + integer: int, unit: ome.units.unit.Unit[ome.units.quantity.Angle] + ) -> ome.units.quantity.Angle: ... + @typing.overload + @staticmethod + def createAngle( + t: _createAngle_2__T, unit: ome.units.unit.Unit[ome.units.quantity.Angle] + ) -> ome.units.quantity.Angle: ... + _createElectricPotential_2__T = typing.TypeVar( + "_createElectricPotential_2__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def createElectricPotential( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.ElectricPotential] + ) -> ome.units.quantity.ElectricPotential: ... + @typing.overload + @staticmethod + def createElectricPotential( + integer: int, unit: ome.units.unit.Unit[ome.units.quantity.ElectricPotential] + ) -> ome.units.quantity.ElectricPotential: ... + @typing.overload + @staticmethod + def createElectricPotential( + t: _createElectricPotential_2__T, + unit: ome.units.unit.Unit[ome.units.quantity.ElectricPotential], + ) -> ome.units.quantity.ElectricPotential: ... + _createFrequency_2__T = typing.TypeVar( + "_createFrequency_2__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def createFrequency( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Frequency] + ) -> ome.units.quantity.Frequency: ... + @typing.overload + @staticmethod + def createFrequency( + integer: int, unit: ome.units.unit.Unit[ome.units.quantity.Frequency] + ) -> ome.units.quantity.Frequency: ... + @typing.overload + @staticmethod + def createFrequency( + t: _createFrequency_2__T, + unit: ome.units.unit.Unit[ome.units.quantity.Frequency], + ) -> ome.units.quantity.Frequency: ... + _createLength_2__T = typing.TypeVar( + "_createLength_2__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def createLength( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Length] + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def createLength( + integer: int, unit: ome.units.unit.Unit[ome.units.quantity.Length] + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def createLength( + t: _createLength_2__T, unit: ome.units.unit.Unit[ome.units.quantity.Length] + ) -> ome.units.quantity.Length: ... + _createPower_2__T = typing.TypeVar( + "_createPower_2__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def createPower( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Power] + ) -> ome.units.quantity.Power: ... + @typing.overload + @staticmethod + def createPower( + integer: int, unit: ome.units.unit.Unit[ome.units.quantity.Power] + ) -> ome.units.quantity.Power: ... + @typing.overload + @staticmethod + def createPower( + t: _createPower_2__T, unit: ome.units.unit.Unit[ome.units.quantity.Power] + ) -> ome.units.quantity.Power: ... + _createPressure_2__T = typing.TypeVar( + "_createPressure_2__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def createPressure( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Pressure] + ) -> ome.units.quantity.Pressure: ... + @typing.overload + @staticmethod + def createPressure( + integer: int, unit: ome.units.unit.Unit[ome.units.quantity.Pressure] + ) -> ome.units.quantity.Pressure: ... + @typing.overload + @staticmethod + def createPressure( + t: _createPressure_2__T, unit: ome.units.unit.Unit[ome.units.quantity.Pressure] + ) -> ome.units.quantity.Pressure: ... + _createTemperature_2__T = typing.TypeVar( + "_createTemperature_2__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def createTemperature( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Temperature] + ) -> ome.units.quantity.Temperature: ... + @typing.overload + @staticmethod + def createTemperature( + integer: int, unit: ome.units.unit.Unit[ome.units.quantity.Temperature] + ) -> ome.units.quantity.Temperature: ... + @typing.overload + @staticmethod + def createTemperature( + t: _createTemperature_2__T, + unit: ome.units.unit.Unit[ome.units.quantity.Temperature], + ) -> ome.units.quantity.Temperature: ... + _createTime_2__T = typing.TypeVar( + "_createTime_2__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def createTime( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Time] + ) -> ome.units.quantity.Time: ... + @typing.overload + @staticmethod + def createTime( + integer: int, unit: ome.units.unit.Unit[ome.units.quantity.Time] + ) -> ome.units.quantity.Time: ... + @typing.overload + @staticmethod + def createTime( + t: _createTime_2__T, unit: ome.units.unit.Unit[ome.units.quantity.Time] + ) -> ome.units.quantity.Time: ... + @staticmethod + def defaultMinMax(int: int) -> typing.MutableSequence[int]: ... + @staticmethod + def equalReaders( + iFormatReader: IFormatReader, iFormatReader2: IFormatReader + ) -> bool: ... + @typing.overload + @staticmethod + def getBytesPerPixel(int: int) -> int: ... + @typing.overload + @staticmethod + def getBytesPerPixel(string: java.lang.String | str) -> int: ... + @staticmethod + def getCutIn(double: float) -> ome.units.quantity.Length: ... + @staticmethod + def getCutOut(double: float) -> ome.units.quantity.Length: ... + @staticmethod + def getEmissionWavelength(double: float) -> ome.units.quantity.Length: ... + @staticmethod + def getExcitationWavelength(double: float) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getFilename( + int: int, + int2: int, + iFormatReader: IFormatReader, + string: java.lang.String | str, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def getFilename( + int: int, + int2: int, + iFormatReader: IFormatReader, + string: java.lang.String | str, + boolean: bool, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def getFilename( + int: int, + int2: int, + metadataRetrieve: loci.formats.meta.MetadataRetrieve, + string: java.lang.String | str, + boolean: bool, + ) -> java.lang.String: ... + @staticmethod + def getFilenames( + string: java.lang.String | str, iFormatReader: IFormatReader + ) -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def getFontSize(integer: int) -> ome.units.quantity.Length: ... + @staticmethod + def getImagesPerFile( + string: java.lang.String | str, iFormatReader: IFormatReader + ) -> int: ... + @typing.overload + @staticmethod + def getIndex( + string: java.lang.String | str, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + ) -> int: ... + @typing.overload + @staticmethod + def getIndex( + string: java.lang.String | str, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + int9: int, + int10: int, + int11: int, + int12: int, + int13: int, + ) -> int: ... + @typing.overload + @staticmethod + def getIndex( + iFormatReader: IFormatReader, int: int, int2: int, int3: int + ) -> int: ... + @typing.overload + @staticmethod + def getIndex( + iFormatReader: IFormatReader, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + ) -> int: ... + @staticmethod + def getMaxFieldCount(integer: int) -> ome.xml.model.primitives.PositiveInteger: ... + @staticmethod + def getPhysicalSize( + double: float, string: java.lang.String | str + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getPhysicalSizeX(double: float) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getPhysicalSizeX( + double: float, string: java.lang.String | str + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getPhysicalSizeX( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Length] + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getPhysicalSizeY(double: float) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getPhysicalSizeY( + double: float, string: java.lang.String | str + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getPhysicalSizeY( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Length] + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getPhysicalSizeZ(double: float) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getPhysicalSizeZ( + double: float, string: java.lang.String | str + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getPhysicalSizeZ( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Length] + ) -> ome.units.quantity.Length: ... + @staticmethod + def getPixelTypeString(int: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def getPlaneSize(iFormatReader: IFormatReader) -> int: ... + @typing.overload + @staticmethod + def getPlaneSize(iFormatReader: IFormatReader, int: int, int2: int) -> int: ... + @staticmethod + def getRasterLength(intArray: list[int] | jpype.JArray) -> int: ... + @staticmethod + def getReader( + iFormatReader: IFormatReader, class_: type[IFormatReader] + ) -> IFormatReader: ... + @typing.overload + @staticmethod + def getReorderedIndex( + string: java.lang.String | str, + string2: java.lang.String | str, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> int: ... + @typing.overload + @staticmethod + def getReorderedIndex( + iFormatReader: IFormatReader, string: java.lang.String | str, int: int + ) -> int: ... + @staticmethod + def getRequiredDirectories( + stringArray: list[java.lang.String] | jpype.JArray, + ) -> int: ... + @typing.overload + @staticmethod + def getStagePosition( + double: float, string: java.lang.String | str + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getStagePosition( + double: float, unit: ome.units.unit.Unit[ome.units.quantity.Length] + ) -> ome.units.quantity.Length: ... + @staticmethod + def getTileFilename( + int: int, int2: int, int3: int, string: java.lang.String | str + ) -> java.lang.String: ... + @staticmethod + def getTime( + double: float, string: java.lang.String | str + ) -> ome.units.quantity.Time: ... + @typing.overload + @staticmethod + def getWavelength(double: float) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getWavelength( + double: float, string: java.lang.String | str + ) -> ome.units.quantity.Length: ... + @staticmethod + def getWellName(int: int, int2: int) -> java.lang.String: ... + @staticmethod + def getWellRowName(int: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def getZCTCoords( + string: java.lang.String | str, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def getZCTCoords( + string: java.lang.String | str, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def getZCTCoords( + iFormatReader: IFormatReader, int: int + ) -> typing.MutableSequence[int]: ... + @staticmethod + def getZCTModuloCoords( + iFormatReader: IFormatReader, int: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def isFloatingPoint(int: int) -> bool: ... + @typing.overload + @staticmethod + def isFloatingPoint(iFormatReader: IFormatReader) -> bool: ... + @staticmethod + def isPositiveValue(double: float) -> bool: ... + @staticmethod + def isSigned(int: int) -> bool: ... + @staticmethod + def openThumbBytes( + iFormatReader: IFormatReader, int: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def parseLength(string: java.lang.String | str) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def parseLength( + string: java.lang.String | str, string2: java.lang.String | str + ) -> ome.units.quantity.Length: ... + @staticmethod + def pixelTypeFromBytes(int: int, boolean: bool, boolean2: bool) -> int: ... + @staticmethod + def pixelTypeFromString(string: java.lang.String | str) -> int: ... + @staticmethod + def positionToRaster( + intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> int: ... + @typing.overload + @staticmethod + def rasterToPosition( + intArray: list[int] | jpype.JArray, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def rasterToPosition( + intArray: list[int] | jpype.JArray, + int2: int, + intArray2: list[int] | jpype.JArray, + ) -> typing.MutableSequence[int]: ... + @staticmethod + def validStream( + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + boolean: bool, + ) -> bool: ... + +class ICompressedTileReader: + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getTileColumns(self, int: int) -> int: ... + def getTileRows(self, int: int) -> int: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + +class ICompressedTileWriter: + def getCodec(self) -> loci.formats.codec.Codec: ... + def getCodecOptions(self) -> loci.formats.codec.CodecOptions: ... + def saveCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + +class IMetadataConfigurable: + def getMetadataOptions(self) -> loci.formats.in_.MetadataOptions: ... + def getSupportedMetadataLevels( + self, + ) -> java.util.Set[loci.formats.in_.MetadataLevel]: ... + def setMetadataOptions( + self, metadataOptions: loci.formats.in_.MetadataOptions + ) -> None: ... + +class IPyramidHandler: + def getResolution(self) -> int: ... + def getResolutionCount(self) -> int: ... + def setResolution(self, int: int) -> None: ... + +class IllegalBlockException(java.lang.IllegalArgumentException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class ImageTools: + @staticmethod + def autoscale( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + boolean: bool, + ) -> typing.MutableSequence[int]: ... + @staticmethod + def bgrToRgb( + byteArray: list[int] | jpype.JArray | bytes, boolean: bool, int: int, int2: int + ) -> None: ... + @staticmethod + def getSubimage( + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + boolean: bool, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def indexedToRGB( + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def indexedToRGB( + shortArray: list[typing.MutableSequence[int]] | jpype.JArray, + byteArray: list[int] | jpype.JArray | bytes, + boolean: bool, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @staticmethod + def interpolate( + shortArray: list[int] | jpype.JArray, + byteArray: list[int] | jpype.JArray | bytes, + intArray: list[int] | jpype.JArray, + int2: int, + int3: int, + boolean: bool, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def make24Bits( + object: typing.Any, int: int, int2: int, boolean: bool, boolean2: bool + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def make24Bits( + object: typing.Any, + int: int, + int2: int, + boolean: bool, + boolean2: bool, + double: float, + double2: float, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def make24Bits( + object: typing.Any, int: int, int2: int, boolean: bool + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def make24Bits( + object: typing.Any, + int: int, + int2: int, + boolean: bool, + double: float, + double2: float, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def padImage( + byteArray: list[int] | jpype.JArray | bytes, + boolean: bool, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def padImage( + doubleArray: list[float] | jpype.JArray, + boolean: bool, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[float]: ... + @typing.overload + @staticmethod + def padImage( + floatArray: list[float] | jpype.JArray, + boolean: bool, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[float]: ... + @typing.overload + @staticmethod + def padImage( + intArray: list[int] | jpype.JArray, + boolean: bool, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def padImage( + shortArray: list[int] | jpype.JArray, + boolean: bool, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[int]: ... + @staticmethod + def scanData( + byteArray: list[int] | jpype.JArray | bytes, int: int, boolean: bool + ) -> typing.MutableSequence[float]: ... + @typing.overload + @staticmethod + def splitChannels( + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + boolean: bool, + boolean2: bool, + int4: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def splitChannels( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + boolean: bool, + boolean2: bool, + ) -> typing.MutableSequence[int]: ... + +_MetadataList__T = typing.TypeVar("_MetadataList__T") # + +class MetadataList(typing.Generic[_MetadataList__T]): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, intArray: list[int] | jpype.JArray): ... + @typing.overload + def __init__(self, metadataList: MetadataList[_MetadataList__T]): ... + @typing.overload + def add(self) -> None: ... + @typing.overload + def add(self, int: int) -> None: ... + @typing.overload + def add(self, int: int, t: _MetadataList__T) -> None: ... + @typing.overload + def add(self, t: _MetadataList__T) -> None: ... + @typing.overload + def add(self, list: java.util.List[_MetadataList__T]) -> None: ... + @typing.overload + def clear(self) -> None: ... + @typing.overload + def clear(self, int: int) -> None: ... + def get(self, int: int, int2: int) -> _MetadataList__T: ... + @typing.overload + def remove(self, int: int, int2: int) -> _MetadataList__T: ... + @typing.overload + def remove(self, int: int) -> java.util.List[_MetadataList__T]: ... + def set(self, int: int, int2: int, t: _MetadataList__T) -> None: ... + @typing.overload + def size(self) -> int: ... + @typing.overload + def size(self, int: int) -> int: ... + def sizes(self) -> typing.MutableSequence[int]: ... + +class MetadataTools: + @staticmethod + def createLSID(string: java.lang.String | str, *int: int) -> java.lang.String: ... + @staticmethod + def createOMEXMLMetadata() -> loci.formats.meta.IMetadata: ... + @staticmethod + def getAcquisitionMode( + string: java.lang.String | str, + ) -> ome.xml.model.enums.AcquisitionMode: ... + @staticmethod + def getArcType(string: java.lang.String | str) -> ome.xml.model.enums.ArcType: ... + @staticmethod + def getBinning(string: java.lang.String | str) -> ome.xml.model.enums.Binning: ... + @staticmethod + def getCompression( + string: java.lang.String | str, + ) -> ome.xml.model.enums.Compression: ... + @staticmethod + def getContrastMethod( + string: java.lang.String | str, + ) -> ome.xml.model.enums.ContrastMethod: ... + @staticmethod + def getCorrection( + string: java.lang.String | str, + ) -> ome.xml.model.enums.Correction: ... + @staticmethod + def getDetectorType( + string: java.lang.String | str, + ) -> ome.xml.model.enums.DetectorType: ... + @staticmethod + def getDimensionOrder( + string: java.lang.String | str, + ) -> ome.xml.model.enums.DimensionOrder: ... + @staticmethod + def getExperimentType( + string: java.lang.String | str, + ) -> ome.xml.model.enums.ExperimentType: ... + @staticmethod + def getFilamentType( + string: java.lang.String | str, + ) -> ome.xml.model.enums.FilamentType: ... + @staticmethod + def getFillRule(string: java.lang.String | str) -> ome.xml.model.enums.FillRule: ... + @staticmethod + def getFilterType( + string: java.lang.String | str, + ) -> ome.xml.model.enums.FilterType: ... + @staticmethod + def getFontFamily( + string: java.lang.String | str, + ) -> ome.xml.model.enums.FontFamily: ... + @staticmethod + def getFontStyle( + string: java.lang.String | str, + ) -> ome.xml.model.enums.FontStyle: ... + @staticmethod + def getIlluminationType( + string: java.lang.String | str, + ) -> ome.xml.model.enums.IlluminationType: ... + @staticmethod + def getImmersion( + string: java.lang.String | str, + ) -> ome.xml.model.enums.Immersion: ... + @staticmethod + def getLaserMedium( + string: java.lang.String | str, + ) -> ome.xml.model.enums.LaserMedium: ... + @staticmethod + def getLaserType( + string: java.lang.String | str, + ) -> ome.xml.model.enums.LaserType: ... + @staticmethod + def getMarker(string: java.lang.String | str) -> ome.xml.model.enums.Marker: ... + @staticmethod + def getMedium(string: java.lang.String | str) -> ome.xml.model.enums.Medium: ... + @staticmethod + def getMicrobeamManipulationType( + string: java.lang.String | str, + ) -> ome.xml.model.enums.MicrobeamManipulationType: ... + @staticmethod + def getMicroscopeType( + string: java.lang.String | str, + ) -> ome.xml.model.enums.MicroscopeType: ... + @staticmethod + def getNamingConvention( + string: java.lang.String | str, + ) -> ome.xml.model.enums.NamingConvention: ... + @staticmethod + def getPixelType( + string: java.lang.String | str, + ) -> ome.xml.model.enums.PixelType: ... + @staticmethod + def getPulse(string: java.lang.String | str) -> ome.xml.model.enums.Pulse: ... + @staticmethod + def keys( + hashtable: java.util.Hashtable[java.lang.String | str, typing.Any], + ) -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def makeSaneDimensionOrder(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def merge( + map: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + map2: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + string: java.lang.String | str, + ) -> None: ... + @typing.overload + @staticmethod + def populateMetadata( + metadataStore: loci.formats.meta.MetadataStore, + int: int, + string: java.lang.String | str, + boolean: bool, + string2: java.lang.String | str, + string3: java.lang.String | str, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + ) -> None: ... + @typing.overload + @staticmethod + def populateMetadata( + metadataStore: loci.formats.meta.MetadataStore, + int: int, + string: java.lang.String | str, + coreMetadata: CoreMetadata, + ) -> None: ... + @typing.overload + @staticmethod + def populateMetadata( + metadataStore: loci.formats.meta.MetadataStore, + string: java.lang.String | str, + int: int, + string2: java.lang.String | str, + boolean: bool, + string3: java.lang.String | str, + string4: java.lang.String | str, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + ) -> None: ... + @typing.overload + @staticmethod + def populatePixels( + metadataStore: loci.formats.meta.MetadataStore, iFormatReader: IFormatReader + ) -> None: ... + @typing.overload + @staticmethod + def populatePixels( + metadataStore: loci.formats.meta.MetadataStore, + iFormatReader: IFormatReader, + boolean: bool, + ) -> None: ... + @typing.overload + @staticmethod + def populatePixels( + metadataStore: loci.formats.meta.MetadataStore, + iFormatReader: IFormatReader, + boolean: bool, + boolean2: bool, + ) -> None: ... + @typing.overload + @staticmethod + def populatePixelsOnly( + metadataStore: loci.formats.meta.MetadataStore, + int: int, + boolean: bool, + string: java.lang.String | str, + string2: java.lang.String | str, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + ) -> None: ... + @typing.overload + @staticmethod + def populatePixelsOnly( + metadataStore: loci.formats.meta.MetadataStore, iFormatReader: IFormatReader + ) -> None: ... + @staticmethod + def setDefaultCreationDate( + metadataStore: loci.formats.meta.MetadataStore, + string: java.lang.String | str, + int: int, + ) -> None: ... + @staticmethod + def setDefaultDateEnabled(boolean: bool) -> None: ... + @typing.overload + @staticmethod + def verifyMinimumPopulated( + metadataRetrieve: loci.formats.meta.MetadataRetrieve, + ) -> None: ... + @typing.overload + @staticmethod + def verifyMinimumPopulated( + metadataRetrieve: loci.formats.meta.MetadataRetrieve, int: int + ) -> None: ... + +class Modulo: + parentDimension: java.lang.String = ... + start: float = ... + step: float = ... + end: float = ... + parentType: java.lang.String = ... + type: java.lang.String = ... + typeDescription: java.lang.String = ... + unit: java.lang.String = ... + labels: typing.MutableSequence[java.lang.String] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, modulo: Modulo): ... + def length(self) -> int: ... + def toXMLAnnotation(self) -> java.lang.String: ... + +class NumberFilter(java.io.FileFilter): + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def accept(self, file: java.io.File | jpype.protocol.SupportsPath) -> bool: ... + @typing.overload + def accept(self, string: java.lang.String | str) -> bool: ... + def getNumber(self, string: java.lang.String | str) -> java.math.BigInteger: ... + +class Resolution: + sizeX: ome.xml.model.primitives.PositiveInteger = ... + sizeY: ome.xml.model.primitives.PositiveInteger = ... + index: int = ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + +class ResourceNamer: + PLATE: typing.ClassVar[java.lang.String] = ... + RUN: typing.ClassVar[java.lang.String] = ... + WELL: typing.ClassVar[java.lang.String] = ... + FIELD: typing.ClassVar[java.lang.String] = ... + FAKE_EXT: typing.ClassVar[java.lang.String] = ... + DOT: typing.ClassVar[java.lang.String] = ... + def __init__(self, int: int): ... + @staticmethod + def alphabeticIndexCount(string: java.lang.String | str) -> int: ... + def getLetter(self) -> java.lang.String: ... + def getLocationFromResourceName( + self, + location: loci.common.Location, + string: java.lang.String | str, + int: int, + string2: java.lang.String | str, + ) -> loci.common.Location: ... + def nextLetter(self) -> None: ... + def restartAlphabet(self) -> None: ... + +class UpgradeChecker: + REGISTRY_IMAGEJ: typing.ClassVar[java.lang.String] = ... + REGISTRY_LIBRARY: typing.ClassVar[java.lang.String] = ... + STABLE_VERSION: typing.ClassVar[java.lang.String] = ... + CI_SERVER: typing.ClassVar[java.lang.String] = ... + TRUNK_BUILD: typing.ClassVar[java.lang.String] = ... + DAILY_BUILD: typing.ClassVar[java.lang.String] = ... + STABLE_BUILD: typing.ClassVar[java.lang.String] = ... + TOOLS: typing.ClassVar[java.lang.String] = ... + OLD_TOOLS: typing.ClassVar[java.lang.String] = ... + OME_TOOLS: typing.ClassVar[java.lang.String] = ... + INDIVIDUAL_JARS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + REGISTRY: typing.ClassVar[java.lang.String] = ... + DEFAULT_CALLER: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def alreadyChecked(self) -> bool: ... + def canDoUpgradeCheck(self) -> bool: ... + def install( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> bool: ... + def installIndividualJars( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> bool: ... + @typing.overload + def newVersionAvailable(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def newVersionAvailable( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> bool: ... + def setCanDoUpgradeCheck(self, boolean: bool) -> None: ... + +class CoreMetadataList(MetadataList[CoreMetadata]): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, intArray: list[int] | jpype.JArray): ... + @typing.overload + def __init__(self, list: java.util.List[CoreMetadata]): ... + @typing.overload + def __init__(self, coreMetadataList: CoreMetadataList): ... + @typing.overload + def add(self, int: int, coreMetadata: CoreMetadata) -> None: ... + @typing.overload + def add(self) -> None: ... + @typing.overload + def add(self, int: int) -> None: ... + @typing.overload + def add(self, t: typing.Any) -> None: ... + @typing.overload + def add(self, list: java.util.List[typing.Any]) -> None: ... + def flattenedIndex(self, int: int, int2: int) -> int: ... + def flattenedIndexes(self, int: int) -> typing.MutableSequence[int]: ... + def flattenedSize(self) -> int: ... + def getFlattenedList(self) -> java.util.List[CoreMetadata]: ... + def getSeriesList(self) -> java.util.List[CoreMetadata]: ... + def reorder(self) -> None: ... + def setFlattenedList(self, list: java.util.List[CoreMetadata]) -> None: ... + +class IFormatHandler(java.io.Closeable, IMetadataConfigurable): + def getFormat(self) -> java.lang.String: ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getSuffixes(self) -> typing.MutableSequence[java.lang.String]: ... + def isThisType(self, string: java.lang.String | str) -> bool: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class MissingLibraryException(FormatException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class SwappableMetadata(CoreMetadata): + inputOrder: java.lang.String = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader, int: int): ... + @typing.overload + def __init__(self, swappableMetadata: SwappableMetadata): ... + @typing.overload + def clone(self) -> typing.Any: ... + @typing.overload + def clone(self, iFormatReader: IFormatReader, int: int) -> CoreMetadata: ... + +class UnknownFormatException(FormatException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class UnsupportedCompressionException(FormatException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class FormatHandler(IFormatHandler): + COMPRESSION_SUFFIXES: typing.ClassVar[ + typing.MutableSequence[java.lang.String] + ] = ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + @staticmethod + def checkSuffix( + string: java.lang.String | str, string2: java.lang.String | str + ) -> bool: ... + @typing.overload + @staticmethod + def checkSuffix( + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> bool: ... + def getFormat(self) -> java.lang.String: ... + def getMetadataOptions(self) -> loci.formats.in_.MetadataOptions: ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getSuffixes(self) -> typing.MutableSequence[java.lang.String]: ... + def getSupportedMetadataLevels( + self, + ) -> java.util.Set[loci.formats.in_.MetadataLevel]: ... + def isThisType(self, string: java.lang.String | str) -> bool: ... + def setMetadataOptions( + self, metadataOptions: loci.formats.in_.MetadataOptions + ) -> None: ... + +class IFormatReader(IFormatHandler, IPyramidHandler, ICompressedTileReader): + MUST_GROUP: typing.ClassVar[int] = ... + CAN_GROUP: typing.ClassVar[int] = ... + CANNOT_GROUP: typing.ClassVar[int] = ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def coreIndexToSeries(self, int: int) -> int: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getAdvancedSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getAdvancedUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getBitsPerPixel(self) -> int: ... + def getCoreIndex(self) -> int: ... + def getCoreMetadataList(self) -> java.util.List[CoreMetadata]: ... + def getCurrentFile(self) -> java.lang.String: ... + def getDatasetStructureDescription(self) -> java.lang.String: ... + def getDimensionOrder(self) -> java.lang.String: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + def getEffectiveSizeC(self) -> int: ... + def getFillColor(self) -> int: ... + def getGlobalMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getImageCount(self) -> int: ... + @typing.overload + def getIndex(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getIndex( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + def getMetadataStore(self) -> loci.formats.meta.MetadataStore: ... + def getMetadataStoreRoot(self) -> typing.Any: ... + def getMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + def getModuloC(self) -> Modulo: ... + def getModuloT(self) -> Modulo: ... + def getModuloZ(self) -> Modulo: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getPixelType(self) -> int: ... + def getPossibleDomains( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + def getRGBChannelCount(self) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + def getSeries(self) -> int: ... + def getSeriesCount(self) -> int: ... + def getSeriesMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getSeriesMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getSizeC(self) -> int: ... + def getSizeT(self) -> int: ... + def getSizeX(self) -> int: ... + def getSizeY(self) -> int: ... + def getSizeZ(self) -> int: ... + def getThumbSizeX(self) -> int: ... + def getThumbSizeY(self) -> int: ... + def getUnderlyingReaders(self) -> typing.MutableSequence[IFormatReader]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getZCTCoords(self, int: int) -> typing.MutableSequence[int]: ... + def getZCTModuloCoords(self, int: int) -> typing.MutableSequence[int]: ... + def hasCompanionFiles(self) -> bool: ... + def hasFlattenedResolutions(self) -> bool: ... + def isFalseColor(self) -> bool: ... + def isGroupFiles(self) -> bool: ... + def isIndexed(self) -> bool: ... + @typing.overload + def isInterleaved(self) -> bool: ... + @typing.overload + def isInterleaved(self, int: int) -> bool: ... + def isLittleEndian(self) -> bool: ... + def isMetadataComplete(self) -> bool: ... + def isMetadataFiltered(self) -> bool: ... + def isNormalized(self) -> bool: ... + def isOrderCertain(self) -> bool: ... + def isOriginalMetadataPopulated(self) -> bool: ... + def isRGB(self) -> bool: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + def isThumbnailSeries(self) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def seriesToCoreIndex(self, int: int) -> int: ... + def setCoreIndex(self, int: int) -> None: ... + def setFillColor(self, byte: int) -> None: ... + def setFlattenedResolutions(self, boolean: bool) -> None: ... + def setGroupFiles(self, boolean: bool) -> None: ... + def setMetadataFiltered(self, boolean: bool) -> None: ... + def setMetadataStore( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> None: ... + def setNormalized(self, boolean: bool) -> None: ... + def setOriginalMetadataPopulated(self, boolean: bool) -> None: ... + def setSeries(self, int: int) -> None: ... + +class IFormatWriter(IFormatHandler, IPyramidHandler, ICompressedTileWriter): + def canDoStacks(self) -> bool: ... + def changeOutputFile(self, string: java.lang.String | str) -> None: ... + def getColorModel(self) -> java.awt.image.ColorModel: ... + def getCompression(self) -> java.lang.String: ... + def getCompressionTypes(self) -> typing.MutableSequence[java.lang.String]: ... + def getFramesPerSecond(self) -> int: ... + def getMetadataRetrieve(self) -> loci.formats.meta.MetadataRetrieve: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def getResolutions(self) -> java.util.List[Resolution]: ... + def getSeries(self) -> int: ... + def getTileSizeX(self) -> int: ... + def getTileSizeY(self) -> int: ... + def isInterleaved(self) -> bool: ... + def isSupportedType(self, int: int) -> bool: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def savePlane(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, region: loci.common.Region + ) -> None: ... + def setCodecOptions( + self, codecOptions: loci.formats.codec.CodecOptions + ) -> None: ... + def setColorModel(self, colorModel: java.awt.image.ColorModel) -> None: ... + def setCompression(self, string: java.lang.String | str) -> None: ... + def setFramesPerSecond(self, int: int) -> None: ... + def setInterleaved(self, boolean: bool) -> None: ... + def setMetadataRetrieve( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> None: ... + def setResolutions(self, list: java.util.List[Resolution]) -> None: ... + def setSeries(self, int: int) -> None: ... + def setTileSizeX(self, int: int) -> int: ... + def setTileSizeY(self, int: int) -> int: ... + def setValidBitsPerPixel(self, int: int) -> None: ... + def setWriteSequentially(self, boolean: bool) -> None: ... + +class FormatReader(FormatHandler, IFormatReader): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def coreIndexToSeries(self, int: int) -> int: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getAdvancedSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getAdvancedUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getBitsPerPixel(self) -> int: ... + def getCoreIndex(self) -> int: ... + def getCoreMetadataList(self) -> java.util.List[CoreMetadata]: ... + def getCurrentFile(self) -> java.lang.String: ... + def getDatasetStructureDescription(self) -> java.lang.String: ... + def getDimensionOrder(self) -> java.lang.String: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + def getEffectiveSizeC(self) -> int: ... + def getFillColor(self) -> int: ... + def getGlobalMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getImageCount(self) -> int: ... + @typing.overload + def getIndex(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getIndex( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + def getMetadataStore(self) -> loci.formats.meta.MetadataStore: ... + def getMetadataStoreRoot(self) -> typing.Any: ... + def getMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + def getModuloC(self) -> Modulo: ... + def getModuloT(self) -> Modulo: ... + def getModuloZ(self) -> Modulo: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getPixelType(self) -> int: ... + def getPossibleDomains( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + def getRGBChannelCount(self) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + def getResolution(self) -> int: ... + def getResolutionCount(self) -> int: ... + def getSeries(self) -> int: ... + def getSeriesCount(self) -> int: ... + def getSeriesMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getSeriesMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getSizeC(self) -> int: ... + def getSizeT(self) -> int: ... + def getSizeX(self) -> int: ... + def getSizeY(self) -> int: ... + def getSizeZ(self) -> int: ... + def getThumbSizeX(self) -> int: ... + def getThumbSizeY(self) -> int: ... + def getTileColumns(self, int: int) -> int: ... + def getTileRows(self, int: int) -> int: ... + def getUnderlyingReaders(self) -> typing.MutableSequence[IFormatReader]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getZCTCoords(self, int: int) -> typing.MutableSequence[int]: ... + def getZCTModuloCoords(self, int: int) -> typing.MutableSequence[int]: ... + def hasCompanionFiles(self) -> bool: ... + def hasFlattenedResolutions(self) -> bool: ... + def isFalseColor(self) -> bool: ... + def isGroupFiles(self) -> bool: ... + def isIndexed(self) -> bool: ... + @typing.overload + def isInterleaved(self) -> bool: ... + @typing.overload + def isInterleaved(self, int: int) -> bool: ... + def isLittleEndian(self) -> bool: ... + def isMetadataComplete(self) -> bool: ... + def isMetadataFiltered(self) -> bool: ... + def isNormalized(self) -> bool: ... + def isOrderCertain(self) -> bool: ... + def isOriginalMetadataPopulated(self) -> bool: ... + def isRGB(self) -> bool: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + def isThumbnailSeries(self) -> bool: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def seriesToCoreIndex(self, int: int) -> int: ... + def setCoreIndex(self, int: int) -> None: ... + def setFillColor(self, byte: int) -> None: ... + def setFlattenedResolutions(self, boolean: bool) -> None: ... + def setGroupFiles(self, boolean: bool) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setMetadataFiltered(self, boolean: bool) -> None: ... + def setMetadataStore( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> None: ... + def setNormalized(self, boolean: bool) -> None: ... + def setOriginalMetadataPopulated(self, boolean: bool) -> None: ... + def setResolution(self, int: int) -> None: ... + def setSeries(self, int: int) -> None: ... + +class FormatWriter(FormatHandler, IFormatWriter): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + def canDoStacks(self) -> bool: ... + def changeOutputFile(self, string: java.lang.String | str) -> None: ... + def close(self) -> None: ... + def getCodecOptions(self) -> loci.formats.codec.CodecOptions: ... + def getColorModel(self) -> java.awt.image.ColorModel: ... + def getCompression(self) -> java.lang.String: ... + def getCompressionTypes(self) -> typing.MutableSequence[java.lang.String]: ... + def getFramesPerSecond(self) -> int: ... + def getMetadataRetrieve(self) -> loci.formats.meta.MetadataRetrieve: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def getResolution(self) -> int: ... + def getResolutionCount(self) -> int: ... + def getResolutions(self) -> java.util.List[Resolution]: ... + def getSeries(self) -> int: ... + def getTileSizeX(self) -> int: ... + def getTileSizeY(self) -> int: ... + def isInterleaved(self) -> bool: ... + def isSupportedType(self, int: int) -> bool: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def savePlane(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, region: loci.common.Region + ) -> None: ... + def setCodecOptions( + self, codecOptions: loci.formats.codec.CodecOptions + ) -> None: ... + def setColorModel(self, colorModel: java.awt.image.ColorModel) -> None: ... + def setCompression(self, string: java.lang.String | str) -> None: ... + def setFramesPerSecond(self, int: int) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setInterleaved(self, boolean: bool) -> None: ... + def setMetadataRetrieve( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> None: ... + def setResolution(self, int: int) -> None: ... + def setResolutions(self, list: java.util.List[Resolution]) -> None: ... + def setSeries(self, int: int) -> None: ... + def setTileSizeX(self, int: int) -> int: ... + def setTileSizeY(self, int: int) -> int: ... + def setValidBitsPerPixel(self, int: int) -> None: ... + def setWriteSequentially(self, boolean: bool) -> None: ... + +class ImageReader(IFormatReader): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, classList: ClassList[IFormatReader]): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def coreIndexToSeries(self, int: int) -> int: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getAdvancedSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getAdvancedUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getBitsPerPixel(self) -> int: ... + def getCoreIndex(self) -> int: ... + def getCoreMetadataList(self) -> java.util.List[CoreMetadata]: ... + def getCurrentFile(self) -> java.lang.String: ... + def getDatasetStructureDescription(self) -> java.lang.String: ... + @staticmethod + def getDefaultReaderClasses() -> ClassList[IFormatReader]: ... + def getDimensionOrder(self) -> java.lang.String: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + def getEffectiveSizeC(self) -> int: ... + def getFillColor(self) -> int: ... + @typing.overload + def getFormat(self) -> java.lang.String: ... + @typing.overload + def getFormat(self, string: java.lang.String | str) -> java.lang.String: ... + def getGlobalMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getImageCount(self) -> int: ... + @typing.overload + def getIndex(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getIndex( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + def getMetadataOptions(self) -> loci.formats.in_.MetadataOptions: ... + def getMetadataStore(self) -> loci.formats.meta.MetadataStore: ... + def getMetadataStoreRoot(self) -> typing.Any: ... + def getMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + def getModuloC(self) -> Modulo: ... + def getModuloT(self) -> Modulo: ... + def getModuloZ(self) -> Modulo: ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getPixelType(self) -> int: ... + def getPossibleDomains( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + def getRGBChannelCount(self) -> int: ... + @typing.overload + def getReader(self) -> IFormatReader: ... + @typing.overload + def getReader(self, class_: type[IFormatReader]) -> IFormatReader: ... + @typing.overload + def getReader(self, string: java.lang.String | str) -> IFormatReader: ... + def getReaders(self) -> typing.MutableSequence[IFormatReader]: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + def getResolution(self) -> int: ... + def getResolutionCount(self) -> int: ... + def getSeries(self) -> int: ... + def getSeriesCount(self) -> int: ... + def getSeriesMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getSeriesMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getSizeC(self) -> int: ... + def getSizeT(self) -> int: ... + def getSizeX(self) -> int: ... + def getSizeY(self) -> int: ... + def getSizeZ(self) -> int: ... + def getSuffixes(self) -> typing.MutableSequence[java.lang.String]: ... + def getSupportedMetadataLevels( + self, + ) -> java.util.Set[loci.formats.in_.MetadataLevel]: ... + def getThumbSizeX(self) -> int: ... + def getThumbSizeY(self) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getTileColumns(self, int: int) -> int: ... + def getTileRows(self, int: int) -> int: ... + def getUnderlyingReaders(self) -> typing.MutableSequence[IFormatReader]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getZCTCoords(self, int: int) -> typing.MutableSequence[int]: ... + def getZCTModuloCoords(self, int: int) -> typing.MutableSequence[int]: ... + def hasCompanionFiles(self) -> bool: ... + def hasFlattenedResolutions(self) -> bool: ... + def isFalseColor(self) -> bool: ... + def isGroupFiles(self) -> bool: ... + def isIndexed(self) -> bool: ... + @typing.overload + def isInterleaved(self) -> bool: ... + @typing.overload + def isInterleaved(self, int: int) -> bool: ... + def isLittleEndian(self) -> bool: ... + def isMetadataComplete(self) -> bool: ... + def isMetadataFiltered(self) -> bool: ... + def isNormalized(self) -> bool: ... + def isOrderCertain(self) -> bool: ... + def isOriginalMetadataPopulated(self) -> bool: ... + def isRGB(self) -> bool: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + def isThumbnailSeries(self) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def seriesToCoreIndex(self, int: int) -> int: ... + def setAllowOpenFiles(self, boolean: bool) -> None: ... + def setCoreIndex(self, int: int) -> None: ... + def setFillColor(self, byte: int) -> None: ... + def setFlattenedResolutions(self, boolean: bool) -> None: ... + def setGroupFiles(self, boolean: bool) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setMetadataFiltered(self, boolean: bool) -> None: ... + def setMetadataOptions( + self, metadataOptions: loci.formats.in_.MetadataOptions + ) -> None: ... + def setMetadataStore( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> None: ... + def setNormalized(self, boolean: bool) -> None: ... + def setOriginalMetadataPopulated(self, boolean: bool) -> None: ... + def setResolution(self, int: int) -> None: ... + def setSeries(self, int: int) -> None: ... + +class ImageWriter(IFormatWriter): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, classList: ClassList[IFormatWriter]): ... + def canDoStacks(self) -> bool: ... + def changeOutputFile(self, string: java.lang.String | str) -> None: ... + def close(self) -> None: ... + def getCodec(self) -> loci.formats.codec.Codec: ... + def getCodecOptions(self) -> loci.formats.codec.CodecOptions: ... + def getColorModel(self) -> java.awt.image.ColorModel: ... + def getCompression(self) -> java.lang.String: ... + def getCompressionTypes(self) -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def getDefaultWriterClasses() -> ClassList[IFormatWriter]: ... + @typing.overload + def getFormat(self) -> java.lang.String: ... + @typing.overload + def getFormat(self, string: java.lang.String | str) -> java.lang.String: ... + def getFramesPerSecond(self) -> int: ... + def getMetadataOptions(self) -> loci.formats.in_.MetadataOptions: ... + def getMetadataRetrieve(self) -> loci.formats.meta.MetadataRetrieve: ... + def getNativeDataType(self) -> type[typing.Any]: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def getResolution(self) -> int: ... + def getResolutionCount(self) -> int: ... + def getResolutions(self) -> java.util.List[Resolution]: ... + def getSeries(self) -> int: ... + def getSuffixes(self) -> typing.MutableSequence[java.lang.String]: ... + def getSupportedMetadataLevels( + self, + ) -> java.util.Set[loci.formats.in_.MetadataLevel]: ... + def getTileSizeX(self) -> int: ... + def getTileSizeY(self) -> int: ... + @typing.overload + def getWriter(self) -> IFormatWriter: ... + @typing.overload + def getWriter(self, class_: type[IFormatWriter]) -> IFormatWriter: ... + @typing.overload + def getWriter(self, string: java.lang.String | str) -> IFormatWriter: ... + def getWriters(self) -> typing.MutableSequence[IFormatWriter]: ... + def isInterleaved(self) -> bool: ... + def isSupportedType(self, int: int) -> bool: ... + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + def saveCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def savePlane(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, region: loci.common.Region + ) -> None: ... + def setCodecOptions( + self, codecOptions: loci.formats.codec.CodecOptions + ) -> None: ... + def setColorModel(self, colorModel: java.awt.image.ColorModel) -> None: ... + def setCompression(self, string: java.lang.String | str) -> None: ... + def setFramesPerSecond(self, int: int) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setInterleaved(self, boolean: bool) -> None: ... + def setMetadataOptions( + self, metadataOptions: loci.formats.in_.MetadataOptions + ) -> None: ... + def setMetadataRetrieve( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> None: ... + def setResolution(self, int: int) -> None: ... + def setResolutions(self, list: java.util.List[Resolution]) -> None: ... + def setSeries(self, int: int) -> None: ... + def setTileSizeX(self, int: int) -> int: ... + def setTileSizeY(self, int: int) -> int: ... + def setValidBitsPerPixel(self, int: int) -> None: ... + def setWriteSequentially(self, boolean: bool) -> None: ... + +class ReaderWrapper(IFormatReader): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def coreIndexToSeries(self, int: int) -> int: ... + def duplicate(self, class_: type[IFormatReader]) -> ReaderWrapper: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getAdvancedSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getAdvancedUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getBitsPerPixel(self) -> int: ... + def getCoreIndex(self) -> int: ... + def getCoreMetadataList(self) -> java.util.List[CoreMetadata]: ... + def getCurrentFile(self) -> java.lang.String: ... + def getDatasetStructureDescription(self) -> java.lang.String: ... + def getDimensionOrder(self) -> java.lang.String: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + def getEffectiveSizeC(self) -> int: ... + def getFillColor(self) -> int: ... + def getFormat(self) -> java.lang.String: ... + def getGlobalMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getImageCount(self) -> int: ... + @typing.overload + def getIndex(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getIndex( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + def getMetadataOptions(self) -> loci.formats.in_.MetadataOptions: ... + def getMetadataStore(self) -> loci.formats.meta.MetadataStore: ... + def getMetadataStoreRoot(self) -> typing.Any: ... + def getMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + def getModuloC(self) -> Modulo: ... + def getModuloT(self) -> Modulo: ... + def getModuloZ(self) -> Modulo: ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getPixelType(self) -> int: ... + def getPossibleDomains( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + def getRGBChannelCount(self) -> int: ... + def getReader(self) -> IFormatReader: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + def getResolution(self) -> int: ... + def getResolutionCount(self) -> int: ... + def getSeries(self) -> int: ... + def getSeriesCount(self) -> int: ... + def getSeriesMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getSeriesMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getSizeC(self) -> int: ... + def getSizeT(self) -> int: ... + def getSizeX(self) -> int: ... + def getSizeY(self) -> int: ... + def getSizeZ(self) -> int: ... + def getSuffixes(self) -> typing.MutableSequence[java.lang.String]: ... + def getSupportedMetadataLevels( + self, + ) -> java.util.Set[loci.formats.in_.MetadataLevel]: ... + def getThumbSizeX(self) -> int: ... + def getThumbSizeY(self) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getTileColumns(self, int: int) -> int: ... + def getTileRows(self, int: int) -> int: ... + def getUnderlyingReaders(self) -> typing.MutableSequence[IFormatReader]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getZCTCoords(self, int: int) -> typing.MutableSequence[int]: ... + def getZCTModuloCoords(self, int: int) -> typing.MutableSequence[int]: ... + def hasCompanionFiles(self) -> bool: ... + def hasFlattenedResolutions(self) -> bool: ... + def isFalseColor(self) -> bool: ... + def isGroupFiles(self) -> bool: ... + def isIndexed(self) -> bool: ... + @typing.overload + def isInterleaved(self) -> bool: ... + @typing.overload + def isInterleaved(self, int: int) -> bool: ... + def isLittleEndian(self) -> bool: ... + def isMetadataComplete(self) -> bool: ... + def isMetadataFiltered(self) -> bool: ... + def isNormalized(self) -> bool: ... + def isOrderCertain(self) -> bool: ... + def isOriginalMetadataPopulated(self) -> bool: ... + def isRGB(self) -> bool: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + def isThumbnailSeries(self) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def seriesToCoreIndex(self, int: int) -> int: ... + def setCoreIndex(self, int: int) -> None: ... + def setFillColor(self, byte: int) -> None: ... + def setFlattenedResolutions(self, boolean: bool) -> None: ... + def setGroupFiles(self, boolean: bool) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setMetadataFiltered(self, boolean: bool) -> None: ... + def setMetadataOptions( + self, metadataOptions: loci.formats.in_.MetadataOptions + ) -> None: ... + def setMetadataStore( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> None: ... + def setNormalized(self, boolean: bool) -> None: ... + def setOriginalMetadataPopulated(self, boolean: bool) -> None: ... + def setResolution(self, int: int) -> None: ... + def setSeries(self, int: int) -> None: ... + @typing.overload + def unwrap(self) -> IFormatReader: ... + @typing.overload + def unwrap( + self, class_: type[IFormatReader], string: java.lang.String | str + ) -> IFormatReader: ... + @typing.overload + def unwrap(self, string: java.lang.String | str) -> IFormatReader: ... + +class WriterWrapper(IFormatWriter): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatWriter: IFormatWriter): ... + def canDoStacks(self) -> bool: ... + def changeOutputFile(self, string: java.lang.String | str) -> None: ... + def close(self) -> None: ... + def duplicate(self, class_: type[IFormatWriter]) -> WriterWrapper: ... + def getCodec(self) -> loci.formats.codec.Codec: ... + def getCodecOptions(self) -> loci.formats.codec.CodecOptions: ... + def getColorModel(self) -> java.awt.image.ColorModel: ... + def getCompression(self) -> java.lang.String: ... + def getCompressionTypes(self) -> typing.MutableSequence[java.lang.String]: ... + def getFormat(self) -> java.lang.String: ... + def getFramesPerSecond(self) -> int: ... + def getMetadataOptions(self) -> loci.formats.in_.MetadataOptions: ... + def getMetadataRetrieve(self) -> loci.formats.meta.MetadataRetrieve: ... + def getNativeDataType(self) -> type[typing.Any]: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def getResolution(self) -> int: ... + def getResolutionCount(self) -> int: ... + def getResolutions(self) -> java.util.List[Resolution]: ... + def getSeries(self) -> int: ... + def getSuffixes(self) -> typing.MutableSequence[java.lang.String]: ... + def getSupportedMetadataLevels( + self, + ) -> java.util.Set[loci.formats.in_.MetadataLevel]: ... + def getTileSizeX(self) -> int: ... + def getTileSizeY(self) -> int: ... + def getWriter(self) -> IFormatWriter: ... + def isInterleaved(self) -> bool: ... + def isSupportedType(self, int: int) -> bool: ... + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + def saveCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def savePlane(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, region: loci.common.Region + ) -> None: ... + def setCodecOptions( + self, codecOptions: loci.formats.codec.CodecOptions + ) -> None: ... + def setColorModel(self, colorModel: java.awt.image.ColorModel) -> None: ... + def setCompression(self, string: java.lang.String | str) -> None: ... + def setFramesPerSecond(self, int: int) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setInterleaved(self, boolean: bool) -> None: ... + def setMetadataOptions( + self, metadataOptions: loci.formats.in_.MetadataOptions + ) -> None: ... + def setMetadataRetrieve( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> None: ... + def setResolution(self, int: int) -> None: ... + def setResolutions(self, list: java.util.List[Resolution]) -> None: ... + def setSeries(self, int: int) -> None: ... + def setTileSizeX(self, int: int) -> int: ... + def setTileSizeY(self, int: int) -> int: ... + def setValidBitsPerPixel(self, int: int) -> None: ... + def setWriteSequentially(self, boolean: bool) -> None: ... + @typing.overload + def unwrap(self) -> IFormatWriter: ... + @typing.overload + def unwrap( + self, class_: type[IFormatWriter], string: java.lang.String | str + ) -> IFormatWriter: ... + @typing.overload + def unwrap(self, string: java.lang.String | str) -> IFormatWriter: ... + +class ChannelFiller(ReaderWrapper): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader): ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getBitsPerPixel(self) -> int: ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getSizeC(self) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def isFilled(self) -> bool: ... + def isIndexed(self) -> bool: ... + def isRGB(self) -> bool: ... + @staticmethod + def makeChannelFiller(iFormatReader: IFormatReader) -> ChannelFiller: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + def setFilled(self, boolean: bool) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class ChannelMerger(ReaderWrapper): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader): ... + def canMerge(self) -> bool: ... + def getDimensionOrder(self) -> java.lang.String: ... + def getImageCount(self) -> int: ... + @typing.overload + def getIndex(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getIndex( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getOriginalIndex(self, int: int) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getZCTCoords(self, int: int) -> typing.MutableSequence[int]: ... + def getZCTModuloCoords(self, int: int) -> typing.MutableSequence[int]: ... + def isIndexed(self) -> bool: ... + @typing.overload + def isInterleaved(self) -> bool: ... + @typing.overload + def isInterleaved(self, int: int) -> bool: ... + def isRGB(self) -> bool: ... + @staticmethod + def makeChannelMerger(iFormatReader: IFormatReader) -> ChannelMerger: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + +class ChannelSeparator(ReaderWrapper): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader): ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def close(self) -> None: ... + def getDimensionOrder(self) -> java.lang.String: ... + def getImageCount(self) -> int: ... + @typing.overload + def getIndex(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getIndex( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getOriginalIndex(self, int: int) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getZCTCoords(self, int: int) -> typing.MutableSequence[int]: ... + def getZCTModuloCoords(self, int: int) -> typing.MutableSequence[int]: ... + def isRGB(self) -> bool: ... + @staticmethod + def makeChannelSeparator(iFormatReader: IFormatReader) -> ChannelSeparator: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class DelegateReader(FormatReader): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def close(self) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getMetadataOptions(self) -> loci.formats.in_.MetadataOptions: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + def getSupportedMetadataLevels( + self, + ) -> java.util.Set[loci.formats.in_.MetadataLevel]: ... + def isLegacy(self) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def setCoreIndex(self, int: int) -> None: ... + def setFlattenedResolutions(self, boolean: bool) -> None: ... + def setGroupFiles(self, boolean: bool) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setLegacy(self, boolean: bool) -> None: ... + def setMetadataFiltered(self, boolean: bool) -> None: ... + def setMetadataOptions( + self, metadataOptions: loci.formats.in_.MetadataOptions + ) -> None: ... + def setMetadataStore( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> None: ... + def setNormalized(self, boolean: bool) -> None: ... + def setOriginalMetadataPopulated(self, boolean: bool) -> None: ... + def setResolution(self, int: int) -> None: ... + def setSeries(self, int: int) -> None: ... + +class DimensionSwapper(ReaderWrapper): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader): ... + def getCoreMetadataList(self) -> java.util.List[CoreMetadata]: ... + def getDimensionOrder(self) -> java.lang.String: ... + @typing.overload + def getIndex(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getIndex( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + def getInputOrder(self) -> java.lang.String: ... + def getSizeC(self) -> int: ... + def getSizeT(self) -> int: ... + def getSizeX(self) -> int: ... + def getSizeY(self) -> int: ... + def getSizeZ(self) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getZCTCoords(self, int: int) -> typing.MutableSequence[int]: ... + def getZCTModuloCoords(self, int: int) -> typing.MutableSequence[int]: ... + @staticmethod + def makeDimensionSwapper(iFormatReader: IFormatReader) -> DimensionSwapper: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setOutputOrder(self, string: java.lang.String | str) -> None: ... + def swapDimensions(self, string: java.lang.String | str) -> None: ... + +class FileStitcher(ReaderWrapper): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader, boolean: bool): ... + def canChangePattern(self) -> bool: ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def coreIndexToSeries(self, int: int) -> int: ... + def findPattern(self, string: java.lang.String | str) -> FilePattern: ... + def findPatterns( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getAdjustedIndex(self, int: int) -> int: ... + def getAdvancedSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getAdvancedUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[FileInfo]: ... + def getAxisGuesser(self) -> AxisGuesser: ... + def getAxisTypes(self) -> typing.MutableSequence[int]: ... + def getBitsPerPixel(self) -> int: ... + def getCoreIndex(self) -> int: ... + def getCoreMetadataList(self) -> java.util.List[CoreMetadata]: ... + def getDimensionOrder(self) -> java.lang.String: ... + def getFilePattern(self) -> FilePattern: ... + def getImageCount(self) -> int: ... + @typing.overload + def getIndex(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getIndex( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + def getMetadataStore(self) -> loci.formats.meta.MetadataStore: ... + def getMetadataStoreRoot(self) -> typing.Any: ... + def getPixelType(self) -> int: ... + @typing.overload + def getReader(self, int: int, int2: int) -> DimensionSwapper: ... + @typing.overload + def getReader(self) -> IFormatReader: ... + @typing.overload + def getReader(self, int: int) -> IFormatReader: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + def getResolution(self) -> int: ... + def getSeries(self) -> int: ... + def getSeriesCount(self) -> int: ... + def getSeriesMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getSizeC(self) -> int: ... + def getSizeT(self) -> int: ... + def getSizeX(self) -> int: ... + def getSizeY(self) -> int: ... + def getSizeZ(self) -> int: ... + def getThumbSizeX(self) -> int: ... + def getThumbSizeY(self) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getUnderlyingReaders(self) -> typing.MutableSequence[IFormatReader]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getZCTCoords(self, int: int) -> typing.MutableSequence[int]: ... + def getZCTModuloCoords(self, int: int) -> typing.MutableSequence[int]: ... + def isFalseColor(self) -> bool: ... + def isGroupFiles(self) -> bool: ... + def isIndexed(self) -> bool: ... + @typing.overload + def isInterleaved(self) -> bool: ... + @typing.overload + def isInterleaved(self, int: int) -> bool: ... + def isLittleEndian(self) -> bool: ... + def isOrderCertain(self) -> bool: ... + def isRGB(self) -> bool: ... + def isThumbnailSeries(self) -> bool: ... + def isUsingPatternIds(self) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def seriesToCoreIndex(self, int: int) -> int: ... + def setAxisTypes(self, intArray: list[int] | jpype.JArray) -> None: ... + def setCanChangePattern(self, boolean: bool) -> None: ... + def setCoreIndex(self, int: int) -> None: ... + def setFlattenedResolutions(self, boolean: bool) -> None: ... + def setGroupFiles(self, boolean: bool) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setMetadataOptions( + self, metadataOptions: loci.formats.in_.MetadataOptions + ) -> None: ... + def setMetadataStore( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> None: ... + def setNormalized(self, boolean: bool) -> None: ... + def setOriginalMetadataPopulated(self, boolean: bool) -> None: ... + def setReaderClassList(self, classList: ClassList[IFormatReader]) -> None: ... + def setResolution(self, int: int) -> None: ... + def setSeries(self, int: int) -> None: ... + def setUsingPatternIds(self, boolean: bool) -> None: ... + +class MinMaxCalculator(ReaderWrapper): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader): ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def close(self) -> None: ... + def getChannelGlobalMaximum(self, int: int) -> float: ... + def getChannelGlobalMinimum(self, int: int) -> float: ... + def getChannelKnownMaximum(self, int: int) -> float: ... + def getChannelKnownMinimum(self, int: int) -> float: ... + def getMinMaxStore(self) -> loci.formats.meta.IMinMaxStore: ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getPlaneMaximum(self, int: int) -> typing.MutableSequence[float]: ... + def getPlaneMinimum(self, int: int) -> typing.MutableSequence[float]: ... + def isMinMaxPopulated(self) -> bool: ... + @staticmethod + def makeMinMaxCalculator(iFormatReader: IFormatReader) -> MinMaxCalculator: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + def setMinMaxStore( + self, iMinMaxStore: loci.formats.meta.IMinMaxStore | typing.Callable + ) -> None: ... + +class SubResolutionFormatReader(FormatReader): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def coreIndexToSeries(self, int: int) -> int: ... + def getCoreIndex(self) -> int: ... + def getCoreMetadataList(self) -> java.util.List[CoreMetadata]: ... + def getResolution(self) -> int: ... + def getResolutionCount(self) -> int: ... + def getSeries(self) -> int: ... + def getSeriesCount(self) -> int: ... + def seriesToCoreIndex(self, int: int) -> int: ... + def setCoreIndex(self, int: int) -> None: ... + def setResolution(self, int: int) -> None: ... + def setSeries(self, int: int) -> None: ... + +class TileStitcher(ReaderWrapper): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader): ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getSeriesCount(self) -> int: ... + def getSizeX(self) -> int: ... + def getSizeY(self) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getTileColumns(self, int: int) -> int: ... + def getTileRows(self, int: int) -> int: ... + @staticmethod + def makeTileStitcher(iFormatReader: IFormatReader) -> TileStitcher: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class WrappedReader(FormatReader): + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def coreIndexToSeries(self, int: int) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getBitsPerPixel(self) -> int: ... + def getCoreIndex(self) -> int: ... + def getCoreMetadataList(self) -> java.util.List[CoreMetadata]: ... + def getDatasetStructureDescription(self) -> java.lang.String: ... + def getDimensionOrder(self) -> java.lang.String: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + def getEffectiveSizeC(self) -> int: ... + def getGlobalMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getImageCount(self) -> int: ... + @typing.overload + def getIndex( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> int: ... + @typing.overload + def getIndex(self, int: int, int2: int, int3: int) -> int: ... + def getMetadataStoreRoot(self) -> typing.Any: ... + def getMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + def getModuloC(self) -> Modulo: ... + def getModuloT(self) -> Modulo: ... + def getModuloZ(self) -> Modulo: ... + def getNativeDataType(self) -> type[typing.Any]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getPixelType(self) -> int: ... + def getPossibleDomains( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + def getRGBChannelCount(self) -> int: ... + def getResolution(self) -> int: ... + def getResolutionCount(self) -> int: ... + def getSeries(self) -> int: ... + def getSeriesCount(self) -> int: ... + def getSeriesMetadata( + self, + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getSeriesMetadataValue(self, string: java.lang.String | str) -> typing.Any: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getSizeC(self) -> int: ... + def getSizeT(self) -> int: ... + def getSizeX(self) -> int: ... + def getSizeY(self) -> int: ... + def getSizeZ(self) -> int: ... + def getThumbSizeX(self) -> int: ... + def getThumbSizeY(self) -> int: ... + def getUnderlyingReaders(self) -> typing.MutableSequence[IFormatReader]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getZCTCoords(self, int: int) -> typing.MutableSequence[int]: ... + def hasCompanionFiles(self) -> bool: ... + def isFalseColor(self) -> bool: ... + def isIndexed(self) -> bool: ... + @typing.overload + def isInterleaved(self) -> bool: ... + @typing.overload + def isInterleaved(self, int: int) -> bool: ... + def isLittleEndian(self) -> bool: ... + def isMetadataComplete(self) -> bool: ... + def isOrderCertain(self) -> bool: ... + def isRGB(self) -> bool: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + def isThumbnailSeries(self) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def seriesToCoreIndex(self, int: int) -> int: ... + def setCoreIndex(self, int: int) -> None: ... + def setResolution(self, int: int) -> None: ... + def setSeries(self, int: int) -> None: ... + +class Memoizer(ReaderWrapper): + VERSION: typing.ClassVar[int] = ... + DEFAULT_MINIMUM_ELAPSED: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader): ... + @typing.overload + def __init__( + self, + iFormatReader: IFormatReader, + file: java.io.File | jpype.protocol.SupportsPath, + ): ... + @typing.overload + def __init__(self, iFormatReader: IFormatReader, long: int): ... + @typing.overload + def __init__( + self, + iFormatReader: IFormatReader, + long: int, + file: java.io.File | jpype.protocol.SupportsPath, + ): ... + @typing.overload + def __init__(self, long: int): ... + @typing.overload + def __init__(self, long: int, file: java.io.File | jpype.protocol.SupportsPath): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def deleteMemo(self) -> bool: ... + def generateMemo(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def getMemoFile(self) -> java.io.File: ... + @typing.overload + def getMemoFile(self, string: java.lang.String | str) -> java.io.File: ... + def getMetadataStore(self) -> loci.formats.meta.MetadataStore: ... + def isLoadedFromMemo(self) -> bool: ... + def isSavedToMemo(self) -> bool: ... + def isVersionChecking(self) -> bool: ... + def loadMemo(self) -> IFormatReader: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def saveMemo(self) -> bool: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setMetadataStore( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> None: ... + def setVersionChecking(self, boolean: bool) -> None: ... + def skipSave(self, boolean: bool) -> None: ... + def versionMismatch(self) -> bool: ... + class Deser: + def close(self) -> None: ... + def loadReader(self) -> IFormatReader: ... + def loadReleaseVersion(self) -> java.lang.String: ... + def loadRevision(self) -> java.lang.String: ... + def loadStart( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> None: ... + def loadStop(self) -> None: ... + def loadVersion(self) -> int: ... + def saveReader(self, iFormatReader: IFormatReader) -> None: ... + def saveReleaseVersion(self, string: java.lang.String | str) -> None: ... + def saveRevision(self, string: java.lang.String | str) -> None: ... + def saveStart( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> None: ... + def saveStop(self) -> None: ... + def saveVersion(self, integer: int) -> None: ... + + class KryoDeser(loci.formats.Memoizer.Deser): + kryo: com.esotericsoftware.kryo.Kryo = ... + def __init__(self): ... + def close(self) -> None: ... + def loadReader(self) -> IFormatReader: ... + def loadReleaseVersion(self) -> java.lang.String: ... + def loadRevision(self) -> java.lang.String: ... + def loadStart( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> None: ... + def loadStop(self) -> None: ... + def loadVersion(self) -> int: ... + def saveReader(self, iFormatReader: IFormatReader) -> None: ... + def saveReleaseVersion(self, string: java.lang.String | str) -> None: ... + def saveRevision(self, string: java.lang.String | str) -> None: ... + def saveStart( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> None: ... + def saveStop(self) -> None: ... + def saveVersion(self, integer: int) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats")``. + + AxisGuesser: type[AxisGuesser] + ChannelFiller: type[ChannelFiller] + ChannelMerger: type[ChannelMerger] + ChannelSeparator: type[ChannelSeparator] + ClassList: type[ClassList] + CoreMetadata: type[CoreMetadata] + CoreMetadataList: type[CoreMetadataList] + DelegateReader: type[DelegateReader] + DimensionSwapper: type[DimensionSwapper] + FileInfo: type[FileInfo] + FilePattern: type[FilePattern] + FilePatternBlock: type[FilePatternBlock] + FileStitcher: type[FileStitcher] + FormatException: type[FormatException] + FormatHandler: type[FormatHandler] + FormatReader: type[FormatReader] + FormatTools: type[FormatTools] + FormatWriter: type[FormatWriter] + ICompressedTileReader: type[ICompressedTileReader] + ICompressedTileWriter: type[ICompressedTileWriter] + IFormatHandler: type[IFormatHandler] + IFormatReader: type[IFormatReader] + IFormatWriter: type[IFormatWriter] + IMetadataConfigurable: type[IMetadataConfigurable] + IPyramidHandler: type[IPyramidHandler] + IllegalBlockException: type[IllegalBlockException] + ImageReader: type[ImageReader] + ImageTools: type[ImageTools] + ImageWriter: type[ImageWriter] + Memoizer: type[Memoizer] + MetadataList: type[MetadataList] + MetadataTools: type[MetadataTools] + MinMaxCalculator: type[MinMaxCalculator] + MissingLibraryException: type[MissingLibraryException] + Modulo: type[Modulo] + NumberFilter: type[NumberFilter] + ReaderWrapper: type[ReaderWrapper] + Resolution: type[Resolution] + ResourceNamer: type[ResourceNamer] + SubResolutionFormatReader: type[SubResolutionFormatReader] + SwappableMetadata: type[SwappableMetadata] + TileStitcher: type[TileStitcher] + UnknownFormatException: type[UnknownFormatException] + UnsupportedCompressionException: type[UnsupportedCompressionException] + UpgradeChecker: type[UpgradeChecker] + WrappedReader: type[WrappedReader] + WriterWrapper: type[WriterWrapper] + cache: loci.formats.cache.__module_protocol__ + codec: loci.formats.codec.__module_protocol__ + dicom: loci.formats.dicom.__module_protocol__ + filter: loci.formats.filter.__module_protocol__ + gui: loci.formats.gui.__module_protocol__ + in_: loci.formats.in_.__module_protocol__ + meta: loci.formats.meta.__module_protocol__ + ome: loci.formats.ome.__module_protocol__ + out: loci.formats.out.__module_protocol__ + services: loci.formats.services.__module_protocol__ + tiff: loci.formats.tiff.__module_protocol__ + tools: loci.formats.tools.__module_protocol__ diff --git a/typings/loci/formats/cache/__init__.pyi b/typings/loci/formats/cache/__init__.pyi new file mode 100644 index 0000000..c3ee337 --- /dev/null +++ b/typings/loci/formats/cache/__init__.pyi @@ -0,0 +1,167 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype +import loci.formats + +class CacheEvent: + SOURCE_CHANGED: typing.ClassVar[int] = ... + STRATEGY_CHANGED: typing.ClassVar[int] = ... + POSITION_CHANGED: typing.ClassVar[int] = ... + PRIORITIES_CHANGED: typing.ClassVar[int] = ... + ORDER_CHANGED: typing.ClassVar[int] = ... + RANGE_CHANGED: typing.ClassVar[int] = ... + OBJECT_LOADED: typing.ClassVar[int] = ... + OBJECT_DROPPED: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, object: typing.Any, int: int): ... + @typing.overload + def __init__(self, object: typing.Any, int: int, int2: int): ... + def getIndex(self) -> int: ... + def getSource(self) -> typing.Any: ... + def getType(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class CacheException(loci.formats.FormatException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class CacheListener: + def cacheUpdated(self, cacheEvent: CacheEvent) -> None: ... + +class CacheReporter: + def addCacheListener( + self, cacheListener: CacheListener | typing.Callable + ) -> None: ... + def getCacheListeners(self) -> typing.MutableSequence[CacheListener]: ... + def removeCacheListener( + self, cacheListener: CacheListener | typing.Callable + ) -> None: ... + +class CacheUpdater(java.lang.Thread): + def __init__(self, cache: Cache): ... + def quit(self) -> None: ... + def run(self) -> None: ... + +class ICacheSource: + def getObject(self, int: int) -> typing.Any: ... + def getObjectCount(self) -> int: ... + +class Cache(CacheReporter): + def __init__( + self, iCacheStrategy: ICacheStrategy, iCacheSource: ICacheSource, boolean: bool + ): ... + def addCacheListener( + self, cacheListener: CacheListener | typing.Callable + ) -> None: ... + def getCacheListeners(self) -> typing.MutableSequence[CacheListener]: ... + def getCurrentPos(self) -> typing.MutableSequence[int]: ... + def getObject(self, intArray: list[int] | jpype.JArray) -> typing.Any: ... + def getSource(self) -> ICacheSource: ... + def getStrategy(self) -> ICacheStrategy: ... + @typing.overload + def isInCache(self, int: int) -> bool: ... + @typing.overload + def isInCache(self, intArray: list[int] | jpype.JArray) -> bool: ... + @typing.overload + def recache(self) -> None: ... + @typing.overload + def recache(self, int: int) -> None: ... + def removeCacheListener( + self, cacheListener: CacheListener | typing.Callable + ) -> None: ... + def reset(self) -> None: ... + def setCurrentPos(self, intArray: list[int] | jpype.JArray) -> None: ... + def setSource(self, iCacheSource: ICacheSource) -> None: ... + def setStrategy(self, iCacheStrategy: ICacheStrategy) -> None: ... + +class CacheSource(ICacheSource): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, iFormatReader: loci.formats.IFormatReader): ... + def getObject(self, int: int) -> typing.Any: ... + def getObjectCount(self) -> int: ... + +class ICacheStrategy(CacheReporter): + MIN_PRIORITY: typing.ClassVar[int] = ... + LOW_PRIORITY: typing.ClassVar[int] = ... + NORMAL_PRIORITY: typing.ClassVar[int] = ... + HIGH_PRIORITY: typing.ClassVar[int] = ... + MAX_PRIORITY: typing.ClassVar[int] = ... + CENTERED_ORDER: typing.ClassVar[int] = ... + FORWARD_ORDER: typing.ClassVar[int] = ... + BACKWARD_ORDER: typing.ClassVar[int] = ... + def getLengths(self) -> typing.MutableSequence[int]: ... + def getLoadList( + self, intArray: list[int] | jpype.JArray + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOrder(self) -> typing.MutableSequence[int]: ... + def getPriorities(self) -> typing.MutableSequence[int]: ... + def getRange(self) -> typing.MutableSequence[int]: ... + def setOrder(self, int: int, int2: int) -> None: ... + def setPriority(self, int: int, int2: int) -> None: ... + def setRange(self, int: int, int2: int) -> None: ... + +class ByteArraySource(CacheSource): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, iFormatReader: loci.formats.IFormatReader): ... + def getObject(self, int: int) -> typing.Any: ... + +class CacheStrategy(CacheReporter, java.util.Comparator, ICacheStrategy): + DEFAULT_RANGE: typing.ClassVar[int] = ... + def __init__(self, intArray: list[int] | jpype.JArray): ... + def addCacheListener( + self, cacheListener: CacheListener | typing.Callable + ) -> None: ... + def compare(self, object: typing.Any, object2: typing.Any) -> int: ... + def distance(self, int: int, int2: int) -> int: ... + def getCacheListeners(self) -> typing.MutableSequence[CacheListener]: ... + def getLengths(self) -> typing.MutableSequence[int]: ... + def getLoadList( + self, intArray: list[int] | jpype.JArray + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOrder(self) -> typing.MutableSequence[int]: ... + def getPriorities(self) -> typing.MutableSequence[int]: ... + def getRange(self) -> typing.MutableSequence[int]: ... + def removeCacheListener( + self, cacheListener: CacheListener | typing.Callable + ) -> None: ... + def setOrder(self, int: int, int2: int) -> None: ... + def setPriority(self, int: int, int2: int) -> None: ... + def setRange(self, int: int, int2: int) -> None: ... + +class CrosshairStrategy(CacheStrategy): + def __init__(self, intArray: list[int] | jpype.JArray): ... + +class RectangleStrategy(CacheStrategy): + def __init__(self, intArray: list[int] | jpype.JArray): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.cache")``. + + ByteArraySource: type[ByteArraySource] + Cache: type[Cache] + CacheEvent: type[CacheEvent] + CacheException: type[CacheException] + CacheListener: type[CacheListener] + CacheReporter: type[CacheReporter] + CacheSource: type[CacheSource] + CacheStrategy: type[CacheStrategy] + CacheUpdater: type[CacheUpdater] + CrosshairStrategy: type[CrosshairStrategy] + ICacheSource: type[ICacheSource] + ICacheStrategy: type[ICacheStrategy] + RectangleStrategy: type[RectangleStrategy] diff --git a/typings/loci/formats/codec/__init__.pyi b/typings/loci/formats/codec/__init__.pyi new file mode 100644 index 0000000..994f604 --- /dev/null +++ b/typings/loci/formats/codec/__init__.pyi @@ -0,0 +1,537 @@ +import typing +from typing import Protocol + +import java.awt.image +import java.lang +import jpype +import loci +import loci.common +import loci.common.enumeration + +class BitBuffer: + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + def getBits(self, int: int) -> int: ... + def getByteBuffer(self) -> typing.MutableSequence[int]: ... + def isBitOnByteBoundary(self) -> bool: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def skipBits(self, long: int) -> None: ... + +class BitWriter: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def toByteArray(self) -> typing.MutableSequence[int]: ... + @typing.overload + def write(self, int: int, int2: int) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + +class ByteVector: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def add(self, byte: int) -> None: ... + @typing.overload + def add(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def add( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def clear(self) -> None: ... + def get(self, int: int) -> int: ... + def size(self) -> int: ... + def toByteArray(self) -> typing.MutableSequence[int]: ... + +class Codec: + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class CodecOptions: + width: int = ... + height: int = ... + channels: int = ... + bitsPerSample: int = ... + littleEndian: bool = ... + interleaved: bool = ... + signed: bool = ... + tileWidth: int = ... + tileHeight: int = ... + tileGridXOffset: int = ... + tileGridYOffset: int = ... + maxBytes: int = ... + previousImage: typing.MutableSequence[int] = ... + lossless: bool = ... + colorModel: java.awt.image.ColorModel = ... + quality: float = ... + ycbcr: bool = ... + disableChromaSubsampling: bool = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, codecOptions: CodecOptions): ... + @staticmethod + def getDefaultOptions() -> CodecOptions: ... + +class CompressionType( + java.lang.Enum["CompressionType"], loci.common.enumeration.CodedEnum +): + UNCOMPRESSED: typing.ClassVar[CompressionType] = ... + ZLIB: typing.ClassVar[CompressionType] = ... + CINEPAK: typing.ClassVar[CompressionType] = ... + ANIMATION: typing.ClassVar[CompressionType] = ... + H_263: typing.ClassVar[CompressionType] = ... + SORENSON: typing.ClassVar[CompressionType] = ... + SORENSON_3: typing.ClassVar[CompressionType] = ... + MPEG_4: typing.ClassVar[CompressionType] = ... + LZW: typing.ClassVar[CompressionType] = ... + J2K: typing.ClassVar[CompressionType] = ... + J2K_LOSSY: typing.ClassVar[CompressionType] = ... + JPEG: typing.ClassVar[CompressionType] = ... + @typing.overload + @staticmethod + def get(int: int) -> CompressionType: ... + @typing.overload + @staticmethod + def get(codec: Codec) -> CompressionType: ... + def getCode(self) -> int: ... + def getCompression(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> CompressionType: ... + @staticmethod + def values() -> typing.MutableSequence[CompressionType]: ... + +class JPEG2000BoxType( + java.lang.Enum["JPEG2000BoxType"], loci.common.enumeration.CodedEnum +): + SIGNATURE: typing.ClassVar[JPEG2000BoxType] = ... + SIGNATURE_WRONG_ENDIANNESS: typing.ClassVar[JPEG2000BoxType] = ... + FILE: typing.ClassVar[JPEG2000BoxType] = ... + HEADER: typing.ClassVar[JPEG2000BoxType] = ... + IMAGE_HEADER: typing.ClassVar[JPEG2000BoxType] = ... + BITS_PER_COMPONENT: typing.ClassVar[JPEG2000BoxType] = ... + COLOUR_SPECIFICATION: typing.ClassVar[JPEG2000BoxType] = ... + PALETTE: typing.ClassVar[JPEG2000BoxType] = ... + COMPONENT_MAPPING: typing.ClassVar[JPEG2000BoxType] = ... + CHANNEL_DEFINITION: typing.ClassVar[JPEG2000BoxType] = ... + RESOLUTION: typing.ClassVar[JPEG2000BoxType] = ... + CAPTURE_RESOLUTION: typing.ClassVar[JPEG2000BoxType] = ... + DEFAULT_DISPLAY_RESOLUTION: typing.ClassVar[JPEG2000BoxType] = ... + CONTIGUOUS_CODESTREAM: typing.ClassVar[JPEG2000BoxType] = ... + INTELLECTUAL_PROPERTY: typing.ClassVar[JPEG2000BoxType] = ... + XML: typing.ClassVar[JPEG2000BoxType] = ... + UUID: typing.ClassVar[JPEG2000BoxType] = ... + UUID_INFO: typing.ClassVar[JPEG2000BoxType] = ... + UUID_LIST: typing.ClassVar[JPEG2000BoxType] = ... + URL: typing.ClassVar[JPEG2000BoxType] = ... + ASSOCIATION: typing.ClassVar[JPEG2000BoxType] = ... + LABEL: typing.ClassVar[JPEG2000BoxType] = ... + PLACEHOLDER: typing.ClassVar[JPEG2000BoxType] = ... + @staticmethod + def get(int: int) -> JPEG2000BoxType: ... + def getCode(self) -> int: ... + def getName(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> JPEG2000BoxType: ... + @staticmethod + def values() -> typing.MutableSequence[JPEG2000BoxType]: ... + +class JPEG2000SegmentMarker( + java.lang.Enum["JPEG2000SegmentMarker"], loci.common.enumeration.CodedEnum +): + RESERVED_DELIMITER_MARKER_MIN: typing.ClassVar[JPEG2000SegmentMarker] = ... + RESERVED_DELIMITER_MARKER_MAX: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOC: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOC_WRONG_ENDIANNESS: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOT: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOD: typing.ClassVar[JPEG2000SegmentMarker] = ... + EOC: typing.ClassVar[JPEG2000SegmentMarker] = ... + SIZ: typing.ClassVar[JPEG2000SegmentMarker] = ... + COD: typing.ClassVar[JPEG2000SegmentMarker] = ... + COC: typing.ClassVar[JPEG2000SegmentMarker] = ... + RGN: typing.ClassVar[JPEG2000SegmentMarker] = ... + QCD: typing.ClassVar[JPEG2000SegmentMarker] = ... + QCC: typing.ClassVar[JPEG2000SegmentMarker] = ... + POC: typing.ClassVar[JPEG2000SegmentMarker] = ... + TLM: typing.ClassVar[JPEG2000SegmentMarker] = ... + PLM: typing.ClassVar[JPEG2000SegmentMarker] = ... + PLT: typing.ClassVar[JPEG2000SegmentMarker] = ... + PPM: typing.ClassVar[JPEG2000SegmentMarker] = ... + PPT: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOP: typing.ClassVar[JPEG2000SegmentMarker] = ... + EPH: typing.ClassVar[JPEG2000SegmentMarker] = ... + CRG: typing.ClassVar[JPEG2000SegmentMarker] = ... + COM: typing.ClassVar[JPEG2000SegmentMarker] = ... + @staticmethod + def get(int: int) -> JPEG2000SegmentMarker: ... + def getCode(self) -> int: ... + def getName(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> JPEG2000SegmentMarker: ... + @staticmethod + def values() -> typing.MutableSequence[JPEG2000SegmentMarker]: ... + +class JPEGTileDecoder(java.lang.AutoCloseable): + def __init__(self): ... + def close(self) -> None: ... + def getHeight(self) -> int: ... + def getScanline(self, int: int) -> typing.MutableSequence[int]: ... + def getWidth(self) -> int: ... + @typing.overload + def initialize(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def initialize( + self, randomAccessInputStream: loci.common.RandomAccessInputStream, int: int + ) -> None: ... + @typing.overload + def initialize( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + int2: int, + int3: int, + ) -> None: ... + def preprocess( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> typing.MutableSequence[int]: ... + +class BaseCodec(Codec): + def __init__(self): ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + def test(self) -> None: ... + +class HuffmanCodecOptions(CodecOptions): + table: typing.MutableSequence[int] = ... + def __init__(self): ... + +class JPEG2000CodecOptions(CodecOptions): + codeBlockSize: typing.MutableSequence[int] = ... + numDecompositionLevels: int = ... + resolution: int = ... + writeBox: bool = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, codecOptions: CodecOptions): ... + @typing.overload + @staticmethod + def getDefaultOptions() -> CodecOptions: ... + @typing.overload + @staticmethod + def getDefaultOptions() -> JPEG2000CodecOptions: ... + @typing.overload + @staticmethod + def getDefaultOptions(codecOptions: CodecOptions) -> JPEG2000CodecOptions: ... + +class MJPBCodecOptions(CodecOptions): + interlaced: bool = ... + def __init__(self): ... + +class NikonCodecOptions(CodecOptions): + curve: typing.MutableSequence[int] = ... + vPredictor: typing.MutableSequence[int] = ... + split: int = ... + def __init__(self): ... + +class JPEGXRCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class NikonCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class TargaRLECodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class Base64Codec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class HuffmanCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + @typing.overload + def getSample( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> int: ... + @typing.overload + def getSample(self, bitBuffer: BitBuffer, codecOptions: CodecOptions) -> int: ... + +class JPEG2000Codec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class JPEGCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class LZOCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class LZWCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class LosslessJPEGCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class MJPBCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class MSRLECodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class MSVideoCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class PackbitsCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class PassthroughCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class QTRLECodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class RPZACodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class ZlibCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + +class ZstdCodec(loci.formats.codec.WrappedCodec): + def __init__(self): ... + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + +class WrappedCodec: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.codec")``. + + Base64Codec: type[Base64Codec] + BaseCodec: type[BaseCodec] + BitBuffer: type[BitBuffer] + BitWriter: type[BitWriter] + ByteVector: type[ByteVector] + Codec: type[Codec] + CodecOptions: type[CodecOptions] + CompressionType: type[CompressionType] + HuffmanCodec: type[HuffmanCodec] + HuffmanCodecOptions: type[HuffmanCodecOptions] + JPEG2000BoxType: type[JPEG2000BoxType] + JPEG2000Codec: type[JPEG2000Codec] + JPEG2000CodecOptions: type[JPEG2000CodecOptions] + JPEG2000SegmentMarker: type[JPEG2000SegmentMarker] + JPEGCodec: type[JPEGCodec] + JPEGTileDecoder: type[JPEGTileDecoder] + JPEGXRCodec: type[JPEGXRCodec] + LZOCodec: type[LZOCodec] + LZWCodec: type[LZWCodec] + LosslessJPEGCodec: type[LosslessJPEGCodec] + MJPBCodec: type[MJPBCodec] + MJPBCodecOptions: type[MJPBCodecOptions] + MSRLECodec: type[MSRLECodec] + MSVideoCodec: type[MSVideoCodec] + NikonCodec: type[NikonCodec] + NikonCodecOptions: type[NikonCodecOptions] + PackbitsCodec: type[PackbitsCodec] + PassthroughCodec: type[PassthroughCodec] + QTRLECodec: type[QTRLECodec] + RPZACodec: type[RPZACodec] + TargaRLECodec: type[TargaRLECodec] + WrappedCodec: type[WrappedCodec] + ZlibCodec: type[ZlibCodec] + ZstdCodec: type[ZstdCodec] diff --git a/typings/loci/formats/dicom/__init__.pyi b/typings/loci/formats/dicom/__init__.pyi new file mode 100644 index 0000000..5522812 --- /dev/null +++ b/typings/loci/formats/dicom/__init__.pyi @@ -0,0 +1,929 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import loci.common +import loci.formats +import ome.units.quantity +import ome.xml.model.primitives + +class DicomAttribute(java.lang.Enum["DicomAttribute"]): + FILE_META_INFO_GROUP_LENGTH: typing.ClassVar[DicomAttribute] = ... + FILE_META_INFO_VERSION: typing.ClassVar[DicomAttribute] = ... + MEDIA_SOP_CLASS_UID: typing.ClassVar[DicomAttribute] = ... + MEDIA_SOP_INSTANCE_UID: typing.ClassVar[DicomAttribute] = ... + TRANSFER_SYNTAX_UID: typing.ClassVar[DicomAttribute] = ... + IMPLEMENTATION_UID: typing.ClassVar[DicomAttribute] = ... + IMPLEMENTATION_VERSION: typing.ClassVar[DicomAttribute] = ... + SOURCE_APPLICATION: typing.ClassVar[DicomAttribute] = ... + SPECIFIC_CHARSET: typing.ClassVar[DicomAttribute] = ... + IMAGE_TYPE: typing.ClassVar[DicomAttribute] = ... + RECOGNITION_CODE: typing.ClassVar[DicomAttribute] = ... + CREATION_DATE: typing.ClassVar[DicomAttribute] = ... + CREATION_TIME: typing.ClassVar[DicomAttribute] = ... + INSTANCE_CREATOR: typing.ClassVar[DicomAttribute] = ... + SOP_CLASS_UID: typing.ClassVar[DicomAttribute] = ... + SOP_INSTANCE_UID: typing.ClassVar[DicomAttribute] = ... + RELATED_SOP_CLASS_UID: typing.ClassVar[DicomAttribute] = ... + ORIGINAL_SOP_CLASS_UID: typing.ClassVar[DicomAttribute] = ... + STUDY_DATE: typing.ClassVar[DicomAttribute] = ... + SERIES_DATE: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_DATE: typing.ClassVar[DicomAttribute] = ... + CONTENT_DATE: typing.ClassVar[DicomAttribute] = ... + OVERLAY_DATE: typing.ClassVar[DicomAttribute] = ... + CURVE_DATE: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_TIMESTAMP: typing.ClassVar[DicomAttribute] = ... + STUDY_TIME: typing.ClassVar[DicomAttribute] = ... + SERIES_TIME: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_TIME: typing.ClassVar[DicomAttribute] = ... + CONTENT_TIME: typing.ClassVar[DicomAttribute] = ... + OVERLAY_TIME: typing.ClassVar[DicomAttribute] = ... + CURVE_TIME: typing.ClassVar[DicomAttribute] = ... + DATASET_SUBTYPE: typing.ClassVar[DicomAttribute] = ... + ACCESSION_NUMBER: typing.ClassVar[DicomAttribute] = ... + QUERY_LEVEL: typing.ClassVar[DicomAttribute] = ... + RETRIEVE_TITLE: typing.ClassVar[DicomAttribute] = ... + INSTANCE_AVAILABILITY: typing.ClassVar[DicomAttribute] = ... + FAILED_SOP_UID_LIST: typing.ClassVar[DicomAttribute] = ... + MODALITY: typing.ClassVar[DicomAttribute] = ... + MODALITIES_IN_STUDY: typing.ClassVar[DicomAttribute] = ... + CLASSES_IN_STUDY: typing.ClassVar[DicomAttribute] = ... + CONVERSION_TYPE: typing.ClassVar[DicomAttribute] = ... + PRESENTATION_INTENT_TYPE: typing.ClassVar[DicomAttribute] = ... + MANUFACTURER: typing.ClassVar[DicomAttribute] = ... + INSTITUTION_NAME: typing.ClassVar[DicomAttribute] = ... + INSTITUTION_ADDRESS: typing.ClassVar[DicomAttribute] = ... + INSTITUTION_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERRING_PHYSICIAN_NAME: typing.ClassVar[DicomAttribute] = ... + REFERRING_PHYSICIAN_ADDRESS: typing.ClassVar[DicomAttribute] = ... + REFERRING_PHYSICIAN_TELEPHONE: typing.ClassVar[DicomAttribute] = ... + REFERRING_PHYSICIAN_ID: typing.ClassVar[DicomAttribute] = ... + CODE_VALUE: typing.ClassVar[DicomAttribute] = ... + CODING_SCHEME_DESIGNATOR: typing.ClassVar[DicomAttribute] = ... + CODING_SCHEME_VERSION: typing.ClassVar[DicomAttribute] = ... + CODE_MEANING: typing.ClassVar[DicomAttribute] = ... + MAPPING_RESOURCE: typing.ClassVar[DicomAttribute] = ... + CONTEXT_GROUP_VERSION: typing.ClassVar[DicomAttribute] = ... + CONTEXT_GROUP_LOCAL_VERSION: typing.ClassVar[DicomAttribute] = ... + CONTEXT_GROUP_EXTENSION_FLAG: typing.ClassVar[DicomAttribute] = ... + CODING_SCHEME_UID: typing.ClassVar[DicomAttribute] = ... + CONTEXT_GROUP_EXTENSION_CREATOR: typing.ClassVar[DicomAttribute] = ... + CONTEXT_ID: typing.ClassVar[DicomAttribute] = ... + CODING_SCHEME_ID: typing.ClassVar[DicomAttribute] = ... + CODING_SCHEME_REGISTRY: typing.ClassVar[DicomAttribute] = ... + CODING_SCHEME_EXTERNAL_ID: typing.ClassVar[DicomAttribute] = ... + CODING_SCHEME_NAME: typing.ClassVar[DicomAttribute] = ... + RESPONSIBLE_ORGANIZATION: typing.ClassVar[DicomAttribute] = ... + TIMEZONE_OFFSET_UTC: typing.ClassVar[DicomAttribute] = ... + STATION_NAME: typing.ClassVar[DicomAttribute] = ... + STUDY_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + PROCEDURE_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SERIES_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + INSTITUTIONAL_DEPARTMENT_NAME: typing.ClassVar[DicomAttribute] = ... + PHYSICIANS: typing.ClassVar[DicomAttribute] = ... + PHYSICIANS_ID: typing.ClassVar[DicomAttribute] = ... + PHYSICIAN_NAME: typing.ClassVar[DicomAttribute] = ... + PHYSICIAN_ID: typing.ClassVar[DicomAttribute] = ... + PHYSICIAN_READING: typing.ClassVar[DicomAttribute] = ... + PHYSICIAN_READING_ID: typing.ClassVar[DicomAttribute] = ... + OPERATOR_NAME: typing.ClassVar[DicomAttribute] = ... + OPERATOR_ID: typing.ClassVar[DicomAttribute] = ... + ADMITTING_DIAGNOSES_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + ADMITTING_DIAGNOSES_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + MANUFACTURER_MODEL_NAME: typing.ClassVar[DicomAttribute] = ... + REFERENCED_RESULTS_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_STUDY_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_PERFORMED_PROCEDURE_STEP: typing.ClassVar[DicomAttribute] = ... + REFERENCED_SERIES_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_PATIENT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_VISIT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_OVERLAY_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_WAVEFORM_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_IMAGE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_CURVE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_INSTANCE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_SOP_CLASS_UID: typing.ClassVar[DicomAttribute] = ... + REFERENCED_SOP_INSTANCE_UID: typing.ClassVar[DicomAttribute] = ... + SOP_CLASSES_SUPPORTED: typing.ClassVar[DicomAttribute] = ... + REFERENCED_FRAME_NUMBER: typing.ClassVar[DicomAttribute] = ... + TRANSACTION_UID: typing.ClassVar[DicomAttribute] = ... + FAILURE_REASON: typing.ClassVar[DicomAttribute] = ... + FAILED_SOP_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_SOP_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + STUDIES_WITH_REFERENCED_INSTANCES: typing.ClassVar[DicomAttribute] = ... + RELATED_SERIES_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + DERIVATION_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + SOURCE_IMAGE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + STAGE_NAME: typing.ClassVar[DicomAttribute] = ... + STAGE_NUMBER: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_STAGES: typing.ClassVar[DicomAttribute] = ... + VIEW_NAME: typing.ClassVar[DicomAttribute] = ... + VIEW_NUMBER: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_EVENT_TIMERS: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_VIEWS_STAGE: typing.ClassVar[DicomAttribute] = ... + EVENT_ELAPSED_TIME: typing.ClassVar[DicomAttribute] = ... + EVENT_TIMER_NAME: typing.ClassVar[DicomAttribute] = ... + START_TRIM: typing.ClassVar[DicomAttribute] = ... + STOP_TRIM: typing.ClassVar[DicomAttribute] = ... + RECOMMENDED_DISPLAY_FRAMERATE: typing.ClassVar[DicomAttribute] = ... + ANATOMIC_REGION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + ANATOMIC_REGION_MODIFIER_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + PRIMARY_ANATOMIC_STRUCTURE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + ANATOMIC_STRUCTURE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + PRIMARY_ANATOMIC_STRUCTURE_MODIFIER: typing.ClassVar[DicomAttribute] = ... + TRANSDUCER_POSITION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + TRANSDUCER_POSITION_MODIFIER_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + TRANSDUCER_ORIENTATION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + TRANSDUCER_ORIENTATION_MODIFIER: typing.ClassVar[DicomAttribute] = ... + ALTERNATE_REPRESENTATION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + FRAME_TYPE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_IMAGE_EVIDENCE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_RAW_DATA_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + CREATOR_VERSION_UID: typing.ClassVar[DicomAttribute] = ... + DERIVATION_IMAGE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SOURCE_IMAGE_EVIDENCE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + PIXEL_PRESENTATION: typing.ClassVar[DicomAttribute] = ... + VOLUMETRIC_PROPERTIES: typing.ClassVar[DicomAttribute] = ... + VOLUME_BASED_CALCULATION_TECHNIQUE: typing.ClassVar[DicomAttribute] = ... + COMPLEX_IMAGE_COMPONENT: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_CONTRAST: typing.ClassVar[DicomAttribute] = ... + DERIVATION_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCE_GRAYSCALE_PRESENTATION_STATE: typing.ClassVar[DicomAttribute] = ... + PATIENT_NAME: typing.ClassVar[DicomAttribute] = ... + PATIENT_ID: typing.ClassVar[DicomAttribute] = ... + ISSUER_OF_PATIENT_ID: typing.ClassVar[DicomAttribute] = ... + PATIENT_BIRTH_DATE: typing.ClassVar[DicomAttribute] = ... + PATIENT_BIRTH_TIME: typing.ClassVar[DicomAttribute] = ... + PATIENT_SEX: typing.ClassVar[DicomAttribute] = ... + PATIENT_INSURANCE_PLAN_CODE: typing.ClassVar[DicomAttribute] = ... + PATIENT_PRIMARY_LANGUAGE_CODE: typing.ClassVar[DicomAttribute] = ... + PATIENT_PRIMARY_LANGUAGE_MODIFIER: typing.ClassVar[DicomAttribute] = ... + OTHER_PATIENT_IDS: typing.ClassVar[DicomAttribute] = ... + OTHER_PATIENT_NAMES: typing.ClassVar[DicomAttribute] = ... + PATIENT_BIRTH_NAME: typing.ClassVar[DicomAttribute] = ... + PATIENT_AGE: typing.ClassVar[DicomAttribute] = ... + PATIENT_SIZE: typing.ClassVar[DicomAttribute] = ... + PATIENT_WEIGHT: typing.ClassVar[DicomAttribute] = ... + PATIENT_ADDRESS: typing.ClassVar[DicomAttribute] = ... + PATIENT_MOTHER_BIRTH_NAME: typing.ClassVar[DicomAttribute] = ... + MILITARY_RANK: typing.ClassVar[DicomAttribute] = ... + BRANCH_OF_SERVICE: typing.ClassVar[DicomAttribute] = ... + MEDICAL_RECORD_LOCATOR: typing.ClassVar[DicomAttribute] = ... + MEDICAL_ALERTS: typing.ClassVar[DicomAttribute] = ... + CONTRAST_ALLERGIES: typing.ClassVar[DicomAttribute] = ... + COUNTRY_OF_RESIDENCE: typing.ClassVar[DicomAttribute] = ... + REGION_OF_RESIDENCE: typing.ClassVar[DicomAttribute] = ... + PATIENT_TELEPHONE_NUMBER: typing.ClassVar[DicomAttribute] = ... + ETHNIC_GROUP: typing.ClassVar[DicomAttribute] = ... + OCCUPATION: typing.ClassVar[DicomAttribute] = ... + SMOKING_STATUS: typing.ClassVar[DicomAttribute] = ... + ADDITIONAL_PATIENT_HISTORY: typing.ClassVar[DicomAttribute] = ... + PREGNANCY_STATUS: typing.ClassVar[DicomAttribute] = ... + LAST_MENSTRUAL_DATE: typing.ClassVar[DicomAttribute] = ... + PATIENT_RELIGIOUS_PREFERENCE: typing.ClassVar[DicomAttribute] = ... + PATIENT_COMMENTS: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_SPONSOR_NAME: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_PROTOCOL_ID: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_PROTOCOL_NAME: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_SITE_ID: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_SITE_NAME: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_SUBJECT_ID: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_SUBJECT_READING_ID: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_TIME_POINT_ID: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_TIME_POINT_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + CLINICAL_TRIAL_COORDINATING_CENTER: typing.ClassVar[DicomAttribute] = ... + CONTRAST_BOLUS_AGENT: typing.ClassVar[DicomAttribute] = ... + CONTRAST_BOLUS_AGENT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + CONTRAST_BOLUS_ADMIN_ROUTE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + BODY_PART_EXAMINED: typing.ClassVar[DicomAttribute] = ... + SCANNING_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SEQUENCE_VARIANT: typing.ClassVar[DicomAttribute] = ... + SCAN_OPTIONS: typing.ClassVar[DicomAttribute] = ... + MR_ACQUISITION_TYPE: typing.ClassVar[DicomAttribute] = ... + SEQUENCE_NAME: typing.ClassVar[DicomAttribute] = ... + ANGIO_FLAG: typing.ClassVar[DicomAttribute] = ... + INTERVENTION_DRUG_INFORMATION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + INTERVENTION_DRUG_STOP_TIME: typing.ClassVar[DicomAttribute] = ... + INTERVENTION_DRUG_DOSE: typing.ClassVar[DicomAttribute] = ... + INTERVENTION_DRUG_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + ADDITIONAL_DRUG_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + RADIOPHARMACEUTICAL: typing.ClassVar[DicomAttribute] = ... + INTERVENTION_DRUG_NAME: typing.ClassVar[DicomAttribute] = ... + INTERVENTION_DRUG_START_TIME: typing.ClassVar[DicomAttribute] = ... + INTERVENTION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + INTERVENTION_STATUS: typing.ClassVar[DicomAttribute] = ... + INTERVENTION_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + CINE_RATE: typing.ClassVar[DicomAttribute] = ... + SLICE_THICKNESS: typing.ClassVar[DicomAttribute] = ... + KVP: typing.ClassVar[DicomAttribute] = ... + COUNTS_ACCUMULATED: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_TERMINATION_CONDITION: typing.ClassVar[DicomAttribute] = ... + EFFECTIVE_DURATION: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_START_CONDITION: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_START_CONDITION_DATA: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_TERMINATION_CONDITION_DATA: typing.ClassVar[DicomAttribute] = ... + REPETITION_TIME: typing.ClassVar[DicomAttribute] = ... + ECHO_TIME: typing.ClassVar[DicomAttribute] = ... + INVERSION_TIME: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_AVERAGES: typing.ClassVar[DicomAttribute] = ... + IMAGING_FREQUENCY: typing.ClassVar[DicomAttribute] = ... + IMAGED_NUCLEUS: typing.ClassVar[DicomAttribute] = ... + ECHO_NUMBER: typing.ClassVar[DicomAttribute] = ... + MAGNETIC_FIELD_STRENGTH: typing.ClassVar[DicomAttribute] = ... + SLICE_SPACING: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_PHASE_ENCODING_STEPS: typing.ClassVar[DicomAttribute] = ... + DATA_COLLECTION_DIAMETER: typing.ClassVar[DicomAttribute] = ... + ECHO_TRAIN_LENGTH: typing.ClassVar[DicomAttribute] = ... + PERCENT_SAMPLING: typing.ClassVar[DicomAttribute] = ... + PERCENT_PHASE_FOV: typing.ClassVar[DicomAttribute] = ... + PIXEL_BANDWIDTH: typing.ClassVar[DicomAttribute] = ... + DEVICE_SERIAL_NUMBER: typing.ClassVar[DicomAttribute] = ... + PLATE_ID: typing.ClassVar[DicomAttribute] = ... + SECONDARY_CAPTURE_DEVICE_ID: typing.ClassVar[DicomAttribute] = ... + HARDCOPY_CREATION_DEVICE_ID: typing.ClassVar[DicomAttribute] = ... + DATE_OF_SECONDARY_CAPTURE: typing.ClassVar[DicomAttribute] = ... + TIME_OF_SECONDARY_CAPTURE: typing.ClassVar[DicomAttribute] = ... + SECONDARY_CAPTURE_DEVICE_MANUFACTURER: typing.ClassVar[DicomAttribute] = ... + HARDCOPY_DEVICE_MANUFACTURER: typing.ClassVar[DicomAttribute] = ... + SECONDARY_CAPTURE_DEVICE_MODEL_NAME: typing.ClassVar[DicomAttribute] = ... + SECONDARY_CAPTURE_DEVICE_SOFTWARE_VERSION: typing.ClassVar[DicomAttribute] = ... + HARDCOPY_DEVICE_SOFTWARE_VERSION: typing.ClassVar[DicomAttribute] = ... + HARDCOPY_DEVICE_MODEL_NAME: typing.ClassVar[DicomAttribute] = ... + SOFTWARE_VERSION: typing.ClassVar[DicomAttribute] = ... + VIDEO_IMAGE_FORMAT_ACQUIRED: typing.ClassVar[DicomAttribute] = ... + DIGITAL_IMAGE_FORMAT_ACQUIRED: typing.ClassVar[DicomAttribute] = ... + PROTOCOL_NAME: typing.ClassVar[DicomAttribute] = ... + CONTRAST_BOLUS_ROUTE: typing.ClassVar[DicomAttribute] = ... + CONTRAST_BOLUS_VOLUME: typing.ClassVar[DicomAttribute] = ... + CONTRAST_BOLUS_START_TIME: typing.ClassVar[DicomAttribute] = ... + CONTRAST_BOLUS_STOP_TIME: typing.ClassVar[DicomAttribute] = ... + CONTRAST_BOLUS_TOTAL_DOSE: typing.ClassVar[DicomAttribute] = ... + SYRINGE_COUNTS: typing.ClassVar[DicomAttribute] = ... + CONTRAST_FLOW_RATE: typing.ClassVar[DicomAttribute] = ... + CONTRAST_FLOW_DURATION: typing.ClassVar[DicomAttribute] = ... + CONTRAST_BOLUS_INGREDIENT: typing.ClassVar[DicomAttribute] = ... + CONTRAST_INGREDIENT_CONCENTRATION: typing.ClassVar[DicomAttribute] = ... + SPATIAL_RESOLUTION: typing.ClassVar[DicomAttribute] = ... + TRIGGER_TIME: typing.ClassVar[DicomAttribute] = ... + TRIGGER_SOURCE_OR_TYPE: typing.ClassVar[DicomAttribute] = ... + NOMINAL_INTERVAL: typing.ClassVar[DicomAttribute] = ... + FRAME_TIME: typing.ClassVar[DicomAttribute] = ... + FRAMING_TYPE: typing.ClassVar[DicomAttribute] = ... + FRAME_TIME_VECTOR: typing.ClassVar[DicomAttribute] = ... + FRAME_DELAY: typing.ClassVar[DicomAttribute] = ... + IMAGE_TRIGGER_DELAY: typing.ClassVar[DicomAttribute] = ... + MULTIPLEX_GROUP_TIME_OFFSET: typing.ClassVar[DicomAttribute] = ... + TRIGGER_TIME_OFFSET: typing.ClassVar[DicomAttribute] = ... + SYNCHRONIZATION_TRIGGER: typing.ClassVar[DicomAttribute] = ... + SYNCHRONIZATION_CHANNEL: typing.ClassVar[DicomAttribute] = ... + TRIGGER_SAMPLE_POSITION: typing.ClassVar[DicomAttribute] = ... + RADIOPHARMACEUTICAL_ROUTE: typing.ClassVar[DicomAttribute] = ... + RADIOPHARMACEUTICAL_VOLUME: typing.ClassVar[DicomAttribute] = ... + RADIOPHARMACEUTICAL_START_TIME: typing.ClassVar[DicomAttribute] = ... + RADIOPHARMACEUTICAL_STOP_TIME: typing.ClassVar[DicomAttribute] = ... + RADIONUCLIDE_TOTAL_DOSE: typing.ClassVar[DicomAttribute] = ... + RADIONUCLIDE_HALF_LIFE: typing.ClassVar[DicomAttribute] = ... + RADIONUCLIDE_POSITRON_FRACTION: typing.ClassVar[DicomAttribute] = ... + RADIOPHARMACEUTICAL_SPECIFIC_ACTIVITY: typing.ClassVar[DicomAttribute] = ... + BEAT_REJECTION_FLAG: typing.ClassVar[DicomAttribute] = ... + LOW_RR_VALUE: typing.ClassVar[DicomAttribute] = ... + HIGH_RR_VALUE: typing.ClassVar[DicomAttribute] = ... + INTERVALS_ACQUIRED: typing.ClassVar[DicomAttribute] = ... + INTERVALS_REJECTED: typing.ClassVar[DicomAttribute] = ... + PVC_REJECTION: typing.ClassVar[DicomAttribute] = ... + SKIP_BEATS: typing.ClassVar[DicomAttribute] = ... + HEART_RATE: typing.ClassVar[DicomAttribute] = ... + CARDIAC_NUMBER_OF_IMAGES: typing.ClassVar[DicomAttribute] = ... + TRIGGER_WINDOW: typing.ClassVar[DicomAttribute] = ... + RECONSTRUCTION_DIAMETER: typing.ClassVar[DicomAttribute] = ... + DISTANCE_SOURCE_TO_DETECTOR: typing.ClassVar[DicomAttribute] = ... + DISTANCE_SOURCE_TO_PATIENT: typing.ClassVar[DicomAttribute] = ... + ESTIMATED_RADIOGRAPHIC_MAG_FACTOR: typing.ClassVar[DicomAttribute] = ... + GANTRY_DETECTOR_TILT: typing.ClassVar[DicomAttribute] = ... + GANTRY_DETECTOR_SKEW: typing.ClassVar[DicomAttribute] = ... + TABLE_HEIGHT: typing.ClassVar[DicomAttribute] = ... + TABLE_TRAVERSE: typing.ClassVar[DicomAttribute] = ... + TABLE_MOTION: typing.ClassVar[DicomAttribute] = ... + TABLE_VERTICAL_INCREMENT: typing.ClassVar[DicomAttribute] = ... + TABLE_LATERAL_INCREMENT: typing.ClassVar[DicomAttribute] = ... + TABLE_LONGITUDINAL_INCREMENT: typing.ClassVar[DicomAttribute] = ... + TABLE_ANGLE: typing.ClassVar[DicomAttribute] = ... + TABLE_TYPE: typing.ClassVar[DicomAttribute] = ... + ROTATION_DIRECTION: typing.ClassVar[DicomAttribute] = ... + ANGULAR_POSITION: typing.ClassVar[DicomAttribute] = ... + RADIAL_POSITION: typing.ClassVar[DicomAttribute] = ... + SCAN_ARC: typing.ClassVar[DicomAttribute] = ... + ANGULAR_STEP: typing.ClassVar[DicomAttribute] = ... + CENTER_OF_ROTATION_OFFSET: typing.ClassVar[DicomAttribute] = ... + FOV_SHAPE: typing.ClassVar[DicomAttribute] = ... + FOV_DIMENSIONS: typing.ClassVar[DicomAttribute] = ... + EXPOSURE_TIME: typing.ClassVar[DicomAttribute] = ... + XRAY_TUBE_CURRENT: typing.ClassVar[DicomAttribute] = ... + EXPOSURE: typing.ClassVar[DicomAttribute] = ... + EXPOSURE_IN_UAS: typing.ClassVar[DicomAttribute] = ... + AVERAGE_PULSE_WIDTH: typing.ClassVar[DicomAttribute] = ... + RADIATION_SETTING: typing.ClassVar[DicomAttribute] = ... + RECTIFICATION_TYPE: typing.ClassVar[DicomAttribute] = ... + RADIATION_MODE: typing.ClassVar[DicomAttribute] = ... + IMAGE_AREA_DOSE_PRODUCT: typing.ClassVar[DicomAttribute] = ... + FILTER_TYPE: typing.ClassVar[DicomAttribute] = ... + TYPE_OF_FILTERS: typing.ClassVar[DicomAttribute] = ... + INTENSIFIER_SIZE: typing.ClassVar[DicomAttribute] = ... + IMAGER_PIXEL_SPACING: typing.ClassVar[DicomAttribute] = ... + GRID: typing.ClassVar[DicomAttribute] = ... + GENERATOR_POWER: typing.ClassVar[DicomAttribute] = ... + COLLIMATOR_GRID_NAME: typing.ClassVar[DicomAttribute] = ... + COLLIMATOR_TYPE: typing.ClassVar[DicomAttribute] = ... + FOCAL_DISTANCE: typing.ClassVar[DicomAttribute] = ... + X_FOCUS_CENTER: typing.ClassVar[DicomAttribute] = ... + Y_FOCUS_CENTER: typing.ClassVar[DicomAttribute] = ... + FOCAL_SPOTS: typing.ClassVar[DicomAttribute] = ... + ANODE_TARGET_MATERIAL: typing.ClassVar[DicomAttribute] = ... + BODY_PART_THICKNESS: typing.ClassVar[DicomAttribute] = ... + COMPRESSION_FORCE: typing.ClassVar[DicomAttribute] = ... + DATE_OF_LAST_CALIBRATION: typing.ClassVar[DicomAttribute] = ... + TIME_OF_LAST_CALIBRATION: typing.ClassVar[DicomAttribute] = ... + CONVOLUTION_KERNEL: typing.ClassVar[DicomAttribute] = ... + ACTUAL_FRAME_DURATION: typing.ClassVar[DicomAttribute] = ... + COUNT_RATE: typing.ClassVar[DicomAttribute] = ... + PREFERRED_PLAYBACK_SEQUENCING: typing.ClassVar[DicomAttribute] = ... + RECEIVE_COIL_NAME: typing.ClassVar[DicomAttribute] = ... + TRANSMIT_COIL_NAME: typing.ClassVar[DicomAttribute] = ... + PLATE_TYPE: typing.ClassVar[DicomAttribute] = ... + PHOSPHOR_TYPE: typing.ClassVar[DicomAttribute] = ... + SCAN_VELOCITY: typing.ClassVar[DicomAttribute] = ... + WHOLE_BODY_TECHNIQUE: typing.ClassVar[DicomAttribute] = ... + SCAN_LENGTH: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_MATRIX: typing.ClassVar[DicomAttribute] = ... + INPLANE_PHASE_ENCODING_DIRECTION: typing.ClassVar[DicomAttribute] = ... + FLIP_ANGLE: typing.ClassVar[DicomAttribute] = ... + VARIABLE_FLIP_ANGLE_FLAG: typing.ClassVar[DicomAttribute] = ... + SAR: typing.ClassVar[DicomAttribute] = ... + DB_DT: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_DEVICE_PROCESSING_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_DEVICE_PROCESSING_CODE: typing.ClassVar[DicomAttribute] = ... + CASSETTE_ORIENTATION: typing.ClassVar[DicomAttribute] = ... + CASSETTE_SIZE: typing.ClassVar[DicomAttribute] = ... + EXPOSURES_ON_PLATE: typing.ClassVar[DicomAttribute] = ... + RELATIVE_XRAY_EXPOSURE: typing.ClassVar[DicomAttribute] = ... + COLUMN_ANGULATION: typing.ClassVar[DicomAttribute] = ... + TOMO_LAYER_HEIGHT: typing.ClassVar[DicomAttribute] = ... + TOMO_ANGLE: typing.ClassVar[DicomAttribute] = ... + TOMO_TIME: typing.ClassVar[DicomAttribute] = ... + TOMO_TYPE: typing.ClassVar[DicomAttribute] = ... + TOMO_CLASS: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_TOMOSYNTHESIS_SOURCE_IMAGES: typing.ClassVar[DicomAttribute] = ... + POSITIONER_MOTION: typing.ClassVar[DicomAttribute] = ... + POSITIONER_TYPE: typing.ClassVar[DicomAttribute] = ... + POSITIONER_PRIMARY_ANGLE: typing.ClassVar[DicomAttribute] = ... + POSITIONER_SECONDARY_ANGLE: typing.ClassVar[DicomAttribute] = ... + POSITIONER_PRIMARY_ANGLE_INCREMENT: typing.ClassVar[DicomAttribute] = ... + POSITIONER_SECONDARY_ANGLE_INCREMENT: typing.ClassVar[DicomAttribute] = ... + DETECTOR_PRIMARY_ANGLE: typing.ClassVar[DicomAttribute] = ... + DETECTOR_SECONDARY_ANGLE: typing.ClassVar[DicomAttribute] = ... + SHUTTER_SHAPE: typing.ClassVar[DicomAttribute] = ... + SHUTTER_LEFT_VERTICAL_EDGE: typing.ClassVar[DicomAttribute] = ... + SHUTTER_RIGHT_VERTICAL_EDGE: typing.ClassVar[DicomAttribute] = ... + SHUTTER_UPPER_HORIZONTAL_EDGE: typing.ClassVar[DicomAttribute] = ... + SHUTTER_LOWER_HORIZONTAL_EDGE: typing.ClassVar[DicomAttribute] = ... + CENTER_OF_CIRCULAR_SHUTTER: typing.ClassVar[DicomAttribute] = ... + RADIUS_OF_CIRCULAR_SHUTTER: typing.ClassVar[DicomAttribute] = ... + VERTICES_OF_POLYGONAL_SHUTTER: typing.ClassVar[DicomAttribute] = ... + SHUTTER_PRESENTATION_VALUE: typing.ClassVar[DicomAttribute] = ... + SHUTTER_OVERLAY_GROUP: typing.ClassVar[DicomAttribute] = ... + COLLIMATOR_SHAPE: typing.ClassVar[DicomAttribute] = ... + COLLIMATOR_LEFT_VERTICAL_EDGE: typing.ClassVar[DicomAttribute] = ... + COLLIMATOR_RIGHT_VERTICAL_EDGE: typing.ClassVar[DicomAttribute] = ... + COLLIMATOR_UPPER_HORIZONTAL_EDGE: typing.ClassVar[DicomAttribute] = ... + COLLIMATOR_LOWER_HORIZONTAL_EDGE: typing.ClassVar[DicomAttribute] = ... + CENTER_OF_CIRCULAR_COLLIMATOR: typing.ClassVar[DicomAttribute] = ... + RADIUS_OF_CIRCULAR_COLLIMATOR: typing.ClassVar[DicomAttribute] = ... + VERTICES_OF_POLYGONAL_COLLIMATOR: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_TIME_SYNCHRONIZED: typing.ClassVar[DicomAttribute] = ... + TIME_SOURCE: typing.ClassVar[DicomAttribute] = ... + TIME_DISTRIBUTION_PROTOCOL: typing.ClassVar[DicomAttribute] = ... + NTP_SOURCE_ADDRESS: typing.ClassVar[DicomAttribute] = ... + PAGE_NUMBER_VECTOR: typing.ClassVar[DicomAttribute] = ... + FRAME_LABEL_VECTOR: typing.ClassVar[DicomAttribute] = ... + FRAME_PRIMARY_ANGLE_VECTOR: typing.ClassVar[DicomAttribute] = ... + FRAME_SECONDARY_ANGLE_VECTOR: typing.ClassVar[DicomAttribute] = ... + SLICE_LOCATION_VECTOR: typing.ClassVar[DicomAttribute] = ... + DISPLAY_WINDOW_LABEL_VECTOR: typing.ClassVar[DicomAttribute] = ... + NOMINAL_SCANNED_PIXEL_SPACING: typing.ClassVar[DicomAttribute] = ... + DIGITIZING_DEVICE_TRANSPORT_DIRECTION: typing.ClassVar[DicomAttribute] = ... + ROTATION_OF_SCANNED_FILM: typing.ClassVar[DicomAttribute] = ... + IVUS_ACQUISITION: typing.ClassVar[DicomAttribute] = ... + IVUS_PULLBACK_RATE: typing.ClassVar[DicomAttribute] = ... + IVUS_GATED_RATE: typing.ClassVar[DicomAttribute] = ... + IVUS_PULLBACK_START_FRAME_NUMBER: typing.ClassVar[DicomAttribute] = ... + IVUS_PULLBACK_STOP_FRAME_NUMBER: typing.ClassVar[DicomAttribute] = ... + LESION_NUMBER: typing.ClassVar[DicomAttribute] = ... + OUTPUT_POWER: typing.ClassVar[DicomAttribute] = ... + TRANSDUCER_DATA: typing.ClassVar[DicomAttribute] = ... + FOCUS_DEPTH: typing.ClassVar[DicomAttribute] = ... + PROCESSING_FUNCTION: typing.ClassVar[DicomAttribute] = ... + POSTPROCESSING_FUNCTION: typing.ClassVar[DicomAttribute] = ... + MECHANICAL_INDEX: typing.ClassVar[DicomAttribute] = ... + BONE_THERMAL_INDEX: typing.ClassVar[DicomAttribute] = ... + CRANIAL_THERMAL_INDEX: typing.ClassVar[DicomAttribute] = ... + SOFT_TISSUE_THERMAL_INDEX: typing.ClassVar[DicomAttribute] = ... + SOFT_TISSUE_FOCUS_THERMAL_INDEX: typing.ClassVar[DicomAttribute] = ... + SOFT_TISSUE_SURFACE_THERMAL_INDEX: typing.ClassVar[DicomAttribute] = ... + DEPTH_OF_SCAN_FIELD: typing.ClassVar[DicomAttribute] = ... + PATIENT_POSITION: typing.ClassVar[DicomAttribute] = ... + VIEW_POSITION: typing.ClassVar[DicomAttribute] = ... + PROJECTION_EPONYMOUS_NAME_CODE: typing.ClassVar[DicomAttribute] = ... + SENSITIVITY: typing.ClassVar[DicomAttribute] = ... + SEQUENCE_OF_ULTRASOUND_REGIONS: typing.ClassVar[DicomAttribute] = ... + REGION_SPATIAL_FORMAT: typing.ClassVar[DicomAttribute] = ... + REGION_DATA_TYPE: typing.ClassVar[DicomAttribute] = ... + REGION_FLAGS: typing.ClassVar[DicomAttribute] = ... + REGION_LOCATION_MIN_X0: typing.ClassVar[DicomAttribute] = ... + REGION_LOCATION_MIN_Y0: typing.ClassVar[DicomAttribute] = ... + REGION_LOCATION_MAX_X1: typing.ClassVar[DicomAttribute] = ... + REGION_LOCATION_MAX_Y1: typing.ClassVar[DicomAttribute] = ... + REFERENCE_PIXEL_X0: typing.ClassVar[DicomAttribute] = ... + REFERENCE_PIXEL_Y0: typing.ClassVar[DicomAttribute] = ... + PHYSICAL_UNITS_X_DIRECTION: typing.ClassVar[DicomAttribute] = ... + PHYSICAL_UNITS_Y_DIRECTION: typing.ClassVar[DicomAttribute] = ... + REFERENCE_PIXEL_PHYSICAL_VALUE_X: typing.ClassVar[DicomAttribute] = ... + REFERENCE_PIXEL_PHYSICAL_VALUE_Y: typing.ClassVar[DicomAttribute] = ... + PHYSICAL_DELTA_X: typing.ClassVar[DicomAttribute] = ... + PHYSICAL_DELTA_Y: typing.ClassVar[DicomAttribute] = ... + TRANSDUCER_FREQUENCY: typing.ClassVar[DicomAttribute] = ... + TRANSDUCER_TYPE: typing.ClassVar[DicomAttribute] = ... + PULSE_REPETITION_FREQUENCY: typing.ClassVar[DicomAttribute] = ... + DOPPLER_CORRECTION_ANGLE: typing.ClassVar[DicomAttribute] = ... + STEERING_ANGLE: typing.ClassVar[DicomAttribute] = ... + DOPPLER_SAMPLE_VOLUME_X_POSITION: typing.ClassVar[DicomAttribute] = ... + DOPPLER_SAMPLE_VOLUME_Y_POSITION: typing.ClassVar[DicomAttribute] = ... + TM_LINE_POSITION_X0: typing.ClassVar[DicomAttribute] = ... + TM_LINE_POSITION_Y0: typing.ClassVar[DicomAttribute] = ... + TM_LINE_POSITION_X1: typing.ClassVar[DicomAttribute] = ... + TM_LINE_POSITION_Y1: typing.ClassVar[DicomAttribute] = ... + PIXEL_COMPONENT_ORGANIZATION: typing.ClassVar[DicomAttribute] = ... + PIXEL_COMPONENT_MASK: typing.ClassVar[DicomAttribute] = ... + PIXEL_COMPONENT_RANGE_START: typing.ClassVar[DicomAttribute] = ... + PIXEL_COMPONENT_RANGE_STOP: typing.ClassVar[DicomAttribute] = ... + PIXEL_COMPONENT_PHYSICAL_UNITS: typing.ClassVar[DicomAttribute] = ... + PIXEL_COMPONENT_DATA_TYPE: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_TABLE_BREAK_POINTS: typing.ClassVar[DicomAttribute] = ... + TABLE_OF_X_BREAK_POINTS: typing.ClassVar[DicomAttribute] = ... + TABLE_OF_Y_BREAK_POINTS: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_TABLE_ENTRIES: typing.ClassVar[DicomAttribute] = ... + TABLE_OF_PIXEL_VALUES: typing.ClassVar[DicomAttribute] = ... + TABLE_OF_PARAMETER_VALUES: typing.ClassVar[DicomAttribute] = ... + R_WAVE_TIME_VECTOR: typing.ClassVar[DicomAttribute] = ... + DETECTOR_CONDITIONS_NOMINAL_FLAG: typing.ClassVar[DicomAttribute] = ... + DETECTOR_TEMPERATURE: typing.ClassVar[DicomAttribute] = ... + DETECTOR_TYPE: typing.ClassVar[DicomAttribute] = ... + DETECTOR_CONFIGURATION: typing.ClassVar[DicomAttribute] = ... + DETECTOR_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + DETECTOR_MODE: typing.ClassVar[DicomAttribute] = ... + DETECTOR_ID: typing.ClassVar[DicomAttribute] = ... + DATE_OF_LAST_DETECTOR_CALIBRATION: typing.ClassVar[DicomAttribute] = ... + TIME_OF_LAST_DETECTOR_CALIBRATION: typing.ClassVar[DicomAttribute] = ... + DETECTOR_TIME_SINCE_LAST_EXPOSURE: typing.ClassVar[DicomAttribute] = ... + DETECTOR_ACTIVE_TIME: typing.ClassVar[DicomAttribute] = ... + DETECTOR_ACTIVATION_OFFSET: typing.ClassVar[DicomAttribute] = ... + DETECTOR_BINNING: typing.ClassVar[DicomAttribute] = ... + DETECTOR_ELEMENT_PHYSICAL_SIZE: typing.ClassVar[DicomAttribute] = ... + DETECTOR_ELEMENT_SPACING: typing.ClassVar[DicomAttribute] = ... + DETECTOR_ACTIVE_SHAPE: typing.ClassVar[DicomAttribute] = ... + DETECTOR_ACTIVE_DIMENSIONS: typing.ClassVar[DicomAttribute] = ... + DETECTOR_ACTIVE_ORIGIN: typing.ClassVar[DicomAttribute] = ... + DETECTOR_MANUFACTURER_NAME: typing.ClassVar[DicomAttribute] = ... + DETECTOR_MODEL_NAME: typing.ClassVar[DicomAttribute] = ... + FOV_ORIGIN: typing.ClassVar[DicomAttribute] = ... + FOV_ROTATION: typing.ClassVar[DicomAttribute] = ... + FOV_HORIZONTAL_FLIP: typing.ClassVar[DicomAttribute] = ... + GRID_ABSORBING_MATERIAL: typing.ClassVar[DicomAttribute] = ... + GRID_SPACING_MATERIAL: typing.ClassVar[DicomAttribute] = ... + GRID_THICKNESS: typing.ClassVar[DicomAttribute] = ... + GRID_PITCH: typing.ClassVar[DicomAttribute] = ... + GRID_ASPECT_RATIO: typing.ClassVar[DicomAttribute] = ... + GRID_PERIOD: typing.ClassVar[DicomAttribute] = ... + GRID_FOCAL_DISTANCE: typing.ClassVar[DicomAttribute] = ... + FILTER_MATERIAL: typing.ClassVar[DicomAttribute] = ... + FILTER_THICKNESS_MIN: typing.ClassVar[DicomAttribute] = ... + FILTER_THICKNESS_MAX: typing.ClassVar[DicomAttribute] = ... + EXPOSURE_CONTROL_MODE: typing.ClassVar[DicomAttribute] = ... + STUDY_INSTANCE_UID: typing.ClassVar[DicomAttribute] = ... + SERIES_INSTANCE_UID: typing.ClassVar[DicomAttribute] = ... + STUDY_ID: typing.ClassVar[DicomAttribute] = ... + SERIES_NUMBER: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_NUMBER: typing.ClassVar[DicomAttribute] = ... + INSTANCE_NUMBER: typing.ClassVar[DicomAttribute] = ... + PATIENT_ORIENTATION: typing.ClassVar[DicomAttribute] = ... + IMAGE_POSITION: typing.ClassVar[DicomAttribute] = ... + IMAGE_POSITION_PATIENT: typing.ClassVar[DicomAttribute] = ... + IMAGE_ORIENTATION_PATIENT: typing.ClassVar[DicomAttribute] = ... + LOCATION: typing.ClassVar[DicomAttribute] = ... + FRAME_OF_REFERENCE_UID: typing.ClassVar[DicomAttribute] = ... + IMAGE_GEOMETRY_TYPE: typing.ClassVar[DicomAttribute] = ... + ACQUISITIONS_IN_SERIES: typing.ClassVar[DicomAttribute] = ... + REFERENCE: typing.ClassVar[DicomAttribute] = ... + SLICE_LOCATION: typing.ClassVar[DicomAttribute] = ... + SAMPLES_PER_PIXEL: typing.ClassVar[DicomAttribute] = ... + SAMPLES_PER_PIXEL_USED: typing.ClassVar[DicomAttribute] = ... + PHOTOMETRIC_INTERPRETATION: typing.ClassVar[DicomAttribute] = ... + PLANAR_CONFIGURATION: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_FRAMES: typing.ClassVar[DicomAttribute] = ... + FRAME_INCREMENT_POINTER: typing.ClassVar[DicomAttribute] = ... + FRAME_DIMENSION_POINTER: typing.ClassVar[DicomAttribute] = ... + ROWS: typing.ClassVar[DicomAttribute] = ... + COLUMNS: typing.ClassVar[DicomAttribute] = ... + PLANES: typing.ClassVar[DicomAttribute] = ... + ULTRASOUND_COLOR_DATA_PRESENT: typing.ClassVar[DicomAttribute] = ... + PIXEL_SPACING: typing.ClassVar[DicomAttribute] = ... + ZOOM_FACTOR: typing.ClassVar[DicomAttribute] = ... + ZOOM_CENTER: typing.ClassVar[DicomAttribute] = ... + PIXEL_ASPECT_RATIO: typing.ClassVar[DicomAttribute] = ... + CORRECTED_IMAGE: typing.ClassVar[DicomAttribute] = ... + BITS_ALLOCATED: typing.ClassVar[DicomAttribute] = ... + BITS_STORED: typing.ClassVar[DicomAttribute] = ... + HIGH_BIT: typing.ClassVar[DicomAttribute] = ... + PIXEL_REPRESENTATION: typing.ClassVar[DicomAttribute] = ... + SMALLEST_IMAGE_PIXEL_VALUE: typing.ClassVar[DicomAttribute] = ... + LARGEST_IMAGE_PIXEL_VALUE: typing.ClassVar[DicomAttribute] = ... + SMALLEST_PIXEL_VALUE_IN_SERIES: typing.ClassVar[DicomAttribute] = ... + LARGEST_PIXEL_VALUE_IN_SERIES: typing.ClassVar[DicomAttribute] = ... + SMALLEST_IMAGE_PIXEL_VALUE_IN_PLANE: typing.ClassVar[DicomAttribute] = ... + LARGEST_IMAGE_PIXEL_VALUE_IN_PLANE: typing.ClassVar[DicomAttribute] = ... + PIXEL_PADDING_VALUE: typing.ClassVar[DicomAttribute] = ... + QUALITY_CONTROL_IMAGE: typing.ClassVar[DicomAttribute] = ... + BURNED_IN_ANNOTATION: typing.ClassVar[DicomAttribute] = ... + PIXEL_INTENSITY_RELATIONSHIP: typing.ClassVar[DicomAttribute] = ... + PIXEL_SIGN: typing.ClassVar[DicomAttribute] = ... + WINDOW_CENTER: typing.ClassVar[DicomAttribute] = ... + WINDOW_WIDTH: typing.ClassVar[DicomAttribute] = ... + RESCALE_INTERCEPT: typing.ClassVar[DicomAttribute] = ... + RESCALE_SLOPE: typing.ClassVar[DicomAttribute] = ... + RESCALE_TYPE: typing.ClassVar[DicomAttribute] = ... + WINDOW_CENTER_AND_WIDTH_EXPLANATION: typing.ClassVar[DicomAttribute] = ... + RECOMMENDED_VIEWING_MODE: typing.ClassVar[DicomAttribute] = ... + RED_LUT_DESCRIPTOR: typing.ClassVar[DicomAttribute] = ... + GREEN_LUT_DESCRIPTOR: typing.ClassVar[DicomAttribute] = ... + BLUE_LUT_DESCRIPTOR: typing.ClassVar[DicomAttribute] = ... + PALETTE_LUT_UID: typing.ClassVar[DicomAttribute] = ... + RED_LUT_DATA: typing.ClassVar[DicomAttribute] = ... + GREEN_LUT_DATA: typing.ClassVar[DicomAttribute] = ... + BLUE_LUT_DATA: typing.ClassVar[DicomAttribute] = ... + SEGMENTED_RED_LUT_DATA: typing.ClassVar[DicomAttribute] = ... + SEGMENTED_GREEN_LUT_DATA: typing.ClassVar[DicomAttribute] = ... + SEGMENTED_BLUE_LUT_DATA: typing.ClassVar[DicomAttribute] = ... + IMPLANT_PRESENT: typing.ClassVar[DicomAttribute] = ... + PARTIAL_VIEW: typing.ClassVar[DicomAttribute] = ... + PARTIAL_VIEW_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + LOSSY_IMAGE_COMPRESSION: typing.ClassVar[DicomAttribute] = ... + LOSSY_IMAGE_COMPRESSION_RATIO: typing.ClassVar[DicomAttribute] = ... + LOSSY_IMAGE_COMPRESSION_METHOD: typing.ClassVar[DicomAttribute] = ... + MODALITY_LUT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + LUT_DESCRIPTOR: typing.ClassVar[DicomAttribute] = ... + LUT_EXPLANATION: typing.ClassVar[DicomAttribute] = ... + MODALITY_LUT_TYPE: typing.ClassVar[DicomAttribute] = ... + LUT_DATA: typing.ClassVar[DicomAttribute] = ... + VOI_LUT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SOFTCOPY_VOI_LUT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + BIPLANE_ACQUISITION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REPRESENTATIVE_FRAME_NUMBER: typing.ClassVar[DicomAttribute] = ... + FRAME_NUMBERS_OF_INTEREST: typing.ClassVar[DicomAttribute] = ... + FRAME_OF_INTEREST_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + FRAME_OF_INTEREST_TYPE: typing.ClassVar[DicomAttribute] = ... + R_WAVE_POINTER: typing.ClassVar[DicomAttribute] = ... + MASK_SUBTRACTION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + MASK_OPERATION: typing.ClassVar[DicomAttribute] = ... + APPLICABLE_FRAME_RANGE: typing.ClassVar[DicomAttribute] = ... + MASK_FRAME_NUMBERS: typing.ClassVar[DicomAttribute] = ... + CONTRAST_FRAME_AVERAGING: typing.ClassVar[DicomAttribute] = ... + MASK_SUBPIXEL_SHIFT: typing.ClassVar[DicomAttribute] = ... + TID_OFFSET: typing.ClassVar[DicomAttribute] = ... + MASK_OPERATION_EXPLANATION: typing.ClassVar[DicomAttribute] = ... + DATA_POINT_ROWS: typing.ClassVar[DicomAttribute] = ... + DATA_POINT_COLUMNS: typing.ClassVar[DicomAttribute] = ... + SIGNAL_DOMAIN_COLUMNS: typing.ClassVar[DicomAttribute] = ... + DATA_REPRESENTATION: typing.ClassVar[DicomAttribute] = ... + PIXEL_MEASURES_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + FRAME_VOI_LUT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + PIXEL_VALUE_TRANSFORMATION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SIGNAL_DOMAIN_ROWS: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_ENERGY_WINDOWS: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_DETECTORS: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_ROTATIONS: typing.ClassVar[DicomAttribute] = ... + SLICE_VECTOR: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_SLICES: typing.ClassVar[DicomAttribute] = ... + TYPE_OF_DETECTOR_MOTION: typing.ClassVar[DicomAttribute] = ... + IMAGE_ID: typing.ClassVar[DicomAttribute] = ... + ICON_IMAGE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + BORDER_DENSITY: typing.ClassVar[DicomAttribute] = ... + PIXEL_DATA_LENGTH: typing.ClassVar[DicomAttribute] = ... + EXTENDED_OFFSET_TABLE: typing.ClassVar[DicomAttribute] = ... + EXTENDED_OFFSET_TABLE_LENGTHS: typing.ClassVar[DicomAttribute] = ... + FLOAT_PIXEL_DATA: typing.ClassVar[DicomAttribute] = ... + DOUBLE_FLOAT_PIXEL_DATA: typing.ClassVar[DicomAttribute] = ... + PIXEL_DATA: typing.ClassVar[DicomAttribute] = ... + ITEM: typing.ClassVar[DicomAttribute] = ... + ITEM_DELIMITATION_ITEM: typing.ClassVar[DicomAttribute] = ... + SEQUENCE_DELIMITATION_ITEM: typing.ClassVar[DicomAttribute] = ... + TRAILING_PADDING: typing.ClassVar[DicomAttribute] = ... + FILE_SET_ID: typing.ClassVar[DicomAttribute] = ... + FILE_SET_DESCRIPTOR_FILE_ID: typing.ClassVar[DicomAttribute] = ... + CHARSET_OF_FILE_SET_DESCRIPTOR_FILE: typing.ClassVar[DicomAttribute] = ... + OFFSET_FIRST_DIRECTORY_RECORD: typing.ClassVar[DicomAttribute] = ... + OFFSET_LAST_DIRECTORY_RECORD: typing.ClassVar[DicomAttribute] = ... + FILE_SET_CONSISTENCY_FLAG: typing.ClassVar[DicomAttribute] = ... + DIRECTORY_RECORD_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + OFFSET_OF_NEXT_DIRECTORY_RECORD: typing.ClassVar[DicomAttribute] = ... + RECORD_IN_USE_FLAG: typing.ClassVar[DicomAttribute] = ... + OFFSET_OF_REFERENCED_DIRECTORY: typing.ClassVar[DicomAttribute] = ... + DIRECTORY_RECORD_TYPE: typing.ClassVar[DicomAttribute] = ... + PRIVATE_RECORD_UID: typing.ClassVar[DicomAttribute] = ... + REFERENCED_FILE_ID: typing.ClassVar[DicomAttribute] = ... + MRDR_RECORD_OFFSET: typing.ClassVar[DicomAttribute] = ... + REFERENCED_SOP_CLASS_UID_FILE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_SOP_INSTANCE_UID_FILE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_TRANSFER_SYNTAX_UID_FILE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_RELATED_SOP_CLASS_UID_FILE: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_REFERENCES: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_DURATION: typing.ClassVar[DicomAttribute] = ... + DIMENSION_ORGANIZATION_TYPE: typing.ClassVar[DicomAttribute] = ... + DIMENSION_INDEX_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + DIMENSION_INDEX_POINTER: typing.ClassVar[DicomAttribute] = ... + DIMENSION_INDEX_PRIVATE_CREATOR: typing.ClassVar[DicomAttribute] = ... + FUNCTIONAL_GROUP_POINTER: typing.ClassVar[DicomAttribute] = ... + FUNCTIONAL_GROUP_PRIVATE_CREATOR: typing.ClassVar[DicomAttribute] = ... + IN_CONCATENATION_NUMBER: typing.ClassVar[DicomAttribute] = ... + CONCATENATION_FRAME_OFFSET_NUMBER: typing.ClassVar[DicomAttribute] = ... + DIMENSION_ORGANIZATION_UID: typing.ClassVar[DicomAttribute] = ... + DIMENSION_ORGANIZATION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + DIMENSION_DESCRIPTION_LABEL: typing.ClassVar[DicomAttribute] = ... + ILLUMINATION_WAVELENGTH: typing.ClassVar[DicomAttribute] = ... + ILLUMINATION_TYPE_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + LIGHT_PATH_FILTER_TYPE_STACK_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + LIGHT_PATH_FILTER_PASSTHROUGH_WAVELENGTH: typing.ClassVar[DicomAttribute] = ... + LIGHT_PATH_FILTER_PASS_BAND: typing.ClassVar[DicomAttribute] = ... + IMAGE_PATH_FILTER_PASSTHROUGH_WAVELENGTH: typing.ClassVar[DicomAttribute] = ... + IMAGE_PATH_FILTER_PASS_BAND: typing.ClassVar[DicomAttribute] = ... + IMAGE_PATH_FILTER_TYPE_STACK_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + LENSES_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + CHANNEL_DESCRIPTION_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + ICC_PROFILE: typing.ClassVar[DicomAttribute] = ... + COLOR_SPACE: typing.ClassVar[DicomAttribute] = ... + CONTAINER_ID: typing.ClassVar[DicomAttribute] = ... + CONTAINER_ID_ISSUER_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + CONTAINER_TYPE_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SPECIMEN_ID: typing.ClassVar[DicomAttribute] = ... + SPECIMEN_UID: typing.ClassVar[DicomAttribute] = ... + ACQUISITION_CONTEXT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SPECIMEN_DESCRIPTION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SPECIMEN_ID_ISSUER_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SPECIMEN_PREP_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + WHOLE_SLIDE_FRAME_TYPE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + X_OFFSET_IN_SLIDE: typing.ClassVar[DicomAttribute] = ... + Y_OFFSET_IN_SLIDE: typing.ClassVar[DicomAttribute] = ... + Z_OFFSET_IN_SLIDE: typing.ClassVar[DicomAttribute] = ... + IMAGED_VOLUME_WIDTH: typing.ClassVar[DicomAttribute] = ... + IMAGED_VOLUME_HEIGHT: typing.ClassVar[DicomAttribute] = ... + IMAGED_VOLUME_DEPTH: typing.ClassVar[DicomAttribute] = ... + TOTAL_PIXEL_MATRIX_COLUMNS: typing.ClassVar[DicomAttribute] = ... + TOTAL_PIXEL_MATRIX_ROWS: typing.ClassVar[DicomAttribute] = ... + TOTAL_PIXEL_MATRIX_ORIGIN_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + SPECIMEN_LABEL_IN_IMAGE: typing.ClassVar[DicomAttribute] = ... + FOCUS_METHOD: typing.ClassVar[DicomAttribute] = ... + EXTENDED_DEPTH_OF_FIELD: typing.ClassVar[DicomAttribute] = ... + NUMBER_OF_FOCAL_PLANES: typing.ClassVar[DicomAttribute] = ... + DISTANCE_BETWEEN_FOCAL_PLANES: typing.ClassVar[DicomAttribute] = ... + RECOMMENDED_ABSENT_PIXEL_CIELAB_VALUE: typing.ClassVar[DicomAttribute] = ... + SLIDE_IMAGE_ORIENTATION: typing.ClassVar[DicomAttribute] = ... + OPTICAL_PATH_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + OPTICAL_PATH_ID: typing.ClassVar[DicomAttribute] = ... + OPTICAL_PATH_DESCRIPTION: typing.ClassVar[DicomAttribute] = ... + ILLUMINATOR_TYPE_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + ILLUMINATION_COLOR_CODE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + CONDENSER_LENS_POWER: typing.ClassVar[DicomAttribute] = ... + OBJECTIVE_LENS_POWER: typing.ClassVar[DicomAttribute] = ... + OBJECTIVE_LENS_NA: typing.ClassVar[DicomAttribute] = ... + PALETTE_COLOR_LUT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + REFERENCED_IMAGE_NAVIGATION_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + OPTICAL_PATH_ID_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + NUMBER_OPTICAL_PATHS: typing.ClassVar[DicomAttribute] = ... + TOTAL_PIXEL_MATRIX_FOCAL_PLANES: typing.ClassVar[DicomAttribute] = ... + PRESENTATION_LUT_SHAPE: typing.ClassVar[DicomAttribute] = ... + PLANE_POSITION_SLIDE_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + COLUMN_POSITION_IN_MATRIX: typing.ClassVar[DicomAttribute] = ... + ROW_POSITION_IN_MATRIX: typing.ClassVar[DicomAttribute] = ... + FRAME_CONTENT_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + FRAME_ACQUISITION_DATETIME: typing.ClassVar[DicomAttribute] = ... + FRAME_REFERENCE_DATETIME: typing.ClassVar[DicomAttribute] = ... + FRAME_ACQUISITION_DURATION: typing.ClassVar[DicomAttribute] = ... + DIMENSION_INDEX_VALUES: typing.ClassVar[DicomAttribute] = ... + SHARED_FUNCTIONAL_GROUPS_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + PER_FRAME_FUNCTIONAL_GROUPS_SEQUENCE: typing.ClassVar[DicomAttribute] = ... + BARCODE_VALUE: typing.ClassVar[DicomAttribute] = ... + LABEL_TEXT: typing.ClassVar[DicomAttribute] = ... + VARIABLE_PIXEL_DATA: typing.ClassVar[DicomAttribute] = ... + INVALID_PIXEL_DATA: typing.ClassVar[DicomAttribute] = ... + INVALID: typing.ClassVar[DicomAttribute] = ... + @staticmethod + def formatTag(int: int) -> java.lang.String: ... + @staticmethod + def get(int: int) -> DicomAttribute: ... + @typing.overload + def getDefaultVR(self) -> DicomVR: ... + @typing.overload + @staticmethod + def getDefaultVR(int: int) -> DicomVR: ... + @typing.overload + def getDescription(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def getDescription(int: int) -> java.lang.String: ... + @typing.overload + def getTag(self) -> int: ... + @typing.overload + @staticmethod + def getTag(string: java.lang.String | str) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> DicomAttribute: ... + @staticmethod + def values() -> typing.MutableSequence[DicomAttribute]: ... + +class DicomFileInfo(java.lang.Comparable["DicomFileInfo"]): + coreMetadata: loci.formats.CoreMetadata = ... + file: java.lang.String = ... + concatenationIndex: int = ... + tiles: java.util.List = ... + imageType: java.lang.String = ... + zOffsets: java.util.List = ... + edf: bool = ... + timestamp: ome.xml.model.primitives.Timestamp = ... + pixelSizeX: ome.units.quantity.Length = ... + pixelSizeY: ome.units.quantity.Length = ... + pixelSizeZ: ome.units.quantity.Length = ... + positionX: java.util.List = ... + positionY: java.util.List = ... + positionZ: java.util.List = ... + channelNames: java.util.List = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def compareTo(self, dicomFileInfo: DicomFileInfo) -> int: ... + +class DicomTag(java.lang.Comparable["DicomTag"]): + parent: DicomTag = ... + children: java.util.List = ... + tag: int = ... + attribute: DicomAttribute = ... + vr: DicomVR = ... + key: java.lang.String = ... + value: typing.Any = ... + elementLength: int = ... + strategy: ResolutionStrategy = ... + @typing.overload + def __init__(self, int: int, dicomVR: DicomVR): ... + @typing.overload + def __init__( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + boolean: bool, + long: int, + boolean2: bool, + ): ... + @typing.overload + def __init__( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + boolean: bool, + long: int, + boolean2: bool, + boolean3: bool, + ): ... + @typing.overload + def __init__(self, dicomAttribute: DicomAttribute): ... + @typing.overload + def __init__(self, dicomAttribute: DicomAttribute, dicomVR: DicomVR): ... + def compareTo(self, dicomTag: DicomTag) -> int: ... + def getEndPointer(self) -> int: ... + def getNumberValue(self) -> java.lang.Number: ... + def getStringValue(self) -> java.lang.String: ... + def getValueStartPointer(self) -> int: ... + def isPrivateContentCreator(self) -> bool: ... + def lookupChild(self, dicomAttribute: DicomAttribute) -> DicomTag: ... + def toString(self) -> java.lang.String: ... + def validate(self, list: java.util.List[DicomTag]) -> bool: ... + def validateValue(self) -> None: ... + +class DicomTile: + region: loci.common.Region = ... + file: java.lang.String = ... + fileIndex: int = ... + fileOffset: int = ... + endOffset: int = ... + zOffset: float = ... + channel: int = ... + last: bool = ... + isJP2K: bool = ... + isJPEG: bool = ... + isRLE: bool = ... + isDeflate: bool = ... + def __init__(self): ... + +class DicomVR(java.lang.Enum["DicomVR"]): + AE: typing.ClassVar[DicomVR] = ... + AS: typing.ClassVar[DicomVR] = ... + AT: typing.ClassVar[DicomVR] = ... + CS: typing.ClassVar[DicomVR] = ... + DA: typing.ClassVar[DicomVR] = ... + DS: typing.ClassVar[DicomVR] = ... + DT: typing.ClassVar[DicomVR] = ... + FD: typing.ClassVar[DicomVR] = ... + FL: typing.ClassVar[DicomVR] = ... + IS: typing.ClassVar[DicomVR] = ... + LO: typing.ClassVar[DicomVR] = ... + LT: typing.ClassVar[DicomVR] = ... + OB: typing.ClassVar[DicomVR] = ... + OD: typing.ClassVar[DicomVR] = ... + OF: typing.ClassVar[DicomVR] = ... + OL: typing.ClassVar[DicomVR] = ... + OV: typing.ClassVar[DicomVR] = ... + OW: typing.ClassVar[DicomVR] = ... + PN: typing.ClassVar[DicomVR] = ... + SH: typing.ClassVar[DicomVR] = ... + SL: typing.ClassVar[DicomVR] = ... + SQ: typing.ClassVar[DicomVR] = ... + SS: typing.ClassVar[DicomVR] = ... + ST: typing.ClassVar[DicomVR] = ... + SV: typing.ClassVar[DicomVR] = ... + TM: typing.ClassVar[DicomVR] = ... + UC: typing.ClassVar[DicomVR] = ... + UI: typing.ClassVar[DicomVR] = ... + UL: typing.ClassVar[DicomVR] = ... + UN: typing.ClassVar[DicomVR] = ... + UR: typing.ClassVar[DicomVR] = ... + US: typing.ClassVar[DicomVR] = ... + UT: typing.ClassVar[DicomVR] = ... + UV: typing.ClassVar[DicomVR] = ... + QQ: typing.ClassVar[DicomVR] = ... + IMPLICIT: typing.ClassVar[DicomVR] = ... + RESERVED: typing.ClassVar[DicomVR] = ... + @staticmethod + def get(int: int) -> DicomVR: ... + def getCode(self) -> int: ... + def getWidth(self) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> DicomVR: ... + @staticmethod + def values() -> typing.MutableSequence[DicomVR]: ... + +class ITagProvider: + def getTags(self) -> java.util.List[DicomTag]: ... + def readTagSource(self, string: java.lang.String | str) -> None: ... + +class ResolutionStrategy(java.lang.Enum["ResolutionStrategy"]): + IGNORE: typing.ClassVar[ResolutionStrategy] = ... + REPLACE: typing.ClassVar[ResolutionStrategy] = ... + APPEND: typing.ClassVar[ResolutionStrategy] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ResolutionStrategy: ... + @staticmethod + def values() -> typing.MutableSequence[ResolutionStrategy]: ... + +class DicomJSONProvider(ITagProvider): + def __init__(self): ... + def getTags(self) -> java.util.List[DicomTag]: ... + def readTagSource(self, string: java.lang.String | str) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.dicom")``. + + DicomAttribute: type[DicomAttribute] + DicomFileInfo: type[DicomFileInfo] + DicomJSONProvider: type[DicomJSONProvider] + DicomTag: type[DicomTag] + DicomTile: type[DicomTile] + DicomVR: type[DicomVR] + ITagProvider: type[ITagProvider] + ResolutionStrategy: type[ResolutionStrategy] diff --git a/typings/loci/formats/filter/__init__.pyi b/typings/loci/formats/filter/__init__.pyi new file mode 100644 index 0000000..102157d --- /dev/null +++ b/typings/loci/formats/filter/__init__.pyi @@ -0,0 +1,36 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype +import ucar.nc2.filter + +class LZ4Filter(ucar.nc2.filter.Filter): + def __init__( + self, + map: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + ): ... + def decode( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + def encode( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + def getId(self) -> int: ... + def getName(self) -> java.lang.String: ... + class LZ4FilterProvider(ucar.nc2.filter.FilterProvider): + def __init__(self): ... + def create( + self, + map: java.util.Map[java.lang.String | str, typing.Any] + | typing.Mapping[java.lang.String | str, typing.Any], + ) -> ucar.nc2.filter.Filter: ... + def getId(self) -> int: ... + def getName(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.filter")``. + + LZ4Filter: type[LZ4Filter] diff --git a/typings/loci/formats/gui/__init__.pyi b/typings/loci/formats/gui/__init__.pyi new file mode 100644 index 0000000..22d479a --- /dev/null +++ b/typings/loci/formats/gui/__init__.pyi @@ -0,0 +1,1023 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.color +import java.awt.event +import java.awt.image +import java.beans +import java.io +import java.lang +import java.util +import javax.swing +import javax.swing.event +import javax.swing.filechooser +import javax.swing.tree +import jpype +import jpype.protocol +import loci.formats +import loci.formats.cache +import loci.formats.meta +import org.w3c.dom + +class AWTImageTools: + @typing.overload + @staticmethod + def autoscale( + bufferedImage: java.awt.image.BufferedImage, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def autoscale( + bufferedImage: java.awt.image.BufferedImage, int: int, int2: int + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def blankImage( + int: int, int2: int, int3: int, int4: int + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def constructImage( + int: int, + int2: int, + int3: int, + int4: int, + boolean: bool, + boolean2: bool, + dataBuffer: java.awt.image.DataBuffer, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def constructImage( + int: int, + int2: int, + int3: int, + int4: int, + boolean: bool, + boolean2: bool, + dataBuffer: java.awt.image.DataBuffer, + colorModel: java.awt.image.ColorModel, + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def convertRenderedImage( + renderedImage: java.awt.image.RenderedImage, + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def copyScaled( + bufferedImage: java.awt.image.BufferedImage, + bufferedImage2: java.awt.image.BufferedImage, + object: typing.Any, + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def get8BitLookupTable( + colorModel: java.awt.image.ColorModel, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getBytes( + bufferedImage: java.awt.image.BufferedImage, boolean: bool + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def getBytes( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getBytes( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getBytes( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @staticmethod + def getDefaultConfiguration() -> java.awt.GraphicsConfiguration: ... + @typing.overload + @staticmethod + def getDoubles( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getDoubles( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getDoubles( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getFloats( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getFloats( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getFloats( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getInts( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getInts( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getInts( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @staticmethod + def getLookupTable( + colorModel: java.awt.image.ColorModel, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getPixelBytes( + bufferedImage: java.awt.image.BufferedImage, boolean: bool + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getPixelBytes( + bufferedImage: java.awt.image.BufferedImage, + boolean: bool, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getPixelBytes( + writableRaster: java.awt.image.WritableRaster, boolean: bool + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getPixelBytes( + writableRaster: java.awt.image.WritableRaster, + boolean: bool, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @staticmethod + def getPixelType(bufferedImage: java.awt.image.BufferedImage) -> int: ... + @typing.overload + @staticmethod + def getPixels(bufferedImage: java.awt.image.BufferedImage) -> typing.Any: ... + @typing.overload + @staticmethod + def getPixels( + bufferedImage: java.awt.image.BufferedImage, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.Any: ... + @typing.overload + @staticmethod + def getPixels(writableRaster: java.awt.image.WritableRaster) -> typing.Any: ... + @typing.overload + @staticmethod + def getPixels( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.Any: ... + @typing.overload + @staticmethod + def getShorts( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getShorts( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getShorts( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @staticmethod + def getSize(image: java.awt.Image) -> java.awt.Dimension: ... + @staticmethod + def getSubimage( + bufferedImage: java.awt.image.BufferedImage, + boolean: bool, + int: int, + int2: int, + int3: int, + int4: int, + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def indexedToRGB( + bufferedImage: java.awt.image.BufferedImage, boolean: bool + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def loadImage(image: java.awt.Image) -> bool: ... + @typing.overload + @staticmethod + def makeBuffered(image: java.awt.Image) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeBuffered( + image: java.awt.Image, colorModel: java.awt.image.ColorModel + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def makeColorModel(int: int, int2: int) -> java.awt.image.ColorModel: ... + @staticmethod + def makeColorSpace(int: int) -> java.awt.color.ColorSpace: ... + @staticmethod + def makeCompatible( + bufferedImage: java.awt.image.BufferedImage, + graphicsConfiguration: java.awt.GraphicsConfiguration, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[int] | jpype.JArray | bytes, + boolean: bool, + metadataRetrieve: loci.formats.meta.MetadataRetrieve, + int: int, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int, boolean: bool + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + boolean: bool, + boolean2: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + boolean: bool, + int4: int, + boolean2: bool, + boolean3: bool, + boolean4: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + int2: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + int2: int, + int3: int, + boolean: bool, + boolean2: bool, + boolean3: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + doubleArray: list[float] | jpype.JArray, int: int, int2: int + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + doubleArray: list[float] | jpype.JArray, + int: int, + int2: int, + int3: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + doubleArray: list[typing.MutableSequence[float]] | jpype.JArray, + int: int, + int2: int, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + floatArray: list[float] | jpype.JArray, int: int, int2: int + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + floatArray: list[float] | jpype.JArray, + int: int, + int2: int, + int3: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + floatArray: list[typing.MutableSequence[float]] | jpype.JArray, + int: int, + int2: int, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + intArray: list[int] | jpype.JArray, int2: int, int3: int, boolean: bool + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + intArray: list[int] | jpype.JArray, + int2: int, + int3: int, + int4: int, + boolean: bool, + boolean2: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + intArray: list[typing.MutableSequence[int]] | jpype.JArray, + int2: int, + int3: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + shortArray: list[int] | jpype.JArray, int: int, int2: int, boolean: bool + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + shortArray: list[int] | jpype.JArray, + int: int, + int2: int, + int3: int, + boolean: bool, + boolean2: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + shortArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + int2: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeRGBImage( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeRGBImage( + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, int: int, int2: int + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def makeUnsigned( + bufferedImage: java.awt.image.BufferedImage, + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def mergeChannels( + bufferedImageArray: list[java.awt.image.BufferedImage] | jpype.JArray, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def openImage( + byteArray: list[int] | jpype.JArray | bytes, + iFormatReader: loci.formats.IFormatReader, + int: int, + int2: int, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def openImage( + byteArray: list[int] | jpype.JArray | bytes, + iFormatReader: loci.formats.IFormatReader, + int: int, + int2: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def padImage( + bufferedImage: java.awt.image.BufferedImage, int: int, int2: int + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def scale( + bufferedImage: java.awt.image.BufferedImage, int: int, int2: int, boolean: bool + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def scale2D( + bufferedImage: java.awt.image.BufferedImage, + int: int, + int2: int, + object: typing.Any, + graphicsConfiguration: java.awt.GraphicsConfiguration, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def scale2D( + bufferedImage: java.awt.image.BufferedImage, + int: int, + int2: int, + object: typing.Any, + colorModel: java.awt.image.ColorModel, + ) -> java.awt.image.BufferedImage: ... + @staticmethod + def scaleAWT( + bufferedImage: java.awt.image.BufferedImage, int: int, int2: int, int3: int + ) -> java.awt.Image: ... + @staticmethod + def splitChannels( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[java.awt.image.BufferedImage]: ... + +class BufferedImageReader(loci.formats.ReaderWrapper): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatReader: loci.formats.IFormatReader): ... + @staticmethod + def makeBufferedImageReader( + iFormatReader: loci.formats.IFormatReader, + ) -> BufferedImageReader: ... + @typing.overload + def openImage(self, int: int) -> java.awt.image.BufferedImage: ... + @typing.overload + def openImage( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> java.awt.image.BufferedImage: ... + def openThumbImage(self, int: int) -> java.awt.image.BufferedImage: ... + +class BufferedImageSource(loci.formats.cache.ICacheSource): + def __init__(self, iFormatReader: loci.formats.IFormatReader): ... + def getObject(self, int: int) -> typing.Any: ... + def getObjectCount(self) -> int: ... + +class BufferedImageWriter(loci.formats.WriterWrapper): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFormatWriter: loci.formats.IFormatWriter): ... + @staticmethod + def makeBufferedImageWriter( + iFormatWriter: loci.formats.IFormatWriter, + ) -> BufferedImageWriter: ... + @typing.overload + def saveImage( + self, int: int, bufferedImage: java.awt.image.BufferedImage + ) -> None: ... + @typing.overload + def saveImage( + self, + int: int, + bufferedImage: java.awt.image.BufferedImage, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @staticmethod + def toBytes( + bufferedImage: java.awt.image.BufferedImage, + iFormatWriter: loci.formats.IFormatWriter, + ) -> typing.MutableSequence[int]: ... + +class CacheComponent( + javax.swing.JPanel, + java.awt.event.ActionListener, + loci.formats.cache.CacheListener, + javax.swing.event.ChangeListener, +): + @typing.overload + def __init__( + self, + cache: loci.formats.cache.Cache, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def __init__( + self, + cache: loci.formats.cache.Cache, + stringArray: list[java.lang.String] | jpype.JArray, + string2: java.lang.String | str, + ): ... + def actionPerformed(self, actionEvent: java.awt.event.ActionEvent) -> None: ... + def cacheUpdated(self, cacheEvent: loci.formats.cache.CacheEvent) -> None: ... + def dispose(self) -> None: ... + def getCache(self) -> loci.formats.cache.Cache: ... + def stateChanged(self, changeEvent: javax.swing.event.ChangeEvent) -> None: ... + +class CacheIndicator(javax.swing.JComponent, loci.formats.cache.CacheListener): + @typing.overload + def __init__(self, cache: loci.formats.cache.Cache, int: int): ... + @typing.overload + def __init__( + self, + cache: loci.formats.cache.Cache, + int: int, + component: java.awt.Component, + int2: int, + int3: int, + ): ... + def cacheUpdated(self, cacheEvent: loci.formats.cache.CacheEvent) -> None: ... + def getMaximumSize(self) -> java.awt.Dimension: ... + def getMinimumSize(self) -> java.awt.Dimension: ... + def getPreferredSize(self) -> java.awt.Dimension: ... + def paintComponent(self, graphics: java.awt.Graphics) -> None: ... + +class ComboFileFilter( + javax.swing.filechooser.FileFilter, java.io.FileFilter, java.lang.Comparable +): + def __init__( + self, + fileFilterArray: list[javax.swing.filechooser.FileFilter] | jpype.JArray, + string: java.lang.String | str, + ): ... + def accept(self, file: java.io.File | jpype.protocol.SupportsPath) -> bool: ... + def compareTo(self, object: typing.Any) -> int: ... + def getDescription(self) -> java.lang.String: ... + def getFilters( + self, + ) -> typing.MutableSequence[javax.swing.filechooser.FileFilter]: ... + @typing.overload + @staticmethod + def sortFilters( + vector: java.util.Vector, + ) -> typing.MutableSequence[javax.swing.filechooser.FileFilter]: ... + @typing.overload + @staticmethod + def sortFilters( + fileFilterArray: list[javax.swing.filechooser.FileFilter] | jpype.JArray, + ) -> typing.MutableSequence[javax.swing.filechooser.FileFilter]: ... + def toString(self) -> java.lang.String: ... + +class DataConverter( + javax.swing.JFrame, + java.awt.event.ActionListener, + javax.swing.event.ChangeListener, + java.lang.Runnable, +): + def __init__(self): ... + def actionPerformed(self, actionEvent: java.awt.event.ActionEvent) -> None: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def run(self) -> None: ... + def stateChanged(self, changeEvent: javax.swing.event.ChangeEvent) -> None: ... + +class ExtensionFileFilter( + javax.swing.filechooser.FileFilter, java.io.FileFilter, java.lang.Comparable +): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + stringArray: list[java.lang.String] | jpype.JArray, + string2: java.lang.String | str, + ): ... + def accept(self, file: java.io.File | jpype.protocol.SupportsPath) -> bool: ... + def compareTo(self, object: typing.Any) -> int: ... + def getDescription(self) -> java.lang.String: ... + def getExtension(self) -> java.lang.String: ... + def getExtensions(self) -> typing.MutableSequence[java.lang.String]: ... + def toString(self) -> java.lang.String: ... + +class FormatFileFilter( + javax.swing.filechooser.FileFilter, java.io.FileFilter, java.lang.Comparable +): + @typing.overload + def __init__(self, iFormatReader: loci.formats.IFormatReader): ... + @typing.overload + def __init__(self, iFormatReader: loci.formats.IFormatReader, boolean: bool): ... + def accept(self, file: java.io.File | jpype.protocol.SupportsPath) -> bool: ... + def compareTo(self, object: typing.Any) -> int: ... + def getDescription(self) -> java.lang.String: ... + def getReader(self) -> loci.formats.IFormatReader: ... + def toString(self) -> java.lang.String: ... + +class GUITools: + @typing.overload + @staticmethod + def buildFileChooser( + fileFilterArray: list[javax.swing.filechooser.FileFilter] | jpype.JArray, + ) -> javax.swing.JFileChooser: ... + @typing.overload + @staticmethod + def buildFileChooser( + fileFilterArray: list[javax.swing.filechooser.FileFilter] | jpype.JArray, + boolean: bool, + ) -> javax.swing.JFileChooser: ... + @typing.overload + @staticmethod + def buildFileChooser( + iFormatHandler: loci.formats.IFormatHandler, + ) -> javax.swing.JFileChooser: ... + @typing.overload + @staticmethod + def buildFileChooser( + iFormatHandler: loci.formats.IFormatHandler, boolean: bool + ) -> javax.swing.JFileChooser: ... + @staticmethod + def buildFileFilters( + iFormatHandler: loci.formats.IFormatHandler, + ) -> typing.MutableSequence[javax.swing.filechooser.FileFilter]: ... + +class ImageViewer( + javax.swing.JFrame, + java.awt.event.ActionListener, + javax.swing.event.ChangeListener, + java.awt.event.KeyListener, + java.awt.event.MouseMotionListener, + java.lang.Runnable, + java.awt.event.WindowListener, +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + def actionPerformed(self, actionEvent: java.awt.event.ActionEvent) -> None: ... + def getC(self) -> int: ... + def getImage(self) -> java.awt.image.BufferedImage: ... + def getImageIndex(self) -> int: ... + def getT(self) -> int: ... + def getZ(self) -> int: ... + def keyPressed(self, keyEvent: java.awt.event.KeyEvent) -> None: ... + def keyReleased(self, keyEvent: java.awt.event.KeyEvent) -> None: ... + def keyTyped(self, keyEvent: java.awt.event.KeyEvent) -> None: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def mouseDragged(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def mouseMoved(self, mouseEvent: java.awt.event.MouseEvent) -> None: ... + def open(self, string: java.lang.String | str) -> None: ... + def run(self) -> None: ... + def save(self, string: java.lang.String | str) -> None: ... + @typing.overload + def setImages( + self, bufferedImageArray: list[java.awt.image.BufferedImage] | jpype.JArray + ) -> None: ... + @typing.overload + def setImages( + self, + iFormatReader: loci.formats.IFormatReader, + bufferedImageArray: list[java.awt.image.BufferedImage] | jpype.JArray, + ) -> None: ... + def setVisible(self, boolean: bool) -> None: ... + def stateChanged(self, changeEvent: javax.swing.event.ChangeEvent) -> None: ... + def windowActivated(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowClosed(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowClosing(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowDeactivated(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowDeiconified(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowIconified(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + def windowOpened(self, windowEvent: java.awt.event.WindowEvent) -> None: ... + +class Index16ColorModel(java.awt.image.ColorModel): + def __init__( + self, + int: int, + int2: int, + shortArray: list[typing.MutableSequence[int]] | jpype.JArray, + boolean: bool, + ): ... + def createCompatibleWritableRaster( + self, int: int, int2: int + ) -> java.awt.image.WritableRaster: ... + @typing.overload + def getAlpha(self, object: typing.Any) -> int: ... + @typing.overload + def getAlpha(self, int: int) -> int: ... + def getAlphas(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getBlue(self, object: typing.Any) -> int: ... + @typing.overload + def getBlue(self, int: int) -> int: ... + def getBlues(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getDataElements( + self, floatArray: list[float] | jpype.JArray, int: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, intArray: list[int] | jpype.JArray, int2: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements(self, int: int, object: typing.Any) -> typing.Any: ... + @typing.overload + def getGreen(self, object: typing.Any) -> int: ... + @typing.overload + def getGreen(self, int: int) -> int: ... + def getGreens(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getRed(self, object: typing.Any) -> int: ... + @typing.overload + def getRed(self, int: int) -> int: ... + def getReds(self) -> typing.MutableSequence[int]: ... + def isCompatibleRaster(self, raster: java.awt.image.Raster) -> bool: ... + +class NoExtensionFileFilter( + javax.swing.filechooser.FileFilter, java.io.FileFilter, java.lang.Comparable +): + def __init__(self): ... + def accept(self, file: java.io.File | jpype.protocol.SupportsPath) -> bool: ... + def compareTo(self, object: typing.Any) -> int: ... + def getDescription(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class PreviewPane( + javax.swing.JPanel, java.beans.PropertyChangeListener, java.lang.Runnable +): + def __init__(self, jFileChooser: javax.swing.JFileChooser): ... + def close(self) -> None: ... + def getPreferredSize(self) -> java.awt.Dimension: ... + def propertyChange( + self, propertyChangeEvent: java.beans.PropertyChangeEvent + ) -> None: ... + def run(self) -> None: ... + +class SignedByteBuffer(java.awt.image.DataBuffer): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes, int: int): ... + @typing.overload + def __init__( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray, int: int + ): ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + +class SignedColorModel(java.awt.image.ColorModel): + def __init__(self, int: int, int2: int, int3: int): ... + def createCompatibleWritableRaster( + self, int: int, int2: int + ) -> java.awt.image.WritableRaster: ... + @typing.overload + def getAlpha(self, int: int) -> int: ... + @typing.overload + def getAlpha(self, object: typing.Any) -> int: ... + @typing.overload + def getBlue(self, int: int) -> int: ... + @typing.overload + def getBlue(self, object: typing.Any) -> int: ... + @typing.overload + def getDataElements( + self, floatArray: list[float] | jpype.JArray, int: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, intArray: list[int] | jpype.JArray, int2: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements(self, int: int, object: typing.Any) -> typing.Any: ... + @typing.overload + def getGreen(self, int: int) -> int: ... + @typing.overload + def getGreen(self, object: typing.Any) -> int: ... + @typing.overload + def getRed(self, int: int) -> int: ... + @typing.overload + def getRed(self, object: typing.Any) -> int: ... + def isCompatibleRaster(self, raster: java.awt.image.Raster) -> bool: ... + +class SignedShortBuffer(java.awt.image.DataBuffer): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, shortArray: list[int] | jpype.JArray, int: int): ... + @typing.overload + def __init__(self, shortArray: list[int] | jpype.JArray, int: int, int2: int): ... + @typing.overload + def __init__( + self, shortArray: list[typing.MutableSequence[int]] | jpype.JArray, int: int + ): ... + @typing.overload + def __init__( + self, + shortArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + +class TwoChannelColorSpace(java.awt.color.ColorSpace): + CS_2C: typing.ClassVar[int] = ... + def fromCIEXYZ( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def fromRGB( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + @staticmethod + def getInstance(int: int) -> java.awt.color.ColorSpace: ... + def getName(self, int: int) -> java.lang.String: ... + def getNumComponents(self) -> int: ... + def getType(self) -> int: ... + def isCS_sRGB(self) -> bool: ... + def toCIEXYZ( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def toRGB( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + +class UnsignedIntBuffer(java.awt.image.DataBuffer): + @typing.overload + def __init__(self, intArray: list[int] | jpype.JArray, int2: int): ... + @typing.overload + def __init__( + self, intArray: list[typing.MutableSequence[int]] | jpype.JArray, int2: int + ): ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def getElemDouble(self, int: int) -> float: ... + @typing.overload + def getElemDouble(self, int: int, int2: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int, int2: int) -> float: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def setElemDouble(self, int: int, double: float) -> None: ... + @typing.overload + def setElemDouble(self, int: int, int2: int, double: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, float: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, int2: int, float: float) -> None: ... + +class UnsignedIntColorModel(java.awt.image.ColorModel): + def __init__(self, int: int, int2: int, int3: int): ... + def createCompatibleWritableRaster( + self, int: int, int2: int + ) -> java.awt.image.WritableRaster: ... + @typing.overload + def getAlpha(self, int: int) -> int: ... + @typing.overload + def getAlpha(self, object: typing.Any) -> int: ... + @typing.overload + def getBlue(self, int: int) -> int: ... + @typing.overload + def getBlue(self, object: typing.Any) -> int: ... + @typing.overload + def getDataElements( + self, floatArray: list[float] | jpype.JArray, int: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, intArray: list[int] | jpype.JArray, int2: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements(self, int: int, object: typing.Any) -> typing.Any: ... + @typing.overload + def getGreen(self, int: int) -> int: ... + @typing.overload + def getGreen(self, object: typing.Any) -> int: ... + @typing.overload + def getRed(self, int: int) -> int: ... + @typing.overload + def getRed(self, object: typing.Any) -> int: ... + def isCompatibleRaster(self, raster: java.awt.image.Raster) -> bool: ... + +class XMLCellRenderer(javax.swing.tree.DefaultTreeCellRenderer): + def __init__(self): ... + def getTreeCellRendererComponent( + self, + jTree: javax.swing.JTree, + object: typing.Any, + boolean: bool, + boolean2: bool, + boolean3: bool, + int: int, + boolean4: bool, + ) -> java.awt.Component: ... + @staticmethod + def makeJTree(document: org.w3c.dom.Document) -> javax.swing.JTree: ... + +class XMLWindow(javax.swing.JFrame): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def getDocument(self) -> org.w3c.dom.Document: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def setDocument(self, document: org.w3c.dom.Document) -> None: ... + @typing.overload + def setXML(self, file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + @typing.overload + def setXML(self, string: java.lang.String | str) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.gui")``. + + AWTImageTools: type[AWTImageTools] + BufferedImageReader: type[BufferedImageReader] + BufferedImageSource: type[BufferedImageSource] + BufferedImageWriter: type[BufferedImageWriter] + CacheComponent: type[CacheComponent] + CacheIndicator: type[CacheIndicator] + ComboFileFilter: type[ComboFileFilter] + DataConverter: type[DataConverter] + ExtensionFileFilter: type[ExtensionFileFilter] + FormatFileFilter: type[FormatFileFilter] + GUITools: type[GUITools] + ImageViewer: type[ImageViewer] + Index16ColorModel: type[Index16ColorModel] + NoExtensionFileFilter: type[NoExtensionFileFilter] + PreviewPane: type[PreviewPane] + SignedByteBuffer: type[SignedByteBuffer] + SignedColorModel: type[SignedColorModel] + SignedShortBuffer: type[SignedShortBuffer] + TwoChannelColorSpace: type[TwoChannelColorSpace] + UnsignedIntBuffer: type[UnsignedIntBuffer] + UnsignedIntColorModel: type[UnsignedIntColorModel] + XMLCellRenderer: type[XMLCellRenderer] + XMLWindow: type[XMLWindow] diff --git a/typings/loci/formats/in_/LeicaMicrosystemsMetadata/__init__.pyi b/typings/loci/formats/in_/LeicaMicrosystemsMetadata/__init__.pyi new file mode 100644 index 0000000..febfc70 --- /dev/null +++ b/typings/loci/formats/in_/LeicaMicrosystemsMetadata/__init__.pyi @@ -0,0 +1,395 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype +import loci +import loci.formats +import loci.formats.meta +import ome.units.quantity +import org.slf4j +import org.w3c.dom + +class Channel: + channelTag: int = ... + resolution: int = ... + min: float = ... + max: float = ... + unit: java.lang.String = ... + lutName: java.lang.String = ... + bytesInc: int = ... + isLutInverted: bool = ... + bitInc: int = ... + dataType: int = ... + nameOfMeasuredQuantity: java.lang.String = ... + channelType: Channel.ChannelType = ... + def __init__( + self, + int: int, + int2: int, + double: float, + double2: float, + string: java.lang.String | str, + string2: java.lang.String | str, + long: int, + ): ... + class ChannelType(java.lang.Enum["Channel.ChannelType"]): + MONO: typing.ClassVar[Channel.ChannelType] = ... + RED: typing.ClassVar[Channel.ChannelType] = ... + GREEN: typing.ClassVar[Channel.ChannelType] = ... + BLUE: typing.ClassVar[Channel.ChannelType] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Channel.ChannelType: ... + @staticmethod + def values() -> typing.MutableSequence[Channel.ChannelType]: ... + +class Dimension: + key: Dimension.DimensionKey = ... + size: int = ... + bytesInc: int = ... + unit: java.lang.String = ... + oldPhysicalSize: bool = ... + frameIndex: int = ... + def __init__( + self, + dimensionKey: Dimension.DimensionKey, + int: int, + long: int, + string: java.lang.String | str, + double: float, + boolean: bool, + ): ... + @staticmethod + def createChannelDimension(int: int, long: int) -> Dimension: ... + def getLength(self) -> float: ... + def setLength(self, double: float) -> None: ... + class DimensionKey(java.lang.Enum["Dimension.DimensionKey"]): + X: typing.ClassVar[Dimension.DimensionKey] = ... + Y: typing.ClassVar[Dimension.DimensionKey] = ... + Z: typing.ClassVar[Dimension.DimensionKey] = ... + T: typing.ClassVar[Dimension.DimensionKey] = ... + C: typing.ClassVar[Dimension.DimensionKey] = ... + S: typing.ClassVar[Dimension.DimensionKey] = ... + id: int = ... + token: str = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Dimension.DimensionKey: ... + @staticmethod + def values() -> typing.MutableSequence[Dimension.DimensionKey]: ... + @staticmethod + def with_(int: int) -> Dimension.DimensionKey: ... + +class LMSCollectionXmlDocument( + loci.formats.in_.LeicaMicrosystemsMetadata.LMSXmlDocument +): + def __init__( + self, + string: java.lang.String | str, + lMSCollectionXmlDocument: LMSCollectionXmlDocument, + ): ... + def getChildrenFiles(self, boolean: bool) -> java.util.List[java.lang.String]: ... + def getXlifs(self) -> java.util.List[XlifDocument]: ... + +class LMSFileReader(loci.formats.FormatReader): + OLD_PHYSICAL_SIZE_KEY: typing.ClassVar[java.lang.String] = ... + OLD_PHYSICAL_SIZE_DEFAULT: typing.ClassVar[bool] = ... + log: typing.ClassVar[org.slf4j.Logger] = ... + metaTemp: MetadataTempBuffer = ... + associatedXmlDoc: LMSXmlDocument = ... + def addSeriesMeta( + self, string: java.lang.String | str, object: typing.Any + ) -> None: ... + def addSeriesMetaList( + self, string: java.lang.String | str, object: typing.Any + ) -> None: ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @staticmethod + def fileExists(string: java.lang.String | str) -> bool: ... + def getCore(self) -> java.util.List[loci.formats.CoreMetadata]: ... + def getImageFormat(self) -> LMSFileReader.ImageFormat: ... + def makeFilterMetadata(self) -> loci.formats.meta.MetadataStore: ... + def setCore( + self, arrayList: java.util.ArrayList[loci.formats.CoreMetadata] + ) -> None: ... + @typing.overload + def translateMetadata(self, list: java.util.List[LMSImageXmlDocument]) -> None: ... + @typing.overload + def translateMetadata(self, lMSImageXmlDocument: LMSImageXmlDocument) -> None: ... + def useOldPhysicalSizeCalculation(self) -> bool: ... + class ImageFormat(java.lang.Enum["LMSFileReader.ImageFormat"]): + LOF: typing.ClassVar[LMSFileReader.ImageFormat] = ... + TIF: typing.ClassVar[LMSFileReader.ImageFormat] = ... + BMP: typing.ClassVar[LMSFileReader.ImageFormat] = ... + JPEG: typing.ClassVar[LMSFileReader.ImageFormat] = ... + PNG: typing.ClassVar[LMSFileReader.ImageFormat] = ... + UNKNOWN: typing.ClassVar[LMSFileReader.ImageFormat] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> LMSFileReader.ImageFormat: ... + @staticmethod + def values() -> typing.MutableSequence[LMSFileReader.ImageFormat]: ... + +class LMSImageXmlDocument(loci.formats.in_.LeicaMicrosystemsMetadata.LMSXmlDocument): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + lMSCollectionXmlDocument: LMSCollectionXmlDocument, + ): ... + def getImageName(self) -> java.lang.String: ... + def getImageNode(self) -> org.w3c.dom.Node: ... + +class LMSMetadataExtractor: + def __init__(self, lMSFileReader: LMSFileReader): ... + @staticmethod + def getChannelIndex(element: org.w3c.dom.Element) -> int: ... + def parseDouble(self, string: java.lang.String | str) -> float: ... + def parseInt(self, string: java.lang.String | str) -> int: ... + def parseLong(self, string: java.lang.String | str) -> int: ... + def translateAttachmentNodes( + self, element: org.w3c.dom.Element, int: int + ) -> None: ... + def translateChannelDescriptions( + self, element: org.w3c.dom.Element, int: int + ) -> None: ... + def translateDetectors(self, element: org.w3c.dom.Element, int: int) -> None: ... + def translateFilterSettings( + self, element: org.w3c.dom.Element, int: int + ) -> None: ... + def translateImage(self, element: org.w3c.dom.Element, int: int) -> None: ... + def translateLaserLines(self, element: org.w3c.dom.Element, int: int) -> None: ... + def translateMetadata(self, list: java.util.List[LMSImageXmlDocument]) -> None: ... + def translateROIs(self, element: org.w3c.dom.Element, int: int) -> None: ... + def translateScannerSettings( + self, element: org.w3c.dom.Element, int: int + ) -> None: ... + def translateSingleROIs(self, element: org.w3c.dom.Element, int: int) -> None: ... + def translateTimestamps(self, element: org.w3c.dom.Element, int: int) -> None: ... + +class LMSXmlDocument: + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + lMSCollectionXmlDocument: LMSCollectionXmlDocument, + ): ... + def getDoc(self) -> org.w3c.dom.Document: ... + def getFilepath(self) -> java.lang.String: ... + def getParentFiles(self) -> java.util.List[java.lang.String]: ... + def nodeToString(self, node: org.w3c.dom.Node) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + @typing.overload + def xPath(self, string: java.lang.String | str) -> org.w3c.dom.NodeList: ... + @typing.overload + def xPath( + self, node: org.w3c.dom.Node, string: java.lang.String | str + ) -> org.w3c.dom.NodeList: ... + class InitFrom(java.lang.Enum["LMSXmlDocument.InitFrom"]): + XML: typing.ClassVar[LMSXmlDocument.InitFrom] = ... + FILEPATH: typing.ClassVar[LMSXmlDocument.InitFrom] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> LMSXmlDocument.InitFrom: ... + @staticmethod + def values() -> typing.MutableSequence[LMSXmlDocument.InitFrom]: ... + +class LofXmlDocument(LMSImageXmlDocument): + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def getImageName(self) -> java.lang.String: ... + def getImageNode(self) -> org.w3c.dom.Node: ... + +class MetadataStoreInitializer: + def __init__(self, lMSFileReader: LMSFileReader): ... + def checkFlip( + self, boolean: bool, length: ome.units.quantity.Length + ) -> ome.units.quantity.Length: ... + def getTileIndex(self, int: int) -> int: ... + def initDetectorModels(self, int: int) -> None: ... + def initFilterModels(self, int: int) -> None: ... + def initImageDetails(self, int: int) -> None: ... + def initLasers(self, int: int) -> None: ... + def initMetadataStore(self) -> None: ... + def initStandDetails(self, int: int) -> None: ... + +class MetadataTempBuffer: + channelColors: java.util.List = ... + channelPrios: typing.MutableSequence[typing.MutableSequence[int]] = ... + physicalSizeXs: java.util.List = ... + physicalSizeYs: java.util.List = ... + fieldPosX: java.util.List = ... + fieldPosY: java.util.List = ... + descriptions: typing.MutableSequence[java.lang.String] = ... + microscopeModels: typing.MutableSequence[java.lang.String] = ... + serialNumber: typing.MutableSequence[java.lang.String] = ... + pinholes: typing.MutableSequence[float] = ... + zooms: typing.MutableSequence[float] = ... + zSteps: typing.MutableSequence[float] = ... + tSteps: typing.MutableSequence[float] = ... + lensNA: typing.MutableSequence[float] = ... + flipX: typing.MutableSequence[bool] = ... + flipY: typing.MutableSequence[bool] = ... + swapXY: typing.MutableSequence[bool] = ... + expTimes: typing.MutableSequence[typing.MutableSequence[float]] = ... + gains: typing.MutableSequence[typing.MutableSequence[float]] = ... + detectorOffsets: typing.MutableSequence[typing.MutableSequence[float]] = ... + channelNames: typing.MutableSequence[typing.MutableSequence[java.lang.String]] = ... + detectorModels: java.util.ArrayList = ... + exWaves: typing.MutableSequence[typing.MutableSequence[float]] = ... + activeDetector: java.util.ArrayList = ... + detectorIndexes: java.util.ArrayList = ... + immersions: typing.MutableSequence[java.lang.String] = ... + corrections: typing.MutableSequence[java.lang.String] = ... + objectiveModels: typing.MutableSequence[java.lang.String] = ... + magnification: typing.MutableSequence[float] = ... + posX: typing.MutableSequence[ome.units.quantity.Length] = ... + posY: typing.MutableSequence[ome.units.quantity.Length] = ... + posZ: typing.MutableSequence[ome.units.quantity.Length] = ... + refractiveIndex: typing.MutableSequence[float] = ... + cutIns: java.util.ArrayList = ... + cutOuts: java.util.ArrayList = ... + filterModels: java.util.ArrayList = ... + timestamps: typing.MutableSequence[typing.MutableSequence[float]] = ... + laserIntensity: java.util.ArrayList = ... + laserWavelength: java.util.ArrayList = ... + laserActive: java.util.ArrayList = ... + laserFrap: java.util.ArrayList = ... + imageROIs: typing.MutableSequence[typing.MutableSequence[ROI]] = ... + alternateCenter: bool = ... + imageNames: typing.MutableSequence[java.lang.String] = ... + acquiredDate: typing.MutableSequence[float] = ... + tileCount: typing.MutableSequence[int] = ... + tileBytesInc: typing.MutableSequence[int] = ... + inverseRgb: typing.MutableSequence[bool] = ... + channels: java.util.ArrayList = ... + def __init__(self, int: int): ... + def addChannelDimension(self, int: int) -> None: ... + def addDimension(self, int: int, dimension: Dimension) -> None: ... + def addMissingDimensions(self, int: int) -> None: ... + def getDimension( + self, int: int, dimensionKey: Dimension.DimensionKey + ) -> Dimension: ... + def getDimensionOrder(self, int: int) -> java.lang.String: ... + def getDimensions(self, int: int) -> java.util.ArrayList[Dimension]: ... + +class MultipleImagesReader(LMSFileReader): + def __init__(self, xlifDocument: XlifDocument, int: int): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getBitsPerPixel(self) -> int: ... + def getImageFormat(self) -> LMSFileReader.ImageFormat: ... + def getPixelType(self) -> int: ... + def getRGBChannelCount(self) -> int: ... + def getSizeC(self) -> int: ... + def isRGB(self) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def setCoreMetadata(self, coreMetadata: loci.formats.CoreMetadata) -> None: ... + def setMetadataTempBuffer(self, metadataTempBuffer: MetadataTempBuffer) -> None: ... + def setSeries(self, int: int) -> None: ... + def swapDimensions(self) -> None: ... + +class XlcfDocument(LMSCollectionXmlDocument): + def __init__( + self, + string: java.lang.String | str, + lMSCollectionXmlDocument: LMSCollectionXmlDocument, + ): ... + +class XlefDocument(LMSCollectionXmlDocument): + def __init__(self, string: java.lang.String | str): ... + def getImageCount(self) -> int: ... + def printReferences(self) -> None: ... + +class XlifDocument(LMSImageXmlDocument): + def __init__( + self, + string: java.lang.String | str, + lMSCollectionXmlDocument: LMSCollectionXmlDocument, + ): ... + def getElementNode(self) -> org.w3c.dom.Node: ... + def getImageFormat(self) -> LMSFileReader.ImageFormat: ... + def getImageName(self) -> java.lang.String: ... + def getImageNode(self) -> org.w3c.dom.Node: ... + def getImagePaths(self) -> java.util.List[java.lang.String]: ... + def getName(self) -> java.lang.String: ... + def getTileCount(self) -> int: ... + def isValid(self) -> bool: ... + def printXlifInfo(self) -> None: ... + +class ROI: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.in_.LeicaMicrosystemsMetadata")``. + + Channel: type[Channel] + Dimension: type[Dimension] + LMSCollectionXmlDocument: type[LMSCollectionXmlDocument] + LMSFileReader: type[LMSFileReader] + LMSImageXmlDocument: type[LMSImageXmlDocument] + LMSMetadataExtractor: type[LMSMetadataExtractor] + LMSXmlDocument: type[LMSXmlDocument] + LofXmlDocument: type[LofXmlDocument] + MetadataStoreInitializer: type[MetadataStoreInitializer] + MetadataTempBuffer: type[MetadataTempBuffer] + MultipleImagesReader: type[MultipleImagesReader] + ROI: type[ROI] + XlcfDocument: type[XlcfDocument] + XlefDocument: type[XlefDocument] + XlifDocument: type[XlifDocument] diff --git a/typings/loci/formats/in_/__init__.pyi b/typings/loci/formats/in_/__init__.pyi new file mode 100644 index 0000000..a1c6161 --- /dev/null +++ b/typings/loci/formats/in_/__init__.pyi @@ -0,0 +1,8353 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import java.util.regex +import jpype +import jpype.protocol +import loci +import loci.common +import loci.common.xml +import loci.formats +import loci.formats.codec +import loci.formats.dicom +import loci.formats.in_.LeicaMicrosystemsMetadata +import loci.formats.meta +import loci.formats.ome +import loci.formats.services +import loci.formats.tiff +import ome.units.quantity +import ome.xml.model.primitives +import org.slf4j +import org.w3c.dom +import org.xml.sax +import org.xml.sax.helpers + +class AFIReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + +class AIMReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class APLReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class APNGReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ARFReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class AVIReader(loci.formats.FormatReader): + AVI_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class AliconaReader(loci.formats.FormatReader): + AL3D_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class AmiraReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class AnalyzeReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class BDReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class BDVReader(loci.formats.FormatReader): + HDF_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + BDV_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class BIFormatReader(loci.formats.FormatReader): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + def getNativeDataType(self) -> type[typing.Any]: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class BMPReader(loci.formats.FormatReader): + BMP_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class BaseTiffReader(loci.formats.in_.MinimalTiffReader): + DATE_FORMATS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @staticmethod + def getExifTagName(int: int) -> java.lang.String: ... + +class BaseZeissReader(loci.formats.FormatReader): + layers: java.util.ArrayList = ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + class Context(java.lang.Enum["BaseZeissReader.Context"]): + MAIN: typing.ClassVar[BaseZeissReader.Context] = ... + SCALING: typing.ClassVar[BaseZeissReader.Context] = ... + PLANE: typing.ClassVar[BaseZeissReader.Context] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> BaseZeissReader.Context: ... + @staticmethod + def values() -> typing.MutableSequence[BaseZeissReader.Context]: ... + + class Tag: + @typing.overload + def __init__( + self, + baseZeissReader: BaseZeissReader, + int: int, + string: java.lang.String | str, + context: BaseZeissReader.Context, + ): ... + @typing.overload + def __init__( + self, + baseZeissReader: BaseZeissReader, + int: int, + context: BaseZeissReader.Context, + ): ... + def getCategory(self) -> int: ... + def getIndex(self) -> int: ... + def getKey(self) -> java.lang.String: ... + def getKeyID(self) -> int: ... + def getValue(self) -> java.lang.String: ... + def setCategory(self, int: int) -> None: ... + def setIndex(self, int: int) -> None: ... + def setKey(self, int: int) -> None: ... + def setValue(self, string: java.lang.String | str) -> None: ... + def toString(self) -> java.lang.String: ... + def valid(self) -> bool: ... + +class BioRadGelReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class BioRadReader(loci.formats.FormatReader): + NOTE_NAMES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + NOTE_TYPE_LIVE: typing.ClassVar[int] = ... + NOTE_TYPE_FILE1: typing.ClassVar[int] = ... + NOTE_TYPE_NUMBER: typing.ClassVar[int] = ... + NOTE_TYPE_USER: typing.ClassVar[int] = ... + NOTE_TYPE_LINE: typing.ClassVar[int] = ... + NOTE_TYPE_COLLECT: typing.ClassVar[int] = ... + NOTE_TYPE_FILE2: typing.ClassVar[int] = ... + NOTE_TYPE_SCALEBAR: typing.ClassVar[int] = ... + NOTE_TYPE_MERGE: typing.ClassVar[int] = ... + NOTE_TYPE_THRUVIEW: typing.ClassVar[int] = ... + NOTE_TYPE_ARROW: typing.ClassVar[int] = ... + NOTE_TYPE_VARIABLE: typing.ClassVar[int] = ... + NOTE_TYPE_STRUCTURE: typing.ClassVar[int] = ... + NOTE_TYPE_4D_SERIES: typing.ClassVar[int] = ... + STRUCTURE_LABELS_1: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + STRUCTURE_LABELS_2: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + STRUCTURE_LABELS_3: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + STRUCTURE_LABELS_4: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + STRUCTURE_LABELS_5: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + STRUCTURE_LABELS_6: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + PIC_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + LUT_LENGTH: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class BioRadSCNReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class BrukerReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class BurleighReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class CV7000Reader(loci.formats.FormatReader): + DUPLICATE_PLANES_KEY: typing.ClassVar[java.lang.String] = ... + DUPLICATE_PLANES_DEFAULT: typing.ClassVar[bool] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def duplicatePlanes(self) -> bool: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class CanonRawReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class CellH5Reader(loci.formats.FormatReader): + HDF_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + class CellH5Constants: + PREFIX_PATH: typing.ClassVar[java.lang.String] = ... + IMAGE_PATH: typing.ClassVar[java.lang.String] = ... + SEGMENTATION_PATH: typing.ClassVar[java.lang.String] = ... + PLATE: typing.ClassVar[java.lang.String] = ... + WELL: typing.ClassVar[java.lang.String] = ... + SITE: typing.ClassVar[java.lang.String] = ... + DEFINITION: typing.ClassVar[java.lang.String] = ... + OBJECT: typing.ClassVar[java.lang.String] = ... + FEATURE: typing.ClassVar[java.lang.String] = ... + IMAGE: typing.ClassVar[java.lang.String] = ... + BBOX: typing.ClassVar[java.lang.String] = ... + CLASS_LABELS: typing.ClassVar[java.lang.String] = ... + PREDICTED_CLASS_LABELS: typing.ClassVar[java.lang.String] = ... + def __init__(self, cellH5Reader: CellH5Reader): ... + + class CellH5Coordinate: + plate: java.lang.String = ... + well: java.lang.String = ... + site: java.lang.String = ... + def toString(self) -> java.lang.String: ... + +class CellSensReader(loci.formats.FormatReader): + FAIL_ON_MISSING_KEY: typing.ClassVar[java.lang.String] = ... + FAIL_ON_MISSING_DEFAULT: typing.ClassVar[bool] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def failOnMissingETS(self) -> bool: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class CellVoyagerReader(loci.formats.FormatReader): + def __init__(self): ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class CellWorxReader(loci.formats.FormatReader): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class CellomicsReader(loci.formats.FormatReader): + C01_MAGIC_BYTES: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ColumbusReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class DCIMGReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class DNGReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class DefaultMetadataOptions(loci.formats.in_.MetadataOptions): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, metadataLevel: MetadataLevel): ... + def getMetadataLevel(self) -> MetadataLevel: ... + def isValidate(self) -> bool: ... + def setMetadataLevel(self, metadataLevel: MetadataLevel) -> None: ... + def setValidate(self, boolean: bool) -> None: ... + +class DeltavisionReader(loci.formats.FormatReader): + DV_MAGIC_BYTES_1: typing.ClassVar[int] = ... + DV_MAGIC_BYTES_2: typing.ClassVar[int] = ... + DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + DATE_FORMATS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getPlaneByteOffset(self, int: int, int2: int, int3: int) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def setTruncatedFileFlag(self, boolean: bool) -> None: ... + +class DicomReader(loci.formats.SubResolutionFormatReader): + DICOM_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + HEADER_LENGTH: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getChannelNames(self) -> java.util.List[java.lang.String]: ... + def getConcatenationIndex(self) -> int: ... + def getImageType(self) -> java.lang.String: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getPixelSizeX(self) -> ome.units.quantity.Length: ... + def getPixelSizeY(self) -> ome.units.quantity.Length: ... + def getPixelSizeZ(self) -> ome.units.quantity.Length: ... + def getPositionX(self) -> java.util.List[float]: ... + def getPositionY(self) -> java.util.List[float]: ... + def getPositionZ(self) -> java.util.List[float]: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def getTags(self) -> java.util.List[loci.formats.dicom.DicomTag]: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getTileColumns(self, int: int) -> int: ... + def getTileRows(self, int: int) -> int: ... + def getTiles(self) -> java.util.List[loci.formats.dicom.DicomTile]: ... + def getTimestamp(self) -> ome.xml.model.primitives.Timestamp: ... + def getZOffsets(self) -> java.util.List[float]: ... + def isExtendedDepthOfField(self) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + +class DynamicMetadataOptions(loci.formats.in_.MetadataOptions): + METADATA_LEVEL_KEY: typing.ClassVar[java.lang.String] = ... + METADATA_LEVEL_DEFAULT: typing.ClassVar[MetadataLevel] = ... + READER_VALIDATE_KEY: typing.ClassVar[java.lang.String] = ... + READER_VALIDATE_DEFAULT: typing.ClassVar[bool] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, metadataLevel: MetadataLevel): ... + @typing.overload + def get(self, string: java.lang.String | str) -> java.lang.String: ... + @typing.overload + def get( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def getBoolean(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def getBoolean(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def getClass(self) -> type[typing.Any]: ... + @typing.overload + def getClass(self, string: java.lang.String | str) -> type[typing.Any]: ... + @typing.overload + def getClass( + self, string: java.lang.String | str, class_: type[typing.Any] + ) -> type[typing.Any]: ... + @typing.overload + def getDouble(self, string: java.lang.String | str) -> float: ... + @typing.overload + def getDouble(self, string: java.lang.String | str, double: float) -> float: ... + _getEnum__T = typing.TypeVar("_getEnum__T", bound=java.lang.Enum) # + def getEnum( + self, string: java.lang.String | str, t: _getEnum__T + ) -> _getEnum__T: ... + @typing.overload + def getFile(self, string: java.lang.String | str) -> java.io.File: ... + @typing.overload + def getFile( + self, + string: java.lang.String | str, + file: java.io.File | jpype.protocol.SupportsPath, + ) -> java.io.File: ... + @typing.overload + def getFloat(self, string: java.lang.String | str) -> float: ... + @typing.overload + def getFloat(self, string: java.lang.String | str, float: float) -> float: ... + @typing.overload + def getInteger(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getInteger(self, string: java.lang.String | str, integer: int) -> int: ... + @typing.overload + def getLong(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getLong(self, string: java.lang.String | str, long: int) -> int: ... + def getMetadataLevel(self) -> MetadataLevel: ... + @staticmethod + def getMetadataOptionsFile(string: java.lang.String | str) -> java.lang.String: ... + def isValidate(self) -> bool: ... + def loadOptions( + self, + string: java.lang.String | str, + arrayList: java.util.ArrayList[java.lang.String | str], + ) -> None: ... + def set( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + def setBoolean(self, string: java.lang.String | str, boolean: bool) -> None: ... + def setClass( + self, string: java.lang.String | str, class_: type[typing.Any] + ) -> None: ... + def setDouble(self, string: java.lang.String | str, double: float) -> None: ... + _setEnum__T = typing.TypeVar("_setEnum__T", bound=java.lang.Enum) # + def setEnum(self, string: java.lang.String | str, t: _setEnum__T) -> None: ... + def setFile( + self, + string: java.lang.String | str, + file: java.io.File | jpype.protocol.SupportsPath, + ) -> None: ... + def setFloat(self, string: java.lang.String | str, float: float) -> None: ... + def setInteger(self, string: java.lang.String | str, integer: int) -> None: ... + def setLong(self, string: java.lang.String | str, long: int) -> None: ... + def setMetadataLevel(self, metadataLevel: MetadataLevel) -> None: ... + def setValidate(self, boolean: bool) -> None: ... + +class EPSReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class Ecat7Reader(loci.formats.FormatReader): + ECAT7_MAGIC: typing.ClassVar[java.lang.String] = ... + ECAT7_MAGIC_REGEX: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class FEIReader(loci.formats.FormatReader): + FEI_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class FEITiffReader(BaseTiffReader): + SFEG_TAG: typing.ClassVar[int] = ... + HELIOS_TAG: typing.ClassVar[int] = ... + TITAN_TAG: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + +class FV1000Reader(loci.formats.FormatReader): + FV1000_MAGIC_STRING_1: typing.ClassVar[java.lang.String] = ... + FV1000_MAGIC_STRING_2: typing.ClassVar[java.lang.String] = ... + OIB_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + OIF_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + FV1000_SUFFIXES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + PREVIEWNAME_PREFIXES: typing.ClassVar[ + typing.MutableSequence[java.lang.String] + ] = ... + DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class FakeReader(loci.formats.FormatReader): + BOX_SIZE: typing.ClassVar[int] = ... + DEFAULT_SIZE_X: typing.ClassVar[int] = ... + DEFAULT_SIZE_Y: typing.ClassVar[int] = ... + DEFAULT_SIZE_Z: typing.ClassVar[int] = ... + DEFAULT_SIZE_C: typing.ClassVar[int] = ... + DEFAULT_SIZE_T: typing.ClassVar[int] = ... + DEFAULT_PIXEL_TYPE: typing.ClassVar[int] = ... + DEFAULT_RGB_CHANNEL_COUNT: typing.ClassVar[int] = ... + DEFAULT_DIMENSION_ORDER: typing.ClassVar[java.lang.String] = ... + DEFAULT_RGB_DIMENSION_ORDER: typing.ClassVar[java.lang.String] = ... + DEFAULT_RESOLUTION_SCALE: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOmeXmlMetadata(self) -> loci.formats.ome.OMEXMLMetadata: ... + def getOmeXmlService(self) -> loci.formats.services.OMEXMLService: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def readSpecialPixels( + byteArray: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def readSpecialPixels( + byteArray: list[int] | jpype.JArray | bytes, int: int, boolean: bool + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def readSpecialPixels( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + boolean: bool, + int2: int, + boolean2: bool, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class FilePatternReader(loci.formats.WrappedReader): + def __init__(self): ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getCoreMetadataList(self) -> java.util.List[loci.formats.CoreMetadata]: ... + def getMetadataStore(self) -> loci.formats.meta.MetadataStore: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def hasCompanionFiles(self) -> bool: ... + def hasFlattenedResolutions(self) -> bool: ... + def isGroupFiles(self) -> bool: ... + def isMetadataFiltered(self) -> bool: ... + def isNormalized(self) -> bool: ... + def isOriginalMetadataPopulated(self) -> bool: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + def setFlattenedResolutions(self, boolean: bool) -> None: ... + def setGroupFiles(self, boolean: bool) -> None: ... + def setMetadataFiltered(self, boolean: bool) -> None: ... + def setMetadataStore( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> None: ... + def setNormalized(self, boolean: bool) -> None: ... + def setOriginalMetadataPopulated(self, boolean: bool) -> None: ... + +class FitsReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class FlexReader(loci.formats.FormatReader): + FLEX: typing.ClassVar[int] = ... + FLEX_SUFFIX: typing.ClassVar[java.lang.String] = ... + MEA_SUFFIX: typing.ClassVar[java.lang.String] = ... + RES_SUFFIX: typing.ClassVar[java.lang.String] = ... + MEASUREMENT_SUFFIXES: typing.ClassVar[ + typing.MutableSequence[java.lang.String] + ] = ... + SUFFIXES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + SCREENING: typing.ClassVar[java.lang.String] = ... + ARCHIVE: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @staticmethod + def appendServerMap( + string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + @staticmethod + def mapServer( + string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + @typing.overload + @staticmethod + def mapServer( + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ) -> None: ... + @staticmethod + def mapServersFromConfigurationFile(string: java.lang.String | str) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + class FlexHandler(loci.common.xml.BaseHandler): + def __init__( + self, + flexReader: FlexReader, + list: java.util.List, + list2: java.util.List, + metadataStore: loci.formats.meta.MetadataStore, + boolean: bool, + int: int, + int2: int, + ): ... + def characters( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + def endElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> None: ... + def startElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + attributes: org.xml.sax.Attributes, + ) -> None: ... + + class MeaHandler(loci.common.xml.BaseHandler): + def __init__(self, flexReader: FlexReader): ... + def getFlexFiles(self) -> java.util.List[java.lang.String]: ... + def startElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + attributes: org.xml.sax.Attributes, + ) -> None: ... + + class ResHandler(loci.common.xml.BaseHandler): + def __init__(self, flexReader: FlexReader): ... + def startElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + attributes: org.xml.sax.Attributes, + ) -> None: ... + +class FlowSightReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class FluoviewReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class FujiReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class GIFReader(loci.formats.FormatReader): + GIF_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class GatanDM2Reader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class GatanReader(loci.formats.FormatReader): + DM3_MAGIC_BYTES: typing.ClassVar[int] = ... + DM4_MAGIC_BYTES: typing.ClassVar[int] = ... + SPLIT_MONTAGE: typing.ClassVar[java.lang.String] = ... + SPLIT_MONTAGE_DEFAULT: typing.ClassVar[bool] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def splitMontage(self) -> bool: ... + +class GelReader(BaseTiffReader): + DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + TIME_FORMAT: typing.ClassVar[java.lang.String] = ... + DATE_TIME_FORMAT: typing.ClassVar[java.lang.String] = ... + FORMATS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class HISReader(loci.formats.FormatReader): + HIS_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class HRDGDFReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class HamamatsuVMSReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class HitachiReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class I2IReader(loci.formats.FormatReader): + def __init__(self): ... + def initFile(self, string: java.lang.String | str) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ICSReader(loci.formats.FormatReader): + NL: typing.ClassVar[java.lang.String] = ... + DATE_FORMATS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isInterleaved(self) -> bool: ... + @typing.overload + def isInterleaved(self, int: int) -> bool: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class IM3Reader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getSpectra(self) -> java.util.List[IM3Reader.Spectrum]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def openRaw(self) -> typing.MutableSequence[int]: ... + def setSeries(self, int: int) -> None: ... + def writeSummary(self) -> None: ... + class Spectrum: + def getMagnitudes(self) -> typing.MutableSequence[float]: ... + def getName(self) -> java.lang.String: ... + def getWavelengths(self) -> typing.MutableSequence[float]: ... + +class IMODReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class INRReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class IPLabReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class IPWReader(loci.formats.FormatReader): + IPW_MAGIC_BYTES: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ImaconReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ImageIOReader(BIFormatReader): + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getOptimalTileHeight(self) -> int: ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + +class ImagicReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class ImarisHDFReader(loci.formats.SubResolutionFormatReader): + HDF_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ImarisReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ImarisTiffReader(BaseTiffReader): + def __init__(self): ... + +class ImprovisionTiffReader(BaseTiffReader): + IMPROVISION_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ImspectorReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class InCell3000Reader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class InCellReader(loci.formats.FormatReader): + DUPLICATE_PLANES_KEY: typing.ClassVar[java.lang.String] = ... + DUPLICATE_PLANES_DEFAULT: typing.ClassVar[bool] = ... + INCELL_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + CYTELL_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def duplicatePlanes(self) -> bool: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class InveonReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class IonpathMIBITiffReader(BaseTiffReader): + IONPATH_MIBI_SOFTWARE_PREFIX: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class IvisionReader(loci.formats.FormatReader): + DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class JEOLReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class JPEG2000MetadataParser: + @typing.overload + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ): ... + @typing.overload + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream, long: int + ): ... + def getCodestreamOffset(self) -> int: ... + def getCodestreamPixelType(self) -> int: ... + def getCodestreamSizeC(self) -> int: ... + def getCodestreamSizeX(self) -> int: ... + def getCodestreamSizeY(self) -> int: ... + def getComments(self) -> java.util.ArrayList[java.lang.String]: ... + def getHeaderPixelType(self) -> int: ... + def getHeaderSizeC(self) -> int: ... + def getHeaderSizeX(self) -> int: ... + def getHeaderSizeY(self) -> int: ... + def getLookupTable(self) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getResolutionLevels(self) -> int: ... + def isRawCodestream(self) -> bool: ... + +class JPEG2000Reader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class JPEGReader(loci.formats.DelegateReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def setId(self, string: java.lang.String | str) -> None: ... + class DefaultJPEGReader(ImageIOReader): + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + +class JPKReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class JPXReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class KLBReader(loci.formats.FormatReader): + CHANNEL_PREFIX: typing.ClassVar[java.lang.String] = ... + TIME_PREFIX: typing.ClassVar[java.lang.String] = ... + TIME_SUFFIX: typing.ClassVar[java.lang.String] = ... + PROJECTION_PREFIX: typing.ClassVar[java.lang.String] = ... + PROJECTION_SUFFIX: typing.ClassVar[java.lang.String] = ... + SERIES_PREFIXES: typing.ClassVar[java.util.Set] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class KhorosReader(loci.formats.FormatReader): + KHOROS_MAGIC_BYTES: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class KodakReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class L2DReader(loci.formats.FormatReader): + DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class LEOReader(BaseTiffReader): + LEO_TAG: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + +class LIFReader(loci.formats.FormatReader): + OLD_PHYSICAL_SIZE_KEY: typing.ClassVar[java.lang.String] = ... + OLD_PHYSICAL_SIZE_DEFAULT: typing.ClassVar[bool] = ... + LIF_MAGIC_BYTE: typing.ClassVar[int] = ... + LIF_MEMORY_BYTE: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def useOldPhysicalSizeCalculation(self) -> bool: ... + +class LIMReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class LIPixelFormat: + PIXELFORMAT_MONO8: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO10: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO10P: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO10PMSB: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO12: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO12P: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO12PMSB: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO12PACKED: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO14: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO14P: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_MONO16: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BGR8: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BGR8PACKED: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_RGB8: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_RGB8PACKED: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERBG8: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERBG12: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERBG12P: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERBG12PMSB: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERBG16: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGB8: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGB12: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGB12P: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGB12PMSB: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGB16: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGR8: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGR10: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGR12: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGR12P: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGR12PMSB: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERGR16: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERRG8: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERRG10: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERRG12: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERRG12P: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERRG12PMSB: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERRG12PACKED: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_BAYERRG16: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @staticmethod + def getPacking(string: java.lang.String | str) -> java.lang.String: ... + @staticmethod + def pixelFormatEqualsBitSize( + integer: int, string: java.lang.String | str + ) -> bool: ... + +class LOFReader(loci.formats.in_.LeicaMicrosystemsMetadata.LMSFileReader): + LOF_MAGIC_BYTE: typing.ClassVar[int] = ... + LOF_MEMORY_BYTE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, xlifDocument: loci.formats.in_.LeicaMicrosystemsMetadata.XlifDocument + ): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getImageFormat( + self, + ) -> loci.formats.in_.LeicaMicrosystemsMetadata.LMSFileReader.ImageFormat: ... + def getOptimalTileHeight(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def setIdWithMetadata( + self, + string: java.lang.String | str, + xlifDocument: loci.formats.in_.LeicaMicrosystemsMetadata.XlifDocument, + ) -> None: ... + class MetadataSource(java.lang.Enum["LOFReader.MetadataSource"]): + LOF: typing.ClassVar[LOFReader.MetadataSource] = ... + XLIF: typing.ClassVar[LOFReader.MetadataSource] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> LOFReader.MetadataSource: ... + @staticmethod + def values() -> typing.MutableSequence[LOFReader.MetadataSource]: ... + +class LeicaHandler(loci.common.xml.BaseHandler): + @typing.overload + def __init__( + self, + metadataStore: loci.formats.meta.MetadataStore, + metadataLevel: MetadataLevel, + ): ... + @typing.overload + def __init__( + self, + metadataStore: loci.formats.meta.MetadataStore, + metadataLevel: MetadataLevel, + boolean: bool, + ): ... + def endElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> None: ... + def getCoreMetadataList(self) -> java.util.List[loci.formats.CoreMetadata]: ... + def getDeltaT(self) -> java.util.Map[java.lang.String, ome.units.quantity.Time]: ... + def getExposureTimes( + self, + ) -> java.util.Map[java.lang.String, ome.units.quantity.Time]: ... + def getGlobalMetadata(self) -> java.util.Hashtable: ... + def getLutNames(self) -> java.util.Vector[java.lang.String]: ... + def startElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + attributes: org.xml.sax.Attributes, + ) -> None: ... + +class LeicaReader(loci.formats.FormatReader): + LEI_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class LeicaSCNReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getThumbSizeX(self) -> int: ... + def getThumbSizeY(self) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + +class LiFlimReader(loci.formats.FormatReader): + INFO_TABLE: typing.ClassVar[java.lang.String] = ... + LAYOUT_TABLE: typing.ClassVar[java.lang.String] = ... + BACKGROUND_TABLE: typing.ClassVar[java.lang.String] = ... + VERSION_KEY: typing.ClassVar[java.lang.String] = ... + COMPRESSION_KEY: typing.ClassVar[java.lang.String] = ... + DATATYPE_KEY: typing.ClassVar[java.lang.String] = ... + PACKING_KEY: typing.ClassVar[java.lang.String] = ... + C_KEY: typing.ClassVar[java.lang.String] = ... + X_KEY: typing.ClassVar[java.lang.String] = ... + Y_KEY: typing.ClassVar[java.lang.String] = ... + Z_KEY: typing.ClassVar[java.lang.String] = ... + P_KEY: typing.ClassVar[java.lang.String] = ... + F_KEY: typing.ClassVar[java.lang.String] = ... + T_KEY: typing.ClassVar[java.lang.String] = ... + DarkImage_KEY: typing.ClassVar[java.lang.String] = ... + TIMESTAMP_KEY: typing.ClassVar[java.lang.String] = ... + NUMBEROFFRAMES_KEY: typing.ClassVar[java.lang.String] = ... + NUMBEROFDARKIMAGES_KEY: typing.ClassVar[java.lang.String] = ... + PIXELFORMAT_KEY: typing.ClassVar[java.lang.String] = ... + KNOWN_VERSIONS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + COMPRESSION_NONE: typing.ClassVar[java.lang.String] = ... + COMPRESSION_GZIP: typing.ClassVar[java.lang.String] = ... + DATATYPE_UINT8: typing.ClassVar[java.lang.String] = ... + DATATYPE_INT8: typing.ClassVar[java.lang.String] = ... + DATATYPE_UINT16: typing.ClassVar[java.lang.String] = ... + DATATYPE_INT16: typing.ClassVar[java.lang.String] = ... + DATATYPE_UINT32: typing.ClassVar[java.lang.String] = ... + DATATYPE_INT32: typing.ClassVar[java.lang.String] = ... + DATATYPE_REAL32: typing.ClassVar[java.lang.String] = ... + DATATYPE_REAL64: typing.ClassVar[java.lang.String] = ... + DATATYPE_UINT12: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class MIASReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def parseMasks(self, metadataStore: loci.formats.meta.MetadataStore) -> None: ... + def populateMaskPixels( + self, + int: int, + int2: int, + int3: int, + metadataStore: loci.formats.meta.MetadataStore, + ) -> bool: ... + def setAutomaticallyParseMasks(self, boolean: bool) -> None: ... + +class MINCReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class MNGReader(BIFormatReader): + MNG_MAGIC_BYTES: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + +class MRCReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def initFile(self, string: java.lang.String | str) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class MRWReader(loci.formats.FormatReader): + MRW_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class MetadataLevel(java.lang.Enum["MetadataLevel"]): + MINIMUM: typing.ClassVar[MetadataLevel] = ... + NO_OVERLAYS: typing.ClassVar[MetadataLevel] = ... + ALL: typing.ClassVar[MetadataLevel] = ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> MetadataLevel: ... + @staticmethod + def values() -> typing.MutableSequence[MetadataLevel]: ... + +class MetadataOptions: + def getMetadataLevel(self) -> MetadataLevel: ... + def isValidate(self) -> bool: ... + def setMetadataLevel(self, metadataLevel: MetadataLevel) -> None: ... + def setValidate(self, boolean: bool) -> None: ... + +class MetamorphHandler(loci.common.xml.BaseHandler): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, hashtable: java.util.Hashtable): ... + def getBinning(self) -> java.lang.String: ... + def getChannelName(self) -> java.lang.String: ... + def getChannelNames(self) -> java.util.Vector[java.lang.String]: ... + def getDate(self) -> java.lang.String: ... + def getExposures(self) -> java.util.Vector[float]: ... + def getGain(self) -> float: ... + def getImageName(self) -> java.lang.String: ... + def getLensNA(self) -> float: ... + def getLensRI(self) -> float: ... + def getPixelSizeX(self) -> float: ... + def getPixelSizeY(self) -> float: ... + def getReadOutRate(self) -> float: ... + def getStageLabel(self) -> java.lang.String: ... + def getStagePositionX(self) -> ome.units.quantity.Length: ... + def getStagePositionY(self) -> ome.units.quantity.Length: ... + def getTemperature(self) -> float: ... + def getTimestamps(self) -> java.util.Vector[java.lang.String]: ... + def getWavelengths(self) -> java.util.Vector[int]: ... + def getZPositions(self) -> java.util.Vector[float]: ... + def getZoom(self) -> float: ... + def hasDualCamera(self) -> bool: ... + def startElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + attributes: org.xml.sax.Attributes, + ) -> None: ... + +class MetamorphReader(BaseTiffReader): + SHORT_DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + LONG_DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + ND_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + STK_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + WELL_COORDS: typing.ClassVar[java.util.regex.Pattern] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @staticmethod + def decodeDate(int: int) -> java.lang.String: ... + @staticmethod + def decodeTime(int: int) -> java.lang.String: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @staticmethod + def intFormat(int: int, int2: int) -> java.lang.String: ... + @staticmethod + def intFormatMax(int: int, int2: int) -> java.lang.String: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class MetamorphTiffReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class MetaxpressTiffReader(CellWorxReader): + def __init__(self): ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + +class MicroCTReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class MicromanagerReader(loci.formats.FormatReader): + DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def initFile(self, string: java.lang.String | str) -> None: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def populateMetadataStore( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> None: ... + +class MikroscanTiffReader(loci.formats.in_.SVSReader): + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + +class MinimalTiffReader(loci.formats.SubResolutionFormatReader): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getIFDs(self) -> loci.formats.tiff.IFDList: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getThumbSizeX(self) -> int: ... + def getThumbSizeY(self) -> int: ... + def getThumbnailIFDs(self) -> loci.formats.tiff.IFDList: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class MolecularImagingReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class NAFReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ND2Handler(loci.common.xml.BaseHandler): + imageMetadataLVExists: bool = ... + @typing.overload + def __init__( + self, coreMetadataList: loci.formats.CoreMetadataList, boolean: bool, int: int + ): ... + @typing.overload + def __init__(self, coreMetadataList: loci.formats.CoreMetadataList, int: int): ... + def endDocument(self) -> None: ... + @typing.overload + def endElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + attributes: org.xml.sax.Attributes, + ) -> None: ... + @typing.overload + def endElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> None: ... + def getBinnings(self) -> java.util.ArrayList[java.lang.String]: ... + def getCameraModel(self) -> java.lang.String: ... + def getChannelColors(self) -> java.util.Hashtable[java.lang.String, int]: ... + def getChannelNames(self) -> java.util.ArrayList[java.lang.String]: ... + def getCoreMetadataList(self) -> loci.formats.CoreMetadataList: ... + def getCorrection(self) -> java.lang.String: ... + def getDate(self) -> java.lang.String: ... + def getEmissionWavelengths(self) -> java.util.ArrayList[float]: ... + def getExcitationWavelengths(self) -> java.util.ArrayList[float]: ... + def getExposureTimes(self) -> java.util.ArrayList[float]: ... + def getFieldIndex(self) -> int: ... + def getGains(self) -> java.util.ArrayList[float]: ... + def getImmersion(self) -> java.lang.String: ... + def getMagnification(self) -> float: ... + def getMetadata(self) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getModalities(self) -> java.util.ArrayList[java.lang.String]: ... + def getNumericalAperture(self) -> float: ... + def getObjectiveModel(self) -> java.lang.String: ... + def getPinholeSize(self) -> float: ... + def getPixelSizeX(self) -> float: ... + def getPixelSizeY(self) -> float: ... + def getPixelSizeZ(self) -> float: ... + def getPositionNames(self) -> java.util.ArrayList[java.lang.String]: ... + def getPowers(self) -> java.util.ArrayList[int]: ... + def getROIs( + self, + ) -> java.util.ArrayList[ + java.util.Hashtable[java.lang.String, java.lang.String] + ]: ... + def getRefractiveIndex(self) -> float: ... + def getSeriesCount(self) -> int: ... + def getSpeeds(self) -> java.util.ArrayList[float]: ... + def getTemperatures(self) -> java.util.ArrayList[float]: ... + def getTimepoints(self) -> java.util.ArrayList[int]: ... + def getVoltage(self) -> float: ... + def getXFields(self) -> int: ... + def getXPositions(self) -> java.util.ArrayList[ome.units.quantity.Length]: ... + def getYPositions(self) -> java.util.ArrayList[ome.units.quantity.Length]: ... + def getZPositions(self) -> java.util.ArrayList[ome.units.quantity.Length]: ... + def getZSections(self) -> java.util.ArrayList[int]: ... + def isDimensions(self, string: java.lang.String | str) -> bool: ... + def isLossless(self) -> bool: ... + def parseKeyAndValue( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> None: ... + def populateROIs(self, metadataStore: loci.formats.meta.MetadataStore) -> None: ... + def startElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + attributes: org.xml.sax.Attributes, + ) -> None: ... + +class ND2Reader(loci.formats.SubResolutionFormatReader): + ND2_MAGIC_BYTES_1: typing.ClassVar[int] = ... + ND2_MAGIC_BYTES_2: typing.ClassVar[int] = ... + USE_CHUNKMAP_LEGACY_KEY: typing.ClassVar[java.lang.String] = ... + USE_CHUNKMAP_KEY: typing.ClassVar[java.lang.String] = ... + USE_CHUNKMAP_DEFAULT: typing.ClassVar[bool] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOffsets(self) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @staticmethod + def sanitizeControl(string: java.lang.String | str) -> java.lang.String: ... + def setOffsets( + self, + string: java.lang.String | str, + longArray: list[typing.MutableSequence[int]] | jpype.JArray, + ) -> None: ... + def useChunkMap(self) -> bool: ... + +class NDPIReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getTileColumns(self, int: int) -> int: ... + def getTileRows(self, int: int) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + +class NDPISReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class NRRDReader(loci.formats.FormatReader): + NRRD_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class NiftiReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class NikonElementsTiffReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + +class NikonReader(BaseTiffReader): + NEF_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class NikonTiffReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + +class OBFReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class OIRReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class OMETiffReader(loci.formats.SubResolutionFormatReader): + OME_TIFF_SUFFIXES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + FAIL_ON_MISSING_KEY: typing.ClassVar[java.lang.String] = ... + FAIL_ON_MISSING_DEFAULT: typing.ClassVar[bool] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def failOnMissingTIFF(self) -> bool: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + def getMetadataStoreForConversion(self) -> loci.formats.meta.MetadataStore: ... + def getMetadataStoreForDisplay(self) -> loci.formats.meta.MetadataStore: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def setSeries(self, int: int) -> None: ... + +class OMEXMLReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getDomains(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class OlympusTileReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class OpenlabRawReader(loci.formats.FormatReader): + OPENLAB_RAW_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class OpenlabReader(loci.formats.FormatReader): + LIFF_MAGIC_BYTES: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class OperettaReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class OxfordInstrumentsReader(loci.formats.FormatReader): + OXFORD_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PCIReader(loci.formats.FormatReader): + PCI_MAGIC_BYTES: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PCORAWReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PCXReader(loci.formats.FormatReader): + PCX_MAGIC_BYTE: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PDSReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PGMReader(loci.formats.FormatReader): + PGM_MAGIC_CHAR: typing.ClassVar[str] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PQBinReader(loci.formats.FormatReader): + HEADER_SIZE: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PSDReader(loci.formats.FormatReader): + PSD_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PerkinElmerReader(loci.formats.FormatReader): + CFG_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + ANO_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + REC_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + TIM_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + CSV_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + ZPO_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + HTM_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + HTML_REGEX: typing.ClassVar[java.lang.String] = ... + DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PhotoshopTiffReader(BaseTiffReader): + IMAGE_SOURCE_DATA: typing.ClassVar[int] = ... + PACKBITS: typing.ClassVar[int] = ... + ZIP: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PictReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PovrayReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PrairieMetadata: + def __init__( + self, + document: org.w3c.dom.Document, + document2: org.w3c.dom.Document, + document3: org.w3c.dom.Document, + ): ... + def getActiveChannels(self) -> typing.MutableSequence[int]: ... + def getBitDepth(self) -> int: ... + @typing.overload + def getConfig(self, string: java.lang.String | str) -> PrairieMetadata.Value: ... + @typing.overload + def getConfig(self) -> PrairieMetadata.ValueTable: ... + def getCycleCount(self) -> int: ... + def getCycleMax(self) -> int: ... + def getCycleMin(self) -> int: ... + def getDate(self) -> java.lang.String: ... + def getFile(self, int: int, int2: int, int3: int) -> PrairieMetadata.PFile: ... + def getFirstSequence(self) -> PrairieMetadata.Sequence: ... + def getFrame(self, int: int, int2: int) -> PrairieMetadata.Frame: ... + def getLaserPower(self) -> float: ... + def getSequence(self, int: int) -> PrairieMetadata.Sequence: ... + def getSequences(self) -> java.util.ArrayList[PrairieMetadata.Sequence]: ... + def getValue(self, string: java.lang.String | str) -> PrairieMetadata.Value: ... + def getValues(self) -> PrairieMetadata.ValueTable: ... + def getWaitTime(self) -> float: ... + def isInvertX(self) -> bool: ... + def isInvertY(self) -> bool: ... + class Frame: + def __init__( + self, + prairieMetadata: PrairieMetadata, + sequence: PrairieMetadata.Sequence, + element: org.w3c.dom.Element, + ): ... + def getAbsoluteTime(self) -> float: ... + def getFile(self, int: int) -> PrairieMetadata.PFile: ... + def getFirstFile(self) -> PrairieMetadata.PFile: ... + def getGain(self, int: int) -> float: ... + def getImagingDevice(self) -> java.lang.String: ... + def getImmersion(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getLinesPerFrame(self) -> int: ... + def getMagnification(self) -> float: ... + def getMicronsPerPixelX(self) -> float: ... + def getMicronsPerPixelY(self) -> float: ... + def getObjectiveLens(self) -> java.lang.String: ... + def getObjectiveLensNA(self) -> float: ... + def getObjectiveManufacturer(self) -> java.lang.String: ... + def getOffset(self, int: int) -> float: ... + def getOpticalZoom(self) -> float: ... + def getPixelsPerLine(self) -> int: ... + def getPositionX(self) -> ome.units.quantity.Length: ... + def getPositionY(self) -> ome.units.quantity.Length: ... + def getPositionZ(self) -> ome.units.quantity.Length: ... + def getRelativeTime(self) -> float: ... + def getSequence(self) -> PrairieMetadata.Sequence: ... + def getValue(self, string: java.lang.String | str) -> PrairieMetadata.Value: ... + def getValues(self) -> PrairieMetadata.ValueTable: ... + def parse(self, element: org.w3c.dom.Element) -> None: ... + + class PFile: + def __init__( + self, + prairieMetadata: PrairieMetadata, + frame: PrairieMetadata.Frame, + element: org.w3c.dom.Element, + ): ... + def getChannel(self) -> int: ... + def getChannelName(self) -> java.lang.String: ... + def getFilename(self) -> java.lang.String: ... + def getFrame(self) -> PrairieMetadata.Frame: ... + def getWavelengthMax(self) -> float: ... + def getWavelengthMin(self) -> float: ... + def parse(self, element: org.w3c.dom.Element) -> None: ... + + class Sequence: + def __init__( + self, prairieMetadata: PrairieMetadata, element: org.w3c.dom.Element + ): ... + def getCycle(self) -> int: ... + def getFile(self, int: int, int2: int) -> PrairieMetadata.PFile: ... + def getFirstFrame(self) -> PrairieMetadata.Frame: ... + def getFrame(self, int: int) -> PrairieMetadata.Frame: ... + def getIndexCount(self) -> int: ... + def getIndexMax(self) -> int: ... + def getIndexMin(self) -> int: ... + def getType(self) -> java.lang.String: ... + def getValue(self, string: java.lang.String | str) -> PrairieMetadata.Value: ... + def getValues(self) -> PrairieMetadata.ValueTable: ... + def isSpectralMode(self) -> bool: ... + def isTimeSeries(self) -> bool: ... + def parse(self, element: org.w3c.dom.Element) -> None: ... + + class Value: + def description(self) -> java.lang.String: ... + @typing.overload + def get(self, int: int) -> PrairieMetadata.Value: ... + @typing.overload + def get(self, object: typing.Any) -> PrairieMetadata.Value: ... + def isTable(self) -> bool: ... + def value(self) -> java.lang.String: ... + + class ValueItem(loci.formats.in_.PrairieMetadata.Value): + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + def description(self) -> java.lang.String: ... + @typing.overload + def get(self, int: int) -> PrairieMetadata.Value: ... + @typing.overload + def get(self, object: typing.Any) -> PrairieMetadata.Value: ... + def isTable(self) -> bool: ... + def toString(self) -> java.lang.String: ... + def value(self) -> java.lang.String: ... + + class ValueTable( + java.util.HashMap[java.lang.String, "PrairieMetadata.Value"], + loci.formats.in_.PrairieMetadata.Value, + ): + def __init__(self): ... + def description(self) -> java.lang.String: ... + @typing.overload + def get(self, object: typing.Any) -> typing.Any: ... + @typing.overload + def get(self, int: int) -> PrairieMetadata.Value: ... + def isTable(self) -> bool: ... + def value(self) -> java.lang.String: ... + +class PrairieReader(loci.formats.FormatReader): + CFG_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + ENV_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + XML_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + PRAIRIE_SUFFIXES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class PyramidTiffReader(BaseTiffReader): + def __init__(self): ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class QTReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class QuesantReader(loci.formats.FormatReader): + MAX_HEADER_SIZE: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class RCPNLReader(DeltavisionReader): + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + +class RHKReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SBIGReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SDTInfo: + BH_HEADER_CHKSUM: typing.ClassVar[int] = ... + BH_HEADER_NOT_VALID: typing.ClassVar[int] = ... + BH_HEADER_VALID: typing.ClassVar[int] = ... + SETUP_IDENTIFIER: typing.ClassVar[java.lang.String] = ... + DATA_IDENTIFIER: typing.ClassVar[java.lang.String] = ... + FLOW_DATA_IDENTIFIER: typing.ClassVar[java.lang.String] = ... + DLL_DATA_IDENTIFIER: typing.ClassVar[java.lang.String] = ... + FCS_DATA_IDENTIFIER: typing.ClassVar[java.lang.String] = ... + X_STRING: typing.ClassVar[java.lang.String] = ... + Y_STRING: typing.ClassVar[java.lang.String] = ... + T_STRING: typing.ClassVar[java.lang.String] = ... + C_STRING: typing.ClassVar[java.lang.String] = ... + X_IMG_STRING: typing.ClassVar[java.lang.String] = ... + Y_IMG_STRING: typing.ClassVar[java.lang.String] = ... + BINARY_SETUP: typing.ClassVar[java.lang.String] = ... + width: int = ... + height: int = ... + timeBins: int = ... + channels: int = ... + timepoints: int = ... + revision: int = ... + infoOffs: int = ... + infoLength: int = ... + setupOffs: int = ... + setupLength: int = ... + dataBlockOffs: int = ... + noOfDataBlocks: int = ... + dataBlockLength: int = ... + measDescBlockOffs: int = ... + noOfMeasDescBlocks: int = ... + measDescBlockLength: int = ... + headerValid: int = ... + reserved1: int = ... + reserved2: int = ... + chksum: int = ... + info: java.lang.String = ... + setup: java.lang.String = ... + hasMeasureInfo: bool = ... + time: java.lang.String = ... + date: java.lang.String = ... + modSerNo: java.lang.String = ... + measMode: int = ... + cfdLL: float = ... + cfdLH: float = ... + cfdZC: float = ... + cfdHF: float = ... + synZC: float = ... + synFD: int = ... + synHF: float = ... + tacR: float = ... + tacG: int = ... + tacOF: float = ... + tacLL: float = ... + tacLH: float = ... + adcRE: int = ... + ealDE: int = ... + ncx: int = ... + ncy: int = ... + page: int = ... + colT: float = ... + repT: float = ... + stopt: int = ... + overfl: int = ... + useMotor: int = ... + steps: int = ... + offset: float = ... + dither: int = ... + incr: int = ... + memBank: int = ... + modType: java.lang.String = ... + synTH: float = ... + deadTimeComp: int = ... + polarityL: int = ... + polarityF: int = ... + polarityP: int = ... + linediv: int = ... + accumulate: int = ... + flbckY: int = ... + flbckX: int = ... + bordU: int = ... + bordL: int = ... + pixTime: float = ... + pixClk: int = ... + trigger: int = ... + scanX: int = ... + scanY: int = ... + scanRX: int = ... + scanRY: int = ... + fifoTyp: int = ... + epxDiv: int = ... + modTypeCode: int = ... + modFpgaVer: int = ... + overflowCorrFactor: float = ... + adcZoom: int = ... + cycles: int = ... + hasMeasStopInfo: bool = ... + status: int = ... + flags: int = ... + stopTime: float = ... + curStep: int = ... + curCycle: int = ... + curPage: int = ... + minSyncRate: float = ... + minCfdRate: float = ... + minTacRate: float = ... + minAdcRate: float = ... + maxSyncRate: float = ... + maxCfdRate: float = ... + maxTacRate: float = ... + maxAdcRate: float = ... + mReserved1: int = ... + mReserved2: float = ... + hasMeasFCSInfo: bool = ... + chan: int = ... + fcsDecayCalc: int = ... + mtResol: int = ... + cortime: float = ... + calcPhotons: int = ... + fcsPoints: int = ... + endTime: float = ... + overruns: int = ... + fcsType: int = ... + crossChan: int = ... + mod: int = ... + crossMod: int = ... + crossMtResol: int = ... + hasExtendedMeasureInfo: bool = ... + imageX: int = ... + imageY: int = ... + imageRX: int = ... + imageRY: int = ... + xyGain: int = ... + masterClock: int = ... + adcDE: int = ... + detType: int = ... + xAxis: int = ... + hasMeasHISTInfo: bool = ... + fidaTime: float = ... + fildaTime: float = ... + fidaPoints: int = ... + fildaPoints: int = ... + mcsTime: float = ... + mcsPoints: int = ... + mcstaPoints: int = ... + blockNo: int = ... + dataOffs: int = ... + nextBlockOffs: int = ... + allBlockOffsets: typing.MutableSequence[int] = ... + allBlockLengths: typing.MutableSequence[int] = ... + blockType: int = ... + measDescBlockNo: int = ... + lblockNo: int = ... + blockLength: int = ... + def __init__( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + hashtable: java.util.Hashtable, + ): ... + +class SDTReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getChannelCount(self) -> int: ... + def getInfo(self) -> SDTInfo: ... + def getTimeBinCount(self) -> int: ... + def isIntensity(self) -> bool: ... + @typing.overload + def isInterleaved(self) -> bool: ... + @typing.overload + def isInterleaved(self, int: int) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def setIntensity(self, boolean: bool) -> None: ... + def setPreLoad(self, boolean: bool) -> None: ... + +class SEQReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SIFReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SISReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + +class SMCameraReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SPCReader(loci.formats.FormatReader): + TAC_RANGE: typing.ClassVar[java.lang.String] = ... + TAC_GAIN: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class SPEReader(loci.formats.FormatReader): + FLOAT: typing.ClassVar[int] = ... + INT32: typing.ClassVar[int] = ... + INT16: typing.ClassVar[int] = ... + UNINT16: typing.ClassVar[int] = ... + UNINT32: typing.ClassVar[int] = ... + coreMetaData: typing.ClassVar[java.util.List] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SVSReader(BaseTiffReader): + REMOVE_THUMBNAIL_KEY: typing.ClassVar[java.lang.String] = ... + REMOVE_THUMBNAIL_DEFAULT: typing.ClassVar[bool] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getTileCodec(self, int: int) -> loci.formats.codec.Codec: ... + def getTileCodecOptions( + self, int: int, int2: int, int3: int + ) -> loci.formats.codec.CodecOptions: ... + def getTileColumns(self, int: int) -> int: ... + def getTileRows(self, int: int) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openCompressedBytes( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def removeThumbnail(self) -> bool: ... + +class ScanrReader(loci.formats.FormatReader): + SKIP_MISSING_WELLS: typing.ClassVar[java.lang.String] = ... + SKIP_MISSING_WELLS_DEFAULT: typing.ClassVar[bool] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def skipMissingWells(self) -> bool: ... + +class SeikoReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SimplePCITiffReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SlideBook7Reader(loci.formats.FormatReader): + LOGGER: typing.ClassVar[org.slf4j.Logger] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SlidebookReader(loci.formats.FormatReader): + SLD_MAGIC_BYTES_1_0: typing.ClassVar[int] = ... + SLD_MAGIC_BYTES_1_1: typing.ClassVar[int] = ... + SLD_MAGIC_BYTES_1_2: typing.ClassVar[int] = ... + SLD_MAGIC_BYTES_2_0: typing.ClassVar[int] = ... + SLD_MAGIC_BYTES_2_1: typing.ClassVar[int] = ... + SLD_MAGIC_BYTES_3: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SlidebookTiffReader(BaseTiffReader): + SLIDEBOOK_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class SpiderReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class TCSReader(loci.formats.FormatReader): + DATE_FORMAT: typing.ClassVar[java.lang.String] = ... + PREFIX: typing.ClassVar[java.lang.String] = ... + SUFFIX: typing.ClassVar[java.lang.String] = ... + XML_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class TargaReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class TecanReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getRequiredDirectories( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class TextReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getChannelLabel(self, int: int) -> java.lang.String: ... + def getNativeDataType(self) -> type[typing.Any]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + +class TiffDelegateReader(loci.formats.DelegateReader): + def __init__(self): ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class TiffJAIReader(BIFormatReader): + def __init__(self): ... + def openPlane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.Any: ... + +class TiffReader(BaseTiffReader): + TIFF_SUFFIXES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + COMPANION_SUFFIXES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + IMAGEJ_TAG: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + +class TileJPEGReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def initFile(self, string: java.lang.String | str) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class TillVisionReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class TopometrixReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class TrestleReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class UBMReader(loci.formats.FormatReader): + HEADER_SIZE: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class UnisokuReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class VGSAMReader(loci.formats.FormatReader): + VG_MAGIC_STRING: typing.ClassVar[java.lang.String] = ... + PIXEL_OFFSET: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class VarianFDFReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class VectraReader(BaseTiffReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getScanProfileXML(self) -> java.lang.String: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + +class VeecoReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class VentanaReader(BaseTiffReader): + SPLIT_TILES_KEY: typing.ClassVar[java.lang.String] = ... + SPLIT_TILES_DEFAULT: typing.ClassVar[bool] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + def getThumbSizeX(self) -> int: ... + def getThumbSizeY(self) -> int: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def openThumbBytes(self, int: int) -> typing.MutableSequence[int]: ... + def splitTiles(self) -> bool: ... + +class VisitechReader(loci.formats.FormatReader): + HTML_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + HEADER_MARKER: typing.ClassVar[java.lang.String] = ... + PIXELS_MARKER: typing.ClassVar[typing.MutableSequence[int]] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getOptimalTileHeight(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class VolocityClippingReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class VolocityReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class WATOPReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class XLEFReader(loci.formats.in_.LeicaMicrosystemsMetadata.LMSFileReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def getImageFormat( + self, + ) -> loci.formats.in_.LeicaMicrosystemsMetadata.LMSFileReader.ImageFormat: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + +class ZeissCZIReader(loci.formats.FormatReader): + ALLOW_AUTOSTITCHING_KEY: typing.ClassVar[java.lang.String] = ... + ALLOW_AUTOSTITCHING_DEFAULT: typing.ClassVar[bool] = ... + INCLUDE_ATTACHMENTS_KEY: typing.ClassVar[java.lang.String] = ... + INCLUDE_ATTACHMENTS_DEFAULT: typing.ClassVar[bool] = ... + TRIM_DIMENSIONS_KEY: typing.ClassVar[java.lang.String] = ... + TRIM_DIMENSIONS_DEFAULT: typing.ClassVar[bool] = ... + RELATIVE_POSITIONS_KEY: typing.ClassVar[java.lang.String] = ... + RELATIVE_POSITIONS_DEFAULT: typing.ClassVar[bool] = ... + def __init__(self): ... + def allowAutostitching(self) -> bool: ... + def canReadAttachments(self) -> bool: ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getFillColor(self) -> int: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalTileWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def storeRelativePositions(self) -> bool: ... + def trimDimensions(self) -> bool: ... + +class ZeissLMSReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def initFile(self, string: java.lang.String | str) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ZeissLSMReader(loci.formats.FormatReader): + MDB_SUFFIX: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def getOptimalTileHeight(self) -> int: ... + def getOptimalWidth(self) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def setCoreIndex(self, int: int) -> None: ... + def setSeries(self, int: int) -> None: ... + +class ZeissTIFFHandler(org.xml.sax.helpers.DefaultHandler): + main_tagset: ZeissTIFFHandler.TagSet = ... + planes: java.util.ArrayList = ... + scalings: java.util.ArrayList = ... + layers: java.util.ArrayList = ... + def characters( + self, charArray: list[str] | jpype.JArray, int: int, int2: int + ) -> None: ... + def endElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> None: ... + def startElement( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + attributes: org.xml.sax.Attributes, + ) -> None: ... + def toString(self) -> java.lang.String: ... + class Plane: + basename: java.lang.String = ... + tagset: ZeissTIFFHandler.TagSet = ... + def toString(self) -> java.lang.String: ... + +class ZeissTIFFReader(BaseZeissReader): + TIFF_SUFFIXES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + XML_NAME: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def fileGroupOption(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSeriesUsedFiles(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getSeriesUsedFiles( + self, boolean: bool + ) -> typing.MutableSequence[java.lang.String]: ... + def isSingleFile(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ZeissZVIReader(BaseZeissReader): + ZVI_MAGIC_BYTES: typing.ClassVar[int] = ... + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + @typing.overload + def isThisType(self, byteArray: list[int] | jpype.JArray | bytes) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isThisType(self, string: java.lang.String | str, boolean: bool) -> bool: ... + @typing.overload + def isThisType( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> bool: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + +class ZipReader(loci.formats.FormatReader): + def __init__(self): ... + @typing.overload + def close(self) -> None: ... + @typing.overload + def close(self, boolean: bool) -> None: ... + def get16BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + def get8BitLookupTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + def openBytes(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def openBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + def reopenFile(self) -> None: ... + def setGroupFiles(self, boolean: bool) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.in_")``. + + AFIReader: type[AFIReader] + AIMReader: type[AIMReader] + APLReader: type[APLReader] + APNGReader: type[APNGReader] + ARFReader: type[ARFReader] + AVIReader: type[AVIReader] + AliconaReader: type[AliconaReader] + AmiraReader: type[AmiraReader] + AnalyzeReader: type[AnalyzeReader] + BDReader: type[BDReader] + BDVReader: type[BDVReader] + BIFormatReader: type[BIFormatReader] + BMPReader: type[BMPReader] + BaseTiffReader: type[BaseTiffReader] + BaseZeissReader: type[BaseZeissReader] + BioRadGelReader: type[BioRadGelReader] + BioRadReader: type[BioRadReader] + BioRadSCNReader: type[BioRadSCNReader] + BrukerReader: type[BrukerReader] + BurleighReader: type[BurleighReader] + CV7000Reader: type[CV7000Reader] + CanonRawReader: type[CanonRawReader] + CellH5Reader: type[CellH5Reader] + CellSensReader: type[CellSensReader] + CellVoyagerReader: type[CellVoyagerReader] + CellWorxReader: type[CellWorxReader] + CellomicsReader: type[CellomicsReader] + ColumbusReader: type[ColumbusReader] + DCIMGReader: type[DCIMGReader] + DNGReader: type[DNGReader] + DefaultMetadataOptions: type[DefaultMetadataOptions] + DeltavisionReader: type[DeltavisionReader] + DicomReader: type[DicomReader] + DynamicMetadataOptions: type[DynamicMetadataOptions] + EPSReader: type[EPSReader] + Ecat7Reader: type[Ecat7Reader] + FEIReader: type[FEIReader] + FEITiffReader: type[FEITiffReader] + FV1000Reader: type[FV1000Reader] + FakeReader: type[FakeReader] + FilePatternReader: type[FilePatternReader] + FitsReader: type[FitsReader] + FlexReader: type[FlexReader] + FlowSightReader: type[FlowSightReader] + FluoviewReader: type[FluoviewReader] + FujiReader: type[FujiReader] + GIFReader: type[GIFReader] + GatanDM2Reader: type[GatanDM2Reader] + GatanReader: type[GatanReader] + GelReader: type[GelReader] + HISReader: type[HISReader] + HRDGDFReader: type[HRDGDFReader] + HamamatsuVMSReader: type[HamamatsuVMSReader] + HitachiReader: type[HitachiReader] + I2IReader: type[I2IReader] + ICSReader: type[ICSReader] + IM3Reader: type[IM3Reader] + IMODReader: type[IMODReader] + INRReader: type[INRReader] + IPLabReader: type[IPLabReader] + IPWReader: type[IPWReader] + ImaconReader: type[ImaconReader] + ImageIOReader: type[ImageIOReader] + ImagicReader: type[ImagicReader] + ImarisHDFReader: type[ImarisHDFReader] + ImarisReader: type[ImarisReader] + ImarisTiffReader: type[ImarisTiffReader] + ImprovisionTiffReader: type[ImprovisionTiffReader] + ImspectorReader: type[ImspectorReader] + InCell3000Reader: type[InCell3000Reader] + InCellReader: type[InCellReader] + InveonReader: type[InveonReader] + IonpathMIBITiffReader: type[IonpathMIBITiffReader] + IvisionReader: type[IvisionReader] + JEOLReader: type[JEOLReader] + JPEG2000MetadataParser: type[JPEG2000MetadataParser] + JPEG2000Reader: type[JPEG2000Reader] + JPEGReader: type[JPEGReader] + JPKReader: type[JPKReader] + JPXReader: type[JPXReader] + KLBReader: type[KLBReader] + KhorosReader: type[KhorosReader] + KodakReader: type[KodakReader] + L2DReader: type[L2DReader] + LEOReader: type[LEOReader] + LIFReader: type[LIFReader] + LIMReader: type[LIMReader] + LIPixelFormat: type[LIPixelFormat] + LOFReader: type[LOFReader] + LeicaHandler: type[LeicaHandler] + LeicaReader: type[LeicaReader] + LeicaSCNReader: type[LeicaSCNReader] + LiFlimReader: type[LiFlimReader] + MIASReader: type[MIASReader] + MINCReader: type[MINCReader] + MNGReader: type[MNGReader] + MRCReader: type[MRCReader] + MRWReader: type[MRWReader] + MetadataLevel: type[MetadataLevel] + MetadataOptions: type[MetadataOptions] + MetamorphHandler: type[MetamorphHandler] + MetamorphReader: type[MetamorphReader] + MetamorphTiffReader: type[MetamorphTiffReader] + MetaxpressTiffReader: type[MetaxpressTiffReader] + MicroCTReader: type[MicroCTReader] + MicromanagerReader: type[MicromanagerReader] + MikroscanTiffReader: type[MikroscanTiffReader] + MinimalTiffReader: type[MinimalTiffReader] + MolecularImagingReader: type[MolecularImagingReader] + NAFReader: type[NAFReader] + ND2Handler: type[ND2Handler] + ND2Reader: type[ND2Reader] + NDPIReader: type[NDPIReader] + NDPISReader: type[NDPISReader] + NRRDReader: type[NRRDReader] + NiftiReader: type[NiftiReader] + NikonElementsTiffReader: type[NikonElementsTiffReader] + NikonReader: type[NikonReader] + NikonTiffReader: type[NikonTiffReader] + OBFReader: type[OBFReader] + OIRReader: type[OIRReader] + OMETiffReader: type[OMETiffReader] + OMEXMLReader: type[OMEXMLReader] + OlympusTileReader: type[OlympusTileReader] + OpenlabRawReader: type[OpenlabRawReader] + OpenlabReader: type[OpenlabReader] + OperettaReader: type[OperettaReader] + OxfordInstrumentsReader: type[OxfordInstrumentsReader] + PCIReader: type[PCIReader] + PCORAWReader: type[PCORAWReader] + PCXReader: type[PCXReader] + PDSReader: type[PDSReader] + PGMReader: type[PGMReader] + PQBinReader: type[PQBinReader] + PSDReader: type[PSDReader] + PerkinElmerReader: type[PerkinElmerReader] + PhotoshopTiffReader: type[PhotoshopTiffReader] + PictReader: type[PictReader] + PovrayReader: type[PovrayReader] + PrairieMetadata: type[PrairieMetadata] + PrairieReader: type[PrairieReader] + PyramidTiffReader: type[PyramidTiffReader] + QTReader: type[QTReader] + QuesantReader: type[QuesantReader] + RCPNLReader: type[RCPNLReader] + RHKReader: type[RHKReader] + SBIGReader: type[SBIGReader] + SDTInfo: type[SDTInfo] + SDTReader: type[SDTReader] + SEQReader: type[SEQReader] + SIFReader: type[SIFReader] + SISReader: type[SISReader] + SMCameraReader: type[SMCameraReader] + SPCReader: type[SPCReader] + SPEReader: type[SPEReader] + SVSReader: type[SVSReader] + ScanrReader: type[ScanrReader] + SeikoReader: type[SeikoReader] + SimplePCITiffReader: type[SimplePCITiffReader] + SlideBook7Reader: type[SlideBook7Reader] + SlidebookReader: type[SlidebookReader] + SlidebookTiffReader: type[SlidebookTiffReader] + SpiderReader: type[SpiderReader] + TCSReader: type[TCSReader] + TargaReader: type[TargaReader] + TecanReader: type[TecanReader] + TextReader: type[TextReader] + TiffDelegateReader: type[TiffDelegateReader] + TiffJAIReader: type[TiffJAIReader] + TiffReader: type[TiffReader] + TileJPEGReader: type[TileJPEGReader] + TillVisionReader: type[TillVisionReader] + TopometrixReader: type[TopometrixReader] + TrestleReader: type[TrestleReader] + UBMReader: type[UBMReader] + UnisokuReader: type[UnisokuReader] + VGSAMReader: type[VGSAMReader] + VarianFDFReader: type[VarianFDFReader] + VectraReader: type[VectraReader] + VeecoReader: type[VeecoReader] + VentanaReader: type[VentanaReader] + VisitechReader: type[VisitechReader] + VolocityClippingReader: type[VolocityClippingReader] + VolocityReader: type[VolocityReader] + WATOPReader: type[WATOPReader] + XLEFReader: type[XLEFReader] + ZeissCZIReader: type[ZeissCZIReader] + ZeissLMSReader: type[ZeissLMSReader] + ZeissLSMReader: type[ZeissLSMReader] + ZeissTIFFHandler: type[ZeissTIFFHandler] + ZeissTIFFReader: type[ZeissTIFFReader] + ZeissZVIReader: type[ZeissZVIReader] + ZipReader: type[ZipReader] + LeicaMicrosystemsMetadata: ( + loci.formats.in_.LeicaMicrosystemsMetadata.__module_protocol__ + ) diff --git a/typings/loci/formats/meta/__init__.pyi b/typings/loci/formats/meta/__init__.pyi new file mode 100644 index 0000000..16206c5 --- /dev/null +++ b/typings/loci/formats/meta/__init__.pyi @@ -0,0 +1,88 @@ +import typing +from typing import Protocol + +import java.lang +import loci.formats +import loci.formats.ome +import ome.xml.meta +import ome.xml.model +import ome.xml.model.primitives + +class BaseMetadata(ome.xml.meta.BaseMetadata): ... + +class IMinMaxStore: + def setChannelGlobalMinMax( + self, int: int, double: float, double2: float, int2: int + ) -> None: ... + +class IPyramidStore: + def getResolutionCount(self, int: int) -> int: ... + def getResolutionSizeX( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getResolutionSizeY( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def setResolutionSizeX( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setResolutionSizeY( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + +class MetadataConverter: + @staticmethod + def convertMetadata( + metadataRetrieve: ome.xml.meta.MetadataRetrieve, + metadataStore: ome.xml.meta.MetadataStore, + ) -> None: ... + +class MetadataRetrieve(ome.xml.meta.MetadataRetrieve): ... +class MetadataStore(ome.xml.meta.MetadataStore): ... + +class ModuloAnnotation(ome.xml.model.XMLAnnotation): + MODULO_NS: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def setModulo( + self, + oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, + modulo: loci.formats.Modulo, + ) -> None: ... + +class OriginalMetadataAnnotation(ome.xml.model.XMLAnnotation): + ORIGINAL_METADATA_NS: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getKey(self) -> java.lang.String: ... + def getValueForKey(self) -> java.lang.String: ... + def setKeyValue( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + +class FilterMetadata(ome.xml.meta.FilterMetadata, MetadataStore): + def __init__(self, metadataStore: MetadataStore, boolean: bool): ... + +class IMetadata(ome.xml.meta.IMetadata, MetadataStore, MetadataRetrieve): ... + +class DummyMetadata(ome.xml.meta.DummyMetadata, IMetadata): + def __init__(self): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.meta")``. + + BaseMetadata: type[BaseMetadata] + DummyMetadata: type[DummyMetadata] + FilterMetadata: type[FilterMetadata] + IMetadata: type[IMetadata] + IMinMaxStore: type[IMinMaxStore] + IPyramidStore: type[IPyramidStore] + MetadataConverter: type[MetadataConverter] + MetadataRetrieve: type[MetadataRetrieve] + MetadataStore: type[MetadataStore] + ModuloAnnotation: type[ModuloAnnotation] + OriginalMetadataAnnotation: type[OriginalMetadataAnnotation] diff --git a/typings/loci/formats/ome/__init__.pyi b/typings/loci/formats/ome/__init__.pyi new file mode 100644 index 0000000..c5efbcd --- /dev/null +++ b/typings/loci/formats/ome/__init__.pyi @@ -0,0 +1,48 @@ +import typing +from typing import Protocol + +import java.lang +import loci.formats.meta +import ome.xml.meta +import ome.xml.model.primitives + +class OMEXMLMetadata(loci.formats.meta.IMetadata, ome.xml.meta.OMEXMLMetadata): ... + +class AbstractOMEXMLMetadata(ome.xml.meta.AbstractOMEXMLMetadata, OMEXMLMetadata): + def __init__(self): ... + +class OMEXMLMetadataImpl(ome.xml.meta.OMEXMLMetadataImpl, OMEXMLMetadata): + def __init__(self): ... + +class OMEPyramidStore(OMEXMLMetadataImpl, loci.formats.meta.IPyramidStore): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def dumpXML(self) -> java.lang.String: ... + def getResolutionCount(self, int: int) -> int: ... + def getResolutionSizeX( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getResolutionSizeY( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def setResolutionSizeX( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setResolutionSizeY( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setRoot(self, metadataRoot: ome.xml.meta.MetadataRoot) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.ome")``. + + AbstractOMEXMLMetadata: type[AbstractOMEXMLMetadata] + OMEPyramidStore: type[OMEPyramidStore] + OMEXMLMetadata: type[OMEXMLMetadata] + OMEXMLMetadataImpl: type[OMEXMLMetadataImpl] diff --git a/typings/loci/formats/out/__init__.pyi b/typings/loci/formats/out/__init__.pyi new file mode 100644 index 0000000..9cbca27 --- /dev/null +++ b/typings/loci/formats/out/__init__.pyi @@ -0,0 +1,694 @@ +import typing +from typing import Protocol + +import java.lang +import jpype +import loci.common +import loci.formats +import loci.formats.codec +import loci.formats.tiff + +class APNGWriter(loci.formats.FormatWriter): + def __init__(self): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class AVIWriter(loci.formats.FormatWriter): + def __init__(self): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class CellH5Writer(loci.formats.FormatWriter): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def getPlaneCount(self) -> int: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class EPSWriter(loci.formats.FormatWriter): + def __init__(self): ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + +class ICSWriter(loci.formats.FormatWriter): + def __init__(self): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setOutputOrder(self, string: java.lang.String | str) -> None: ... + +class IExtraMetadataWriter: + def setExtraMetadata(self, string: java.lang.String | str) -> None: ... + +class ImageIOWriter(loci.formats.FormatWriter): + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + string3: java.lang.String | str, + ): ... + def getNativeDataType(self) -> type[typing.Any]: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def savePlane(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, region: loci.common.Region + ) -> None: ... + @typing.overload + def savePlane( + self, int: int, object: typing.Any, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + +class JPEG2000Writer(loci.formats.FormatWriter): + def __init__(self): ... + def canDoStacks(self) -> bool: ... + def compressBuffer( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + +class JavaWriter(loci.formats.FormatWriter): + def __init__(self): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class OMEXMLWriter(loci.formats.FormatWriter): + CREATOR_KEY: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def preserveCreator(self) -> bool: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class QTWriter(loci.formats.FormatWriter): + CODEC_MOTION_JPEG_B: typing.ClassVar[int] = ... + CODEC_CINEPAK: typing.ClassVar[int] = ... + CODEC_ANIMATION: typing.ClassVar[int] = ... + CODEC_H_263: typing.ClassVar[int] = ... + CODEC_SORENSON: typing.ClassVar[int] = ... + CODEC_SORENSON_3: typing.ClassVar[int] = ... + CODEC_MPEG_4: typing.ClassVar[int] = ... + CODEC_RAW: typing.ClassVar[int] = ... + QUALITY_LOW: typing.ClassVar[int] = ... + QUALITY_NORMAL: typing.ClassVar[int] = ... + QUALITY_HIGH: typing.ClassVar[int] = ... + QUALITY_MAXIMUM: typing.ClassVar[int] = ... + def __init__(self): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setCodec(self, int: int) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setQuality(self, int: int) -> None: ... + +class TiffWriter(loci.formats.FormatWriter): + COMPRESSION_UNCOMPRESSED: typing.ClassVar[java.lang.String] = ... + COMPRESSION_LZW: typing.ClassVar[java.lang.String] = ... + COMPRESSION_J2K: typing.ClassVar[java.lang.String] = ... + COMPRESSION_J2K_LOSSY: typing.ClassVar[java.lang.String] = ... + COMPRESSION_JPEG: typing.ClassVar[java.lang.String] = ... + COMPRESSION_ZLIB: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + def getCodec(self) -> loci.formats.codec.Codec: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def getPlaneCount(self) -> int: ... + def getTileSizeX(self) -> int: ... + def getTileSizeY(self) -> int: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + iFD: loci.formats.tiff.IFD, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + iFD: loci.formats.tiff.IFD, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def saveCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setBigTiff(self, boolean: bool) -> None: ... + def setCanDetectBigTiff(self, boolean: bool) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setTileSizeX(self, int: int) -> int: ... + def setTileSizeY(self, int: int) -> int: ... + +class V3DrawWriter(loci.formats.FormatWriter): + def __init__(self): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setOutputOrder(self, string: java.lang.String | str) -> None: ... + +class DicomWriter(loci.formats.FormatWriter, IExtraMetadataWriter): + UID_ROOT_KEY: typing.ClassVar[java.lang.String] = ... + UID_DEFAULT_ROOT: typing.ClassVar[java.lang.String] = ... + TIFF_KEY: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def canDoStacks(self) -> bool: ... + def close(self) -> None: ... + def getCodec(self) -> loci.formats.codec.Codec: ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def getTileSizeX(self) -> int: ... + def getTileSizeY(self) -> int: ... + def getUIDRoot(self) -> java.lang.String: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def saveCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setBigTiff(self, boolean: bool) -> None: ... + def setExtraMetadata(self, string: java.lang.String | str) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + def setResolution(self, int: int) -> None: ... + def setSeries(self, int: int) -> None: ... + def setTileSizeX(self, int: int) -> int: ... + def setTileSizeY(self, int: int) -> int: ... + def writeDualPersonality(self) -> bool: ... + +class JPEGWriter(ImageIOWriter): + def __init__(self): ... + @typing.overload + def getPixelTypes(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getPixelTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + +class OMETiffWriter(TiffWriter): + COMPANION_KEY: typing.ClassVar[java.lang.String] = ... + CREATOR_KEY: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def close(self) -> None: ... + def getCompanion(self) -> java.lang.String: ... + def preserveCreator(self) -> bool: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + iFD: loci.formats.tiff.IFD, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + iFD: loci.formats.tiff.IFD, + ) -> None: ... + def saveCompressedBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + def setId(self, string: java.lang.String | str) -> None: ... + +class PyramidOMETiffWriter(OMETiffWriter): + def __init__(self): ... + def close(self) -> None: ... + def isThisType(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def saveBytes( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + region: loci.common.Region, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + iFD: loci.formats.tiff.IFD, + int2: int, + int3: int, + int4: int, + int5: int, + ) -> None: ... + @typing.overload + def saveBytes( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + iFD: loci.formats.tiff.IFD, + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.out")``. + + APNGWriter: type[APNGWriter] + AVIWriter: type[AVIWriter] + CellH5Writer: type[CellH5Writer] + DicomWriter: type[DicomWriter] + EPSWriter: type[EPSWriter] + ICSWriter: type[ICSWriter] + IExtraMetadataWriter: type[IExtraMetadataWriter] + ImageIOWriter: type[ImageIOWriter] + JPEG2000Writer: type[JPEG2000Writer] + JPEGWriter: type[JPEGWriter] + JavaWriter: type[JavaWriter] + OMETiffWriter: type[OMETiffWriter] + OMEXMLWriter: type[OMEXMLWriter] + PyramidOMETiffWriter: type[PyramidOMETiffWriter] + QTWriter: type[QTWriter] + TiffWriter: type[TiffWriter] + V3DrawWriter: type[V3DrawWriter] diff --git a/typings/loci/formats/services/__init__.pyi b/typings/loci/formats/services/__init__.pyi new file mode 100644 index 0000000..880ca6f --- /dev/null +++ b/typings/loci/formats/services/__init__.pyi @@ -0,0 +1,753 @@ +import typing +from typing import Protocol + +import ch.systemsx.cisd.base.mdarray +import ch.systemsx.cisd.hdf5 +import com.esotericsoftware.kryo +import com.esotericsoftware.kryo.io +import java.awt.image +import java.io +import java.lang +import java.util +import jpype +import loci.common +import loci.common.services +import loci.formats +import loci.formats.codec +import loci.formats.meta +import loci.formats.ome +import ome.xml.model +import org.w3c.dom + +class EXIFService(loci.common.services.Service): + def close(self) -> None: ... + def getCreationDate(self) -> java.util.Date: ... + def getTags(self) -> java.util.HashMap[java.lang.String, java.lang.String]: ... + def initialize(self, string: java.lang.String | str) -> None: ... + +class JAIIIOService(loci.common.services.Service): + @typing.overload + def readImage( + self, inputStream: java.io.InputStream + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def readImage( + self, + inputStream: java.io.InputStream, + jPEG2000CodecOptions: loci.formats.codec.JPEG2000CodecOptions, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def readRaster(self, inputStream: java.io.InputStream) -> java.awt.image.Raster: ... + @typing.overload + def readRaster( + self, + inputStream: java.io.InputStream, + jPEG2000CodecOptions: loci.formats.codec.JPEG2000CodecOptions, + ) -> java.awt.image.Raster: ... + def writeImage( + self, + outputStream: java.io.OutputStream, + bufferedImage: java.awt.image.BufferedImage, + jPEG2000CodecOptions: loci.formats.codec.JPEG2000CodecOptions, + ) -> None: ... + +class JHDFService(loci.common.services.Service): + def close(self) -> None: ... + def createGroup(self, string: java.lang.String | str) -> None: ... + def exists(self, string: java.lang.String | str) -> bool: ... + def getElementSize(self, string: java.lang.String | str) -> int: ... + def getFile(self) -> java.lang.String: ... + def getMember( + self, string: java.lang.String | str + ) -> java.util.List[java.lang.String]: ... + def getShape( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def initIntArray( + self, + string: java.lang.String | str, + longArray: list[int] | jpype.JArray, + long2: int, + ) -> None: ... + def readByteArray( + self, string: java.lang.String | str + ) -> ch.systemsx.cisd.base.mdarray.MDByteArray: ... + def readByteBlockArray( + self, + string: java.lang.String | str, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ) -> ch.systemsx.cisd.base.mdarray.MDByteArray: ... + def readCompoundArrayDataMap( + self, string: java.lang.String | str + ) -> typing.MutableSequence[ch.systemsx.cisd.hdf5.HDF5CompoundDataMap]: ... + def readIntArray( + self, string: java.lang.String | str + ) -> ch.systemsx.cisd.base.mdarray.MDIntArray: ... + def readIntBlockArray( + self, + string: java.lang.String | str, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ) -> ch.systemsx.cisd.base.mdarray.MDIntArray: ... + def readShortBlockArray( + self, + string: java.lang.String | str, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ) -> ch.systemsx.cisd.base.mdarray.MDShortArray: ... + def readStringArray( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + def setFile(self, string: java.lang.String | str) -> None: ... + def setFileForWrite(self, string: java.lang.String | str) -> None: ... + @typing.overload + def writeArraySlice( + self, + string: java.lang.String | str, + mDByteArray: ch.systemsx.cisd.base.mdarray.MDByteArray, + longArray: list[int] | jpype.JArray, + ) -> None: ... + @typing.overload + def writeArraySlice( + self, + string: java.lang.String | str, + mDIntArray: ch.systemsx.cisd.base.mdarray.MDIntArray, + longArray: list[int] | jpype.JArray, + ) -> None: ... + @typing.overload + def writeArraySlice( + self, + string: java.lang.String | str, + mDShortArray: ch.systemsx.cisd.base.mdarray.MDShortArray, + longArray: list[int] | jpype.JArray, + ) -> None: ... + +class JPEGTurboService(loci.common.services.Service): + def close(self) -> None: ... + @typing.overload + def getCompressedTile( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getCompressedTile(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getRestartMarkers(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getTile( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getTile(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getTileColumns(self) -> int: ... + def getTileHeight(self) -> int: ... + def getTileRows(self) -> int: ... + def getTileWidth(self) -> int: ... + def initialize( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + int2: int, + ) -> None: ... + def isLibraryLoaded(self) -> bool: ... + def setRestartMarkers(self, longArray: list[int] | jpype.JArray) -> None: ... + +class JPEGXRService(loci.common.services.Service): + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + +class MDBService(loci.common.services.Service): + def close(self) -> None: ... + def initialize(self, string: java.lang.String | str) -> None: ... + def parseDatabase( + self, + ) -> java.util.Vector[ + java.util.Vector[typing.MutableSequence[java.lang.String]] + ]: ... + def parseTable( + self, string: java.lang.String | str + ) -> java.util.Vector[typing.MutableSequence[java.lang.String]]: ... + +class MetakitService(loci.common.services.Service): + def close(self) -> None: ... + def getColumNames(self, int: int) -> typing.MutableSequence[java.lang.String]: ... + def getColumnNames( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getColumnTypes(self, int: int) -> typing.MutableSequence[type]: ... + @typing.overload + def getColumnTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[type]: ... + @typing.overload + def getRowCount(self, int: int) -> int: ... + @typing.overload + def getRowCount(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getRowData(self, int: int, int2: int) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def getRowData( + self, int: int, string: java.lang.String | str + ) -> typing.MutableSequence[typing.Any]: ... + def getTableCount(self) -> int: ... + @typing.overload + def getTableData( + self, int: int + ) -> typing.MutableSequence[typing.MutableSequence[typing.Any]]: ... + @typing.overload + def getTableData( + self, string: java.lang.String | str + ) -> typing.MutableSequence[typing.MutableSequence[typing.Any]]: ... + def getTableNames(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def initialize(self, string: java.lang.String | str) -> None: ... + @typing.overload + def initialize( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> None: ... + +class NetCDFService(loci.common.services.Service): + def close(self) -> None: ... + def getArray( + self, + string: java.lang.String | str, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ) -> typing.Any: ... + def getAttributeList(self) -> java.util.Vector[java.lang.String]: ... + def getAttributeValue(self, string: java.lang.String | str) -> java.lang.String: ... + def getDimension(self, string: java.lang.String | str) -> int: ... + def getFile(self) -> java.lang.String: ... + def getVariableAttributes( + self, string: java.lang.String | str + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getVariableList(self) -> java.util.Vector[java.lang.String]: ... + def getVariableValue(self, string: java.lang.String | str) -> typing.Any: ... + def setFile(self, string: java.lang.String | str) -> None: ... + +class OMEXMLService(loci.common.services.Service): + @typing.overload + def addMetadataOnly( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int + ) -> None: ... + @typing.overload + def addMetadataOnly( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int, boolean: bool + ) -> None: ... + def addModuloAlong( + self, + oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, + coreMetadata: loci.formats.CoreMetadata, + int: int, + ) -> None: ... + def asRetrieve( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> loci.formats.meta.MetadataRetrieve: ... + def asStore( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> loci.formats.meta.MetadataStore: ... + @typing.overload + def convertMetadata( + self, + string: java.lang.String | str, + metadataStore: loci.formats.meta.MetadataStore, + ) -> None: ... + @typing.overload + def convertMetadata( + self, + metadataRetrieve: loci.formats.meta.MetadataRetrieve, + metadataStore: loci.formats.meta.MetadataStore, + ) -> None: ... + @typing.overload + def createOMEXMLMetadata(self) -> loci.formats.ome.OMEXMLMetadata: ... + @typing.overload + def createOMEXMLMetadata( + self, string: java.lang.String | str + ) -> loci.formats.ome.OMEXMLMetadata: ... + @typing.overload + def createOMEXMLMetadata( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> loci.formats.ome.OMEXMLMetadata: ... + def createOMEXMLRoot( + self, string: java.lang.String | str + ) -> ome.xml.model.OMEModelObject: ... + def getLatestVersion(self) -> java.lang.String: ... + def getModuloAlongC( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int + ) -> loci.formats.Modulo: ... + def getModuloAlongT( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int + ) -> loci.formats.Modulo: ... + def getModuloAlongZ( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int + ) -> loci.formats.Modulo: ... + def getOMEMetadata( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> loci.formats.ome.OMEXMLMetadata: ... + def getOMEXML( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> java.lang.String: ... + def getOMEXMLVersion(self, object: typing.Any) -> java.lang.String: ... + def getOriginalMetadata( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata + ) -> java.util.Hashtable: ... + def isEqual( + self, + oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, + oMEXMLMetadata2: loci.formats.ome.OMEXMLMetadata, + ) -> bool: ... + def isOMEXMLMetadata(self, object: typing.Any) -> bool: ... + def isOMEXMLRoot(self, object: typing.Any) -> bool: ... + @typing.overload + def populateOriginalMetadata( + self, + oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, + string: java.lang.String | str, + string2: java.lang.String | str, + ) -> None: ... + @typing.overload + def populateOriginalMetadata( + self, + oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, + hashtable: java.util.Hashtable[java.lang.String | str, typing.Any], + ) -> None: ... + def removeBinData( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata + ) -> None: ... + def removeChannels( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int, int2: int + ) -> None: ... + def removeTiffData( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata + ) -> None: ... + def transformToLatestVersion( + self, string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def validateOMEXML(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def validateOMEXML(self, string: java.lang.String | str, boolean: bool) -> bool: ... + +class POIService(loci.common.services.Service): + def close(self) -> None: ... + @typing.overload + def getDocumentBytes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getDocumentBytes( + self, string: java.lang.String | str, int: int + ) -> typing.MutableSequence[int]: ... + def getDocumentList(self) -> java.util.Vector[java.lang.String]: ... + def getDocumentStream( + self, string: java.lang.String | str + ) -> loci.common.RandomAccessInputStream: ... + def getFileSize(self, string: java.lang.String | str) -> int: ... + def getInputStream(self, string: java.lang.String | str) -> java.io.InputStream: ... + @typing.overload + def initialize(self, string: java.lang.String | str) -> None: ... + @typing.overload + def initialize( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> None: ... + +class EXIFServiceImpl(loci.common.services.AbstractService, EXIFService): + def __init__(self): ... + def close(self) -> None: ... + def getCreationDate(self) -> java.util.Date: ... + def getTags(self) -> java.util.HashMap[java.lang.String, java.lang.String]: ... + def initialize(self, string: java.lang.String | str) -> None: ... + +class JAIIIOServiceImpl(loci.common.services.AbstractService, JAIIIOService): + NO_J2K_MSG: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def readImage( + self, inputStream: java.io.InputStream + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def readImage( + self, + inputStream: java.io.InputStream, + jPEG2000CodecOptions: loci.formats.codec.JPEG2000CodecOptions, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def readRaster(self, inputStream: java.io.InputStream) -> java.awt.image.Raster: ... + @typing.overload + def readRaster( + self, + inputStream: java.io.InputStream, + jPEG2000CodecOptions: loci.formats.codec.JPEG2000CodecOptions, + ) -> java.awt.image.Raster: ... + def writeImage( + self, + outputStream: java.io.OutputStream, + bufferedImage: java.awt.image.BufferedImage, + jPEG2000CodecOptions: loci.formats.codec.JPEG2000CodecOptions, + ) -> None: ... + +class JHDFServiceImpl(loci.common.services.AbstractService, JHDFService): + NO_JHDF_MSG: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def close(self) -> None: ... + def createGroup(self, string: java.lang.String | str) -> None: ... + def exists(self, string: java.lang.String | str) -> bool: ... + def getElementSize(self, string: java.lang.String | str) -> int: ... + def getFile(self) -> java.lang.String: ... + def getMember( + self, string: java.lang.String | str + ) -> java.util.List[java.lang.String]: ... + def getShape( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + def initIntArray( + self, + string: java.lang.String | str, + longArray: list[int] | jpype.JArray, + long2: int, + ) -> None: ... + def readByteArray( + self, string: java.lang.String | str + ) -> ch.systemsx.cisd.base.mdarray.MDByteArray: ... + def readByteBlockArray( + self, + string: java.lang.String | str, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ) -> ch.systemsx.cisd.base.mdarray.MDByteArray: ... + def readCompoundArrayDataMap( + self, string: java.lang.String | str + ) -> typing.MutableSequence[ch.systemsx.cisd.hdf5.HDF5CompoundDataMap]: ... + def readIntArray( + self, string: java.lang.String | str + ) -> ch.systemsx.cisd.base.mdarray.MDIntArray: ... + def readIntBlockArray( + self, + string: java.lang.String | str, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ) -> ch.systemsx.cisd.base.mdarray.MDIntArray: ... + def readShortBlockArray( + self, + string: java.lang.String | str, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ) -> ch.systemsx.cisd.base.mdarray.MDShortArray: ... + def readStringArray( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + def setFile(self, string: java.lang.String | str) -> None: ... + def setFileForWrite(self, string: java.lang.String | str) -> None: ... + @typing.overload + def writeArraySlice( + self, + string: java.lang.String | str, + mDByteArray: ch.systemsx.cisd.base.mdarray.MDByteArray, + longArray: list[int] | jpype.JArray, + ) -> None: ... + @typing.overload + def writeArraySlice( + self, + string: java.lang.String | str, + mDIntArray: ch.systemsx.cisd.base.mdarray.MDIntArray, + longArray: list[int] | jpype.JArray, + ) -> None: ... + @typing.overload + def writeArraySlice( + self, + string: java.lang.String | str, + mDShortArray: ch.systemsx.cisd.base.mdarray.MDShortArray, + longArray: list[int] | jpype.JArray, + ) -> None: ... + +class JPEGTurboServiceImpl(JPEGTurboService): + def __init__(self): ... + def close(self) -> None: ... + @typing.overload + def getCompressedTile( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getCompressedTile(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getRestartMarkers(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getTile( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getTile(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getTileColumns(self) -> int: ... + def getTileHeight(self) -> int: ... + def getTileRows(self) -> int: ... + def getTileWidth(self) -> int: ... + def initialize( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + int2: int, + ) -> None: ... + def isLibraryLoaded(self) -> bool: ... + def setRestartMarkers(self, longArray: list[int] | jpype.JArray) -> None: ... + +class JPEGXRServiceImpl(loci.common.services.AbstractService, JPEGXRService): + def __init__(self): ... + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + +class MDBServiceImpl(loci.common.services.AbstractService, MDBService): + def __init__(self): ... + def close(self) -> None: ... + def initialize(self, string: java.lang.String | str) -> None: ... + def parseDatabase( + self, + ) -> java.util.Vector[ + java.util.Vector[typing.MutableSequence[java.lang.String]] + ]: ... + def parseTable( + self, string: java.lang.String | str + ) -> java.util.Vector[typing.MutableSequence[java.lang.String]]: ... + +class MetakitServiceImpl(MetakitService): + def __init__(self): ... + def close(self) -> None: ... + def getColumNames(self, int: int) -> typing.MutableSequence[java.lang.String]: ... + def getColumnNames( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getColumnTypes(self, int: int) -> typing.MutableSequence[type]: ... + @typing.overload + def getColumnTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[type]: ... + @typing.overload + def getRowCount(self, int: int) -> int: ... + @typing.overload + def getRowCount(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getRowData(self, int: int, int2: int) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def getRowData( + self, int: int, string: java.lang.String | str + ) -> typing.MutableSequence[typing.Any]: ... + def getTableCount(self) -> int: ... + @typing.overload + def getTableData( + self, int: int + ) -> typing.MutableSequence[typing.MutableSequence[typing.Any]]: ... + @typing.overload + def getTableData( + self, string: java.lang.String | str + ) -> typing.MutableSequence[typing.MutableSequence[typing.Any]]: ... + def getTableNames(self) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def initialize(self, string: java.lang.String | str) -> None: ... + @typing.overload + def initialize( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> None: ... + +class NetCDFServiceImpl( + loci.common.services.AbstractService, + NetCDFService, + com.esotericsoftware.kryo.KryoSerializable, +): + NO_NETCDF_MSG: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def close(self) -> None: ... + def getArray( + self, + string: java.lang.String | str, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + ) -> typing.Any: ... + def getAttributeList(self) -> java.util.Vector[java.lang.String]: ... + def getAttributeValue(self, string: java.lang.String | str) -> java.lang.String: ... + def getDimension(self, string: java.lang.String | str) -> int: ... + def getFile(self) -> java.lang.String: ... + def getVariableAttributes( + self, string: java.lang.String | str + ) -> java.util.Hashtable[java.lang.String, typing.Any]: ... + def getVariableList(self) -> java.util.Vector[java.lang.String]: ... + def getVariableValue(self, string: java.lang.String | str) -> typing.Any: ... + def read( + self, + kryo: com.esotericsoftware.kryo.Kryo, + input: com.esotericsoftware.kryo.io.Input, + ) -> None: ... + def setFile(self, string: java.lang.String | str) -> None: ... + def write( + self, + kryo: com.esotericsoftware.kryo.Kryo, + output: com.esotericsoftware.kryo.io.Output, + ) -> None: ... + +class OMEXMLServiceImpl(loci.common.services.AbstractService, OMEXMLService): + LATEST_VERSION: typing.ClassVar[java.lang.String] = ... + NO_OME_XML_MSG: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def addMetadataOnly( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int + ) -> None: ... + @typing.overload + def addMetadataOnly( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int, boolean: bool + ) -> None: ... + def addModuloAlong( + self, + oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, + coreMetadata: loci.formats.CoreMetadata, + int: int, + ) -> None: ... + def asRetrieve( + self, metadataStore: loci.formats.meta.MetadataStore + ) -> loci.formats.meta.MetadataRetrieve: ... + def asStore( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> loci.formats.meta.MetadataStore: ... + @typing.overload + def convertMetadata( + self, + string: java.lang.String | str, + metadataStore: loci.formats.meta.MetadataStore, + ) -> None: ... + @typing.overload + def convertMetadata( + self, + metadataRetrieve: loci.formats.meta.MetadataRetrieve, + metadataStore: loci.formats.meta.MetadataStore, + ) -> None: ... + @typing.overload + def createOMEXMLMetadata(self) -> loci.formats.ome.OMEXMLMetadata: ... + @typing.overload + def createOMEXMLMetadata( + self, string: java.lang.String | str + ) -> loci.formats.ome.OMEXMLMetadata: ... + @typing.overload + def createOMEXMLMetadata( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> loci.formats.ome.OMEXMLMetadata: ... + def createOMEXMLRoot( + self, string: java.lang.String | str + ) -> ome.xml.model.OMEModelObject: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def equals(self, node: org.w3c.dom.Node, node2: org.w3c.dom.Node) -> bool: ... + def getLatestVersion(self) -> java.lang.String: ... + def getModuloAlongC( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int + ) -> loci.formats.Modulo: ... + def getModuloAlongT( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int + ) -> loci.formats.Modulo: ... + def getModuloAlongZ( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int + ) -> loci.formats.Modulo: ... + def getOMEMetadata( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> loci.formats.ome.OMEXMLMetadata: ... + def getOMEXML( + self, metadataRetrieve: loci.formats.meta.MetadataRetrieve + ) -> java.lang.String: ... + def getOMEXMLVersion(self, object: typing.Any) -> java.lang.String: ... + def getOriginalMetadata( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata + ) -> java.util.Hashtable: ... + def isEqual( + self, + oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, + oMEXMLMetadata2: loci.formats.ome.OMEXMLMetadata, + ) -> bool: ... + def isOMEXMLMetadata(self, object: typing.Any) -> bool: ... + def isOMEXMLRoot(self, object: typing.Any) -> bool: ... + @typing.overload + def populateOriginalMetadata( + self, + oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, + string: java.lang.String | str, + string2: java.lang.String | str, + ) -> None: ... + @typing.overload + def populateOriginalMetadata( + self, + oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, + hashtable: java.util.Hashtable[java.lang.String | str, typing.Any], + ) -> None: ... + def removeBinData( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata + ) -> None: ... + def removeChannels( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata, int: int, int2: int + ) -> None: ... + def removeTiffData( + self, oMEXMLMetadata: loci.formats.ome.OMEXMLMetadata + ) -> None: ... + def transformToLatestVersion( + self, string: java.lang.String | str + ) -> java.lang.String: ... + @typing.overload + def validateOMEXML(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def validateOMEXML(self, string: java.lang.String | str, boolean: bool) -> bool: ... + +class POIServiceImpl(loci.common.services.AbstractService, POIService): + def __init__(self): ... + def close(self) -> None: ... + @typing.overload + def getDocumentBytes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getDocumentBytes( + self, string: java.lang.String | str, int: int + ) -> typing.MutableSequence[int]: ... + def getDocumentList(self) -> java.util.Vector[java.lang.String]: ... + def getDocumentStream( + self, string: java.lang.String | str + ) -> loci.common.RandomAccessInputStream: ... + def getFileSize(self, string: java.lang.String | str) -> int: ... + def getInputStream(self, string: java.lang.String | str) -> java.io.InputStream: ... + @typing.overload + def initialize(self, string: java.lang.String | str) -> None: ... + @typing.overload + def initialize( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.services")``. + + EXIFService: type[EXIFService] + EXIFServiceImpl: type[EXIFServiceImpl] + JAIIIOService: type[JAIIIOService] + JAIIIOServiceImpl: type[JAIIIOServiceImpl] + JHDFService: type[JHDFService] + JHDFServiceImpl: type[JHDFServiceImpl] + JPEGTurboService: type[JPEGTurboService] + JPEGTurboServiceImpl: type[JPEGTurboServiceImpl] + JPEGXRService: type[JPEGXRService] + JPEGXRServiceImpl: type[JPEGXRServiceImpl] + MDBService: type[MDBService] + MDBServiceImpl: type[MDBServiceImpl] + MetakitService: type[MetakitService] + MetakitServiceImpl: type[MetakitServiceImpl] + NetCDFService: type[NetCDFService] + NetCDFServiceImpl: type[NetCDFServiceImpl] + OMEXMLService: type[OMEXMLService] + OMEXMLServiceImpl: type[OMEXMLServiceImpl] + POIService: type[POIService] + POIServiceImpl: type[POIServiceImpl] diff --git a/typings/loci/formats/tiff/__init__.pyi b/typings/loci/formats/tiff/__init__.pyi new file mode 100644 index 0000000..a5bac55 --- /dev/null +++ b/typings/loci/formats/tiff/__init__.pyi @@ -0,0 +1,596 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import jpype +import loci.common +import loci.common.enumeration +import loci.formats.codec + +class IFD(java.util.HashMap[int, typing.Any]): + LITTLE_ENDIAN: typing.ClassVar[int] = ... + BIG_TIFF: typing.ClassVar[int] = ... + REUSE: typing.ClassVar[int] = ... + NEW_SUBFILE_TYPE: typing.ClassVar[int] = ... + SUBFILE_TYPE: typing.ClassVar[int] = ... + IMAGE_WIDTH: typing.ClassVar[int] = ... + IMAGE_LENGTH: typing.ClassVar[int] = ... + BITS_PER_SAMPLE: typing.ClassVar[int] = ... + COMPRESSION: typing.ClassVar[int] = ... + PHOTOMETRIC_INTERPRETATION: typing.ClassVar[int] = ... + THRESHHOLDING: typing.ClassVar[int] = ... + CELL_WIDTH: typing.ClassVar[int] = ... + CELL_LENGTH: typing.ClassVar[int] = ... + FILL_ORDER: typing.ClassVar[int] = ... + DOCUMENT_NAME: typing.ClassVar[int] = ... + IMAGE_DESCRIPTION: typing.ClassVar[int] = ... + MAKE: typing.ClassVar[int] = ... + MODEL: typing.ClassVar[int] = ... + STRIP_OFFSETS: typing.ClassVar[int] = ... + ORIENTATION: typing.ClassVar[int] = ... + SAMPLES_PER_PIXEL: typing.ClassVar[int] = ... + ROWS_PER_STRIP: typing.ClassVar[int] = ... + STRIP_BYTE_COUNTS: typing.ClassVar[int] = ... + MIN_SAMPLE_VALUE: typing.ClassVar[int] = ... + MAX_SAMPLE_VALUE: typing.ClassVar[int] = ... + X_RESOLUTION: typing.ClassVar[int] = ... + Y_RESOLUTION: typing.ClassVar[int] = ... + PLANAR_CONFIGURATION: typing.ClassVar[int] = ... + PAGE_NAME: typing.ClassVar[int] = ... + X_POSITION: typing.ClassVar[int] = ... + Y_POSITION: typing.ClassVar[int] = ... + FREE_OFFSETS: typing.ClassVar[int] = ... + FREE_BYTE_COUNTS: typing.ClassVar[int] = ... + GRAY_RESPONSE_UNIT: typing.ClassVar[int] = ... + GRAY_RESPONSE_CURVE: typing.ClassVar[int] = ... + T4_OPTIONS: typing.ClassVar[int] = ... + T6_OPTIONS: typing.ClassVar[int] = ... + RESOLUTION_UNIT: typing.ClassVar[int] = ... + PAGE_NUMBER: typing.ClassVar[int] = ... + TRANSFER_FUNCTION: typing.ClassVar[int] = ... + SOFTWARE: typing.ClassVar[int] = ... + DATE_TIME: typing.ClassVar[int] = ... + ARTIST: typing.ClassVar[int] = ... + HOST_COMPUTER: typing.ClassVar[int] = ... + PREDICTOR: typing.ClassVar[int] = ... + WHITE_POINT: typing.ClassVar[int] = ... + PRIMARY_CHROMATICITIES: typing.ClassVar[int] = ... + COLOR_MAP: typing.ClassVar[int] = ... + HALFTONE_HINTS: typing.ClassVar[int] = ... + TILE_WIDTH: typing.ClassVar[int] = ... + TILE_LENGTH: typing.ClassVar[int] = ... + TILE_OFFSETS: typing.ClassVar[int] = ... + TILE_BYTE_COUNTS: typing.ClassVar[int] = ... + SUB_IFD: typing.ClassVar[int] = ... + INK_SET: typing.ClassVar[int] = ... + INK_NAMES: typing.ClassVar[int] = ... + NUMBER_OF_INKS: typing.ClassVar[int] = ... + DOT_RANGE: typing.ClassVar[int] = ... + TARGET_PRINTER: typing.ClassVar[int] = ... + EXTRA_SAMPLES: typing.ClassVar[int] = ... + SAMPLE_FORMAT: typing.ClassVar[int] = ... + S_MIN_SAMPLE_VALUE: typing.ClassVar[int] = ... + S_MAX_SAMPLE_VALUE: typing.ClassVar[int] = ... + TRANSFER_RANGE: typing.ClassVar[int] = ... + JPEG_TABLES: typing.ClassVar[int] = ... + JPEG_PROC: typing.ClassVar[int] = ... + JPEG_INTERCHANGE_FORMAT: typing.ClassVar[int] = ... + JPEG_INTERCHANGE_FORMAT_LENGTH: typing.ClassVar[int] = ... + JPEG_RESTART_INTERVAL: typing.ClassVar[int] = ... + JPEG_LOSSLESS_PREDICTORS: typing.ClassVar[int] = ... + JPEG_POINT_TRANSFORMS: typing.ClassVar[int] = ... + JPEG_Q_TABLES: typing.ClassVar[int] = ... + JPEG_DC_TABLES: typing.ClassVar[int] = ... + JPEG_AC_TABLES: typing.ClassVar[int] = ... + Y_CB_CR_COEFFICIENTS: typing.ClassVar[int] = ... + Y_CB_CR_SUB_SAMPLING: typing.ClassVar[int] = ... + Y_CB_CR_POSITIONING: typing.ClassVar[int] = ... + REFERENCE_BLACK_WHITE: typing.ClassVar[int] = ... + COPYRIGHT: typing.ClassVar[int] = ... + EXIF: typing.ClassVar[int] = ... + EXPOSURE_TIME: typing.ClassVar[int] = ... + F_NUMBER: typing.ClassVar[int] = ... + EXPOSURE_PROGRAM: typing.ClassVar[int] = ... + SPECTRAL_SENSITIVITY: typing.ClassVar[int] = ... + ISO_SPEED_RATINGS: typing.ClassVar[int] = ... + OECF: typing.ClassVar[int] = ... + EXIF_VERSION: typing.ClassVar[int] = ... + DATE_TIME_ORIGINAL: typing.ClassVar[int] = ... + DATE_TIME_DIGITIZED: typing.ClassVar[int] = ... + COMPONENTS_CONFIGURATION: typing.ClassVar[int] = ... + COMPRESSED_BITS_PER_PIXEL: typing.ClassVar[int] = ... + SHUTTER_SPEED_VALUE: typing.ClassVar[int] = ... + APERTURE_VALUE: typing.ClassVar[int] = ... + BRIGHTNESS_VALUE: typing.ClassVar[int] = ... + EXPOSURE_BIAS_VALUE: typing.ClassVar[int] = ... + MAX_APERTURE_VALUE: typing.ClassVar[int] = ... + SUBJECT_DISTANCE: typing.ClassVar[int] = ... + METERING_MODE: typing.ClassVar[int] = ... + LIGHT_SOURCE: typing.ClassVar[int] = ... + FLASH: typing.ClassVar[int] = ... + FOCAL_LENGTH: typing.ClassVar[int] = ... + MAKER_NOTE: typing.ClassVar[int] = ... + USER_COMMENT: typing.ClassVar[int] = ... + SUB_SEC_TIME: typing.ClassVar[int] = ... + SUB_SEC_TIME_ORIGINAL: typing.ClassVar[int] = ... + SUB_SEC_TIME_DIGITIZED: typing.ClassVar[int] = ... + FLASH_PIX_VERSION: typing.ClassVar[int] = ... + COLOR_SPACE: typing.ClassVar[int] = ... + PIXEL_X_DIMENSION: typing.ClassVar[int] = ... + PIXEL_Y_DIMENSION: typing.ClassVar[int] = ... + RELATED_SOUND_FILE: typing.ClassVar[int] = ... + FLASH_ENERGY: typing.ClassVar[int] = ... + SPATIAL_FREQUENCY_RESPONSE: typing.ClassVar[int] = ... + FOCAL_PLANE_X_RESOLUTION: typing.ClassVar[int] = ... + FOCAL_PLANE_Y_RESOLUTION: typing.ClassVar[int] = ... + FOCAL_PLANE_RESOLUTION_UNIT: typing.ClassVar[int] = ... + SUBJECT_LOCATION: typing.ClassVar[int] = ... + EXPOSURE_INDEX: typing.ClassVar[int] = ... + SENSING_METHOD: typing.ClassVar[int] = ... + FILE_SOURCE: typing.ClassVar[int] = ... + SCENE_TYPE: typing.ClassVar[int] = ... + CFA_PATTERN: typing.ClassVar[int] = ... + CUSTOM_RENDERED: typing.ClassVar[int] = ... + EXPOSURE_MODE: typing.ClassVar[int] = ... + WHITE_BALANCE: typing.ClassVar[int] = ... + DIGITAL_ZOOM_RATIO: typing.ClassVar[int] = ... + FOCAL_LENGTH_35MM_FILM: typing.ClassVar[int] = ... + SCENE_CAPTURE_TYPE: typing.ClassVar[int] = ... + GAIN_CONTROL: typing.ClassVar[int] = ... + CONTRAST: typing.ClassVar[int] = ... + SATURATION: typing.ClassVar[int] = ... + SHARPNESS: typing.ClassVar[int] = ... + SUBJECT_DISTANCE_RANGE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, iFD: IFD): ... + def getBitsPerSample(self) -> typing.MutableSequence[int]: ... + def getBytesPerSample(self) -> typing.MutableSequence[int]: ... + def getComment(self) -> java.lang.String: ... + def getCompression(self) -> TiffCompression: ... + @staticmethod + def getFieldName(int: int) -> java.lang.String: ... + def getIFDIntArray(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getIFDIntValue(self, int: int) -> int: ... + @typing.overload + def getIFDIntValue(self, int: int, int2: int) -> int: ... + def getIFDLongArray(self, int: int) -> typing.MutableSequence[int]: ... + def getIFDLongValue(self, int: int, long: int) -> int: ... + def getIFDRationalValue(self, int: int) -> TiffRational: ... + def getIFDShortArray(self, int: int) -> typing.MutableSequence[int]: ... + def getIFDStringValue(self, int: int) -> java.lang.String: ... + @staticmethod + def getIFDTagName(int: int) -> java.lang.String: ... + def getIFDTextValue(self, int: int) -> java.lang.String: ... + @typing.overload + def getIFDValue(self, int: int) -> typing.Any: ... + @typing.overload + def getIFDValue(self, int: int, class_: type) -> typing.Any: ... + def getImageLength(self) -> int: ... + def getImageWidth(self) -> int: ... + def getOnDemandStripOffsets(self) -> OnDemandLongArray: ... + def getPhotometricInterpretation(self) -> PhotoInterp: ... + def getPixelType(self) -> int: ... + def getPlanarConfiguration(self) -> int: ... + def getResolutionMultiplier(self) -> int: ... + def getRowsPerStrip(self) -> typing.MutableSequence[int]: ... + def getSamplesPerPixel(self) -> int: ... + def getStripByteCounts(self) -> typing.MutableSequence[int]: ... + def getStripOffsets(self) -> typing.MutableSequence[int]: ... + def getTileLength(self) -> int: ... + def getTileWidth(self) -> int: ... + def getTilesPerColumn(self) -> int: ... + def getTilesPerRow(self) -> int: ... + def getXResolution(self) -> float: ... + def getYResolution(self) -> float: ... + def isBigTiff(self) -> bool: ... + def isLittleEndian(self) -> bool: ... + def isTiled(self) -> bool: ... + def printIFD(self) -> None: ... + @typing.overload + def putIFDValue(self, int: int, int2: int) -> None: ... + @typing.overload + def putIFDValue(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def putIFDValue(self, int: int, long: int) -> None: ... + @typing.overload + def putIFDValue(self, int: int, short: int) -> None: ... + +class IFDList(java.util.ArrayList[IFD]): + def __init__(self): ... + +class IFDType(java.lang.Enum["IFDType"], loci.common.enumeration.CodedEnum): + BYTE: typing.ClassVar[IFDType] = ... + ASCII: typing.ClassVar[IFDType] = ... + SHORT: typing.ClassVar[IFDType] = ... + LONG: typing.ClassVar[IFDType] = ... + RATIONAL: typing.ClassVar[IFDType] = ... + SBYTE: typing.ClassVar[IFDType] = ... + UNDEFINED: typing.ClassVar[IFDType] = ... + SSHORT: typing.ClassVar[IFDType] = ... + SLONG: typing.ClassVar[IFDType] = ... + SRATIONAL: typing.ClassVar[IFDType] = ... + FLOAT: typing.ClassVar[IFDType] = ... + DOUBLE: typing.ClassVar[IFDType] = ... + IFD: typing.ClassVar[IFDType] = ... + LONG8: typing.ClassVar[IFDType] = ... + SLONG8: typing.ClassVar[IFDType] = ... + IFD8: typing.ClassVar[IFDType] = ... + @staticmethod + def get(int: int) -> IFDType: ... + def getBytesPerElement(self) -> int: ... + def getCode(self) -> int: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> IFDType: ... + @staticmethod + def values() -> typing.MutableSequence[IFDType]: ... + +class OnDemandLongArray: + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ): ... + def close(self) -> None: ... + def get(self, int: int) -> int: ... + def getStream(self) -> loci.common.RandomAccessInputStream: ... + def setSize(self, int: int) -> None: ... + def setStream( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> None: ... + def size(self) -> int: ... + def toArray(self) -> typing.MutableSequence[int]: ... + +class PhotoInterp(java.lang.Enum["PhotoInterp"], loci.common.enumeration.CodedEnum): + WHITE_IS_ZERO: typing.ClassVar[PhotoInterp] = ... + BLACK_IS_ZERO: typing.ClassVar[PhotoInterp] = ... + RGB: typing.ClassVar[PhotoInterp] = ... + RGB_PALETTE: typing.ClassVar[PhotoInterp] = ... + TRANSPARENCY_MASK: typing.ClassVar[PhotoInterp] = ... + CMYK: typing.ClassVar[PhotoInterp] = ... + Y_CB_CR: typing.ClassVar[PhotoInterp] = ... + CIE_LAB: typing.ClassVar[PhotoInterp] = ... + CFA_ARRAY: typing.ClassVar[PhotoInterp] = ... + LUMA_RED: typing.ClassVar[float] = ... + LUMA_GREEN: typing.ClassVar[float] = ... + LUMA_BLUE: typing.ClassVar[float] = ... + @staticmethod + def get(int: int) -> PhotoInterp: ... + def getCode(self) -> int: ... + def getMetadataType(self) -> java.lang.String: ... + def getName(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> PhotoInterp: ... + @staticmethod + def values() -> typing.MutableSequence[PhotoInterp]: ... + +class TiffCompression( + java.lang.Enum["TiffCompression"], loci.common.enumeration.CodedEnum +): + DEFAULT_UNCOMPRESSED: typing.ClassVar[TiffCompression] = ... + UNCOMPRESSED: typing.ClassVar[TiffCompression] = ... + CCITT_1D: typing.ClassVar[TiffCompression] = ... + GROUP_3_FAX: typing.ClassVar[TiffCompression] = ... + GROUP_4_FAX: typing.ClassVar[TiffCompression] = ... + LZW: typing.ClassVar[TiffCompression] = ... + OLD_JPEG: typing.ClassVar[TiffCompression] = ... + JPEG: typing.ClassVar[TiffCompression] = ... + PACK_BITS: typing.ClassVar[TiffCompression] = ... + PROPRIETARY_DEFLATE: typing.ClassVar[TiffCompression] = ... + DEFLATE: typing.ClassVar[TiffCompression] = ... + THUNDERSCAN: typing.ClassVar[TiffCompression] = ... + JPEG_2000: typing.ClassVar[TiffCompression] = ... + JPEG_2000_LOSSY: typing.ClassVar[TiffCompression] = ... + ALT_JPEG2000: typing.ClassVar[TiffCompression] = ... + ALT_JPEG: typing.ClassVar[TiffCompression] = ... + OLYMPUS_JPEG2000: typing.ClassVar[TiffCompression] = ... + NIKON: typing.ClassVar[TiffCompression] = ... + JPEGXR: typing.ClassVar[TiffCompression] = ... + ZSTD: typing.ClassVar[TiffCompression] = ... + def compress( + self, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: loci.formats.codec.CodecOptions, + ) -> typing.MutableSequence[int]: ... + def decompress( + self, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: loci.formats.codec.CodecOptions, + ) -> typing.MutableSequence[int]: ... + @staticmethod + def difference(byteArray: list[int] | jpype.JArray | bytes, iFD: IFD) -> None: ... + @staticmethod + def get(int: int) -> TiffCompression: ... + def getCode(self) -> int: ... + def getCodec(self) -> loci.formats.codec.Codec: ... + def getCodecName(self) -> java.lang.String: ... + @typing.overload + def getCompressionCodecOptions( + self, iFD: IFD + ) -> loci.formats.codec.CodecOptions: ... + @typing.overload + def getCompressionCodecOptions( + self, iFD: IFD, codecOptions: loci.formats.codec.CodecOptions + ) -> loci.formats.codec.CodecOptions: ... + @staticmethod + def undifference(byteArray: list[int] | jpype.JArray | bytes, iFD: IFD) -> None: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> TiffCompression: ... + @staticmethod + def values() -> typing.MutableSequence[TiffCompression]: ... + +class TiffConstants: + BYTES_PER_ENTRY: typing.ClassVar[int] = ... + BIG_TIFF_BYTES_PER_ENTRY: typing.ClassVar[int] = ... + MAGIC_NUMBER: typing.ClassVar[int] = ... + BIG_TIFF_MAGIC_NUMBER: typing.ClassVar[int] = ... + LITTLE: typing.ClassVar[int] = ... + BIG: typing.ClassVar[int] = ... + BIG_TIFF_CUTOFF: typing.ClassVar[int] = ... + +class TiffIFDEntry(java.lang.Comparable[typing.Any]): + def __init__(self, int: int, iFDType: IFDType, int2: int, long: int): ... + def compareTo(self, object: typing.Any) -> int: ... + def getTag(self) -> int: ... + def getType(self) -> IFDType: ... + def getValueCount(self) -> int: ... + def getValueOffset(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class TiffParser(java.io.Closeable): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ): ... + def checkHeader(self) -> bool: ... + def close(self) -> None: ... + def fillInIFD(self, iFD: IFD) -> None: ... + def getCodecOptions(self) -> loci.formats.codec.CodecOptions: ... + def getColorMap(self, iFD: IFD) -> typing.MutableSequence[int]: ... + def getComment(self) -> java.lang.String: ... + def getExifIFDs(self) -> IFDList: ... + def getFirstIFD(self) -> IFD: ... + def getFirstIFDEntry(self, int: int) -> TiffIFDEntry: ... + def getFirstOffset(self) -> int: ... + def getIFD(self, long: int) -> IFD: ... + def getIFDOffsets(self) -> typing.MutableSequence[int]: ... + def getIFDValue(self, tiffIFDEntry: TiffIFDEntry) -> typing.Any: ... + def getIFDs(self) -> IFDList: ... + def getMainIFDs(self) -> IFDList: ... + def getNonThumbnailIFDs(self) -> IFDList: ... + @typing.overload + def getSamples( + self, iFD: IFD, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getSamples( + self, + iFD: IFD, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + long: int, + long2: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getSamples( + self, + iFD: IFD, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + long: int, + long2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[int]: ... + def getStream(self) -> loci.common.RandomAccessInputStream: ... + def getSubIFDs(self, iFD: IFD) -> IFDList: ... + def getThumbnailIFDs(self) -> IFDList: ... + def getTile( + self, iFD: IFD, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + def isBigTiff(self) -> bool: ... + def isValidHeader(self) -> bool: ... + def setAssumeEqualStrips(self, boolean: bool) -> None: ... + def setCodecOptions( + self, codecOptions: loci.formats.codec.CodecOptions + ) -> None: ... + def setDoCaching(self, boolean: bool) -> None: ... + def setUse64BitOffsets(self, boolean: bool) -> None: ... + def setYCbCrCorrection(self, boolean: bool) -> None: ... + @staticmethod + def unpackBytes( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + byteArray2: list[int] | jpype.JArray | bytes, + iFD: IFD, + ) -> None: ... + +class TiffRational(java.lang.Number, java.lang.Comparable["TiffRational"]): + def __init__(self, long: int, long2: int): ... + def byteValue(self) -> int: ... + def compareTo(self, tiffRational: TiffRational) -> int: ... + def doubleValue(self) -> float: ... + def equals(self, object: typing.Any) -> bool: ... + def floatValue(self) -> float: ... + def getDenominator(self) -> int: ... + def getNumerator(self) -> int: ... + def hashCode(self) -> int: ... + def intValue(self) -> int: ... + def longValue(self) -> int: ... + def reduce(self) -> None: ... + def shortValue(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class TiffSaver(java.io.Closeable): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, + randomAccessOutputStream: loci.common.RandomAccessOutputStream, + string: java.lang.String | str, + ): ... + @typing.overload + def __init__( + self, + randomAccessOutputStream: loci.common.RandomAccessOutputStream, + byteArrayHandle: loci.common.ByteArrayHandle, + ): ... + def close(self) -> None: ... + def getStream(self) -> loci.common.RandomAccessOutputStream: ... + def isBigTiff(self) -> bool: ... + def isLittleEndian(self) -> bool: ... + def makeValidIFD(self, iFD: IFD, int: int, int2: int) -> None: ... + def overwriteComment( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + object: typing.Any, + ) -> None: ... + def overwriteIFDOffset( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + long: int, + long2: int, + ) -> None: ... + @typing.overload + def overwriteIFDValue( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + int2: int, + object: typing.Any, + ) -> None: ... + @typing.overload + def overwriteIFDValue( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + long: int, + int: int, + object: typing.Any, + ) -> None: ... + @typing.overload + def overwriteIFDValue( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + long: int, + int: int, + object: typing.Any, + boolean: bool, + ) -> None: ... + def overwriteLastIFDOffset( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> None: ... + def setBigTiff(self, boolean: bool) -> None: ... + def setCodecOptions( + self, codecOptions: loci.formats.codec.CodecOptions + ) -> None: ... + def setLittleEndian(self, boolean: bool) -> None: ... + def setWritingSequentially(self, boolean: bool) -> None: ... + def writeHeader(self) -> None: ... + @typing.overload + def writeIFD(self, iFD: IFD, long: int) -> None: ... + @typing.overload + def writeIFD(self, iFD: IFD, long: int, boolean: bool) -> None: ... + def writeIFDValue( + self, + randomAccessOutputStream: loci.common.RandomAccessOutputStream, + long: int, + int: int, + object: typing.Any, + ) -> None: ... + @typing.overload + def writeImage( + self, + byteArray: list[int] | jpype.JArray | bytes, + iFD: IFD, + int: int, + int2: int, + boolean: bool, + ) -> None: ... + @typing.overload + def writeImage( + self, + byteArray: list[int] | jpype.JArray | bytes, + iFD: IFD, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + boolean: bool, + ) -> None: ... + @typing.overload + def writeImage( + self, + byteArray: list[int] | jpype.JArray | bytes, + iFD: IFD, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + boolean: bool, + integer: int, + boolean2: bool, + ) -> None: ... + @typing.overload + def writeImage( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + iFDList: IFDList, + int: int, + ) -> None: ... + def writeImageIFD( + self, + iFD: IFD, + int: int, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + int2: int, + boolean: bool, + int3: int, + int4: int, + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.tiff")``. + + IFD: type[IFD] + IFDList: type[IFDList] + IFDType: type[IFDType] + OnDemandLongArray: type[OnDemandLongArray] + PhotoInterp: type[PhotoInterp] + TiffCompression: type[TiffCompression] + TiffConstants: type[TiffConstants] + TiffIFDEntry: type[TiffIFDEntry] + TiffParser: type[TiffParser] + TiffRational: type[TiffRational] + TiffSaver: type[TiffSaver] diff --git a/typings/loci/formats/tools/__init__.pyi b/typings/loci/formats/tools/__init__.pyi new file mode 100644 index 0000000..6880e4e --- /dev/null +++ b/typings/loci/formats/tools/__init__.pyi @@ -0,0 +1,134 @@ +import typing +from typing import Protocol + +import java.awt.event +import java.awt.image +import java.io +import java.lang +import java.util +import javax.swing +import jpype +import jpype.protocol +import loci.common +import loci.formats + +class AmiraParameters: + width: int = ... + height: int = ... + depth: int = ... + firstDataStream: int = ... + x0: float = ... + y0: float = ... + z0: float = ... + x1: float = ... + y1: float = ... + z1: float = ... + littleEndian: bool = ... + ascii: bool = ... + nStreams: int = ... + streamNames: typing.MutableSequence[java.lang.String] = ... + streamTypes: typing.MutableSequence[java.lang.String] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ): ... + @staticmethod + def entryToString( + object: typing.Any, string: java.lang.String | str + ) -> java.lang.String: ... + def getMap(self) -> java.util.Map: ... + def getStreams(self) -> java.util.Map: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString( + map: java.util.Map | typing.Mapping, string: java.lang.String | str + ) -> java.lang.String: ... + +class AsciiImage: + def __init__(self, bufferedImage: java.awt.image.BufferedImage): ... + def toString(self) -> java.lang.String: ... + +class BioFormatsExtensionPrinter: + def __init__(self): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + +class CacheConsole: + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + +class EditTiffG(javax.swing.JFrame, java.awt.event.ActionListener): + def __init__(self): ... + def actionPerformed(self, actionEvent: java.awt.event.ActionEvent) -> None: ... + def exit(self) -> None: ... + def getXML(self) -> java.lang.String: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def open(string: java.lang.String | str) -> loci.common.RandomAccessInputStream: ... + @typing.overload + def open(self) -> None: ... + @typing.overload + @staticmethod + def openFile(string: java.lang.String | str) -> None: ... + @typing.overload + def openFile(self, file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + @typing.overload + def openFile( + self, + file: java.io.File | jpype.protocol.SupportsPath, + randomAccessInputStream: loci.common.RandomAccessInputStream, + ) -> None: ... + def save(self) -> None: ... + def saveFile(self, file: java.io.File | jpype.protocol.SupportsPath) -> None: ... + def setXML(self, string: java.lang.String | str) -> None: ... + def showError(self, throwable: java.lang.Throwable) -> None: ... + +class FakeImage: + def __init__(self, location: loci.common.Location): ... + def generateScreen( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> loci.common.Location: ... + @staticmethod + def isValidRange(int: int, int2: int, int3: int) -> None: ... + +class MakeTestOmeTiff: + sizeZsub: int = ... + sizeTsub: int = ... + sizeCsub: int = ... + isModulo: bool = ... + def __init__(self): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + @typing.overload + def makeOmeTiff(self, *string: java.lang.String | str) -> int: ... + @typing.overload + def makeOmeTiff( + self, string: java.lang.String | str, coreMetadata: loci.formats.CoreMetadata + ) -> None: ... + def makeOmeTiffExtensions(self, *string: java.lang.String | str) -> None: ... + def makeSamples(self) -> None: ... + +class UpgradeCheck: + def __init__(self): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.formats.tools")``. + + AmiraParameters: type[AmiraParameters] + AsciiImage: type[AsciiImage] + BioFormatsExtensionPrinter: type[BioFormatsExtensionPrinter] + CacheConsole: type[CacheConsole] + EditTiffG: type[EditTiffG] + FakeImage: type[FakeImage] + MakeTestOmeTiff: type[MakeTestOmeTiff] + UpgradeCheck: type[UpgradeCheck] diff --git a/typings/loci/poi/__init__.pyi b/typings/loci/poi/__init__.pyi new file mode 100644 index 0000000..c8d1fab --- /dev/null +++ b/typings/loci/poi/__init__.pyi @@ -0,0 +1,32 @@ +from typing import Protocol + +import java.lang +import loci.poi.ddf +import loci.poi.dev +import loci.poi.hpsf +import loci.poi.hssf +import loci.poi.poifs +import loci.poi.util + +class POIDocument: + def __init__(self): ... + def getDocumentSummaryInformation( + self, + ) -> loci.poi.hpsf.DocumentSummaryInformation: ... + def getSummaryInformation(self) -> loci.poi.hpsf.SummaryInformation: ... + +class POITextExtractor: + def __init__(self, pOIDocument: POIDocument): ... + def getText(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi")``. + + POIDocument: type[POIDocument] + POITextExtractor: type[POITextExtractor] + ddf: loci.poi.ddf.__module_protocol__ + dev: loci.poi.dev.__module_protocol__ + hpsf: loci.poi.hpsf.__module_protocol__ + hssf: loci.poi.hssf.__module_protocol__ + poifs: loci.poi.poifs.__module_protocol__ + util: loci.poi.util.__module_protocol__ diff --git a/typings/loci/poi/ddf/__init__.pyi b/typings/loci/poi/ddf/__init__.pyi new file mode 100644 index 0000000..f878246 --- /dev/null +++ b/typings/loci/poi/ddf/__init__.pyi @@ -0,0 +1,1239 @@ +import typing +from typing import Protocol + +import java.awt +import java.io +import java.lang +import java.util +import jpype + +class EscherDump: + def __init__(self): ... + @typing.overload + def dump( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + printStream: java.io.PrintStream, + ) -> None: ... + @typing.overload + def dump( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + printStream: java.io.PrintStream, + ) -> None: ... + def dumpOld( + self, + long: int, + inputStream: java.io.InputStream, + printStream: java.io.PrintStream, + ) -> None: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + +class EscherProperties: + TRANSFORM__ROTATION: typing.ClassVar[int] = ... + PROTECTION__LOCKROTATION: typing.ClassVar[int] = ... + PROTECTION__LOCKASPECTRATIO: typing.ClassVar[int] = ... + PROTECTION__LOCKPOSITION: typing.ClassVar[int] = ... + PROTECTION__LOCKAGAINSTSELECT: typing.ClassVar[int] = ... + PROTECTION__LOCKCROPPING: typing.ClassVar[int] = ... + PROTECTION__LOCKVERTICES: typing.ClassVar[int] = ... + PROTECTION__LOCKTEXT: typing.ClassVar[int] = ... + PROTECTION__LOCKADJUSTHANDLES: typing.ClassVar[int] = ... + PROTECTION__LOCKAGAINSTGROUPING: typing.ClassVar[int] = ... + TEXT__TEXTID: typing.ClassVar[int] = ... + TEXT__TEXTLEFT: typing.ClassVar[int] = ... + TEXT__TEXTTOP: typing.ClassVar[int] = ... + TEXT__TEXTRIGHT: typing.ClassVar[int] = ... + TEXT__TEXTBOTTOM: typing.ClassVar[int] = ... + TEXT__WRAPTEXT: typing.ClassVar[int] = ... + TEXT__SCALETEXT: typing.ClassVar[int] = ... + TEXT__ANCHORTEXT: typing.ClassVar[int] = ... + TEXT__TEXTFLOW: typing.ClassVar[int] = ... + TEXT__FONTROTATION: typing.ClassVar[int] = ... + TEXT__IDOFNEXTSHAPE: typing.ClassVar[int] = ... + TEXT__BIDIR: typing.ClassVar[int] = ... + TEXT__SINGLECLICKSELECTS: typing.ClassVar[int] = ... + TEXT__USEHOSTMARGINS: typing.ClassVar[int] = ... + TEXT__ROTATETEXTWITHSHAPE: typing.ClassVar[int] = ... + TEXT__SIZESHAPETOFITTEXT: typing.ClassVar[int] = ... + TEXT__SIZE_TEXT_TO_FIT_SHAPE: typing.ClassVar[int] = ... + GEOTEXT__UNICODE: typing.ClassVar[int] = ... + GEOTEXT__RTFTEXT: typing.ClassVar[int] = ... + GEOTEXT__ALIGNMENTONCURVE: typing.ClassVar[int] = ... + GEOTEXT__DEFAULTPOINTSIZE: typing.ClassVar[int] = ... + GEOTEXT__TEXTSPACING: typing.ClassVar[int] = ... + GEOTEXT__FONTFAMILYNAME: typing.ClassVar[int] = ... + GEOTEXT__REVERSEROWORDER: typing.ClassVar[int] = ... + GEOTEXT__HASTEXTEFFECT: typing.ClassVar[int] = ... + GEOTEXT__ROTATECHARACTERS: typing.ClassVar[int] = ... + GEOTEXT__KERNCHARACTERS: typing.ClassVar[int] = ... + GEOTEXT__TIGHTORTRACK: typing.ClassVar[int] = ... + GEOTEXT__STRETCHTOFITSHAPE: typing.ClassVar[int] = ... + GEOTEXT__CHARBOUNDINGBOX: typing.ClassVar[int] = ... + GEOTEXT__SCALETEXTONPATH: typing.ClassVar[int] = ... + GEOTEXT__STRETCHCHARHEIGHT: typing.ClassVar[int] = ... + GEOTEXT__NOMEASUREALONGPATH: typing.ClassVar[int] = ... + GEOTEXT__BOLDFONT: typing.ClassVar[int] = ... + GEOTEXT__ITALICFONT: typing.ClassVar[int] = ... + GEOTEXT__UNDERLINEFONT: typing.ClassVar[int] = ... + GEOTEXT__SHADOWFONT: typing.ClassVar[int] = ... + GEOTEXT__SMALLCAPSFONT: typing.ClassVar[int] = ... + GEOTEXT__STRIKETHROUGHFONT: typing.ClassVar[int] = ... + BLIP__CROPFROMTOP: typing.ClassVar[int] = ... + BLIP__CROPFROMBOTTOM: typing.ClassVar[int] = ... + BLIP__CROPFROMLEFT: typing.ClassVar[int] = ... + BLIP__CROPFROMRIGHT: typing.ClassVar[int] = ... + BLIP__BLIPTODISPLAY: typing.ClassVar[int] = ... + BLIP__BLIPFILENAME: typing.ClassVar[int] = ... + BLIP__BLIPFLAGS: typing.ClassVar[int] = ... + BLIP__TRANSPARENTCOLOR: typing.ClassVar[int] = ... + BLIP__CONTRASTSETTING: typing.ClassVar[int] = ... + BLIP__BRIGHTNESSSETTING: typing.ClassVar[int] = ... + BLIP__GAMMA: typing.ClassVar[int] = ... + BLIP__PICTUREID: typing.ClassVar[int] = ... + BLIP__DOUBLEMOD: typing.ClassVar[int] = ... + BLIP__PICTUREFILLMOD: typing.ClassVar[int] = ... + BLIP__PICTURELINE: typing.ClassVar[int] = ... + BLIP__PRINTBLIP: typing.ClassVar[int] = ... + BLIP__PRINTBLIPFILENAME: typing.ClassVar[int] = ... + BLIP__PRINTFLAGS: typing.ClassVar[int] = ... + BLIP__NOHITTESTPICTURE: typing.ClassVar[int] = ... + BLIP__PICTUREGRAY: typing.ClassVar[int] = ... + BLIP__PICTUREBILEVEL: typing.ClassVar[int] = ... + BLIP__PICTUREACTIVE: typing.ClassVar[int] = ... + GEOMETRY__LEFT: typing.ClassVar[int] = ... + GEOMETRY__TOP: typing.ClassVar[int] = ... + GEOMETRY__RIGHT: typing.ClassVar[int] = ... + GEOMETRY__BOTTOM: typing.ClassVar[int] = ... + GEOMETRY__SHAPEPATH: typing.ClassVar[int] = ... + GEOMETRY__VERTICES: typing.ClassVar[int] = ... + GEOMETRY__SEGMENTINFO: typing.ClassVar[int] = ... + GEOMETRY__ADJUSTVALUE: typing.ClassVar[int] = ... + GEOMETRY__ADJUST2VALUE: typing.ClassVar[int] = ... + GEOMETRY__ADJUST3VALUE: typing.ClassVar[int] = ... + GEOMETRY__ADJUST4VALUE: typing.ClassVar[int] = ... + GEOMETRY__ADJUST5VALUE: typing.ClassVar[int] = ... + GEOMETRY__ADJUST6VALUE: typing.ClassVar[int] = ... + GEOMETRY__ADJUST7VALUE: typing.ClassVar[int] = ... + GEOMETRY__ADJUST8VALUE: typing.ClassVar[int] = ... + GEOMETRY__ADJUST9VALUE: typing.ClassVar[int] = ... + GEOMETRY__ADJUST10VALUE: typing.ClassVar[int] = ... + GEOMETRY__SHADOWok: typing.ClassVar[int] = ... + GEOMETRY__3DOK: typing.ClassVar[int] = ... + GEOMETRY__LINEOK: typing.ClassVar[int] = ... + GEOMETRY__GEOTEXTOK: typing.ClassVar[int] = ... + GEOMETRY__FILLSHADESHAPEOK: typing.ClassVar[int] = ... + GEOMETRY__FILLOK: typing.ClassVar[int] = ... + FILL__FILLTYPE: typing.ClassVar[int] = ... + FILL__FILLCOLOR: typing.ClassVar[int] = ... + FILL__FILLOPACITY: typing.ClassVar[int] = ... + FILL__FILLBACKCOLOR: typing.ClassVar[int] = ... + FILL__BACKOPACITY: typing.ClassVar[int] = ... + FILL__CRMOD: typing.ClassVar[int] = ... + FILL__PATTERNTEXTURE: typing.ClassVar[int] = ... + FILL__BLIPFILENAME: typing.ClassVar[int] = ... + FILL__BLIPFLAGS: typing.ClassVar[int] = ... + FILL__WIDTH: typing.ClassVar[int] = ... + FILL__HEIGHT: typing.ClassVar[int] = ... + FILL__ANGLE: typing.ClassVar[int] = ... + FILL__FOCUS: typing.ClassVar[int] = ... + FILL__TOLEFT: typing.ClassVar[int] = ... + FILL__TOTOP: typing.ClassVar[int] = ... + FILL__TORIGHT: typing.ClassVar[int] = ... + FILL__TOBOTTOM: typing.ClassVar[int] = ... + FILL__RECTLEFT: typing.ClassVar[int] = ... + FILL__RECTTOP: typing.ClassVar[int] = ... + FILL__RECTRIGHT: typing.ClassVar[int] = ... + FILL__RECTBOTTOM: typing.ClassVar[int] = ... + FILL__DZTYPE: typing.ClassVar[int] = ... + FILL__SHADEPRESET: typing.ClassVar[int] = ... + FILL__SHADECOLORS: typing.ClassVar[int] = ... + FILL__ORIGINX: typing.ClassVar[int] = ... + FILL__ORIGINY: typing.ClassVar[int] = ... + FILL__SHAPEORIGINX: typing.ClassVar[int] = ... + FILL__SHAPEORIGINY: typing.ClassVar[int] = ... + FILL__SHADETYPE: typing.ClassVar[int] = ... + FILL__FILLED: typing.ClassVar[int] = ... + FILL__HITTESTFILL: typing.ClassVar[int] = ... + FILL__SHAPE: typing.ClassVar[int] = ... + FILL__USERECT: typing.ClassVar[int] = ... + FILL__NOFILLHITTEST: typing.ClassVar[int] = ... + LINESTYLE__COLOR: typing.ClassVar[int] = ... + LINESTYLE__OPACITY: typing.ClassVar[int] = ... + LINESTYLE__BACKCOLOR: typing.ClassVar[int] = ... + LINESTYLE__CRMOD: typing.ClassVar[int] = ... + LINESTYLE__LINETYPE: typing.ClassVar[int] = ... + LINESTYLE__FILLBLIP: typing.ClassVar[int] = ... + LINESTYLE__FILLBLIPNAME: typing.ClassVar[int] = ... + LINESTYLE__FILLBLIPFLAGS: typing.ClassVar[int] = ... + LINESTYLE__FILLWIDTH: typing.ClassVar[int] = ... + LINESTYLE__FILLHEIGHT: typing.ClassVar[int] = ... + LINESTYLE__FILLDZTYPE: typing.ClassVar[int] = ... + LINESTYLE__LINEWIDTH: typing.ClassVar[int] = ... + LINESTYLE__LINEMITERLIMIT: typing.ClassVar[int] = ... + LINESTYLE__LINESTYLE: typing.ClassVar[int] = ... + LINESTYLE__LINEDASHING: typing.ClassVar[int] = ... + LINESTYLE__LINEDASHSTYLE: typing.ClassVar[int] = ... + LINESTYLE__LINESTARTARROWHEAD: typing.ClassVar[int] = ... + LINESTYLE__LINEENDARROWHEAD: typing.ClassVar[int] = ... + LINESTYLE__LINESTARTARROWWIDTH: typing.ClassVar[int] = ... + LINESTYLE__LINEESTARTARROWLENGTH: typing.ClassVar[int] = ... + LINESTYLE__LINEENDARROWWIDTH: typing.ClassVar[int] = ... + LINESTYLE__LINEENDARROWLENGTH: typing.ClassVar[int] = ... + LINESTYLE__LINEJOINSTYLE: typing.ClassVar[int] = ... + LINESTYLE__LINEENDCAPSTYLE: typing.ClassVar[int] = ... + LINESTYLE__ARROWHEADSOK: typing.ClassVar[int] = ... + LINESTYLE__ANYLINE: typing.ClassVar[int] = ... + LINESTYLE__HITLINETEST: typing.ClassVar[int] = ... + LINESTYLE__LINEFILLSHAPE: typing.ClassVar[int] = ... + LINESTYLE__NOLINEDRAWDASH: typing.ClassVar[int] = ... + SHADOWSTYLE__TYPE: typing.ClassVar[int] = ... + SHADOWSTYLE__COLOR: typing.ClassVar[int] = ... + SHADOWSTYLE__HIGHLIGHT: typing.ClassVar[int] = ... + SHADOWSTYLE__CRMOD: typing.ClassVar[int] = ... + SHADOWSTYLE__OPACITY: typing.ClassVar[int] = ... + SHADOWSTYLE__OFFSETX: typing.ClassVar[int] = ... + SHADOWSTYLE__OFFSETY: typing.ClassVar[int] = ... + SHADOWSTYLE__SECONDOFFSETX: typing.ClassVar[int] = ... + SHADOWSTYLE__SECONDOFFSETY: typing.ClassVar[int] = ... + SHADOWSTYLE__SCALEXTOX: typing.ClassVar[int] = ... + SHADOWSTYLE__SCALEYTOX: typing.ClassVar[int] = ... + SHADOWSTYLE__SCALEXTOY: typing.ClassVar[int] = ... + SHADOWSTYLE__SCALEYTOY: typing.ClassVar[int] = ... + SHADOWSTYLE__PERSPECTIVEX: typing.ClassVar[int] = ... + SHADOWSTYLE__PERSPECTIVEY: typing.ClassVar[int] = ... + SHADOWSTYLE__WEIGHT: typing.ClassVar[int] = ... + SHADOWSTYLE__ORIGINX: typing.ClassVar[int] = ... + SHADOWSTYLE__ORIGINY: typing.ClassVar[int] = ... + SHADOWSTYLE__SHADOW: typing.ClassVar[int] = ... + SHADOWSTYLE__SHADOWOBSURED: typing.ClassVar[int] = ... + PERSPECTIVE__TYPE: typing.ClassVar[int] = ... + PERSPECTIVE__OFFSETX: typing.ClassVar[int] = ... + PERSPECTIVE__OFFSETY: typing.ClassVar[int] = ... + PERSPECTIVE__SCALEXTOX: typing.ClassVar[int] = ... + PERSPECTIVE__SCALEYTOX: typing.ClassVar[int] = ... + PERSPECTIVE__SCALEXTOY: typing.ClassVar[int] = ... + PERSPECTIVE__SCALEYTOY: typing.ClassVar[int] = ... + PERSPECTIVE__PERSPECTIVEX: typing.ClassVar[int] = ... + PERSPECTIVE__PERSPECTIVEY: typing.ClassVar[int] = ... + PERSPECTIVE__WEIGHT: typing.ClassVar[int] = ... + PERSPECTIVE__ORIGINX: typing.ClassVar[int] = ... + PERSPECTIVE__ORIGINY: typing.ClassVar[int] = ... + PERSPECTIVE__PERSPECTIVEON: typing.ClassVar[int] = ... + THREED__SPECULARAMOUNT: typing.ClassVar[int] = ... + THREED__DIFFUSEAMOUNT: typing.ClassVar[int] = ... + THREED__SHININESS: typing.ClassVar[int] = ... + THREED__EDGETHICKNESS: typing.ClassVar[int] = ... + THREED__EXTRUDEFORWARD: typing.ClassVar[int] = ... + THREED__EXTRUDEBACKWARD: typing.ClassVar[int] = ... + THREED__EXTRUDEPLANE: typing.ClassVar[int] = ... + THREED__EXTRUSIONCOLOR: typing.ClassVar[int] = ... + THREED__CRMOD: typing.ClassVar[int] = ... + THREED__3DEFFECT: typing.ClassVar[int] = ... + THREED__METALLIC: typing.ClassVar[int] = ... + THREED__USEEXTRUSIONCOLOR: typing.ClassVar[int] = ... + THREED__LIGHTFACE: typing.ClassVar[int] = ... + THREEDSTYLE__YROTATIONANGLE: typing.ClassVar[int] = ... + THREEDSTYLE__XROTATIONANGLE: typing.ClassVar[int] = ... + THREEDSTYLE__ROTATIONAXISX: typing.ClassVar[int] = ... + THREEDSTYLE__ROTATIONAXISY: typing.ClassVar[int] = ... + THREEDSTYLE__ROTATIONAXISZ: typing.ClassVar[int] = ... + THREEDSTYLE__ROTATIONANGLE: typing.ClassVar[int] = ... + THREEDSTYLE__ROTATIONCENTERX: typing.ClassVar[int] = ... + THREEDSTYLE__ROTATIONCENTERY: typing.ClassVar[int] = ... + THREEDSTYLE__ROTATIONCENTERZ: typing.ClassVar[int] = ... + THREEDSTYLE__RENDERMODE: typing.ClassVar[int] = ... + THREEDSTYLE__TOLERANCE: typing.ClassVar[int] = ... + THREEDSTYLE__XVIEWPOINT: typing.ClassVar[int] = ... + THREEDSTYLE__YVIEWPOINT: typing.ClassVar[int] = ... + THREEDSTYLE__ZVIEWPOINT: typing.ClassVar[int] = ... + THREEDSTYLE__ORIGINX: typing.ClassVar[int] = ... + THREEDSTYLE__ORIGINY: typing.ClassVar[int] = ... + THREEDSTYLE__SKEWANGLE: typing.ClassVar[int] = ... + THREEDSTYLE__SKEWAMOUNT: typing.ClassVar[int] = ... + THREEDSTYLE__AMBIENTINTENSITY: typing.ClassVar[int] = ... + THREEDSTYLE__KEYX: typing.ClassVar[int] = ... + THREEDSTYLE__KEYY: typing.ClassVar[int] = ... + THREEDSTYLE__KEYZ: typing.ClassVar[int] = ... + THREEDSTYLE__KEYINTENSITY: typing.ClassVar[int] = ... + THREEDSTYLE__FILLX: typing.ClassVar[int] = ... + THREEDSTYLE__FILLY: typing.ClassVar[int] = ... + THREEDSTYLE__FILLZ: typing.ClassVar[int] = ... + THREEDSTYLE__FILLINTENSITY: typing.ClassVar[int] = ... + THREEDSTYLE__CONSTRAINROTATION: typing.ClassVar[int] = ... + THREEDSTYLE__ROTATIONCENTERAUTO: typing.ClassVar[int] = ... + THREEDSTYLE__PARALLEL: typing.ClassVar[int] = ... + THREEDSTYLE__KEYHARSH: typing.ClassVar[int] = ... + THREEDSTYLE__FILLHARSH: typing.ClassVar[int] = ... + SHAPE__MASTER: typing.ClassVar[int] = ... + SHAPE__CONNECTORSTYLE: typing.ClassVar[int] = ... + SHAPE__BLACKANDWHITESETTINGS: typing.ClassVar[int] = ... + SHAPE__WMODEPUREBW: typing.ClassVar[int] = ... + SHAPE__WMODEBW: typing.ClassVar[int] = ... + SHAPE__OLEICON: typing.ClassVar[int] = ... + SHAPE__PREFERRELATIVERESIZE: typing.ClassVar[int] = ... + SHAPE__LOCKSHAPETYPE: typing.ClassVar[int] = ... + SHAPE__DELETEATTACHEDOBJECT: typing.ClassVar[int] = ... + SHAPE__BACKGROUNDSHAPE: typing.ClassVar[int] = ... + CALLOUT__CALLOUTTYPE: typing.ClassVar[int] = ... + CALLOUT__XYCALLOUTGAP: typing.ClassVar[int] = ... + CALLOUT__CALLOUTANGLE: typing.ClassVar[int] = ... + CALLOUT__CALLOUTDROPTYPE: typing.ClassVar[int] = ... + CALLOUT__CALLOUTDROPSPECIFIED: typing.ClassVar[int] = ... + CALLOUT__CALLOUTLENGTHSPECIFIED: typing.ClassVar[int] = ... + CALLOUT__ISCALLOUT: typing.ClassVar[int] = ... + CALLOUT__CALLOUTACCENTBAR: typing.ClassVar[int] = ... + CALLOUT__CALLOUTTEXTBORDER: typing.ClassVar[int] = ... + CALLOUT__CALLOUTMINUSX: typing.ClassVar[int] = ... + CALLOUT__CALLOUTMINUSY: typing.ClassVar[int] = ... + CALLOUT__DROPAUTO: typing.ClassVar[int] = ... + CALLOUT__LENGTHSPECIFIED: typing.ClassVar[int] = ... + GROUPSHAPE__SHAPENAME: typing.ClassVar[int] = ... + GROUPSHAPE__DESCRIPTION: typing.ClassVar[int] = ... + GROUPSHAPE__HYPERLINK: typing.ClassVar[int] = ... + GROUPSHAPE__WRAPPOLYGONVERTICES: typing.ClassVar[int] = ... + GROUPSHAPE__WRAPDISTLEFT: typing.ClassVar[int] = ... + GROUPSHAPE__WRAPDISTTOP: typing.ClassVar[int] = ... + GROUPSHAPE__WRAPDISTRIGHT: typing.ClassVar[int] = ... + GROUPSHAPE__WRAPDISTBOTTOM: typing.ClassVar[int] = ... + GROUPSHAPE__REGROUPID: typing.ClassVar[int] = ... + GROUPSHAPE__EDITEDWRAP: typing.ClassVar[int] = ... + GROUPSHAPE__BEHINDDOCUMENT: typing.ClassVar[int] = ... + GROUPSHAPE__ONDBLCLICKNOTIFY: typing.ClassVar[int] = ... + GROUPSHAPE__ISBUTTON: typing.ClassVar[int] = ... + GROUPSHAPE__1DADJUSTMENT: typing.ClassVar[int] = ... + GROUPSHAPE__HIDDEN: typing.ClassVar[int] = ... + GROUPSHAPE__PRINT: typing.ClassVar[int] = ... + def __init__(self): ... + @staticmethod + def getPropertyName(short: int) -> java.lang.String: ... + @staticmethod + def getPropertyType(short: int) -> int: ... + +class EscherProperty: + @typing.overload + def __init__(self, short: int): ... + @typing.overload + def __init__(self, short: int, boolean: bool, boolean2: bool): ... + def getId(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getPropertyNumber(self) -> int: ... + def getPropertySize(self) -> int: ... + def isBlipId(self) -> bool: ... + def isComplex(self) -> bool: ... + def serializeComplexPart( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + def serializeSimplePart( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + +class EscherPropertyFactory: + def __init__(self): ... + def createProperties( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, short: int + ) -> java.util.List: ... + +class EscherPropertyMetaData: + TYPE_UNKNOWN: typing.ClassVar[int] = ... + TYPE_BOOLEAN: typing.ClassVar[int] = ... + TYPE_RGB: typing.ClassVar[int] = ... + TYPE_SHAPEPATH: typing.ClassVar[int] = ... + TYPE_SIMPLE: typing.ClassVar[int] = ... + TYPE_ARRAY: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, byte: int): ... + def getDescription(self) -> java.lang.String: ... + def getType(self) -> int: ... + +class EscherRecord: + def __init__(self): ... + def clone(self) -> typing.Any: ... + def display(self, printWriter: java.io.PrintWriter, int: int) -> None: ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getChild(self, int: int) -> EscherRecord: ... + def getChildRecords(self) -> java.util.List: ... + def getInstance(self) -> int: ... + def getOptions(self) -> int: ... + def getRecordId(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + def isContainerRecord(self) -> bool: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setChildRecords(self, list: java.util.List) -> None: ... + def setOptions(self, short: int) -> None: ... + def setRecordId(self, short: int) -> None: ... + +class EscherRecordFactory: + def createRecord( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> EscherRecord: ... + +class EscherSerializationListener: + def afterRecordSerialize( + self, int: int, short: int, int2: int, escherRecord: EscherRecord + ) -> None: ... + def beforeRecordSerialize( + self, int: int, short: int, escherRecord: EscherRecord + ) -> None: ... + +class DefaultEscherRecordFactory(EscherRecordFactory): + def __init__(self): ... + def createRecord( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> EscherRecord: ... + +class EscherBSERecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + BT_ERROR: typing.ClassVar[int] = ... + BT_UNKNOWN: typing.ClassVar[int] = ... + BT_EMF: typing.ClassVar[int] = ... + BT_WMF: typing.ClassVar[int] = ... + BT_PICT: typing.ClassVar[int] = ... + BT_JPEG: typing.ClassVar[int] = ... + BT_PNG: typing.ClassVar[int] = ... + BT_DIB: typing.ClassVar[int] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getBlipRecord(self) -> EscherBlipRecord: ... + def getBlipType(self, byte: int) -> java.lang.String: ... + def getBlipTypeMacOS(self) -> int: ... + def getBlipTypeWin32(self) -> int: ... + def getName(self) -> int: ... + def getOffset(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + def getRef(self) -> int: ... + def getRemainingData(self) -> typing.MutableSequence[int]: ... + def getSize(self) -> int: ... + def getTag(self) -> int: ... + def getUid(self) -> typing.MutableSequence[int]: ... + def getUnused2(self) -> int: ... + def getUnused3(self) -> int: ... + def getUsage(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBlipRecord(self, escherBlipRecord: EscherBlipRecord) -> None: ... + def setBlipTypeMacOS(self, byte: int) -> None: ... + def setBlipTypeWin32(self, byte: int) -> None: ... + def setName(self, byte: int) -> None: ... + def setOffset(self, int: int) -> None: ... + def setRef(self, int: int) -> None: ... + def setRemainingData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setSize(self, int: int) -> None: ... + def setTag(self, short: int) -> None: ... + def setUid(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setUnused2(self, byte: int) -> None: ... + def setUnused3(self, byte: int) -> None: ... + def setUsage(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherBlipRecord(EscherRecord): + RECORD_ID_START: typing.ClassVar[int] = ... + RECORD_ID_END: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getPicturedata(self) -> typing.MutableSequence[int]: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setPictureData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherChildAnchorRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getDx1(self) -> int: ... + def getDx2(self) -> int: ... + def getDy1(self) -> int: ... + def getDy2(self) -> int: ... + def getRecordId(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setDx1(self, int: int) -> None: ... + def setDx2(self, int: int) -> None: ... + def setDy1(self, int: int) -> None: ... + def setDy2(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherClientAnchorRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getCol1(self) -> int: ... + def getCol2(self) -> int: ... + def getDx1(self) -> int: ... + def getDx2(self) -> int: ... + def getDy1(self) -> int: ... + def getDy2(self) -> int: ... + def getFlag(self) -> int: ... + def getRecordId(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + def getRemainingData(self) -> typing.MutableSequence[int]: ... + def getRow1(self) -> int: ... + def getRow2(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCol1(self, short: int) -> None: ... + def setCol2(self, short: int) -> None: ... + def setDx1(self, short: int) -> None: ... + def setDx2(self, short: int) -> None: ... + def setDy1(self, short: int) -> None: ... + def setDy2(self, short: int) -> None: ... + def setFlag(self, short: int) -> None: ... + def setRemainingData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setRow1(self, short: int) -> None: ... + def setRow2(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherClientDataRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getRecordId(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + def getRemainingData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setRemainingData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherComplexProperty(EscherProperty): + @typing.overload + def __init__( + self, short: int, boolean: bool, byteArray: list[int] | jpype.JArray | bytes + ): ... + @typing.overload + def __init__(self, short: int, byteArray: list[int] | jpype.JArray | bytes): ... + def equals(self, object: typing.Any) -> bool: ... + def getComplexData(self) -> typing.MutableSequence[int]: ... + def getPropertySize(self) -> int: ... + def hashCode(self) -> int: ... + def serializeComplexPart( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + def serializeSimplePart( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class EscherContainerRecord(EscherRecord): + DGG_CONTAINER: typing.ClassVar[int] = ... + BSTORE_CONTAINER: typing.ClassVar[int] = ... + DG_CONTAINER: typing.ClassVar[int] = ... + SPGR_CONTAINER: typing.ClassVar[int] = ... + SP_CONTAINER: typing.ClassVar[int] = ... + SOLVER_CONTAINER: typing.ClassVar[int] = ... + def __init__(self): ... + def addChildRecord(self, escherRecord: EscherRecord) -> None: ... + def display(self, printWriter: java.io.PrintWriter, int: int) -> None: ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getChildById(self, short: int) -> EscherSpRecord: ... + def getChildRecords(self) -> java.util.List: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setChildRecords(self, list: java.util.List) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherDgRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getDrawingGroupId(self) -> int: ... + def getLastMSOSPID(self) -> int: ... + def getNumShapes(self) -> int: ... + def getRecordId(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + def incrementShapeCount(self) -> None: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setLastMSOSPID(self, int: int) -> None: ... + def setNumShapes(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherDggRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def addCluster(self, int: int, int2: int) -> None: ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getDrawingsSaved(self) -> int: ... + def getFileIdClusters( + self, + ) -> typing.MutableSequence[EscherDggRecord.FileIdCluster]: ... + def getNumIdClusters(self) -> int: ... + def getNumShapesSaved(self) -> int: ... + def getRecordId(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + def getShapeIdMax(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setDrawingsSaved(self, int: int) -> None: ... + def setFileIdClusters( + self, fileIdClusterArray: list[EscherDggRecord.FileIdCluster] | jpype.JArray + ) -> None: ... + def setNumShapesSaved(self, int: int) -> None: ... + def setShapeIdMax(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + class FileIdCluster: + def __init__(self, int: int, int2: int): ... + def getDrawingGroupId(self) -> int: ... + def getNumShapeIdsUsed(self) -> int: ... + def incrementShapeId(self) -> None: ... + +class EscherOptRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def addEscherProperty(self, escherProperty: EscherProperty) -> None: ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getEscherProperties(self) -> java.util.List: ... + def getEscherProperty(self, int: int) -> EscherProperty: ... + def getOptions(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def sortProperties(self) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherSimpleProperty(EscherProperty): + @typing.overload + def __init__(self, short: int, boolean: bool, boolean2: bool, int: int): ... + @typing.overload + def __init__(self, short: int, int: int): ... + def equals(self, object: typing.Any) -> bool: ... + def getPropertyValue(self) -> int: ... + def hashCode(self) -> int: ... + def serializeComplexPart( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + def serializeSimplePart( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class EscherSpRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + FLAG_GROUP: typing.ClassVar[int] = ... + FLAG_CHILD: typing.ClassVar[int] = ... + FLAG_PATRIARCH: typing.ClassVar[int] = ... + FLAG_DELETED: typing.ClassVar[int] = ... + FLAG_OLESHAPE: typing.ClassVar[int] = ... + FLAG_HAVEMASTER: typing.ClassVar[int] = ... + FLAG_FLIPHORIZ: typing.ClassVar[int] = ... + FLAG_FLIPVERT: typing.ClassVar[int] = ... + FLAG_CONNECTOR: typing.ClassVar[int] = ... + FLAG_HAVEANCHOR: typing.ClassVar[int] = ... + FLAG_BACKGROUND: typing.ClassVar[int] = ... + FLAG_HASSHAPETYPE: typing.ClassVar[int] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getFlags(self) -> int: ... + def getRecordId(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + def getShapeId(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + def setFlags(self, int: int) -> None: ... + def setShapeId(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherSpgrRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getRecordId(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + def getRectX1(self) -> int: ... + def getRectX2(self) -> int: ... + def getRectY1(self) -> int: ... + def getRectY2(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + def setRectX1(self, int: int) -> None: ... + def setRectX2(self, int: int) -> None: ... + def setRectY1(self, int: int) -> None: ... + def setRectY2(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherSplitMenuColorsRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getColor1(self) -> int: ... + def getColor2(self) -> int: ... + def getColor3(self) -> int: ... + def getColor4(self) -> int: ... + def getRecordId(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + def setColor1(self, int: int) -> None: ... + def setColor2(self, int: int) -> None: ... + def setColor3(self, int: int) -> None: ... + def setColor4(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherTextboxRecord(EscherRecord): + RECORD_ID: typing.ClassVar[int] = ... + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def clone(self) -> typing.Any: ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getData(self) -> typing.MutableSequence[int]: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def setData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def toString(self) -> java.lang.String: ... + +class NullEscherSerializationListener(EscherSerializationListener): + def __init__(self): ... + def afterRecordSerialize( + self, int: int, short: int, int2: int, escherRecord: EscherRecord + ) -> None: ... + def beforeRecordSerialize( + self, int: int, short: int, escherRecord: EscherRecord + ) -> None: ... + +class UnknownEscherRecord(EscherRecord): + def __init__(self): ... + def addChildRecord(self, escherRecord: EscherRecord) -> None: ... + def clone(self) -> typing.Any: ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getChildRecords(self) -> java.util.List: ... + def getData(self) -> typing.MutableSequence[int]: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + def setChildRecords(self, list: java.util.List) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherArrayProperty(EscherComplexProperty): + @typing.overload + def __init__( + self, short: int, boolean: bool, byteArray: list[int] | jpype.JArray | bytes + ): ... + @typing.overload + def __init__(self, short: int, byteArray: list[int] | jpype.JArray | bytes): ... + @staticmethod + def getActualSizeOfElements(short: int) -> int: ... + def getElement(self, int: int) -> typing.MutableSequence[int]: ... + def getNumberOfElementsInArray(self) -> int: ... + def getNumberOfElementsInMemory(self) -> int: ... + def getSizeOfElements(self) -> int: ... + def serializeSimplePart( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + def setArrayData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + def setElement( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + def setNumberOfElementsInArray(self, int: int) -> None: ... + def setNumberOfElementsInMemory(self, int: int) -> None: ... + def setSizeOfElements(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherBitmapBlip(EscherBlipRecord): + RECORD_ID_JPEG: typing.ClassVar[int] = ... + RECORD_ID_PNG: typing.ClassVar[int] = ... + RECORD_ID_DIB: typing.ClassVar[int] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getMarker(self) -> int: ... + def getRecordSize(self) -> int: ... + def getUID(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setMarker(self, byte: int) -> None: ... + def setUID(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherBlipWMFRecord(EscherBlipRecord): + RECORD_DESCRIPTION: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @staticmethod + def compress( + byteArray: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[int]: ... + @staticmethod + def decompress( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getBoundaryHeight(self) -> int: ... + def getBoundaryLeft(self) -> int: ... + def getBoundaryTop(self) -> int: ... + def getBoundaryWidth(self) -> int: ... + def getCacheOfSavedSize(self) -> int: ... + def getCacheOfSize(self) -> int: ... + def getCompressionFlag(self) -> int: ... + def getData(self) -> typing.MutableSequence[int]: ... + def getFilter(self) -> int: ... + def getHeight(self) -> int: ... + def getRecordName(self) -> java.lang.String: ... + def getRecordSize(self) -> int: ... + def getSecondaryUID(self) -> typing.MutableSequence[int]: ... + def getWidth(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBoundaryHeight(self, int: int) -> None: ... + def setBoundaryLeft(self, int: int) -> None: ... + def setBoundaryTop(self, int: int) -> None: ... + def setBoundaryWidth(self, int: int) -> None: ... + def setCacheOfSavedSize(self, int: int) -> None: ... + def setCacheOfSize(self, int: int) -> None: ... + def setCompressionFlag(self, byte: int) -> None: ... + def setData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setFilter(self, byte: int) -> None: ... + def setHeight(self, int: int) -> None: ... + def setSecondaryUID(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setWidth(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherBoolProperty(EscherSimpleProperty): + def __init__(self, short: int, int: int): ... + def isFalse(self) -> bool: ... + def isTrue(self) -> bool: ... + +class EscherMetafileBlip(EscherBlipRecord): + RECORD_ID_EMF: typing.ClassVar[int] = ... + RECORD_ID_WMF: typing.ClassVar[int] = ... + RECORD_ID_PICT: typing.ClassVar[int] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getBounds(self) -> java.awt.Rectangle: ... + def getCompressedSize(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSizeEMU(self) -> java.awt.Dimension: ... + def getUID(self) -> typing.MutableSequence[int]: ... + def getUncompressedSize(self) -> int: ... + def isCompressed(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBounds(self, rectangle: java.awt.Rectangle) -> None: ... + def setCompressed(self, boolean: bool) -> None: ... + def setCompressedSize(self, int: int) -> None: ... + def setSizeEMU(self, dimension: java.awt.Dimension) -> None: ... + def setUID(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setUncompressedSize(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherPictBlip(EscherBlipRecord): + RECORD_ID_EMF: typing.ClassVar[int] = ... + RECORD_ID_WMF: typing.ClassVar[int] = ... + RECORD_ID_PICT: typing.ClassVar[int] = ... + def __init__(self): ... + def fillFields( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + escherRecordFactory: EscherRecordFactory | typing.Callable, + ) -> int: ... + def getBounds(self) -> java.awt.Rectangle: ... + def getCompressedSize(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSizeEMU(self) -> java.awt.Dimension: ... + def getUID(self) -> typing.MutableSequence[int]: ... + def getUncompressedSize(self) -> int: ... + def isCompressed(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + escherSerializationListener: EscherSerializationListener, + ) -> int: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBounds(self, rectangle: java.awt.Rectangle) -> None: ... + def setCompressed(self, boolean: bool) -> None: ... + def setCompressedSize(self, int: int) -> None: ... + def setSizeEMU(self, dimension: java.awt.Dimension) -> None: ... + def setUID(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setUncompressedSize(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class EscherRGBProperty(EscherSimpleProperty): + def __init__(self, short: int, int: int): ... + def getBlue(self) -> int: ... + def getGreen(self) -> int: ... + def getRed(self) -> int: ... + def getRgbColor(self) -> int: ... + +class EscherShapePathProperty(EscherSimpleProperty): + LINE_OF_STRAIGHT_SEGMENTS: typing.ClassVar[int] = ... + CLOSED_POLYGON: typing.ClassVar[int] = ... + CURVES: typing.ClassVar[int] = ... + CLOSED_CURVES: typing.ClassVar[int] = ... + COMPLEX: typing.ClassVar[int] = ... + def __init__(self, short: int, int: int): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.ddf")``. + + DefaultEscherRecordFactory: type[DefaultEscherRecordFactory] + EscherArrayProperty: type[EscherArrayProperty] + EscherBSERecord: type[EscherBSERecord] + EscherBitmapBlip: type[EscherBitmapBlip] + EscherBlipRecord: type[EscherBlipRecord] + EscherBlipWMFRecord: type[EscherBlipWMFRecord] + EscherBoolProperty: type[EscherBoolProperty] + EscherChildAnchorRecord: type[EscherChildAnchorRecord] + EscherClientAnchorRecord: type[EscherClientAnchorRecord] + EscherClientDataRecord: type[EscherClientDataRecord] + EscherComplexProperty: type[EscherComplexProperty] + EscherContainerRecord: type[EscherContainerRecord] + EscherDgRecord: type[EscherDgRecord] + EscherDggRecord: type[EscherDggRecord] + EscherDump: type[EscherDump] + EscherMetafileBlip: type[EscherMetafileBlip] + EscherOptRecord: type[EscherOptRecord] + EscherPictBlip: type[EscherPictBlip] + EscherProperties: type[EscherProperties] + EscherProperty: type[EscherProperty] + EscherPropertyFactory: type[EscherPropertyFactory] + EscherPropertyMetaData: type[EscherPropertyMetaData] + EscherRGBProperty: type[EscherRGBProperty] + EscherRecord: type[EscherRecord] + EscherRecordFactory: type[EscherRecordFactory] + EscherSerializationListener: type[EscherSerializationListener] + EscherShapePathProperty: type[EscherShapePathProperty] + EscherSimpleProperty: type[EscherSimpleProperty] + EscherSpRecord: type[EscherSpRecord] + EscherSpgrRecord: type[EscherSpgrRecord] + EscherSplitMenuColorsRecord: type[EscherSplitMenuColorsRecord] + EscherTextboxRecord: type[EscherTextboxRecord] + NullEscherSerializationListener: type[NullEscherSerializationListener] + UnknownEscherRecord: type[UnknownEscherRecord] diff --git a/typings/loci/poi/dev/__init__.pyi b/typings/loci/poi/dev/__init__.pyi new file mode 100644 index 0000000..0aa9a23 --- /dev/null +++ b/typings/loci/poi/dev/__init__.pyi @@ -0,0 +1,14 @@ +from typing import Protocol + +import java.lang +import jpype + +class RecordGenerator: + def __init__(self): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.dev")``. + + RecordGenerator: type[RecordGenerator] diff --git a/typings/loci/poi/hpsf/__init__.pyi b/typings/loci/poi/hpsf/__init__.pyi new file mode 100644 index 0000000..908b8e5 --- /dev/null +++ b/typings/loci/poi/hpsf/__init__.pyi @@ -0,0 +1,796 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import jpype +import loci.common +import loci.poi.hpsf.wellknown +import loci.poi.poifs.filesystem + +class ClassID: + LENGTH: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes, int: int): ... + def equals(self, object: typing.Any) -> bool: ... + def getBytes(self) -> typing.MutableSequence[int]: ... + def hashCode(self) -> int: ... + def length(self) -> int: ... + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> typing.MutableSequence[int]: ... + def setBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + def write(self, byteArray: list[int] | jpype.JArray | bytes, int: int) -> None: ... + +class Constants: + CP_037: typing.ClassVar[int] = ... + CP_SJIS: typing.ClassVar[int] = ... + CP_GBK: typing.ClassVar[int] = ... + CP_MS949: typing.ClassVar[int] = ... + CP_UTF16: typing.ClassVar[int] = ... + CP_UTF16_BE: typing.ClassVar[int] = ... + CP_WINDOWS_1250: typing.ClassVar[int] = ... + CP_WINDOWS_1251: typing.ClassVar[int] = ... + CP_WINDOWS_1252: typing.ClassVar[int] = ... + CP_WINDOWS_1253: typing.ClassVar[int] = ... + CP_WINDOWS_1254: typing.ClassVar[int] = ... + CP_WINDOWS_1255: typing.ClassVar[int] = ... + CP_WINDOWS_1256: typing.ClassVar[int] = ... + CP_WINDOWS_1257: typing.ClassVar[int] = ... + CP_WINDOWS_1258: typing.ClassVar[int] = ... + CP_JOHAB: typing.ClassVar[int] = ... + CP_MAC_ROMAN: typing.ClassVar[int] = ... + CP_MAC_JAPAN: typing.ClassVar[int] = ... + CP_MAC_CHINESE_TRADITIONAL: typing.ClassVar[int] = ... + CP_MAC_KOREAN: typing.ClassVar[int] = ... + CP_MAC_ARABIC: typing.ClassVar[int] = ... + CP_MAC_HEBREW: typing.ClassVar[int] = ... + CP_MAC_GREEK: typing.ClassVar[int] = ... + CP_MAC_CYRILLIC: typing.ClassVar[int] = ... + CP_MAC_CHINESE_SIMPLE: typing.ClassVar[int] = ... + CP_MAC_ROMANIA: typing.ClassVar[int] = ... + CP_MAC_UKRAINE: typing.ClassVar[int] = ... + CP_MAC_THAI: typing.ClassVar[int] = ... + CP_MAC_CENTRAL_EUROPE: typing.ClassVar[int] = ... + CP_MAC_ICELAND: typing.ClassVar[int] = ... + CP_MAC_TURKISH: typing.ClassVar[int] = ... + CP_MAC_CROATIAN: typing.ClassVar[int] = ... + CP_US_ACSII: typing.ClassVar[int] = ... + CP_KOI8_R: typing.ClassVar[int] = ... + CP_ISO_8859_1: typing.ClassVar[int] = ... + CP_ISO_8859_2: typing.ClassVar[int] = ... + CP_ISO_8859_3: typing.ClassVar[int] = ... + CP_ISO_8859_4: typing.ClassVar[int] = ... + CP_ISO_8859_5: typing.ClassVar[int] = ... + CP_ISO_8859_6: typing.ClassVar[int] = ... + CP_ISO_8859_7: typing.ClassVar[int] = ... + CP_ISO_8859_8: typing.ClassVar[int] = ... + CP_ISO_8859_9: typing.ClassVar[int] = ... + CP_ISO_2022_JP1: typing.ClassVar[int] = ... + CP_ISO_2022_JP2: typing.ClassVar[int] = ... + CP_ISO_2022_JP3: typing.ClassVar[int] = ... + CP_ISO_2022_KR: typing.ClassVar[int] = ... + CP_EUC_JP: typing.ClassVar[int] = ... + CP_EUC_KR: typing.ClassVar[int] = ... + CP_GB2312: typing.ClassVar[int] = ... + CP_GB18030: typing.ClassVar[int] = ... + CP_US_ASCII2: typing.ClassVar[int] = ... + CP_UTF8: typing.ClassVar[int] = ... + CP_UNICODE: typing.ClassVar[int] = ... + def __init__(self): ... + +class CustomProperties(java.util.HashMap): + def __init__(self): ... + @typing.overload + def get(self, object: typing.Any) -> typing.Any: ... + @typing.overload + def get(self, string: java.lang.String | str) -> typing.Any: ... + def getCodepage(self) -> int: ... + def isPure(self) -> bool: ... + @typing.overload + def put(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + @typing.overload + def put(self, string: java.lang.String | str, boolean: bool) -> typing.Any: ... + @typing.overload + def put(self, string: java.lang.String | str, double: float) -> typing.Any: ... + @typing.overload + def put(self, string: java.lang.String | str, integer: int) -> typing.Any: ... + @typing.overload + def put(self, string: java.lang.String | str, long: int) -> typing.Any: ... + @typing.overload + def put( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> typing.Any: ... + @typing.overload + def put( + self, string: java.lang.String | str, date: java.util.Date + ) -> typing.Any: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> typing.Any: ... + @typing.overload + def remove(self, string: java.lang.String | str) -> typing.Any: ... + def setCodepage(self, int: int) -> None: ... + def setPure(self, boolean: bool) -> None: ... + +class HPSFException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + def getReason(self) -> java.lang.Throwable: ... + +class HPSFRuntimeException(java.lang.RuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + def getReason(self) -> java.lang.Throwable: ... + @typing.overload + def printStackTrace(self) -> None: ... + @typing.overload + def printStackTrace(self, printStream: java.io.PrintStream) -> None: ... + @typing.overload + def printStackTrace(self, printWriter: java.io.PrintWriter) -> None: ... + +class Property: + @typing.overload + def __init__( + self, + long: int, + byteArray: list[int] | jpype.JArray | bytes, + long2: int, + int: int, + int2: int, + ): ... + @typing.overload + def __init__(self, long: int, long2: int, object: typing.Any): ... + def equals(self, object: typing.Any) -> bool: ... + def getID(self) -> int: ... + def getType(self) -> int: ... + def getValue(self) -> typing.Any: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class PropertySet: + OS_WIN16: typing.ClassVar[int] = ... + OS_MACINTOSH: typing.ClassVar[int] = ... + OS_WIN32: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ): ... + @typing.overload + def __init__(self, inputStream: java.io.InputStream): ... + def equals(self, object: typing.Any) -> bool: ... + def getByteOrder(self) -> int: ... + def getClassID(self) -> ClassID: ... + def getFirstSection(self) -> Section: ... + def getFormat(self) -> int: ... + def getOSVersion(self) -> int: ... + def getProperties(self) -> typing.MutableSequence[Property]: ... + def getSectionCount(self) -> int: ... + def getSections(self) -> java.util.List: ... + def getSingleSection(self) -> Section: ... + def hashCode(self) -> int: ... + def isDocumentSummaryInformation(self) -> bool: ... + @typing.overload + @staticmethod + def isPropertySetStream( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> bool: ... + @typing.overload + @staticmethod + def isPropertySetStream(inputStream: java.io.InputStream) -> bool: ... + def isSummaryInformation(self) -> bool: ... + def toString(self) -> java.lang.String: ... + def wasNull(self) -> bool: ... + +class PropertySetFactory: + def __init__(self): ... + @staticmethod + def create(inputStream: java.io.InputStream) -> PropertySet: ... + @staticmethod + def newDocumentSummaryInformation() -> DocumentSummaryInformation: ... + @staticmethod + def newSummaryInformation() -> SummaryInformation: ... + +class Section: + def __init__(self, byteArray: list[int] | jpype.JArray | bytes, int: int): ... + def equals(self, object: typing.Any) -> bool: ... + def getCodepage(self) -> int: ... + def getDictionary(self) -> java.util.Map: ... + def getFormatID(self) -> ClassID: ... + def getOffset(self) -> int: ... + def getPIDString(self, long: int) -> java.lang.String: ... + def getProperties(self) -> typing.MutableSequence[Property]: ... + def getProperty(self, long: int) -> typing.Any: ... + def getPropertyCount(self) -> int: ... + def getSize(self) -> int: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def wasNull(self) -> bool: ... + +class Thumbnail: + OFFSET_CFTAG: typing.ClassVar[int] = ... + OFFSET_CF: typing.ClassVar[int] = ... + OFFSET_WMFDATA: typing.ClassVar[int] = ... + CFTAG_WINDOWS: typing.ClassVar[int] = ... + CFTAG_MACINTOSH: typing.ClassVar[int] = ... + CFTAG_FMTID: typing.ClassVar[int] = ... + CFTAG_NODATA: typing.ClassVar[int] = ... + CF_METAFILEPICT: typing.ClassVar[int] = ... + CF_DIB: typing.ClassVar[int] = ... + CF_ENHMETAFILE: typing.ClassVar[int] = ... + CF_BITMAP: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + def getClipboardFormat(self) -> int: ... + def getClipboardFormatTag(self) -> int: ... + def getThumbnail(self) -> typing.MutableSequence[int]: ... + def getThumbnailAsWMF(self) -> typing.MutableSequence[int]: ... + def setThumbnail(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + +class TypeWriter: + def __init__(self): ... + @typing.overload + @staticmethod + def writeToStream(outputStream: java.io.OutputStream, double: float) -> int: ... + @typing.overload + @staticmethod + def writeToStream(outputStream: java.io.OutputStream, int: int) -> int: ... + @typing.overload + @staticmethod + def writeToStream(outputStream: java.io.OutputStream, classID: ClassID) -> int: ... + @typing.overload + @staticmethod + def writeToStream(outputStream: java.io.OutputStream, long: int) -> int: ... + @typing.overload + @staticmethod + def writeToStream(outputStream: java.io.OutputStream, short: int) -> int: ... + @typing.overload + @staticmethod + def writeToStream( + outputStream: java.io.OutputStream, + propertyArray: list[Property] | jpype.JArray, + int: int, + ) -> None: ... + @staticmethod + def writeUIntToStream(outputStream: java.io.OutputStream, long: int) -> int: ... + @staticmethod + def writeUShortToStream(outputStream: java.io.OutputStream, int: int) -> None: ... + +class Util: + EPOCH_DIFF: typing.ClassVar[int] = ... + def __init__(self): ... + @staticmethod + def cat( + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def copy( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def copy( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + byteArray2: list[int] | jpype.JArray | bytes, + int3: int, + ) -> None: ... + @staticmethod + def dateToFileTime(date: java.util.Date) -> int: ... + @staticmethod + def equal( + byteArray: list[int] | jpype.JArray | bytes, + byteArray2: list[int] | jpype.JArray | bytes, + ) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + @staticmethod + def equals( + objectArray: list[typing.Any] | jpype.JArray, + objectArray2: list[typing.Any] | jpype.JArray, + ) -> bool: ... + @typing.overload + @staticmethod + def equals( + collection: java.util.Collection | typing.Sequence | set, + collection2: java.util.Collection | typing.Sequence | set, + ) -> bool: ... + @typing.overload + @staticmethod + def filetimeToDate(int: int, int2: int) -> java.util.Date: ... + @typing.overload + @staticmethod + def filetimeToDate(long: int) -> java.util.Date: ... + @typing.overload + @staticmethod + def pad4( + byteArray: list[int] | jpype.JArray | bytes, + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def pad4(charArray: list[str] | jpype.JArray) -> typing.MutableSequence[str]: ... + @typing.overload + @staticmethod + def pad4(string: java.lang.String | str) -> typing.MutableSequence[str]: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + @staticmethod + def toString(throwable: java.lang.Throwable) -> java.lang.String: ... + +class Variant: + VT_EMPTY: typing.ClassVar[int] = ... + VT_NULL: typing.ClassVar[int] = ... + VT_I2: typing.ClassVar[int] = ... + VT_I4: typing.ClassVar[int] = ... + VT_R4: typing.ClassVar[int] = ... + VT_R8: typing.ClassVar[int] = ... + VT_CY: typing.ClassVar[int] = ... + VT_DATE: typing.ClassVar[int] = ... + VT_BSTR: typing.ClassVar[int] = ... + VT_DISPATCH: typing.ClassVar[int] = ... + VT_ERROR: typing.ClassVar[int] = ... + VT_BOOL: typing.ClassVar[int] = ... + VT_VARIANT: typing.ClassVar[int] = ... + VT_UNKNOWN: typing.ClassVar[int] = ... + VT_DECIMAL: typing.ClassVar[int] = ... + VT_I1: typing.ClassVar[int] = ... + VT_UI1: typing.ClassVar[int] = ... + VT_UI2: typing.ClassVar[int] = ... + VT_UI4: typing.ClassVar[int] = ... + VT_I8: typing.ClassVar[int] = ... + VT_UI8: typing.ClassVar[int] = ... + VT_INT: typing.ClassVar[int] = ... + VT_UINT: typing.ClassVar[int] = ... + VT_VOID: typing.ClassVar[int] = ... + VT_HRESULT: typing.ClassVar[int] = ... + VT_PTR: typing.ClassVar[int] = ... + VT_SAFEARRAY: typing.ClassVar[int] = ... + VT_CARRAY: typing.ClassVar[int] = ... + VT_USERDEFINED: typing.ClassVar[int] = ... + VT_LPSTR: typing.ClassVar[int] = ... + VT_LPWSTR: typing.ClassVar[int] = ... + VT_FILETIME: typing.ClassVar[int] = ... + VT_BLOB: typing.ClassVar[int] = ... + VT_STREAM: typing.ClassVar[int] = ... + VT_STORAGE: typing.ClassVar[int] = ... + VT_STREAMED_OBJECT: typing.ClassVar[int] = ... + VT_STORED_OBJECT: typing.ClassVar[int] = ... + VT_BLOB_OBJECT: typing.ClassVar[int] = ... + VT_CF: typing.ClassVar[int] = ... + VT_CLSID: typing.ClassVar[int] = ... + VT_VECTOR: typing.ClassVar[int] = ... + VT_ARRAY: typing.ClassVar[int] = ... + VT_BYREF: typing.ClassVar[int] = ... + VT_RESERVED: typing.ClassVar[int] = ... + VT_ILLEGAL: typing.ClassVar[int] = ... + VT_ILLEGALMASKED: typing.ClassVar[int] = ... + VT_TYPEMASK: typing.ClassVar[int] = ... + LENGTH_UNKNOWN: typing.ClassVar[int] = ... + LENGTH_VARIABLE: typing.ClassVar[int] = ... + LENGTH_0: typing.ClassVar[int] = ... + LENGTH_2: typing.ClassVar[int] = ... + LENGTH_4: typing.ClassVar[int] = ... + LENGTH_8: typing.ClassVar[int] = ... + def __init__(self): ... + @staticmethod + def getVariantLength(long: int) -> int: ... + @staticmethod + def getVariantName(long: int) -> java.lang.String: ... + +class IllegalPropertySetDataException(HPSFRuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class MarkUnsupportedException(HPSFException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class MissingSectionException(HPSFRuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class MutableProperty(Property): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, property: Property): ... + def setID(self, long: int) -> None: ... + def setType(self, long: int) -> None: ... + def setValue(self, object: typing.Any) -> None: ... + def write(self, outputStream: java.io.OutputStream, int: int) -> int: ... + +class MutablePropertySet(PropertySet): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, propertySet: PropertySet): ... + def addSection(self, section: Section) -> None: ... + def clearSections(self) -> None: ... + def setByteOrder(self, int: int) -> None: ... + def setClassID(self, classID: ClassID) -> None: ... + def setFormat(self, int: int) -> None: ... + def setOSVersion(self, int: int) -> None: ... + def toInputStream(self) -> loci.common.RandomAccessInputStream: ... + @typing.overload + def write(self, outputStream: java.io.OutputStream) -> None: ... + @typing.overload + def write( + self, + directoryEntry: loci.poi.poifs.filesystem.DirectoryEntry, + string: java.lang.String | str, + ) -> None: ... + +class MutableSection(Section): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, section: Section): ... + def clear(self) -> None: ... + def getProperties(self) -> typing.MutableSequence[Property]: ... + def getProperty(self, long: int) -> typing.Any: ... + def getPropertyCount(self) -> int: ... + def getSize(self) -> int: ... + def removeProperty(self, long: int) -> None: ... + def setCodepage(self, int: int) -> None: ... + def setDictionary(self, map: java.util.Map | typing.Mapping) -> None: ... + @typing.overload + def setFormatID(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def setFormatID(self, classID: ClassID) -> None: ... + def setProperties(self, propertyArray: list[Property] | jpype.JArray) -> None: ... + @typing.overload + def setProperty(self, int: int, boolean: bool) -> None: ... + @typing.overload + def setProperty(self, int: int, int2: int) -> None: ... + @typing.overload + def setProperty(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def setProperty(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setProperty(self, int: int, long: int) -> None: ... + @typing.overload + def setProperty(self, int: int, long: int, object: typing.Any) -> None: ... + @typing.overload + def setProperty(self, property: Property) -> None: ... + def write(self, outputStream: java.io.OutputStream) -> int: ... + +class NoFormatIDException(HPSFRuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class NoPropertySetStreamException(HPSFException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class NoSingleSectionException(HPSFRuntimeException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class UnexpectedPropertySetTypeException(HPSFException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class VariantSupport(Variant): + def __init__(self): ... + @staticmethod + def codepageToEncoding(int: int) -> java.lang.String: ... + @staticmethod + def isLogUnsupportedTypes() -> bool: ... + @staticmethod + def read( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + long: int, + int3: int, + ) -> typing.Any: ... + @staticmethod + def setLogUnsupportedTypes(boolean: bool) -> None: ... + @staticmethod + def write( + outputStream: java.io.OutputStream, long: int, object: typing.Any, int: int + ) -> int: ... + +class VariantTypeException(HPSFException): + def __init__( + self, long: int, object: typing.Any, string: java.lang.String | str + ): ... + def getValue(self) -> typing.Any: ... + def getVariantType(self) -> int: ... + +class CustomProperty(MutableProperty): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, property: Property): ... + @typing.overload + def __init__(self, property: Property, string: java.lang.String | str): ... + def equalsContents(self, object: typing.Any) -> bool: ... + def getName(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def setName(self, string: java.lang.String | str) -> None: ... + +class IllegalVariantTypeException(VariantTypeException): + @typing.overload + def __init__(self, long: int, object: typing.Any): ... + @typing.overload + def __init__( + self, long: int, object: typing.Any, string: java.lang.String | str + ): ... + +class SpecialPropertySet(MutablePropertySet): + @typing.overload + def __init__(self, mutablePropertySet: MutablePropertySet): ... + @typing.overload + def __init__(self, propertySet: PropertySet): ... + def addSection(self, section: Section) -> None: ... + def clearSections(self) -> None: ... + def equals(self, object: typing.Any) -> bool: ... + def getByteOrder(self) -> int: ... + def getClassID(self) -> ClassID: ... + def getFirstSection(self) -> Section: ... + def getFormat(self) -> int: ... + def getOSVersion(self) -> int: ... + def getProperties(self) -> typing.MutableSequence[Property]: ... + def getSectionCount(self) -> int: ... + def getSections(self) -> java.util.List: ... + def hashCode(self) -> int: ... + def isDocumentSummaryInformation(self) -> bool: ... + def isSummaryInformation(self) -> bool: ... + def setByteOrder(self, int: int) -> None: ... + def setClassID(self, classID: ClassID) -> None: ... + def setFormat(self, int: int) -> None: ... + def setOSVersion(self, int: int) -> None: ... + def toInputStream(self) -> loci.common.RandomAccessInputStream: ... + def toString(self) -> java.lang.String: ... + def wasNull(self) -> bool: ... + @typing.overload + def write(self, outputStream: java.io.OutputStream) -> None: ... + @typing.overload + def write( + self, + directoryEntry: loci.poi.poifs.filesystem.DirectoryEntry, + string: java.lang.String | str, + ) -> None: ... + +class UnsupportedVariantTypeException(VariantTypeException): + def __init__(self, long: int, object: typing.Any): ... + +class DocumentSummaryInformation(SpecialPropertySet): + DEFAULT_STREAM_NAME: typing.ClassVar[java.lang.String] = ... + def __init__(self, propertySet: PropertySet): ... + def getByteCount(self) -> int: ... + def getCategory(self) -> java.lang.String: ... + def getCompany(self) -> java.lang.String: ... + def getCustomProperties(self) -> CustomProperties: ... + def getDocparts(self) -> typing.MutableSequence[int]: ... + def getHeadingPair(self) -> typing.MutableSequence[int]: ... + def getHiddenCount(self) -> int: ... + def getLineCount(self) -> int: ... + def getLinksDirty(self) -> bool: ... + def getMMClipCount(self) -> int: ... + def getManager(self) -> java.lang.String: ... + def getNoteCount(self) -> int: ... + def getParCount(self) -> int: ... + def getPresentationFormat(self) -> java.lang.String: ... + def getScale(self) -> bool: ... + def getSlideCount(self) -> int: ... + def removeByteCount(self) -> None: ... + def removeCategory(self) -> None: ... + def removeCompany(self) -> None: ... + def removeCustomProperties(self) -> None: ... + def removeDocparts(self) -> None: ... + def removeHeadingPair(self) -> None: ... + def removeHiddenCount(self) -> None: ... + def removeLineCount(self) -> None: ... + def removeLinksDirty(self) -> None: ... + def removeMMClipCount(self) -> None: ... + def removeManager(self) -> None: ... + def removeNoteCount(self) -> None: ... + def removeParCount(self) -> None: ... + def removePresentationFormat(self) -> None: ... + def removeScale(self) -> None: ... + def removeSlideCount(self) -> None: ... + def setByteCount(self, int: int) -> None: ... + def setCategory(self, string: java.lang.String | str) -> None: ... + def setCompany(self, string: java.lang.String | str) -> None: ... + def setCustomProperties(self, customProperties: CustomProperties) -> None: ... + def setDocparts(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setHeadingPair(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setHiddenCount(self, int: int) -> None: ... + def setLineCount(self, int: int) -> None: ... + def setLinksDirty(self, boolean: bool) -> None: ... + def setMMClipCount(self, int: int) -> None: ... + def setManager(self, string: java.lang.String | str) -> None: ... + def setNoteCount(self, int: int) -> None: ... + def setParCount(self, int: int) -> None: ... + def setPresentationFormat(self, string: java.lang.String | str) -> None: ... + def setScale(self, boolean: bool) -> None: ... + def setSlideCount(self, int: int) -> None: ... + +class ReadingNotSupportedException(UnsupportedVariantTypeException): + def __init__(self, long: int, object: typing.Any): ... + +class SummaryInformation(SpecialPropertySet): + DEFAULT_STREAM_NAME: typing.ClassVar[java.lang.String] = ... + def __init__(self, propertySet: PropertySet): ... + def getApplicationName(self) -> java.lang.String: ... + def getAuthor(self) -> java.lang.String: ... + def getCharCount(self) -> int: ... + def getComments(self) -> java.lang.String: ... + def getCreateDateTime(self) -> java.util.Date: ... + def getEditTime(self) -> int: ... + def getKeywords(self) -> java.lang.String: ... + def getLastAuthor(self) -> java.lang.String: ... + def getLastPrinted(self) -> java.util.Date: ... + def getLastSaveDateTime(self) -> java.util.Date: ... + def getPageCount(self) -> int: ... + def getRevNumber(self) -> java.lang.String: ... + def getSecurity(self) -> int: ... + def getSubject(self) -> java.lang.String: ... + def getTemplate(self) -> java.lang.String: ... + def getThumbnail(self) -> typing.MutableSequence[int]: ... + def getTitle(self) -> java.lang.String: ... + def getWordCount(self) -> int: ... + def removeApplicationName(self) -> None: ... + def removeAuthor(self) -> None: ... + def removeCharCount(self) -> None: ... + def removeComments(self) -> None: ... + def removeCreateDateTime(self) -> None: ... + def removeEditTime(self) -> None: ... + def removeKeywords(self) -> None: ... + def removeLastAuthor(self) -> None: ... + def removeLastPrinted(self) -> None: ... + def removeLastSaveDateTime(self) -> None: ... + def removePageCount(self) -> None: ... + def removeRevNumber(self) -> None: ... + def removeSecurity(self) -> None: ... + def removeSubject(self) -> None: ... + def removeTemplate(self) -> None: ... + def removeThumbnail(self) -> None: ... + def removeTitle(self) -> None: ... + def removeWordCount(self) -> None: ... + def setApplicationName(self, string: java.lang.String | str) -> None: ... + def setAuthor(self, string: java.lang.String | str) -> None: ... + def setCharCount(self, int: int) -> None: ... + def setComments(self, string: java.lang.String | str) -> None: ... + def setCreateDateTime(self, date: java.util.Date) -> None: ... + def setEditTime(self, long: int) -> None: ... + def setKeywords(self, string: java.lang.String | str) -> None: ... + def setLastAuthor(self, string: java.lang.String | str) -> None: ... + def setLastPrinted(self, date: java.util.Date) -> None: ... + def setLastSaveDateTime(self, date: java.util.Date) -> None: ... + def setPageCount(self, int: int) -> None: ... + def setRevNumber(self, string: java.lang.String | str) -> None: ... + def setSecurity(self, int: int) -> None: ... + def setSubject(self, string: java.lang.String | str) -> None: ... + def setTemplate(self, string: java.lang.String | str) -> None: ... + def setThumbnail(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setTitle(self, string: java.lang.String | str) -> None: ... + def setWordCount(self, int: int) -> None: ... + +class WritingNotSupportedException(UnsupportedVariantTypeException): + def __init__(self, long: int, object: typing.Any): ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hpsf")``. + + ClassID: type[ClassID] + Constants: type[Constants] + CustomProperties: type[CustomProperties] + CustomProperty: type[CustomProperty] + DocumentSummaryInformation: type[DocumentSummaryInformation] + HPSFException: type[HPSFException] + HPSFRuntimeException: type[HPSFRuntimeException] + IllegalPropertySetDataException: type[IllegalPropertySetDataException] + IllegalVariantTypeException: type[IllegalVariantTypeException] + MarkUnsupportedException: type[MarkUnsupportedException] + MissingSectionException: type[MissingSectionException] + MutableProperty: type[MutableProperty] + MutablePropertySet: type[MutablePropertySet] + MutableSection: type[MutableSection] + NoFormatIDException: type[NoFormatIDException] + NoPropertySetStreamException: type[NoPropertySetStreamException] + NoSingleSectionException: type[NoSingleSectionException] + Property: type[Property] + PropertySet: type[PropertySet] + PropertySetFactory: type[PropertySetFactory] + ReadingNotSupportedException: type[ReadingNotSupportedException] + Section: type[Section] + SpecialPropertySet: type[SpecialPropertySet] + SummaryInformation: type[SummaryInformation] + Thumbnail: type[Thumbnail] + TypeWriter: type[TypeWriter] + UnexpectedPropertySetTypeException: type[UnexpectedPropertySetTypeException] + UnsupportedVariantTypeException: type[UnsupportedVariantTypeException] + Util: type[Util] + Variant: type[Variant] + VariantSupport: type[VariantSupport] + VariantTypeException: type[VariantTypeException] + WritingNotSupportedException: type[WritingNotSupportedException] + wellknown: loci.poi.hpsf.wellknown.__module_protocol__ diff --git a/typings/loci/poi/hpsf/wellknown/__init__.pyi b/typings/loci/poi/hpsf/wellknown/__init__.pyi new file mode 100644 index 0000000..6220b6a --- /dev/null +++ b/typings/loci/poi/hpsf/wellknown/__init__.pyi @@ -0,0 +1,92 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype + +class PropertyIDMap(java.util.HashMap): + PID_TITLE: typing.ClassVar[int] = ... + PID_SUBJECT: typing.ClassVar[int] = ... + PID_AUTHOR: typing.ClassVar[int] = ... + PID_KEYWORDS: typing.ClassVar[int] = ... + PID_COMMENTS: typing.ClassVar[int] = ... + PID_TEMPLATE: typing.ClassVar[int] = ... + PID_LASTAUTHOR: typing.ClassVar[int] = ... + PID_REVNUMBER: typing.ClassVar[int] = ... + PID_EDITTIME: typing.ClassVar[int] = ... + PID_LASTPRINTED: typing.ClassVar[int] = ... + PID_CREATE_DTM: typing.ClassVar[int] = ... + PID_LASTSAVE_DTM: typing.ClassVar[int] = ... + PID_PAGECOUNT: typing.ClassVar[int] = ... + PID_WORDCOUNT: typing.ClassVar[int] = ... + PID_CHARCOUNT: typing.ClassVar[int] = ... + PID_THUMBNAIL: typing.ClassVar[int] = ... + PID_APPNAME: typing.ClassVar[int] = ... + PID_SECURITY: typing.ClassVar[int] = ... + PID_DICTIONARY: typing.ClassVar[int] = ... + PID_CODEPAGE: typing.ClassVar[int] = ... + PID_CATEGORY: typing.ClassVar[int] = ... + PID_PRESFORMAT: typing.ClassVar[int] = ... + PID_BYTECOUNT: typing.ClassVar[int] = ... + PID_LINECOUNT: typing.ClassVar[int] = ... + PID_PARCOUNT: typing.ClassVar[int] = ... + PID_SLIDECOUNT: typing.ClassVar[int] = ... + PID_NOTECOUNT: typing.ClassVar[int] = ... + PID_HIDDENCOUNT: typing.ClassVar[int] = ... + PID_MMCLIPCOUNT: typing.ClassVar[int] = ... + PID_SCALE: typing.ClassVar[int] = ... + PID_HEADINGPAIR: typing.ClassVar[int] = ... + PID_DOCPARTS: typing.ClassVar[int] = ... + PID_MANAGER: typing.ClassVar[int] = ... + PID_COMPANY: typing.ClassVar[int] = ... + PID_LINKSDIRTY: typing.ClassVar[int] = ... + PID_MAX: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, int: int, float: float): ... + @typing.overload + def __init__(self, map: java.util.Map | typing.Mapping): ... + @typing.overload + def get(self, object: typing.Any) -> typing.Any: ... + @typing.overload + def get(self, long: int) -> typing.Any: ... + @staticmethod + def getDocumentSummaryInformationProperties() -> PropertyIDMap: ... + @staticmethod + def getSummaryInformationProperties() -> PropertyIDMap: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + @typing.overload + def put(self, k: typing.Any, v: typing.Any) -> typing.Any: ... + @typing.overload + def put(self, long: int, string: java.lang.String | str) -> typing.Any: ... + +class SectionIDMap(java.util.HashMap): + SUMMARY_INFORMATION_ID: typing.ClassVar[typing.MutableSequence[int]] = ... + DOCUMENT_SUMMARY_INFORMATION_ID: typing.ClassVar[ + typing.MutableSequence[typing.MutableSequence[int]] + ] = ... + UNDEFINED: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def get(self, object: typing.Any) -> typing.Any: ... + @typing.overload + def get(self, byteArray: list[int] | jpype.JArray | bytes) -> PropertyIDMap: ... + @staticmethod + def getInstance() -> SectionIDMap: ... + @staticmethod + def getPIDString( + byteArray: list[int] | jpype.JArray | bytes, long: int + ) -> java.lang.String: ... + @typing.overload + def put( + self, byteArray: list[int] | jpype.JArray | bytes, propertyIDMap: PropertyIDMap + ) -> typing.Any: ... + @typing.overload + def put(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hpsf.wellknown")``. + + PropertyIDMap: type[PropertyIDMap] + SectionIDMap: type[SectionIDMap] diff --git a/typings/loci/poi/hssf/__init__.pyi b/typings/loci/poi/hssf/__init__.pyi new file mode 100644 index 0000000..56edf6b --- /dev/null +++ b/typings/loci/poi/hssf/__init__.pyi @@ -0,0 +1,22 @@ +from typing import Protocol + +import loci.poi.hssf.dev +import loci.poi.hssf.eventmodel +import loci.poi.hssf.eventusermodel +import loci.poi.hssf.extractor +import loci.poi.hssf.model +import loci.poi.hssf.record +import loci.poi.hssf.usermodel +import loci.poi.hssf.util + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf")``. + + dev: loci.poi.hssf.dev.__module_protocol__ + eventmodel: loci.poi.hssf.eventmodel.__module_protocol__ + eventusermodel: loci.poi.hssf.eventusermodel.__module_protocol__ + extractor: loci.poi.hssf.extractor.__module_protocol__ + model: loci.poi.hssf.model.__module_protocol__ + record: loci.poi.hssf.record.__module_protocol__ + usermodel: loci.poi.hssf.usermodel.__module_protocol__ + util: loci.poi.hssf.util.__module_protocol__ diff --git a/typings/loci/poi/hssf/dev/__init__.pyi b/typings/loci/poi/hssf/dev/__init__.pyi new file mode 100644 index 0000000..79254a6 --- /dev/null +++ b/typings/loci/poi/hssf/dev/__init__.pyi @@ -0,0 +1,59 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import jpype +import loci.poi.hssf.record + +class BiffViewer: + def __init__(self, stringArray: list[java.lang.String] | jpype.JArray): ... + @staticmethod + def createRecords( + inputStream: java.io.InputStream, boolean: bool + ) -> typing.MutableSequence[loci.poi.hssf.record.Record]: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def run(self) -> None: ... + def setDump(self, boolean: bool) -> None: ... + +class EFBiffViewer: + def __init__(self): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def run(self) -> None: ... + def setFile(self, string: java.lang.String | str) -> None: ... + +class FormulaViewer: + def __init__(self): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def parseFormulaRecord( + self, formulaRecord: loci.poi.hssf.record.FormulaRecord + ) -> None: ... + def run(self) -> None: ... + def setFile(self, string: java.lang.String | str) -> None: ... + def setList(self, boolean: bool) -> None: ... + +class HSSF: + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, string: java.lang.String | str, boolean: bool): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + boolean: bool, + ): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.dev")``. + + BiffViewer: type[BiffViewer] + EFBiffViewer: type[EFBiffViewer] + FormulaViewer: type[FormulaViewer] + HSSF: type[HSSF] diff --git a/typings/loci/poi/hssf/eventmodel/__init__.pyi b/typings/loci/poi/hssf/eventmodel/__init__.pyi new file mode 100644 index 0000000..8d67301 --- /dev/null +++ b/typings/loci/poi/hssf/eventmodel/__init__.pyi @@ -0,0 +1,47 @@ +import typing +from typing import Protocol + +import java.io +import jpype +import loci.poi.hssf.model +import loci.poi.hssf.record + +class ERFListener: + def processRecord(self, record: loci.poi.hssf.record.Record) -> bool: ... + +class EventRecordFactory: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, boolean: bool): ... + @staticmethod + def createRecord( + recordInputStream: loci.poi.hssf.record.RecordInputStream, + ) -> typing.MutableSequence[loci.poi.hssf.record.Record]: ... + @staticmethod + def getAllKnownRecordSIDs() -> typing.MutableSequence[int]: ... + def processRecords(self, inputStream: java.io.InputStream) -> None: ... + def registerListener( + self, + eRFListener: ERFListener | typing.Callable, + shortArray: list[int] | jpype.JArray, + ) -> None: ... + +class ModelFactoryListener: + def process(self, model: loci.poi.hssf.model.Model) -> bool: ... + +class ModelFactory(ERFListener): + def __init__(self): ... + def processRecord(self, record: loci.poi.hssf.record.Record) -> bool: ... + def registerListener( + self, modelFactoryListener: ModelFactoryListener | typing.Callable + ) -> None: ... + def run(self, inputStream: java.io.InputStream) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.eventmodel")``. + + ERFListener: type[ERFListener] + EventRecordFactory: type[EventRecordFactory] + ModelFactory: type[ModelFactory] + ModelFactoryListener: type[ModelFactoryListener] diff --git a/typings/loci/poi/hssf/eventusermodel/__init__.pyi b/typings/loci/poi/hssf/eventusermodel/__init__.pyi new file mode 100644 index 0000000..62da622 --- /dev/null +++ b/typings/loci/poi/hssf/eventusermodel/__init__.pyi @@ -0,0 +1,65 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import loci.poi.hssf.record +import loci.poi.poifs.filesystem + +class HSSFEventFactory: + def __init__(self): ... + def abortableProcessEvents( + self, hSSFRequest: HSSFRequest, inputStream: java.io.InputStream + ) -> int: ... + def abortableProcessWorkbookEvents( + self, + hSSFRequest: HSSFRequest, + pOIFSFileSystem: loci.poi.poifs.filesystem.POIFSFileSystem, + ) -> int: ... + def processEvents( + self, hSSFRequest: HSSFRequest, inputStream: java.io.InputStream + ) -> None: ... + def processWorkbookEvents( + self, + hSSFRequest: HSSFRequest, + pOIFSFileSystem: loci.poi.poifs.filesystem.POIFSFileSystem, + ) -> None: ... + +class HSSFListener: + def processRecord(self, record: loci.poi.hssf.record.Record) -> None: ... + +class HSSFRequest: + def __init__(self): ... + def addListener( + self, hSSFListener: HSSFListener | typing.Callable, short: int + ) -> None: ... + def addListenerForAllRecords( + self, hSSFListener: HSSFListener | typing.Callable + ) -> None: ... + +class HSSFUserException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + def getReason(self) -> java.lang.Throwable: ... + +class AbortableHSSFListener(HSSFListener): + def __init__(self): ... + def abortableProcessRecord(self, record: loci.poi.hssf.record.Record) -> int: ... + def processRecord(self, record: loci.poi.hssf.record.Record) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.eventusermodel")``. + + AbortableHSSFListener: type[AbortableHSSFListener] + HSSFEventFactory: type[HSSFEventFactory] + HSSFListener: type[HSSFListener] + HSSFRequest: type[HSSFRequest] + HSSFUserException: type[HSSFUserException] diff --git a/typings/loci/poi/hssf/extractor/__init__.pyi b/typings/loci/poi/hssf/extractor/__init__.pyi new file mode 100644 index 0000000..8072866 --- /dev/null +++ b/typings/loci/poi/hssf/extractor/__init__.pyi @@ -0,0 +1,21 @@ +import typing +from typing import Protocol + +import java.lang +import loci.poi +import loci.poi.hssf.usermodel +import loci.poi.poifs.filesystem + +class ExcelExtractor(loci.poi.POITextExtractor): + @typing.overload + def __init__(self, hSSFWorkbook: loci.poi.hssf.usermodel.HSSFWorkbook): ... + @typing.overload + def __init__(self, pOIFSFileSystem: loci.poi.poifs.filesystem.POIFSFileSystem): ... + def getText(self) -> java.lang.String: ... + def setFormulasNotResults(self, boolean: bool) -> None: ... + def setIncludeSheetNames(self, boolean: bool) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.extractor")``. + + ExcelExtractor: type[ExcelExtractor] diff --git a/typings/loci/poi/hssf/model/__init__.pyi b/typings/loci/poi/hssf/model/__init__.pyi new file mode 100644 index 0000000..a613473 --- /dev/null +++ b/typings/loci/poi/hssf/model/__init__.pyi @@ -0,0 +1,403 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype +import loci.poi.ddf +import loci.poi.hssf.record +import loci.poi.hssf.record.formula +import loci.poi.hssf.usermodel +import loci.poi.hssf.util + +class AbstractShape: + @staticmethod + def createShape( + hSSFShape: loci.poi.hssf.usermodel.HSSFShape, int: int + ) -> AbstractShape: ... + def getObjRecord(self) -> loci.poi.hssf.record.ObjRecord: ... + def getSpContainer(self) -> loci.poi.ddf.EscherContainerRecord: ... + +class ConvertAnchor: + def __init__(self): ... + @staticmethod + def createAnchor( + hSSFAnchor: loci.poi.hssf.usermodel.HSSFAnchor, + ) -> loci.poi.ddf.EscherRecord: ... + +class DrawingManager: + def __init__(self, escherDggRecord: loci.poi.ddf.EscherDggRecord): ... + def allocateShapeId(self, short: int) -> int: ... + def createDgRecord(self) -> loci.poi.ddf.EscherDgRecord: ... + def getDgg(self) -> loci.poi.ddf.EscherDggRecord: ... + +class DrawingManager2: + def __init__(self, escherDggRecord: loci.poi.ddf.EscherDggRecord): ... + def allocateShapeId(self, short: int) -> int: ... + def createDgRecord(self) -> loci.poi.ddf.EscherDgRecord: ... + def getDgg(self) -> loci.poi.ddf.EscherDggRecord: ... + +class FormulaParser: + FORMULA_TYPE_CELL: typing.ClassVar[int] = ... + FORMULA_TYPE_SHARED: typing.ClassVar[int] = ... + FORMULA_TYPE_ARRAY: typing.ClassVar[int] = ... + FORMULA_TYPE_CONDFOMRAT: typing.ClassVar[int] = ... + FORMULA_TYPE_NAMEDRANGE: typing.ClassVar[int] = ... + def __init__(self, string: java.lang.String | str, workbook: Workbook): ... + @typing.overload + def getRPNPtg(self) -> typing.MutableSequence[loci.poi.hssf.record.formula.Ptg]: ... + @typing.overload + def getRPNPtg( + self, int: int + ) -> typing.MutableSequence[loci.poi.hssf.record.formula.Ptg]: ... + def parse(self) -> None: ... + @typing.overload + def toFormulaString(self, list: java.util.List) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, ptgArray: list[loci.poi.hssf.record.formula.Ptg] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def toFormulaString( + workbook: Workbook, list: java.util.List + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def toFormulaString( + workbook: Workbook, + ptgArray: list[loci.poi.hssf.record.formula.Ptg] | jpype.JArray, + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + +class Model: ... + +class WorkbookRecordList: + def __init__(self): ... + def add(self, int: int, record: loci.poi.hssf.record.Record) -> None: ... + def get(self, int: int) -> loci.poi.hssf.record.Record: ... + def getBackuppos(self) -> int: ... + def getBspos(self) -> int: ... + def getExternsheetPos(self) -> int: ... + def getFontpos(self) -> int: ... + def getNamepos(self) -> int: ... + def getPalettepos(self) -> int: ... + def getProtpos(self) -> int: ... + def getRecords(self) -> java.util.List: ... + def getSupbookpos(self) -> int: ... + def getTabpos(self) -> int: ... + def getXfpos(self) -> int: ... + def iterator(self) -> java.util.Iterator: ... + @typing.overload + def remove(self, int: int) -> None: ... + @typing.overload + def remove(self, object: typing.Any) -> None: ... + def setBackuppos(self, int: int) -> None: ... + def setBspos(self, int: int) -> None: ... + def setExternsheetPos(self, int: int) -> None: ... + def setFontpos(self, int: int) -> None: ... + def setNamepos(self, int: int) -> None: ... + def setPalettepos(self, int: int) -> None: ... + def setProtpos(self, int: int) -> None: ... + def setRecords(self, list: java.util.List) -> None: ... + def setSupbookpos(self, int: int) -> None: ... + def setTabpos(self, int: int) -> None: ... + def setXfpos(self, int: int) -> None: ... + def size(self) -> int: ... + +class LineShape(AbstractShape): + def getObjRecord(self) -> loci.poi.hssf.record.ObjRecord: ... + def getSpContainer(self) -> loci.poi.ddf.EscherContainerRecord: ... + +class PictureShape(AbstractShape): + def getObjRecord(self) -> loci.poi.hssf.record.ObjRecord: ... + def getSpContainer(self) -> loci.poi.ddf.EscherContainerRecord: ... + +class PolygonShape(AbstractShape): + OBJECT_TYPE_MICROSOFT_OFFICE_DRAWING: typing.ClassVar[int] = ... + def getObjRecord(self) -> loci.poi.hssf.record.ObjRecord: ... + def getSpContainer(self) -> loci.poi.ddf.EscherContainerRecord: ... + +class Sheet(Model): + LeftMargin: typing.ClassVar[int] = ... + RightMargin: typing.ClassVar[int] = ... + TopMargin: typing.ClassVar[int] = ... + BottomMargin: typing.ClassVar[int] = ... + PANE_LOWER_RIGHT: typing.ClassVar[int] = ... + PANE_UPPER_RIGHT: typing.ClassVar[int] = ... + PANE_LOWER_LEFT: typing.ClassVar[int] = ... + PANE_UPPER_LEFT: typing.ClassVar[int] = ... + def __init__(self): ... + def addMergedRegion(self, int: int, short: int, int2: int, short2: int) -> int: ... + def addRow(self, rowRecord: loci.poi.hssf.record.RowRecord) -> None: ... + def addValueRecord( + self, + int: int, + cellValueRecordInterface: loci.poi.hssf.record.CellValueRecordInterface, + ) -> None: ... + def aggregateDrawingRecords(self, drawingManager2: DrawingManager2) -> int: ... + def checkDimsLoc(self, record: loci.poi.hssf.record.Record, int: int) -> None: ... + def cloneSheet(self) -> Sheet: ... + def createBlank(self, int: int, short: int) -> loci.poi.hssf.record.BlankRecord: ... + def createFormula( + self, int: int, short: int, string: java.lang.String | str + ) -> loci.poi.hssf.record.FormulaRecord: ... + def createFreezePane(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def createLabelSST( + self, int: int, short: int, int2: int + ) -> loci.poi.hssf.record.LabelSSTRecord: ... + def createNumber( + self, int: int, short: int, double: float + ) -> loci.poi.hssf.record.NumberRecord: ... + def createRow(self, int: int) -> loci.poi.hssf.record.RowRecord: ... + @typing.overload + @staticmethod + def createSheet() -> Sheet: ... + @typing.overload + @staticmethod + def createSheet(list: java.util.List, int: int) -> Sheet: ... + @typing.overload + @staticmethod + def createSheet(list: java.util.List, int: int, int2: int) -> Sheet: ... + def createSplitPane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + def findFirstRecordBySid(self, short: int) -> loci.poi.hssf.record.Record: ... + def findFirstRecordLocBySid(self, short: int) -> int: ... + def getActiveCellCol(self) -> int: ... + def getActiveCellRow(self) -> int: ... + def getColumnBreaks(self) -> java.util.Iterator: ... + def getColumnWidth(self, short: int) -> int: ... + def getDefaultColumnWidth(self) -> int: ... + def getDefaultRowHeight(self) -> int: ... + def getDimsLoc(self) -> int: ... + def getEofLoc(self) -> int: ... + def getFooter(self) -> loci.poi.hssf.record.FooterRecord: ... + def getGridsetRecord(self) -> loci.poi.hssf.record.GridsetRecord: ... + def getHeader(self) -> loci.poi.hssf.record.HeaderRecord: ... + def getLeftCol(self) -> int: ... + def getLoc(self) -> int: ... + def getMargin(self, short: int) -> float: ... + def getMergedRegionAt( + self, int: int + ) -> loci.poi.hssf.record.MergeCellsRecord.MergedRegion: ... + def getNextRow(self) -> loci.poi.hssf.record.RowRecord: ... + def getNextValueRecord(self) -> loci.poi.hssf.record.CellValueRecordInterface: ... + def getNumColumnBreaks(self) -> int: ... + def getNumMergedRegions(self) -> int: ... + def getNumRecords(self) -> int: ... + def getNumRowBreaks(self) -> int: ... + def getPaneInformation(self) -> loci.poi.hssf.util.PaneInformation: ... + def getPassword(self) -> loci.poi.hssf.record.PasswordRecord: ... + def getPreOffset(self) -> int: ... + def getPrintGridlines(self) -> loci.poi.hssf.record.PrintGridlinesRecord: ... + def getPrintSetup(self) -> loci.poi.hssf.record.PrintSetupRecord: ... + def getProtect(self) -> loci.poi.hssf.record.ProtectRecord: ... + def getRecords(self) -> java.util.List: ... + def getRow(self, int: int) -> loci.poi.hssf.record.RowRecord: ... + def getRowBreaks(self) -> java.util.Iterator: ... + def getSelection(self) -> loci.poi.hssf.record.SelectionRecord: ... + def getSize(self) -> int: ... + def getTopRow(self) -> int: ... + def getXFIndexForColAt(self, short: int) -> int: ... + def groupColumnRange(self, short: int, short2: int, boolean: bool) -> None: ... + def groupRowRange(self, int: int, int2: int, boolean: bool) -> None: ... + def isColumnBroken(self, short: int) -> bool: ... + def isColumnHidden(self, short: int) -> bool: ... + def isDisplayFormulas(self) -> bool: ... + def isDisplayGridlines(self) -> bool: ... + def isDisplayRowColHeadings(self) -> bool: ... + def isGridsPrinted(self) -> bool: ... + def isProtected(self) -> typing.MutableSequence[bool]: ... + def isRowBroken(self, int: int) -> bool: ... + def preSerialize(self) -> None: ... + def protectSheet( + self, string: java.lang.String | str, boolean: bool, boolean2: bool + ) -> None: ... + def removeColumnBreak(self, short: int) -> None: ... + def removeMergedRegion(self, int: int) -> None: ... + def removeRow(self, rowRecord: loci.poi.hssf.record.RowRecord) -> None: ... + def removeRowBreak(self, int: int) -> None: ... + def removeValueRecord( + self, + int: int, + cellValueRecordInterface: loci.poi.hssf.record.CellValueRecordInterface, + ) -> None: ... + def replaceValueRecord( + self, cellValueRecordInterface: loci.poi.hssf.record.CellValueRecordInterface + ) -> None: ... + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setActiveCellCol(self, short: int) -> None: ... + def setActiveCellRow(self, int: int) -> None: ... + @typing.overload + def setColumn( + self, short: int, short2: int, integer: int, boolean: bool, boolean2: bool + ) -> None: ... + @typing.overload + def setColumn( + self, + short: int, + short2: int, + short3: int, + integer: int, + boolean: bool, + boolean2: bool, + ) -> None: ... + def setColumnBreak(self, short: int, short2: int, short3: int) -> None: ... + def setColumnGroupCollapsed(self, short: int, boolean: bool) -> None: ... + def setColumnHidden(self, short: int, boolean: bool) -> None: ... + def setColumnWidth(self, short: int, short2: int) -> None: ... + def setDefaultColumnWidth(self, short: int) -> None: ... + def setDefaultRowHeight(self, short: int) -> None: ... + def setDimensions(self, int: int, short: int, int2: int, short2: int) -> None: ... + def setDisplayFormulas(self, boolean: bool) -> None: ... + def setDisplayGridlines(self, boolean: bool) -> None: ... + def setDisplayRowColHeadings(self, boolean: bool) -> None: ... + def setFooter(self, footerRecord: loci.poi.hssf.record.FooterRecord) -> None: ... + def setGridsPrinted(self, boolean: bool) -> None: ... + def setHeader(self, headerRecord: loci.poi.hssf.record.HeaderRecord) -> None: ... + def setLeftCol(self, short: int) -> None: ... + def setLoc(self, int: int) -> None: ... + def setMargin(self, short: int, double: float) -> None: ... + def setPreOffset(self, int: int) -> None: ... + def setPrintGridlines( + self, printGridlinesRecord: loci.poi.hssf.record.PrintGridlinesRecord + ) -> None: ... + def setPrintSetup( + self, printSetupRecord: loci.poi.hssf.record.PrintSetupRecord + ) -> None: ... + def setRowBreak(self, int: int, short: int, short2: int) -> None: ... + def setRowGroupCollapsed(self, int: int, boolean: bool) -> None: ... + def setSCLRecord(self, sCLRecord: loci.poi.hssf.record.SCLRecord) -> None: ... + def setSelected(self, boolean: bool) -> None: ... + def setSelection( + self, selectionRecord: loci.poi.hssf.record.SelectionRecord + ) -> None: ... + def setTopRow(self, short: int) -> None: ... + def shiftBreaks( + self, + pageBreakRecord: loci.poi.hssf.record.PageBreakRecord, + short: int, + short2: int, + int: int, + ) -> None: ... + def shiftColumnBreaks(self, short: int, short2: int, short3: int) -> None: ... + def shiftRowBreaks(self, int: int, int2: int, int3: int) -> None: ... + def unprotectSheet(self, boolean: bool, boolean2: bool, boolean3: bool) -> None: ... + +class SimpleFilledShape(AbstractShape): + def getObjRecord(self) -> loci.poi.hssf.record.ObjRecord: ... + def getSpContainer(self) -> loci.poi.ddf.EscherContainerRecord: ... + +class TextboxShape(AbstractShape): + def getEscherTextbox(self) -> loci.poi.ddf.EscherRecord: ... + def getObjRecord(self) -> loci.poi.hssf.record.ObjRecord: ... + def getSpContainer(self) -> loci.poi.ddf.EscherContainerRecord: ... + def getTextObjectRecord(self) -> loci.poi.hssf.record.TextObjectRecord: ... + +class Workbook(Model): + def __init__(self): ... + def addBSERecord(self, escherBSERecord: loci.poi.ddf.EscherBSERecord) -> int: ... + def addName( + self, nameRecord: loci.poi.hssf.record.NameRecord + ) -> loci.poi.hssf.record.NameRecord: ... + def addSSTString( + self, unicodeString: loci.poi.hssf.record.UnicodeString + ) -> int: ... + def checkExternSheet(self, int: int) -> int: ... + def createBuiltInName( + self, byte: int, int: int + ) -> loci.poi.hssf.record.NameRecord: ... + def createCellXF(self) -> loci.poi.hssf.record.ExtendedFormatRecord: ... + def createDrawingGroup(self) -> None: ... + def createFormat(self, string: java.lang.String | str) -> int: ... + def createName(self) -> loci.poi.hssf.record.NameRecord: ... + def createNewFont(self) -> loci.poi.hssf.record.FontRecord: ... + @typing.overload + @staticmethod + def createWorkbook() -> Workbook: ... + @typing.overload + @staticmethod + def createWorkbook(list: java.util.List) -> Workbook: ... + def doesContainsSheetName( + self, string: java.lang.String | str, int: int + ) -> bool: ... + def findFirstRecordBySid(self, short: int) -> loci.poi.hssf.record.Record: ... + def findFirstRecordLocBySid(self, short: int) -> int: ... + def findNextRecordBySid( + self, short: int, int: int + ) -> loci.poi.hssf.record.Record: ... + def findSheetNameFromExternSheet(self, short: int) -> java.lang.String: ... + def getBSERecord(self, int: int) -> loci.poi.ddf.EscherBSERecord: ... + def getBackupRecord(self) -> loci.poi.hssf.record.BackupRecord: ... + def getCustomPalette(self) -> loci.poi.hssf.record.PaletteRecord: ... + def getDrawingManager(self) -> DrawingManager2: ... + def getExFormatAt(self, int: int) -> loci.poi.hssf.record.ExtendedFormatRecord: ... + def getFileSharing(self) -> loci.poi.hssf.record.FileSharingRecord: ... + def getFontRecordAt(self, int: int) -> loci.poi.hssf.record.FontRecord: ... + def getFormat(self, string: java.lang.String | str, boolean: bool) -> int: ... + def getFormats(self) -> java.util.ArrayList: ... + def getNameRecord(self, int: int) -> loci.poi.hssf.record.NameRecord: ... + def getNumExFormats(self) -> int: ... + def getNumNames(self) -> int: ... + def getNumRecords(self) -> int: ... + def getNumSheets(self) -> int: ... + def getNumberOfFontRecords(self) -> int: ... + def getRecords(self) -> java.util.List: ... + def getSSTString(self, int: int) -> loci.poi.hssf.record.UnicodeString: ... + def getSheetIndex(self, string: java.lang.String | str) -> int: ... + def getSheetIndexFromExternSheetIndex(self, int: int) -> int: ... + def getSheetName(self, int: int) -> java.lang.String: ... + def getSheetReferences(self) -> loci.poi.hssf.util.SheetReferences: ... + def getSize(self) -> int: ... + def getSpecificBuiltinRecord( + self, byte: int, int: int + ) -> loci.poi.hssf.record.NameRecord: ... + def getWindowOne(self) -> loci.poi.hssf.record.WindowOneRecord: ... + def getWriteAccess(self) -> loci.poi.hssf.record.WriteAccessRecord: ... + def getWriteProtect(self) -> loci.poi.hssf.record.WriteProtectRecord: ... + def insertSST(self) -> None: ... + def isUsing1904DateWindowing(self) -> bool: ... + def removeBuiltinRecord(self, byte: int, int: int) -> None: ... + def removeName(self, int: int) -> None: ... + def removeSheet(self, int: int) -> None: ... + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setSheetBof(self, int: int, int2: int) -> None: ... + @typing.overload + def setSheetName(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setSheetName( + self, int: int, string: java.lang.String | str, short: int + ) -> None: ... + def setSheetOrder(self, string: java.lang.String | str, int: int) -> None: ... + def unwriteProtectWorkbook(self) -> None: ... + def writeProtectWorkbook( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + +class CommentShape(TextboxShape): + def __init__(self, hSSFComment: loci.poi.hssf.usermodel.HSSFComment, int: int): ... + def getNoteRecord(self) -> loci.poi.hssf.record.NoteRecord: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.model")``. + + AbstractShape: type[AbstractShape] + CommentShape: type[CommentShape] + ConvertAnchor: type[ConvertAnchor] + DrawingManager: type[DrawingManager] + DrawingManager2: type[DrawingManager2] + FormulaParser: type[FormulaParser] + LineShape: type[LineShape] + Model: type[Model] + PictureShape: type[PictureShape] + PolygonShape: type[PolygonShape] + Sheet: type[Sheet] + SimpleFilledShape: type[SimpleFilledShape] + TextboxShape: type[TextboxShape] + Workbook: type[Workbook] + WorkbookRecordList: type[WorkbookRecordList] diff --git a/typings/loci/poi/hssf/record/__init__.pyi b/typings/loci/poi/hssf/record/__init__.pyi new file mode 100644 index 0000000..f7625be --- /dev/null +++ b/typings/loci/poi/hssf/record/__init__.pyi @@ -0,0 +1,4465 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import jpype +import loci.poi.ddf +import loci.poi.hssf.model +import loci.poi.hssf.record.aggregates +import loci.poi.hssf.record.formula +import loci.poi.hssf.usermodel +import loci.poi.util + +class CellValueRecordInterface: + def clone(self) -> typing.Any: ... + def getColumn(self) -> int: ... + def getRow(self) -> int: ... + def getXFIndex(self) -> int: ... + def isAfter(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isBefore(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isEqual(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def setColumn(self, short: int) -> None: ... + def setRow(self, int: int) -> None: ... + def setXFIndex(self, short: int) -> None: ... + +class CustomField(java.lang.Cloneable): + def fillField(self, recordInputStream: RecordInputStream) -> int: ... + def getSize(self) -> int: ... + def serializeField( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self, stringBuffer: java.lang.StringBuffer) -> None: ... + +class Margin: + def getMargin(self) -> float: ... + def setMargin(self, double: float) -> None: ... + +class Record: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isInValueSection(self) -> bool: ... + def isValue(self) -> bool: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + def toString(self) -> java.lang.String: ... + +class RecordFactory: + def __init__(self): ... + @staticmethod + def createRecord( + recordInputStream: RecordInputStream, + ) -> typing.MutableSequence[Record]: ... + @staticmethod + def createRecords(inputStream: java.io.InputStream) -> java.util.List: ... + @staticmethod + def getAllKnownRecordSIDs() -> typing.MutableSequence[int]: ... + @staticmethod + def setCapacity(int: int) -> None: ... + +class RecordFormatException(java.lang.RuntimeException): + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class RecordInputStream(java.io.InputStream): + MAX_RECORD_DATA_SIZE: typing.ClassVar[int] = ... + def __init__(self, inputStream: java.io.InputStream): ... + def getAutoContinue(self) -> bool: ... + def getLength(self) -> int: ... + def getNANData(self) -> typing.MutableSequence[int]: ... + def getPos(self) -> int: ... + def getRecordOffset(self) -> int: ... + def getSid(self) -> int: ... + def hasNextRecord(self) -> bool: ... + def isContinueNext(self) -> bool: ... + def nextRecord(self) -> None: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + @typing.overload + def read(self) -> int: ... + def readAllContinuedRemainder(self) -> typing.MutableSequence[int]: ... + def readByte(self) -> int: ... + def readCompressedUnicode(self, int: int) -> java.lang.String: ... + def readDouble(self) -> float: ... + def readInt(self) -> int: ... + def readLong(self) -> int: ... + def readRemainder(self) -> typing.MutableSequence[int]: ... + def readShort(self) -> int: ... + def readShortArray(self) -> typing.MutableSequence[int]: ... + def readUShort(self) -> int: ... + def readUnicodeLEString(self, int: int) -> java.lang.String: ... + def readUnicodeString(self) -> UnicodeString: ... + def remaining(self) -> int: ... + def setAutoContinue(self, boolean: bool) -> None: ... + +class UnicodeString(java.lang.Comparable): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def addFormatRun(self, formatRun: UnicodeString.FormatRun) -> None: ... + def clearFormatting(self) -> None: ... + def clone(self) -> typing.Any: ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def formatIterator(self) -> java.util.Iterator: ... + def getCharCount(self) -> int: ... + def getDebugInfo(self) -> java.lang.String: ... + def getExtendedRst(self) -> typing.MutableSequence[int]: ... + def getFormatRun(self, int: int) -> UnicodeString.FormatRun: ... + def getFormatRunCount(self) -> int: ... + def getOptionFlags(self) -> int: ... + def getRecordSize( + self, unicodeRecordStats: UnicodeString.UnicodeRecordStats + ) -> None: ... + def getSid(self) -> int: ... + def getString(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def isExtendedText(self) -> bool: ... + def isRichText(self) -> bool: ... + def removeFormatRun(self, formatRun: UnicodeString.FormatRun) -> None: ... + def serialize( + self, + unicodeRecordStats: UnicodeString.UnicodeRecordStats, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + ) -> int: ... + def setCharCount(self, short: int) -> None: ... + def setCompressedUnicode(self) -> None: ... + def setExtendedRst(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setOptionFlags(self, byte: int) -> None: ... + def setString(self, string: java.lang.String | str) -> None: ... + def setUncompressedUnicode(self) -> None: ... + def toString(self) -> java.lang.String: ... + class FormatRun(java.lang.Comparable): + def __init__(self, short: int, short2: int): ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getCharacterPos(self) -> int: ... + def getFontIndex(self) -> int: ... + def toString(self) -> java.lang.String: ... + + class UnicodeRecordStats: + recordSize: int = ... + remainingSize: int = ... + lastLengthPos: int = ... + def __init__(self): ... + +class AbstractEscherHolderRecord(Record): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + @typing.overload + def addEscherRecord(self, escherRecord: loci.poi.ddf.EscherRecord) -> bool: ... + @typing.overload + def addEscherRecord( + self, int: int, escherRecord: loci.poi.ddf.EscherRecord + ) -> None: ... + def clearEscherRecords(self) -> None: ... + def clone(self) -> typing.Any: ... + def decode(self) -> None: ... + def getEscherRecord(self, int: int) -> loci.poi.ddf.EscherRecord: ... + def getEscherRecords(self) -> java.util.List: ... + def getRawData(self) -> typing.MutableSequence[int]: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def join(self, abstractEscherHolderRecord: AbstractEscherHolderRecord) -> None: ... + def processContinueRecord( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setRawData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + +class AreaFormatRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getBackcolorIndex(self) -> int: ... + def getBackgroundColor(self) -> int: ... + def getForecolorIndex(self) -> int: ... + def getForegroundColor(self) -> int: ... + def getFormatFlags(self) -> int: ... + def getPattern(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isAutomatic(self) -> bool: ... + def isInvert(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAutomatic(self, boolean: bool) -> None: ... + def setBackcolorIndex(self, short: int) -> None: ... + def setBackgroundColor(self, int: int) -> None: ... + def setForecolorIndex(self, short: int) -> None: ... + def setForegroundColor(self, int: int) -> None: ... + def setFormatFlags(self, short: int) -> None: ... + def setInvert(self, boolean: bool) -> None: ... + def setPattern(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class AreaRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getFormatFlags(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isDisplayAsPercentage(self) -> bool: ... + def isShadow(self) -> bool: ... + def isStacked(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setDisplayAsPercentage(self, boolean: bool) -> None: ... + def setFormatFlags(self, short: int) -> None: ... + def setShadow(self, boolean: bool) -> None: ... + def setStacked(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class AxisLineFormatRecord(Record): + sid: typing.ClassVar[int] = ... + AXIS_TYPE_AXIS_LINE: typing.ClassVar[int] = ... + AXIS_TYPE_MAJOR_GRID_LINE: typing.ClassVar[int] = ... + AXIS_TYPE_MINOR_GRID_LINE: typing.ClassVar[int] = ... + AXIS_TYPE_WALLS_OR_FLOOR: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getAxisType(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAxisType(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class AxisOptionsRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getBaseUnit(self) -> int: ... + def getCrossingPoint(self) -> int: ... + def getMajorUnit(self) -> int: ... + def getMajorUnitValue(self) -> int: ... + def getMaximumCategory(self) -> int: ... + def getMinimumCategory(self) -> int: ... + def getMinorUnit(self) -> int: ... + def getMinorUnitValue(self) -> int: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isDefaultBase(self) -> bool: ... + def isDefaultCross(self) -> bool: ... + def isDefaultDateSettings(self) -> bool: ... + def isDefaultMajor(self) -> bool: ... + def isDefaultMaximum(self) -> bool: ... + def isDefaultMinimum(self) -> bool: ... + def isDefaultMinorUnit(self) -> bool: ... + def isIsDate(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBaseUnit(self, short: int) -> None: ... + def setCrossingPoint(self, short: int) -> None: ... + def setDefaultBase(self, boolean: bool) -> None: ... + def setDefaultCross(self, boolean: bool) -> None: ... + def setDefaultDateSettings(self, boolean: bool) -> None: ... + def setDefaultMajor(self, boolean: bool) -> None: ... + def setDefaultMaximum(self, boolean: bool) -> None: ... + def setDefaultMinimum(self, boolean: bool) -> None: ... + def setDefaultMinorUnit(self, boolean: bool) -> None: ... + def setIsDate(self, boolean: bool) -> None: ... + def setMajorUnit(self, short: int) -> None: ... + def setMajorUnitValue(self, short: int) -> None: ... + def setMaximumCategory(self, short: int) -> None: ... + def setMinimumCategory(self, short: int) -> None: ... + def setMinorUnit(self, short: int) -> None: ... + def setMinorUnitValue(self, short: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class AxisParentRecord(Record): + sid: typing.ClassVar[int] = ... + AXIS_TYPE_MAIN: typing.ClassVar[int] = ... + AXIS_TYPE_SECONDARY: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getAxisType(self) -> int: ... + def getHeight(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getWidth(self) -> int: ... + def getX(self) -> int: ... + def getY(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAxisType(self, short: int) -> None: ... + def setHeight(self, int: int) -> None: ... + def setWidth(self, int: int) -> None: ... + def setX(self, int: int) -> None: ... + def setY(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class AxisRecord(Record): + sid: typing.ClassVar[int] = ... + AXIS_TYPE_CATEGORY_OR_X_AXIS: typing.ClassVar[int] = ... + AXIS_TYPE_VALUE_AXIS: typing.ClassVar[int] = ... + AXIS_TYPE_SERIES_AXIS: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getAxisType(self) -> int: ... + def getRecordSize(self) -> int: ... + def getReserved1(self) -> int: ... + def getReserved2(self) -> int: ... + def getReserved3(self) -> int: ... + def getReserved4(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAxisType(self, short: int) -> None: ... + def setReserved1(self, int: int) -> None: ... + def setReserved2(self, int: int) -> None: ... + def setReserved3(self, int: int) -> None: ... + def setReserved4(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class AxisUsedRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumAxis(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setNumAxis(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class BOFRecord(Record): + sid: typing.ClassVar[int] = ... + VERSION: typing.ClassVar[int] = ... + BUILD: typing.ClassVar[int] = ... + BUILD_YEAR: typing.ClassVar[int] = ... + HISTORY_MASK: typing.ClassVar[int] = ... + TYPE_WORKBOOK: typing.ClassVar[int] = ... + TYPE_VB_MODULE: typing.ClassVar[int] = ... + TYPE_WORKSHEET: typing.ClassVar[int] = ... + TYPE_CHART: typing.ClassVar[int] = ... + TYPE_EXCEL_4_MACRO: typing.ClassVar[int] = ... + TYPE_WORKSPACE_FILE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getBuild(self) -> int: ... + def getBuildYear(self) -> int: ... + def getHistoryBitMask(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRequiredVersion(self) -> int: ... + def getSid(self) -> int: ... + def getType(self) -> int: ... + def getVersion(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBuild(self, short: int) -> None: ... + def setBuildYear(self, short: int) -> None: ... + def setHistoryBitMask(self, int: int) -> None: ... + def setRequiredVersion(self, int: int) -> None: ... + def setType(self, short: int) -> None: ... + def setVersion(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class BackupRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getBackup(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBackup(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class BarRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getBarSpace(self) -> int: ... + def getCategorySpace(self) -> int: ... + def getFormatFlags(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isDisplayAsPercentage(self) -> bool: ... + def isHorizontal(self) -> bool: ... + def isShadow(self) -> bool: ... + def isStacked(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBarSpace(self, short: int) -> None: ... + def setCategorySpace(self, short: int) -> None: ... + def setDisplayAsPercentage(self, boolean: bool) -> None: ... + def setFormatFlags(self, short: int) -> None: ... + def setHorizontal(self, boolean: bool) -> None: ... + def setShadow(self, boolean: bool) -> None: ... + def setStacked(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class BeginRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class BlankRecord(Record, CellValueRecordInterface, java.lang.Comparable): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getColumn(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRow(self) -> int: ... + def getSid(self) -> int: ... + def getXFIndex(self) -> int: ... + def isAfter(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isBefore(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isEqual(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isInValueSection(self) -> bool: ... + def isValue(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColumn(self, short: int) -> None: ... + def setRow(self, int: int) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class BookBoolRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSaveLinkValues(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setSaveLinkValues(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class BoolErrRecord(Record, CellValueRecordInterface, java.lang.Comparable): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getBooleanValue(self) -> bool: ... + def getColumn(self) -> int: ... + def getErrorValue(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRow(self) -> int: ... + def getSid(self) -> int: ... + def getXFIndex(self) -> int: ... + def isAfter(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isBefore(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isBoolean(self) -> bool: ... + def isEqual(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isError(self) -> bool: ... + def isInValueSection(self) -> bool: ... + def isValue(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColumn(self, short: int) -> None: ... + def setError(self, boolean: bool) -> None: ... + def setRow(self, int: int) -> None: ... + @typing.overload + def setValue(self, boolean: bool) -> None: ... + @typing.overload + def setValue(self, byte: int) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class BottomMarginRecord(Record, Margin): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getMargin(self) -> float: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setMargin(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + +class BoundSheetRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getCompressedUnicodeFlag(self) -> int: ... + def getOptionFlags(self) -> int: ... + def getPositionOfBof(self) -> int: ... + def getRawSheetnameLength(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSheetname(self) -> java.lang.String: ... + def getSheetnameLength(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCompressedUnicodeFlag(self, byte: int) -> None: ... + def setOptionFlags(self, short: int) -> None: ... + def setPositionOfBof(self, int: int) -> None: ... + def setSheetname(self, string: java.lang.String | str) -> None: ... + def setSheetnameLength(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class CalcCountRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getIterations(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setIterations(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class CalcModeRecord(Record): + sid: typing.ClassVar[int] = ... + MANUAL: typing.ClassVar[int] = ... + AUTOMATIC: typing.ClassVar[int] = ... + AUTOMATIC_EXCEPT_TABLES: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getCalcMode(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCalcMode(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class CategorySeriesAxisRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getCrossingPoint(self) -> int: ... + def getLabelFrequency(self) -> int: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getTickMarkFrequency(self) -> int: ... + def isCrossesFarRight(self) -> bool: ... + def isReversed(self) -> bool: ... + def isValueAxisCrossing(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCrossesFarRight(self, boolean: bool) -> None: ... + def setCrossingPoint(self, short: int) -> None: ... + def setLabelFrequency(self, short: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def setReversed(self, boolean: bool) -> None: ... + def setTickMarkFrequency(self, short: int) -> None: ... + def setValueAxisCrossing(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class ChartFormatRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getHeight(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getVaryDisplayPattern(self) -> bool: ... + def getWidth(self) -> int: ... + def getXPosition(self) -> int: ... + def getYPosition(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setHeight(self, int: int) -> None: ... + def setVaryDisplayPattern(self, boolean: bool) -> None: ... + def setWidth(self, int: int) -> None: ... + def setXPosition(self, int: int) -> None: ... + def setYPosition(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ChartRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getHeight(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getWidth(self) -> int: ... + def getX(self) -> int: ... + def getY(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setHeight(self, int: int) -> None: ... + def setWidth(self, int: int) -> None: ... + def setX(self, int: int) -> None: ... + def setY(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class CodepageRecord(Record): + sid: typing.ClassVar[int] = ... + CODEPAGE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getCodepage(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCodepage(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ColumnInfoRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getCollapsed(self) -> bool: ... + def getColumnWidth(self) -> int: ... + def getFirstColumn(self) -> int: ... + def getHidden(self) -> bool: ... + def getLastColumn(self) -> int: ... + def getOptions(self) -> int: ... + def getOutlineLevel(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getXFIndex(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCollapsed(self, boolean: bool) -> None: ... + def setColumnWidth(self, short: int) -> None: ... + def setFirstColumn(self, short: int) -> None: ... + def setHidden(self, boolean: bool) -> None: ... + def setLastColumn(self, short: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def setOutlineLevel(self, short: int) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ContinueRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getData(self) -> typing.MutableSequence[int]: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + +class CountryRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getCurrentCountry(self) -> int: ... + def getDefaultCountry(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCurrentCountry(self, short: int) -> None: ... + def setDefaultCountry(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class DBCellRecord(Record): + BLOCK_SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def addCellOffset(self, short: int) -> None: ... + def getCellOffsetAt(self, int: int) -> int: ... + def getNumCellOffsets(self) -> int: ... + def getRecordSize(self) -> int: ... + @staticmethod + def getRecordSizeForRows(int: int) -> int: ... + def getRowOffset(self) -> int: ... + def getSid(self) -> int: ... + def isInValueSection(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setRowOffset(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class DSFRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getDsf(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setDsf(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class DatRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isBorder(self) -> bool: ... + def isHorizontalBorder(self) -> bool: ... + def isShowSeriesKey(self) -> bool: ... + def isVerticalBorder(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBorder(self, boolean: bool) -> None: ... + def setHorizontalBorder(self, boolean: bool) -> None: ... + def setOptions(self, short: int) -> None: ... + def setShowSeriesKey(self, boolean: bool) -> None: ... + def setVerticalBorder(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class DataFormatRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getFormatFlags(self) -> int: ... + def getPointNumber(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSeriesIndex(self) -> int: ... + def getSeriesNumber(self) -> int: ... + def getSid(self) -> int: ... + def isUseExcel4Colors(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFormatFlags(self, short: int) -> None: ... + def setPointNumber(self, short: int) -> None: ... + def setSeriesIndex(self, short: int) -> None: ... + def setSeriesNumber(self, short: int) -> None: ... + def setUseExcel4Colors(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class DateWindow1904Record(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getWindowing(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setWindowing(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class DefaultColWidthRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getColWidth(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColWidth(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class DefaultDataLabelTextPropertiesRecord(Record): + sid: typing.ClassVar[int] = ... + CATEGORY_DATA_TYPE_SHOW_LABELS_CHARACTERISTIC: typing.ClassVar[int] = ... + CATEGORY_DATA_TYPE_VALUE_AND_PERCENTAGE_CHARACTERISTIC: typing.ClassVar[int] = ... + CATEGORY_DATA_TYPE_ALL_TEXT_CHARACTERISTIC: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getCategoryDataType(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCategoryDataType(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class DefaultRowHeightRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getOptionFlags(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRowHeight(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setOptionFlags(self, short: int) -> None: ... + def setRowHeight(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class DeltaRecord(Record): + sid: typing.ClassVar[int] = ... + DEFAULT_VALUE: typing.ClassVar[float] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getMaxChange(self) -> float: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setMaxChange(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + +class DimensionsRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getFirstCol(self) -> int: ... + def getFirstRow(self) -> int: ... + def getLastCol(self) -> int: ... + def getLastRow(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFirstCol(self, short: int) -> None: ... + def setFirstRow(self, int: int) -> None: ... + def setLastCol(self, short: int) -> None: ... + def setLastRow(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class DrawingRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getData(self) -> typing.MutableSequence[int]: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def processContinueRecord( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> None: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setData(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + +class EOFRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class EndRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class ExtSSTInfoSubRecord(Record): + INFO_SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getBucketSSTOffset(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getStreamPos(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBucketRecordOffset(self, short: int) -> None: ... + def setStreamPos(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ExtSSTRecord(Record): + DEFAULT_BUCKET_SIZE: typing.ClassVar[int] = ... + MAX_BUCKETS: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def addInfoRecord(self, extSSTInfoSubRecord: ExtSSTInfoSubRecord) -> None: ... + def getInfoRecordAt(self, int: int) -> ExtSSTInfoSubRecord: ... + def getNumInfoRecords(self) -> int: ... + def getNumStringsPerBucket(self) -> int: ... + @staticmethod + def getNumberOfInfoRecsForStrings(int: int) -> int: ... + def getRecordSize(self) -> int: ... + @staticmethod + def getRecordSizeForStrings(int: int) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBucketOffsets( + self, intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> None: ... + def setNumStringsPerBucket(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ExtendedFormatRecord(Record): + sid: typing.ClassVar[int] = ... + NULL: typing.ClassVar[int] = ... + XF_STYLE: typing.ClassVar[int] = ... + XF_CELL: typing.ClassVar[int] = ... + NONE: typing.ClassVar[int] = ... + THIN: typing.ClassVar[int] = ... + MEDIUM: typing.ClassVar[int] = ... + DASHED: typing.ClassVar[int] = ... + DOTTED: typing.ClassVar[int] = ... + THICK: typing.ClassVar[int] = ... + DOUBLE: typing.ClassVar[int] = ... + HAIR: typing.ClassVar[int] = ... + MEDIUM_DASHED: typing.ClassVar[int] = ... + DASH_DOT: typing.ClassVar[int] = ... + MEDIUM_DASH_DOT: typing.ClassVar[int] = ... + DASH_DOT_DOT: typing.ClassVar[int] = ... + MEDIUM_DASH_DOT_DOT: typing.ClassVar[int] = ... + SLANTED_DASH_DOT: typing.ClassVar[int] = ... + GENERAL: typing.ClassVar[int] = ... + LEFT: typing.ClassVar[int] = ... + CENTER: typing.ClassVar[int] = ... + RIGHT: typing.ClassVar[int] = ... + FILL: typing.ClassVar[int] = ... + JUSTIFY: typing.ClassVar[int] = ... + CENTER_SELECTION: typing.ClassVar[int] = ... + VERTICAL_TOP: typing.ClassVar[int] = ... + VERTICAL_CENTER: typing.ClassVar[int] = ... + VERTICAL_BOTTOM: typing.ClassVar[int] = ... + VERTICAL_JUSTIFY: typing.ClassVar[int] = ... + NO_FILL: typing.ClassVar[int] = ... + SOLID_FILL: typing.ClassVar[int] = ... + FINE_DOTS: typing.ClassVar[int] = ... + ALT_BARS: typing.ClassVar[int] = ... + SPARSE_DOTS: typing.ClassVar[int] = ... + THICK_HORZ_BANDS: typing.ClassVar[int] = ... + THICK_VERT_BANDS: typing.ClassVar[int] = ... + THICK_BACKWARD_DIAG: typing.ClassVar[int] = ... + THICK_FORWARD_DIAG: typing.ClassVar[int] = ... + BIG_SPOTS: typing.ClassVar[int] = ... + BRICKS: typing.ClassVar[int] = ... + THIN_HORZ_BANDS: typing.ClassVar[int] = ... + THIN_VERT_BANDS: typing.ClassVar[int] = ... + THIN_BACKWARD_DIAG: typing.ClassVar[int] = ... + THIN_FORWARD_DIAG: typing.ClassVar[int] = ... + SQUARES: typing.ClassVar[int] = ... + DIAMONDS: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def get123Prefix(self) -> bool: ... + def getAdtlDiag(self) -> int: ... + def getAdtlDiagLineStyle(self) -> int: ... + def getAdtlFillPattern(self) -> int: ... + def getAdtlPaletteOptions(self) -> int: ... + def getAlignment(self) -> int: ... + def getAlignmentOptions(self) -> int: ... + def getBorderBottom(self) -> int: ... + def getBorderLeft(self) -> int: ... + def getBorderOptions(self) -> int: ... + def getBorderRight(self) -> int: ... + def getBorderTop(self) -> int: ... + def getBottomBorderPaletteIdx(self) -> int: ... + def getCellOptions(self) -> int: ... + def getDiag(self) -> int: ... + def getFillBackground(self) -> int: ... + def getFillForeground(self) -> int: ... + def getFillPaletteOptions(self) -> int: ... + def getFontIndex(self) -> int: ... + def getFormatIndex(self) -> int: ... + def getIndent(self) -> int: ... + def getIndentionOptions(self) -> int: ... + def getJustifyLast(self) -> int: ... + def getLeftBorderPaletteIdx(self) -> int: ... + def getMergeCells(self) -> bool: ... + def getPaletteOptions(self) -> int: ... + def getParentIndex(self) -> int: ... + def getReadingOrder(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRightBorderPaletteIdx(self) -> int: ... + def getRotation(self) -> int: ... + def getShrinkToFit(self) -> bool: ... + def getSid(self) -> int: ... + def getTopBorderPaletteIdx(self) -> int: ... + def getVerticalAlignment(self) -> int: ... + def getWrapText(self) -> bool: ... + def getXFType(self) -> int: ... + def isHidden(self) -> bool: ... + def isIndentNotParentAlignment(self) -> bool: ... + def isIndentNotParentBorder(self) -> bool: ... + def isIndentNotParentCellOptions(self) -> bool: ... + def isIndentNotParentFont(self) -> bool: ... + def isIndentNotParentFormat(self) -> bool: ... + def isIndentNotParentPattern(self) -> bool: ... + def isLocked(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def set123Prefix(self, boolean: bool) -> None: ... + def setAdtlDiag(self, short: int) -> None: ... + def setAdtlDiagLineStyle(self, short: int) -> None: ... + def setAdtlFillPattern(self, short: int) -> None: ... + def setAdtlPaletteOptions(self, short: int) -> None: ... + def setAlignment(self, short: int) -> None: ... + def setAlignmentOptions(self, short: int) -> None: ... + def setBorderBottom(self, short: int) -> None: ... + def setBorderLeft(self, short: int) -> None: ... + def setBorderOptions(self, short: int) -> None: ... + def setBorderRight(self, short: int) -> None: ... + def setBorderTop(self, short: int) -> None: ... + def setBottomBorderPaletteIdx(self, short: int) -> None: ... + def setCellOptions(self, short: int) -> None: ... + def setDiag(self, short: int) -> None: ... + def setFillBackground(self, short: int) -> None: ... + def setFillForeground(self, short: int) -> None: ... + def setFillPaletteOptions(self, short: int) -> None: ... + def setFontIndex(self, short: int) -> None: ... + def setFormatIndex(self, short: int) -> None: ... + def setHidden(self, boolean: bool) -> None: ... + def setIndent(self, short: int) -> None: ... + def setIndentNotParentAlignment(self, boolean: bool) -> None: ... + def setIndentNotParentBorder(self, boolean: bool) -> None: ... + def setIndentNotParentCellOptions(self, boolean: bool) -> None: ... + def setIndentNotParentFont(self, boolean: bool) -> None: ... + def setIndentNotParentFormat(self, boolean: bool) -> None: ... + def setIndentNotParentPattern(self, boolean: bool) -> None: ... + def setIndentionOptions(self, short: int) -> None: ... + def setJustifyLast(self, short: int) -> None: ... + def setLeftBorderPaletteIdx(self, short: int) -> None: ... + def setLocked(self, boolean: bool) -> None: ... + def setMergeCells(self, boolean: bool) -> None: ... + def setPaletteOptions(self, short: int) -> None: ... + def setParentIndex(self, short: int) -> None: ... + def setReadingOrder(self, short: int) -> None: ... + def setRightBorderPaletteIdx(self, short: int) -> None: ... + def setRotation(self, short: int) -> None: ... + def setShrinkToFit(self, boolean: bool) -> None: ... + def setTopBorderPaletteIdx(self, short: int) -> None: ... + def setVerticalAlignment(self, short: int) -> None: ... + def setWrapText(self, boolean: bool) -> None: ... + def setXFType(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ExternSheetRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def addREFRecord(self, externSheetSubRecord: ExternSheetSubRecord) -> None: ... + def getNumOfREFRecords(self) -> int: ... + def getNumOfREFStructures(self) -> int: ... + def getREFRecordAt(self, int: int) -> ExternSheetSubRecord: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setNumOfREFStructures(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ExternSheetSubRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getIndexToFirstSupBook(self) -> int: ... + def getIndexToLastSupBook(self) -> int: ... + def getIndexToSupBook(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setIndexToFirstSupBook(self, short: int) -> None: ... + def setIndexToLastSupBook(self, short: int) -> None: ... + def setIndexToSupBook(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class FilePassRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class FileSharingRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getPassword(self) -> int: ... + def getReadOnly(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getUnknown(self) -> int: ... + def getUsername(self) -> java.lang.String: ... + def getUsernameLength(self) -> int: ... + @staticmethod + def hashPassword(string: java.lang.String | str) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setPassword(self, short: int) -> None: ... + def setReadOnly(self, short: int) -> None: ... + def setUnknown(self, short: int) -> None: ... + def setUsername(self, string: java.lang.String | str) -> None: ... + def setUsernameLength(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class FnGroupCountRecord(Record): + sid: typing.ClassVar[int] = ... + COUNT: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getCount(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCount(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class FontBasisRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getHeightBasis(self) -> int: ... + def getIndexToFontTable(self) -> int: ... + def getRecordSize(self) -> int: ... + def getScale(self) -> int: ... + def getSid(self) -> int: ... + def getXBasis(self) -> int: ... + def getYBasis(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setHeightBasis(self, short: int) -> None: ... + def setIndexToFontTable(self, short: int) -> None: ... + def setScale(self, short: int) -> None: ... + def setXBasis(self, short: int) -> None: ... + def setYBasis(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class FontIndexRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getFontIndex(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFontIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class FontRecord(Record): + sid: typing.ClassVar[int] = ... + SS_NONE: typing.ClassVar[int] = ... + SS_SUPER: typing.ClassVar[int] = ... + SS_SUB: typing.ClassVar[int] = ... + U_NONE: typing.ClassVar[int] = ... + U_SINGLE: typing.ClassVar[int] = ... + U_DOUBLE: typing.ClassVar[int] = ... + U_SINGLE_ACCOUNTING: typing.ClassVar[int] = ... + U_DOUBLE_ACCOUNTING: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getAttributes(self) -> int: ... + def getBoldWeight(self) -> int: ... + def getCharset(self) -> int: ... + def getColorPaletteIndex(self) -> int: ... + def getFamily(self) -> int: ... + def getFontHeight(self) -> int: ... + def getFontName(self) -> java.lang.String: ... + def getFontNameLength(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getSuperSubScript(self) -> int: ... + def getUnderline(self) -> int: ... + def isItalic(self) -> bool: ... + def isMacoutlined(self) -> bool: ... + def isMacshadowed(self) -> bool: ... + def isStruckout(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAttributes(self, short: int) -> None: ... + def setBoldWeight(self, short: int) -> None: ... + def setCharset(self, byte: int) -> None: ... + def setColorPaletteIndex(self, short: int) -> None: ... + def setFamily(self, byte: int) -> None: ... + def setFontHeight(self, short: int) -> None: ... + def setFontName(self, string: java.lang.String | str) -> None: ... + def setFontNameLength(self, byte: int) -> None: ... + def setItalic(self, boolean: bool) -> None: ... + def setMacoutline(self, boolean: bool) -> None: ... + def setMacshadow(self, boolean: bool) -> None: ... + def setStrikeout(self, boolean: bool) -> None: ... + def setSuperSubScript(self, short: int) -> None: ... + def setUnderline(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class FooterRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getFooter(self) -> java.lang.String: ... + def getFooterLength(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isMultibyte(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFooter(self, string: java.lang.String | str) -> None: ... + def setFooterLength(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class FormatRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getFormatString(self) -> java.lang.String: ... + def getIndexCode(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getUnicodeFlag(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFormatString(self, string: java.lang.String | str) -> None: ... + def setFormatStringLength(self, byte: int) -> None: ... + def setIndexCode(self, short: int) -> None: ... + def setUnicodeFlag(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class FormulaRecord(Record, CellValueRecordInterface, java.lang.Comparable): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getColumn(self) -> int: ... + def getExpressionLength(self) -> int: ... + def getNumberOfExpressionTokens(self) -> int: ... + def getOptions(self) -> int: ... + def getParsedExpression(self) -> java.util.List: ... + def getRecordSize(self) -> int: ... + def getRow(self) -> int: ... + def getSid(self) -> int: ... + def getValue(self) -> float: ... + def getXFIndex(self) -> int: ... + def isAfter(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isBefore(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isEqual(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isInValueSection(self) -> bool: ... + def isSharedFormula(self) -> bool: ... + def isValue(self) -> bool: ... + def peekExpressionToken(self) -> loci.poi.hssf.record.formula.Ptg: ... + def popExpressionToken(self) -> loci.poi.hssf.record.formula.Ptg: ... + def pushExpressionToken(self, ptg: loci.poi.hssf.record.formula.Ptg) -> None: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColumn(self, short: int) -> None: ... + def setExpressionLength(self, short: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def setParsedExpression(self, stack: java.util.Stack) -> None: ... + def setRow(self, int: int) -> None: ... + def setSharedFormula(self, boolean: bool) -> None: ... + def setValue(self, double: float) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class FrameRecord(Record): + sid: typing.ClassVar[int] = ... + BORDER_TYPE_REGULAR: typing.ClassVar[int] = ... + BORDER_TYPE_SHADOW: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getBorderType(self) -> int: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isAutoPosition(self) -> bool: ... + def isAutoSize(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAutoPosition(self, boolean: bool) -> None: ... + def setAutoSize(self, boolean: bool) -> None: ... + def setBorderType(self, short: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class GridsetRecord(Record): + sid: typing.ClassVar[int] = ... + field_1_gridset_flag: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getGridset(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setGridset(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class GutsRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getColLevelMax(self) -> int: ... + def getLeftRowGutter(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRowLevelMax(self) -> int: ... + def getSid(self) -> int: ... + def getTopColGutter(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColLevelMax(self, short: int) -> None: ... + def setLeftRowGutter(self, short: int) -> None: ... + def setRowLevelMax(self, short: int) -> None: ... + def setTopColGutter(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class HCenterRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getHCenter(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setHCenter(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class HeaderRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getHeader(self) -> java.lang.String: ... + def getHeaderLength(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isMultibyte(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setHeader(self, string: java.lang.String | str) -> None: ... + def setHeaderLength(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class HideObjRecord(Record): + sid: typing.ClassVar[int] = ... + HIDE_ALL: typing.ClassVar[int] = ... + SHOW_PLACEHOLDERS: typing.ClassVar[int] = ... + SHOW_ALL: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getHideObj(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setHideObj(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class IndexRecord(Record): + sid: typing.ClassVar[int] = ... + DBCELL_CAPACITY: typing.ClassVar[int] = ... + field_1_zero: int = ... + field_2_first_row: int = ... + field_3_last_row_add1: int = ... + field_4_zero: int = ... + field_5_dbcells: loci.poi.util.IntList = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def addDbcell(self, int: int) -> None: ... + def clone(self) -> typing.Any: ... + def getDbcellAt(self, int: int) -> int: ... + def getFirstRow(self) -> int: ... + def getLastRowAdd1(self) -> int: ... + def getNumDbcells(self) -> int: ... + def getRecordSize(self) -> int: ... + @staticmethod + def getRecordSizeForBlockCount(int: int) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setDbcell(self, int: int, int2: int) -> None: ... + def setFirstRow(self, int: int) -> None: ... + def setLastRowAdd1(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class InterfaceEndRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class InterfaceHdrRecord(Record): + sid: typing.ClassVar[int] = ... + CODEPAGE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getCodepage(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCodepage(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class IterationRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getIteration(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setIteration(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class LabelRecord(Record, CellValueRecordInterface): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getColumn(self) -> int: ... + def getRow(self) -> int: ... + def getSid(self) -> int: ... + def getStringLength(self) -> int: ... + def getValue(self) -> java.lang.String: ... + def getXFIndex(self) -> int: ... + def isAfter(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isBefore(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isEqual(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isInValueSection(self) -> bool: ... + def isUnCompressedUnicode(self) -> bool: ... + def isValue(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColumn(self, short: int) -> None: ... + def setRow(self, int: int) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class LabelSSTRecord(Record, CellValueRecordInterface, java.lang.Comparable): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getColumn(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRow(self) -> int: ... + def getSSTIndex(self) -> int: ... + def getSid(self) -> int: ... + def getXFIndex(self) -> int: ... + def isAfter(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isBefore(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isEqual(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isInValueSection(self) -> bool: ... + def isValue(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColumn(self, short: int) -> None: ... + def setRow(self, int: int) -> None: ... + def setSSTIndex(self, int: int) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class LeftMarginRecord(Record, Margin): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getMargin(self) -> float: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setMargin(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + +class LegendRecord(Record): + sid: typing.ClassVar[int] = ... + TYPE_BOTTOM: typing.ClassVar[int] = ... + TYPE_CORNER: typing.ClassVar[int] = ... + TYPE_TOP: typing.ClassVar[int] = ... + TYPE_RIGHT: typing.ClassVar[int] = ... + TYPE_LEFT: typing.ClassVar[int] = ... + TYPE_UNDOCKED: typing.ClassVar[int] = ... + SPACING_CLOSE: typing.ClassVar[int] = ... + SPACING_MEDIUM: typing.ClassVar[int] = ... + SPACING_OPEN: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getSpacing(self) -> int: ... + def getType(self) -> int: ... + def getXAxisUpperLeft(self) -> int: ... + def getXSize(self) -> int: ... + def getYAxisUpperLeft(self) -> int: ... + def getYSize(self) -> int: ... + def isAutoPosition(self) -> bool: ... + def isAutoSeries(self) -> bool: ... + def isAutoXPositioning(self) -> bool: ... + def isAutoYPositioning(self) -> bool: ... + def isDataTable(self) -> bool: ... + def isVertical(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAutoPosition(self, boolean: bool) -> None: ... + def setAutoSeries(self, boolean: bool) -> None: ... + def setAutoXPositioning(self, boolean: bool) -> None: ... + def setAutoYPositioning(self, boolean: bool) -> None: ... + def setDataTable(self, boolean: bool) -> None: ... + def setOptions(self, short: int) -> None: ... + def setSpacing(self, byte: int) -> None: ... + def setType(self, byte: int) -> None: ... + def setVertical(self, boolean: bool) -> None: ... + def setXAxisUpperLeft(self, int: int) -> None: ... + def setXSize(self, int: int) -> None: ... + def setYAxisUpperLeft(self, int: int) -> None: ... + def setYSize(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class LineFormatRecord(Record): + sid: typing.ClassVar[int] = ... + LINE_PATTERN_SOLID: typing.ClassVar[int] = ... + LINE_PATTERN_DASH: typing.ClassVar[int] = ... + LINE_PATTERN_DOT: typing.ClassVar[int] = ... + LINE_PATTERN_DASH_DOT: typing.ClassVar[int] = ... + LINE_PATTERN_DASH_DOT_DOT: typing.ClassVar[int] = ... + LINE_PATTERN_NONE: typing.ClassVar[int] = ... + LINE_PATTERN_DARK_GRAY_PATTERN: typing.ClassVar[int] = ... + LINE_PATTERN_MEDIUM_GRAY_PATTERN: typing.ClassVar[int] = ... + LINE_PATTERN_LIGHT_GRAY_PATTERN: typing.ClassVar[int] = ... + WEIGHT_HAIRLINE: typing.ClassVar[int] = ... + WEIGHT_NARROW: typing.ClassVar[int] = ... + WEIGHT_MEDIUM: typing.ClassVar[int] = ... + WEIGHT_WIDE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getColourPaletteIndex(self) -> int: ... + def getFormat(self) -> int: ... + def getLineColor(self) -> int: ... + def getLinePattern(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getWeight(self) -> int: ... + def isAuto(self) -> bool: ... + def isDrawTicks(self) -> bool: ... + def isUnknown(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAuto(self, boolean: bool) -> None: ... + def setColourPaletteIndex(self, short: int) -> None: ... + def setDrawTicks(self, boolean: bool) -> None: ... + def setFormat(self, short: int) -> None: ... + def setLineColor(self, int: int) -> None: ... + def setLinePattern(self, short: int) -> None: ... + def setUnknown(self, boolean: bool) -> None: ... + def setWeight(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class LinkedDataFormulaField(CustomField): + def __init__(self): ... + def clone(self) -> typing.Any: ... + def fillField(self, recordInputStream: RecordInputStream) -> int: ... + def getFormulaTokens(self) -> java.util.Stack: ... + def getSize(self) -> int: ... + def serializeField( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFormulaTokens(self, stack: java.util.Stack) -> None: ... + @typing.overload + def toString(self) -> java.lang.String: ... + @typing.overload + def toString(self, stringBuffer: java.lang.StringBuffer) -> None: ... + +class LinkedDataRecord(Record): + sid: typing.ClassVar[int] = ... + LINK_TYPE_TITLE_OR_TEXT: typing.ClassVar[int] = ... + LINK_TYPE_VALUES: typing.ClassVar[int] = ... + LINK_TYPE_CATEGORIES: typing.ClassVar[int] = ... + REFERENCE_TYPE_DEFAULT_CATEGORIES: typing.ClassVar[int] = ... + REFERENCE_TYPE_DIRECT: typing.ClassVar[int] = ... + REFERENCE_TYPE_WORKSHEET: typing.ClassVar[int] = ... + REFERENCE_TYPE_NOT_USED: typing.ClassVar[int] = ... + REFERENCE_TYPE_ERROR_REPORTED: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getFormulaOfLink(self) -> LinkedDataFormulaField: ... + def getIndexNumberFmtRecord(self) -> int: ... + def getLinkType(self) -> int: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getReferenceType(self) -> int: ... + def getSid(self) -> int: ... + def isCustomNumberFormat(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCustomNumberFormat(self, boolean: bool) -> None: ... + def setFormulaOfLink( + self, linkedDataFormulaField: LinkedDataFormulaField + ) -> None: ... + def setIndexNumberFmtRecord(self, short: int) -> None: ... + def setLinkType(self, byte: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def setReferenceType(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class MMSRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getAddMenuCount(self) -> int: ... + def getDelMenuCount(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAddMenuCount(self, byte: int) -> None: ... + def setDelMenuCount(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class MergeCellsRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def addArea(self, int: int, short: int, int2: int, short2: int) -> int: ... + def clone(self) -> typing.Any: ... + def getAreaAt(self, int: int) -> MergeCellsRecord.MergedRegion: ... + def getNumAreas(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def removeAreaAt(self, int: int) -> None: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setNumAreas(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + class MergedRegion: + row_from: int = ... + row_to: int = ... + col_from: int = ... + col_to: int = ... + def __init__( + self, + mergeCellsRecord: MergeCellsRecord, + int: int, + int2: int, + short: int, + short2: int, + ): ... + +class MulBlankRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getFirstColumn(self) -> int: ... + def getLastColumn(self) -> int: ... + def getNumColumns(self) -> int: ... + def getRow(self) -> int: ... + def getSid(self) -> int: ... + def getXFAt(self, int: int) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class MulRKRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getFirstColumn(self) -> int: ... + def getLastColumn(self) -> int: ... + def getNumColumns(self) -> int: ... + def getRKNumberAt(self, int: int) -> float: ... + def getRow(self) -> int: ... + def getSid(self) -> int: ... + def getXFAt(self, int: int) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class NameRecord(Record): + sid: typing.ClassVar[int] = ... + BUILTIN_CONSOLIDATE_AREA: typing.ClassVar[int] = ... + BUILTIN_AUTO_OPEN: typing.ClassVar[int] = ... + BUILTIN_AUTO_CLOSE: typing.ClassVar[int] = ... + BUILTIN_DATABASE: typing.ClassVar[int] = ... + BUILTIN_CRITERIA: typing.ClassVar[int] = ... + BUILTIN_PRINT_AREA: typing.ClassVar[int] = ... + BUILTIN_PRINT_TITLE: typing.ClassVar[int] = ... + BUILTIN_RECORDER: typing.ClassVar[int] = ... + BUILTIN_DATA_FORM: typing.ClassVar[int] = ... + BUILTIN_AUTO_ACTIVATE: typing.ClassVar[int] = ... + BUILTIN_AUTO_DEACTIVATE: typing.ClassVar[int] = ... + BUILTIN_SHEET_TITLE: typing.ClassVar[int] = ... + OPT_HIDDEN_NAME: typing.ClassVar[int] = ... + OPT_FUNCTION_NAME: typing.ClassVar[int] = ... + OPT_COMMAND_NAME: typing.ClassVar[int] = ... + OPT_MACRO: typing.ClassVar[int] = ... + OPT_COMPLEX: typing.ClassVar[int] = ... + OPT_BUILTIN: typing.ClassVar[int] = ... + OPT_BINDATA: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, byte: int, short: int): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getAreaReference( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def getBuiltInName(self) -> int: ... + def getCompressedUnicodeFlag(self) -> int: ... + def getCustomMenuLength(self) -> int: ... + def getCustomMenuText(self) -> java.lang.String: ... + def getDefinitionLength(self) -> int: ... + def getDescriptionText(self) -> java.lang.String: ... + def getDescriptionTextLength(self) -> int: ... + def getEqualsToIndexToSheet(self) -> int: ... + def getExternSheetNumber(self) -> int: ... + def getFnGroup(self) -> int: ... + def getHelpTopicLength(self) -> int: ... + def getHelpTopicText(self) -> java.lang.String: ... + def getIndexToSheet(self) -> int: ... + def getKeyboardShortcut(self) -> int: ... + def getNameDefinition(self) -> java.util.List: ... + def getNameText(self) -> java.lang.String: ... + def getNameTextLength(self) -> int: ... + def getOptionFlag(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getStatusBarLength(self) -> int: ... + def getStatusBarText(self) -> java.lang.String: ... + def getTextsLength(self) -> int: ... + def getUnused(self) -> int: ... + def isBuiltInName(self) -> bool: ... + def isCommandName(self) -> bool: ... + def isComplexFunction(self) -> bool: ... + def isFunctionName(self) -> bool: ... + def isHiddenName(self) -> bool: ... + def isMacro(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAreaReference(self, string: java.lang.String | str) -> None: ... + def setCompressedUnicodeFlag(self, byte: int) -> None: ... + def setCustomMenuLength(self, byte: int) -> None: ... + def setCustomMenuText(self, string: java.lang.String | str) -> None: ... + def setDefinitionTextLength(self, short: int) -> None: ... + def setDescriptionText(self, string: java.lang.String | str) -> None: ... + def setDescriptionTextLength(self, byte: int) -> None: ... + def setEqualsToIndexToSheet(self, short: int) -> None: ... + def setExternSheetNumber(self, short: int) -> None: ... + def setHelpTopicLength(self, byte: int) -> None: ... + def setHelpTopicText(self, string: java.lang.String | str) -> None: ... + def setKeyboardShortcut(self, byte: int) -> None: ... + def setNameDefinition(self, stack: java.util.Stack) -> None: ... + def setNameText(self, string: java.lang.String | str) -> None: ... + def setNameTextLength(self, byte: int) -> None: ... + def setOptionFlag(self, short: int) -> None: ... + def setStatusBarLength(self, byte: int) -> None: ... + def setStatusBarText(self, string: java.lang.String | str) -> None: ... + def setUnused(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class NoteRecord(Record): + sid: typing.ClassVar[int] = ... + NOTE_HIDDEN: typing.ClassVar[int] = ... + NOTE_VISIBLE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getAuthor(self) -> java.lang.String: ... + def getColumn(self) -> int: ... + def getFlags(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRow(self) -> int: ... + def getShapeId(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAuthor(self, string: java.lang.String | str) -> None: ... + def setColumn(self, short: int) -> None: ... + def setFlags(self, short: int) -> None: ... + def setRow(self, short: int) -> None: ... + def setShapeId(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class NumberFormatIndexRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getFormatIndex(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFormatIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class NumberRecord(Record, CellValueRecordInterface, java.lang.Comparable): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getColumn(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRow(self) -> int: ... + def getSid(self) -> int: ... + def getValue(self) -> float: ... + def getXFIndex(self) -> int: ... + def isAfter(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isBefore(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isEqual(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isInValueSection(self) -> bool: ... + def isValue(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColumn(self, short: int) -> None: ... + def setRow(self, int: int) -> None: ... + def setValue(self, double: float) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ObjRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + @typing.overload + def addSubRecord(self, object: typing.Any) -> bool: ... + @typing.overload + def addSubRecord(self, int: int, object: typing.Any) -> None: ... + def clearSubRecords(self) -> None: ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getSubRecords(self) -> java.util.List: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class ObjectLinkRecord(Record): + sid: typing.ClassVar[int] = ... + ANCHOR_ID_CHART_TITLE: typing.ClassVar[int] = ... + ANCHOR_ID_Y_AXIS: typing.ClassVar[int] = ... + ANCHOR_ID_X_AXIS: typing.ClassVar[int] = ... + ANCHOR_ID_SERIES_OR_POINT: typing.ClassVar[int] = ... + ANCHOR_ID_Z_AXIS: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getAnchorId(self) -> int: ... + def getLink1(self) -> int: ... + def getLink2(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAnchorId(self, short: int) -> None: ... + def setLink1(self, short: int) -> None: ... + def setLink2(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class ObjectProtectRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getProtect(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setProtect(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class PageBreakRecord(Record): + HORIZONTAL_SID: typing.ClassVar[int] = ... + VERTICAL_SID: typing.ClassVar[int] = ... + sid: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + @typing.overload + def __init__(self, short: int): ... + def addBreak(self, short: int, short2: int, short3: int) -> None: ... + def clone(self) -> typing.Any: ... + def getBreak(self, short: int) -> PageBreakRecord.Break: ... + def getBreaksIterator(self) -> java.util.Iterator: ... + def getNumBreaks(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def removeBreak(self, short: int) -> None: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setNumBreaks(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + class Break: + main: int = ... + subFrom: int = ... + subTo: int = ... + def __init__( + self, pageBreakRecord: PageBreakRecord, short: int, short2: int, short3: int + ): ... + +class PaletteRecord(Record): + sid: typing.ClassVar[int] = ... + STANDARD_PALETTE_SIZE: typing.ClassVar[int] = ... + FIRST_COLOR_INDEX: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getColor(self, short: int) -> typing.MutableSequence[int]: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColor(self, short: int, byte: int, byte2: int, byte3: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class PaneRecord(Record): + sid: typing.ClassVar[int] = ... + ACTIVE_PANE_LOWER_RIGHT: typing.ClassVar[int] = ... + ACTIVE_PANE_UPPER_RIGHT: typing.ClassVar[int] = ... + ACTIVE_PANE_LOWER_LEFT: typing.ClassVar[int] = ... + ACTIVE_PANE_UPER_LEFT: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getActivePane(self) -> int: ... + def getLeftColumn(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getTopRow(self) -> int: ... + def getX(self) -> int: ... + def getY(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setActivePane(self, short: int) -> None: ... + def setLeftColumn(self, short: int) -> None: ... + def setTopRow(self, short: int) -> None: ... + def setX(self, short: int) -> None: ... + def setY(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class PasswordRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getPassword(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @staticmethod + def hashPassword(string: java.lang.String | str) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setPassword(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class PasswordRev4Record(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getPassword(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setPassword(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class PlotAreaRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class PlotGrowthRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getHorizontalScale(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getVerticalScale(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setHorizontalScale(self, int: int) -> None: ... + def setVerticalScale(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class PrecisionRecord(Record): + sid: typing.ClassVar[int] = ... + field_1_precision: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getFullPrecision(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFullPrecision(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class PrintGridlinesRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getPrintGridlines(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setPrintGridlines(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class PrintHeadersRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getPrintHeaders(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setPrintHeaders(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class PrintSetupRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getCopies(self) -> int: ... + def getDraft(self) -> bool: ... + def getFitHeight(self) -> int: ... + def getFitWidth(self) -> int: ... + def getFooterMargin(self) -> float: ... + def getHResolution(self) -> int: ... + def getHeaderMargin(self) -> float: ... + def getLandscape(self) -> bool: ... + def getLeftToRight(self) -> bool: ... + def getNoColor(self) -> bool: ... + def getNoOrientation(self) -> bool: ... + def getNotes(self) -> bool: ... + def getOptions(self) -> int: ... + def getPageStart(self) -> int: ... + def getPaperSize(self) -> int: ... + def getRecordSize(self) -> int: ... + def getScale(self) -> int: ... + def getSid(self) -> int: ... + def getUsePage(self) -> bool: ... + def getVResolution(self) -> int: ... + def getValidSettings(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCopies(self, short: int) -> None: ... + def setDraft(self, boolean: bool) -> None: ... + def setFitHeight(self, short: int) -> None: ... + def setFitWidth(self, short: int) -> None: ... + def setFooterMargin(self, double: float) -> None: ... + def setHResolution(self, short: int) -> None: ... + def setHeaderMargin(self, double: float) -> None: ... + def setLandscape(self, boolean: bool) -> None: ... + def setLeftToRight(self, boolean: bool) -> None: ... + def setNoColor(self, boolean: bool) -> None: ... + def setNoOrientation(self, boolean: bool) -> None: ... + def setNotes(self, boolean: bool) -> None: ... + def setOptions(self, short: int) -> None: ... + def setPageStart(self, short: int) -> None: ... + def setPaperSize(self, short: int) -> None: ... + def setScale(self, short: int) -> None: ... + def setUsePage(self, boolean: bool) -> None: ... + def setVResolution(self, short: int) -> None: ... + def setValidSettings(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class ProtectRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getProtect(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setProtect(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class ProtectionRev4Record(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getProtect(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setProtect(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class RKRecord(Record, CellValueRecordInterface): + sid: typing.ClassVar[int] = ... + RK_IEEE_NUMBER: typing.ClassVar[int] = ... + RK_IEEE_NUMBER_TIMES_100: typing.ClassVar[int] = ... + RK_INTEGER: typing.ClassVar[int] = ... + RK_INTEGER_TIMES_100: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getColumn(self) -> int: ... + def getRKField(self) -> int: ... + def getRKNumber(self) -> float: ... + def getRKType(self) -> int: ... + def getRow(self) -> int: ... + def getSid(self) -> int: ... + def getXFIndex(self) -> int: ... + def isAfter(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isBefore(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isEqual(self, cellValueRecordInterface: CellValueRecordInterface) -> bool: ... + def isInValueSection(self) -> bool: ... + def isValue(self) -> bool: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColumn(self, short: int) -> None: ... + def setRow(self, int: int) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class RecalcIdRecord(Record): + sid: typing.ClassVar[int] = ... + field_1_recalcids: typing.MutableSequence[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecalcIdArray(self) -> typing.MutableSequence[int]: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isNeeded(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setIsNeeded(self, boolean: bool) -> None: ... + def setRecalcIdArray(self, shortArray: list[int] | jpype.JArray) -> None: ... + def toString(self) -> java.lang.String: ... + +class RefModeRecord(Record): + sid: typing.ClassVar[int] = ... + USE_A1_MODE: typing.ClassVar[int] = ... + USE_R1C1_MODE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getMode(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setMode(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class RefreshAllRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getRefreshAll(self) -> bool: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setRefreshAll(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class RightMarginRecord(Record, Margin): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getMargin(self) -> float: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setMargin(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + +class RowRecord(Record, java.lang.Comparable): + sid: typing.ClassVar[int] = ... + MAX_ROW_NUMBER: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getBadFontHeight(self) -> bool: ... + def getColapsed(self) -> bool: ... + def getFirstCol(self) -> int: ... + def getFormatted(self) -> bool: ... + def getHeight(self) -> int: ... + def getLastCol(self) -> int: ... + def getOptimize(self) -> int: ... + def getOptionFlags(self) -> int: ... + def getOutlineLevel(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRowNumber(self) -> int: ... + def getSid(self) -> int: ... + def getXFIndex(self) -> int: ... + def getZeroHeight(self) -> bool: ... + def isInValueSection(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBadFontHeight(self, boolean: bool) -> None: ... + def setColapsed(self, boolean: bool) -> None: ... + def setFirstCol(self, short: int) -> None: ... + def setFormatted(self, boolean: bool) -> None: ... + def setHeight(self, short: int) -> None: ... + def setLastCol(self, short: int) -> None: ... + def setOptimize(self, short: int) -> None: ... + def setOptionFlags(self, short: int) -> None: ... + def setOutlineLevel(self, short: int) -> None: ... + def setRowNumber(self, int: int) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def setZeroHeight(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class SCLRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDenominator(self) -> int: ... + def getNumerator(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setDenominator(self, short: int) -> None: ... + def setNumerator(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class SSTRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def addString(self, unicodeString: UnicodeString) -> int: ... + def calcExtSSTRecordSize(self) -> int: ... + def createExtSSTRecord(self, int: int) -> ExtSSTRecord: ... + def equals(self, object: typing.Any) -> bool: ... + def getNumStrings(self) -> int: ... + def getNumUniqueStrings(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getString(self, int: int) -> UnicodeString: ... + def hashCode(self) -> int: ... + def isString16bit(self, int: int) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setNumStrings(self, int: int) -> None: ... + def setNumUniqueStrings(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class SaveRecalcRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecalc(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setRecalc(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class ScenarioProtectRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getProtect(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setProtect(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class SelectionRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getActiveCellCol(self) -> int: ... + def getActiveCellRef(self) -> int: ... + def getActiveCellRow(self) -> int: ... + def getNumRefs(self) -> int: ... + def getPane(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setActiveCellCol(self, short: int) -> None: ... + def setActiveCellRef(self, short: int) -> None: ... + def setActiveCellRow(self, int: int) -> None: ... + def setNumRefs(self, short: int) -> None: ... + def setPane(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + class Reference: + def getFirstColumn(self) -> int: ... + def getFirstRow(self) -> int: ... + def getLastColumn(self) -> int: ... + def getLastRow(self) -> int: ... + +class SeriesChartGroupIndexRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getChartGroupIndex(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setChartGroupIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class SeriesIndexRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getIndex(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class SeriesLabelsRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getFormatFlags(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isLabelAsPercentage(self) -> bool: ... + def isShowActual(self) -> bool: ... + def isShowBubbleSizes(self) -> bool: ... + def isShowLabel(self) -> bool: ... + def isShowPercent(self) -> bool: ... + def isSmoothedLine(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFormatFlags(self, short: int) -> None: ... + def setLabelAsPercentage(self, boolean: bool) -> None: ... + def setShowActual(self, boolean: bool) -> None: ... + def setShowBubbleSizes(self, boolean: bool) -> None: ... + def setShowLabel(self, boolean: bool) -> None: ... + def setShowPercent(self, boolean: bool) -> None: ... + def setSmoothedLine(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class SeriesListRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSeriesNumbers(self) -> typing.MutableSequence[int]: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setSeriesNumbers(self, shortArray: list[int] | jpype.JArray) -> None: ... + def toString(self) -> java.lang.String: ... + +class SeriesRecord(Record): + sid: typing.ClassVar[int] = ... + CATEGORY_DATA_TYPE_DATES: typing.ClassVar[int] = ... + CATEGORY_DATA_TYPE_NUMERIC: typing.ClassVar[int] = ... + CATEGORY_DATA_TYPE_SEQUENCE: typing.ClassVar[int] = ... + CATEGORY_DATA_TYPE_TEXT: typing.ClassVar[int] = ... + VALUES_DATA_TYPE_DATES: typing.ClassVar[int] = ... + VALUES_DATA_TYPE_NUMERIC: typing.ClassVar[int] = ... + VALUES_DATA_TYPE_SEQUENCE: typing.ClassVar[int] = ... + VALUES_DATA_TYPE_TEXT: typing.ClassVar[int] = ... + BUBBLE_SERIES_TYPE_DATES: typing.ClassVar[int] = ... + BUBBLE_SERIES_TYPE_NUMERIC: typing.ClassVar[int] = ... + BUBBLE_SERIES_TYPE_SEQUENCE: typing.ClassVar[int] = ... + BUBBLE_SERIES_TYPE_TEXT: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getBubbleSeriesType(self) -> int: ... + def getCategoryDataType(self) -> int: ... + def getNumBubbleValues(self) -> int: ... + def getNumCategories(self) -> int: ... + def getNumValues(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getValuesDataType(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBubbleSeriesType(self, short: int) -> None: ... + def setCategoryDataType(self, short: int) -> None: ... + def setNumBubbleValues(self, short: int) -> None: ... + def setNumCategories(self, short: int) -> None: ... + def setNumValues(self, short: int) -> None: ... + def setValuesDataType(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class SeriesTextRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getId(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getText(self) -> java.lang.String: ... + def getTextLength(self) -> int: ... + def getUndocumented(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setId(self, short: int) -> None: ... + def setText(self, string: java.lang.String | str) -> None: ... + def setTextLength(self, byte: int) -> None: ... + def setUndocumented(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class SeriesToChartGroupRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getChartGroupIndex(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setChartGroupIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class SharedFormulaRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def convertSharedFormulaRecord(self, formulaRecord: FormulaRecord) -> None: ... + def getExpressionLength(self) -> int: ... + def getFirstColumn(self) -> int: ... + def getFirstRow(self) -> int: ... + def getLastColumn(self) -> int: ... + def getLastRow(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isFormulaInShared(self, formulaRecord: FormulaRecord) -> bool: ... + def isInValueSection(self) -> bool: ... + def isValue(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class SheetPropertiesRecord(Record): + sid: typing.ClassVar[int] = ... + EMPTY_NOT_PLOTTED: typing.ClassVar[int] = ... + EMPTY_ZERO: typing.ClassVar[int] = ... + EMPTY_INTERPOLATED: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getEmpty(self) -> int: ... + def getFlags(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isAutoPlotArea(self) -> bool: ... + def isChartTypeManuallyFormatted(self) -> bool: ... + def isDefaultPlotDimensions(self) -> bool: ... + def isDoNotSizeWithWindow(self) -> bool: ... + def isPlotVisibleOnly(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAutoPlotArea(self, boolean: bool) -> None: ... + def setChartTypeManuallyFormatted(self, boolean: bool) -> None: ... + def setDefaultPlotDimensions(self, boolean: bool) -> None: ... + def setDoNotSizeWithWindow(self, boolean: bool) -> None: ... + def setEmpty(self, byte: int) -> None: ... + def setFlags(self, short: int) -> None: ... + def setPlotVisibleOnly(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class StringRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getString(self) -> java.lang.String: ... + def isInValueSection(self) -> bool: ... + def isUnCompressedUnicode(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setCompressedFlag(self, byte: int) -> None: ... + def setString(self, string: java.lang.String | str) -> None: ... + def toString(self) -> java.lang.String: ... + +class StyleRecord(Record): + sid: typing.ClassVar[int] = ... + STYLE_USER_DEFINED: typing.ClassVar[int] = ... + STYLE_BUILT_IN: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getBuiltin(self) -> int: ... + def getIndex(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getNameLength(self) -> int: ... + def getOutlineStyleLevel(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getType(self) -> int: ... + def getXFIndex(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setBuiltin(self, byte: int) -> None: ... + def setIndex(self, short: int) -> None: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setNameLength(self, byte: int) -> None: ... + def setOutlineStyleLevel(self, byte: int) -> None: ... + def setType(self, short: int) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class SubRecord(Record): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + @staticmethod + def createSubRecord(recordInputStream: RecordInputStream) -> Record: ... + +class SupBookRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getFlag(self) -> int: ... + def getNumberOfSheets(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFlag(self, short: int) -> None: ... + def setNumberOfSheets(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class TabIdRecord(Record): + sid: typing.ClassVar[int] = ... + field_1_tabids: typing.MutableSequence[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getTabIdArray(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setTabIdArray(self, shortArray: list[int] | jpype.JArray) -> None: ... + def toString(self) -> java.lang.String: ... + +class TextObjectBaseRecord(Record): + sid: typing.ClassVar[int] = ... + HORIZONTAL_TEXT_ALIGNMENT_LEFT_ALIGNED: typing.ClassVar[int] = ... + HORIZONTAL_TEXT_ALIGNMENT_CENTERED: typing.ClassVar[int] = ... + HORIZONTAL_TEXT_ALIGNMENT_RIGHT_ALIGNED: typing.ClassVar[int] = ... + HORIZONTAL_TEXT_ALIGNMENT_JUSTIFIED: typing.ClassVar[int] = ... + VERTICAL_TEXT_ALIGNMENT_TOP: typing.ClassVar[int] = ... + VERTICAL_TEXT_ALIGNMENT_CENTER: typing.ClassVar[int] = ... + VERTICAL_TEXT_ALIGNMENT_BOTTOM: typing.ClassVar[int] = ... + VERTICAL_TEXT_ALIGNMENT_JUSTIFY: typing.ClassVar[int] = ... + TEXT_ORIENTATION_NONE: typing.ClassVar[int] = ... + TEXT_ORIENTATION_TOP_TO_BOTTOM: typing.ClassVar[int] = ... + TEXT_ORIENTATION_ROT_RIGHT: typing.ClassVar[int] = ... + TEXT_ORIENTATION_ROT_LEFT: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getFormattingRunLength(self) -> int: ... + def getHorizontalTextAlignment(self) -> int: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getReserved2(self) -> int: ... + def getReserved3(self) -> int: ... + def getReserved4(self) -> int: ... + def getReserved5(self) -> int: ... + def getReserved6(self) -> int: ... + def getReserved7(self) -> int: ... + def getSid(self) -> int: ... + def getTextLength(self) -> int: ... + def getTextOrientation(self) -> int: ... + def getVerticalTextAlignment(self) -> int: ... + def isReserved1(self) -> bool: ... + def isTextLocked(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFormattingRunLength(self, short: int) -> None: ... + def setHorizontalTextAlignment(self, short: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def setReserved1(self, boolean: bool) -> None: ... + def setReserved2(self, short: int) -> None: ... + def setReserved3(self, short: int) -> None: ... + def setReserved4(self, short: int) -> None: ... + def setReserved5(self, short: int) -> None: ... + def setReserved6(self, short: int) -> None: ... + def setReserved7(self, int: int) -> None: ... + def setTextLength(self, short: int) -> None: ... + def setTextLocked(self, boolean: bool) -> None: ... + def setTextOrientation(self, short: int) -> None: ... + def setVerticalTextAlignment(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class TextRecord(Record): + sid: typing.ClassVar[int] = ... + HORIZONTAL_ALIGNMENT_LEFT: typing.ClassVar[int] = ... + HORIZONTAL_ALIGNMENT_CENTER: typing.ClassVar[int] = ... + HORIZONTAL_ALIGNMENT_BOTTOM: typing.ClassVar[int] = ... + HORIZONTAL_ALIGNMENT_JUSTIFY: typing.ClassVar[int] = ... + VERTICAL_ALIGNMENT_TOP: typing.ClassVar[int] = ... + VERTICAL_ALIGNMENT_CENTER: typing.ClassVar[int] = ... + VERTICAL_ALIGNMENT_BOTTOM: typing.ClassVar[int] = ... + VERTICAL_ALIGNMENT_JUSTIFY: typing.ClassVar[int] = ... + DISPLAY_MODE_TRANSPARENT: typing.ClassVar[int] = ... + DISPLAY_MODE_OPAQUE: typing.ClassVar[int] = ... + ROTATION_NONE: typing.ClassVar[int] = ... + ROTATION_TOP_TO_BOTTOM: typing.ClassVar[int] = ... + ROTATION_ROTATED_90_DEGREES: typing.ClassVar[int] = ... + ROTATION_ROTATED_90_DEGREES_CLOCKWISE: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_CHART_DEPENDENT: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_OUTSIDE: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_INSIDE: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_CENTER: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_AXIS: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_ABOVE: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_BELOW: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_LEFT: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_RIGHT: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_AUTO: typing.ClassVar[int] = ... + DATA_LABEL_PLACEMENT_USER_MOVED: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDataLabelPlacement(self) -> int: ... + def getDisplayMode(self) -> int: ... + def getHeight(self) -> int: ... + def getHorizontalAlignment(self) -> int: ... + def getIndexOfColorValue(self) -> int: ... + def getOptions1(self) -> int: ... + def getOptions2(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRgbColor(self) -> int: ... + def getRotation(self) -> int: ... + def getSid(self) -> int: ... + def getTextRotation(self) -> int: ... + def getVerticalAlignment(self) -> int: ... + def getWidth(self) -> int: ... + def getX(self) -> int: ... + def getY(self) -> int: ... + def isAutoBackground(self) -> bool: ... + def isAutoColor(self) -> bool: ... + def isAutoGeneratedText(self) -> bool: ... + def isAutoLabelDeleted(self) -> bool: ... + def isGenerated(self) -> bool: ... + def isShowBubbleSizes(self) -> bool: ... + def isShowCategoryLabelAsPercentage(self) -> bool: ... + def isShowKey(self) -> bool: ... + def isShowLabel(self) -> bool: ... + def isShowValue(self) -> bool: ... + def isShowValueAsPercentage(self) -> bool: ... + def isVertical(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAutoBackground(self, boolean: bool) -> None: ... + def setAutoColor(self, boolean: bool) -> None: ... + def setAutoGeneratedText(self, boolean: bool) -> None: ... + def setAutoLabelDeleted(self, boolean: bool) -> None: ... + def setDataLabelPlacement(self, short: int) -> None: ... + def setDisplayMode(self, short: int) -> None: ... + def setGenerated(self, boolean: bool) -> None: ... + def setHeight(self, int: int) -> None: ... + def setHorizontalAlignment(self, byte: int) -> None: ... + def setIndexOfColorValue(self, short: int) -> None: ... + def setOptions1(self, short: int) -> None: ... + def setOptions2(self, short: int) -> None: ... + def setRgbColor(self, int: int) -> None: ... + def setRotation(self, short: int) -> None: ... + def setShowBubbleSizes(self, boolean: bool) -> None: ... + def setShowCategoryLabelAsPercentage(self, boolean: bool) -> None: ... + def setShowKey(self, boolean: bool) -> None: ... + def setShowLabel(self, boolean: bool) -> None: ... + def setShowValue(self, boolean: bool) -> None: ... + def setShowValueAsPercentage(self, boolean: bool) -> None: ... + def setTextRotation(self, short: int) -> None: ... + def setVertical(self, boolean: bool) -> None: ... + def setVerticalAlignment(self, byte: int) -> None: ... + def setWidth(self, int: int) -> None: ... + def setX(self, int: int) -> None: ... + def setY(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class TickRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getBackground(self) -> int: ... + def getLabelColorRgb(self) -> int: ... + def getLabelPosition(self) -> int: ... + def getMajorTickType(self) -> int: ... + def getMinorTickType(self) -> int: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRotation(self) -> int: ... + def getSid(self) -> int: ... + def getTickColor(self) -> int: ... + def getZero1(self) -> int: ... + def getZero2(self) -> int: ... + def getZero3(self) -> int: ... + def isAutoTextBackground(self) -> bool: ... + def isAutoTextColor(self) -> bool: ... + def isAutorotate(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAutoTextBackground(self, boolean: bool) -> None: ... + def setAutoTextColor(self, boolean: bool) -> None: ... + def setAutorotate(self, boolean: bool) -> None: ... + def setBackground(self, byte: int) -> None: ... + def setLabelColorRgb(self, int: int) -> None: ... + def setLabelPosition(self, byte: int) -> None: ... + def setMajorTickType(self, byte: int) -> None: ... + def setMinorTickType(self, byte: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def setRotation(self, short: int) -> None: ... + def setTickColor(self, short: int) -> None: ... + def setZero1(self, int: int) -> None: ... + def setZero2(self, int: int) -> None: ... + def setZero3(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class TopMarginRecord(Record, Margin): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getMargin(self) -> float: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setMargin(self, double: float) -> None: ... + def toString(self) -> java.lang.String: ... + +class UnitsRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getUnits(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setUnits(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class UnknownRecord(Record): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + @typing.overload + def __init__(self, short: int, byteArray: list[int] | jpype.JArray | bytes): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class UseSelFSRecord(Record): + sid: typing.ClassVar[int] = ... + TRUE: typing.ClassVar[int] = ... + FALSE: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getFlag(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setFlag(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class VCenterRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getVCenter(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setVCenter(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class ValueRangeRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getCategoryAxisCross(self) -> float: ... + def getMajorIncrement(self) -> float: ... + def getMaximumAxisValue(self) -> float: ... + def getMinimumAxisValue(self) -> float: ... + def getMinorIncrement(self) -> float: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def isAutomaticCategoryCrossing(self) -> bool: ... + def isAutomaticMajor(self) -> bool: ... + def isAutomaticMaximum(self) -> bool: ... + def isAutomaticMinimum(self) -> bool: ... + def isAutomaticMinor(self) -> bool: ... + def isCrossCategoryAxisAtMaximum(self) -> bool: ... + def isLogarithmicScale(self) -> bool: ... + def isReserved(self) -> bool: ... + def isValuesInReverse(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAutomaticCategoryCrossing(self, boolean: bool) -> None: ... + def setAutomaticMajor(self, boolean: bool) -> None: ... + def setAutomaticMaximum(self, boolean: bool) -> None: ... + def setAutomaticMinimum(self, boolean: bool) -> None: ... + def setAutomaticMinor(self, boolean: bool) -> None: ... + def setCategoryAxisCross(self, double: float) -> None: ... + def setCrossCategoryAxisAtMaximum(self, boolean: bool) -> None: ... + def setLogarithmicScale(self, boolean: bool) -> None: ... + def setMajorIncrement(self, double: float) -> None: ... + def setMaximumAxisValue(self, double: float) -> None: ... + def setMinimumAxisValue(self, double: float) -> None: ... + def setMinorIncrement(self, double: float) -> None: ... + def setOptions(self, short: int) -> None: ... + def setReserved(self, boolean: bool) -> None: ... + def setValuesInReverse(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class WSBoolRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getAlternateExpression(self) -> bool: ... + def getAlternateFormula(self) -> bool: ... + def getAutobreaks(self) -> bool: ... + def getDialog(self) -> bool: ... + def getDisplayGuts(self) -> bool: ... + def getFitToPage(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getRowSumsBelow(self) -> bool: ... + def getRowSumsRight(self) -> bool: ... + def getSid(self) -> int: ... + def getWSBool1(self) -> int: ... + def getWSBool2(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAlternateExpression(self, boolean: bool) -> None: ... + def setAlternateFormula(self, boolean: bool) -> None: ... + def setAutobreaks(self, boolean: bool) -> None: ... + def setDialog(self, boolean: bool) -> None: ... + def setDisplayGuts(self, boolean: bool) -> None: ... + def setFitToPage(self, boolean: bool) -> None: ... + def setRowSumsBelow(self, boolean: bool) -> None: ... + def setRowSumsRight(self, boolean: bool) -> None: ... + def setWSBool1(self, byte: int) -> None: ... + def setWSBool2(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class WindowOneRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getDisplayHorizontalScrollbar(self) -> bool: ... + def getDisplayTabs(self) -> bool: ... + def getDisplayVerticalScrollbar(self) -> bool: ... + def getDisplayedTab(self) -> int: ... + def getHeight(self) -> int: ... + def getHidden(self) -> bool: ... + def getHorizontalHold(self) -> int: ... + def getIconic(self) -> bool: ... + def getNumSelectedTabs(self) -> int: ... + def getOptions(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSelectedTab(self) -> int: ... + def getSid(self) -> int: ... + def getTabWidthRatio(self) -> int: ... + def getVerticalHold(self) -> int: ... + def getWidth(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setDisplayHorizonalScrollbar(self, boolean: bool) -> None: ... + def setDisplayTabs(self, boolean: bool) -> None: ... + def setDisplayVerticalScrollbar(self, boolean: bool) -> None: ... + def setDisplayedTab(self, short: int) -> None: ... + def setHeight(self, short: int) -> None: ... + def setHidden(self, boolean: bool) -> None: ... + def setHorizontalHold(self, short: int) -> None: ... + def setIconic(self, boolean: bool) -> None: ... + def setNumSelectedTabs(self, short: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def setSelectedTab(self, short: int) -> None: ... + def setTabWidthRatio(self, short: int) -> None: ... + def setVerticalHold(self, short: int) -> None: ... + def setWidth(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class WindowProtectRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getProtect(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setProtect(self, boolean: bool) -> None: ... + def toString(self) -> java.lang.String: ... + +class WindowTwoRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getArabic(self) -> bool: ... + def getDefaultHeader(self) -> bool: ... + def getDisplayFormulas(self) -> bool: ... + def getDisplayGridlines(self) -> bool: ... + def getDisplayGuts(self) -> bool: ... + def getDisplayRowColHeadings(self) -> bool: ... + def getDisplayZeros(self) -> bool: ... + def getFreezePanes(self) -> bool: ... + def getFreezePanesNoSplit(self) -> bool: ... + def getHeaderColor(self) -> int: ... + def getLeftCol(self) -> int: ... + def getNormalZoom(self) -> int: ... + def getOptions(self) -> int: ... + def getPageBreakZoom(self) -> int: ... + def getPaged(self) -> bool: ... + def getRecordSize(self) -> int: ... + def getReserved(self) -> int: ... + def getSavedInPageBreakPreview(self) -> bool: ... + def getSelected(self) -> bool: ... + def getSid(self) -> int: ... + def getTopRow(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setArabic(self, boolean: bool) -> None: ... + def setDefaultHeader(self, boolean: bool) -> None: ... + def setDisplayFormulas(self, boolean: bool) -> None: ... + def setDisplayGridlines(self, boolean: bool) -> None: ... + def setDisplayGuts(self, boolean: bool) -> None: ... + def setDisplayRowColHeadings(self, boolean: bool) -> None: ... + def setDisplayZeros(self, boolean: bool) -> None: ... + def setFreezePanes(self, boolean: bool) -> None: ... + def setFreezePanesNoSplit(self, boolean: bool) -> None: ... + def setHeaderColor(self, int: int) -> None: ... + def setLeftCol(self, short: int) -> None: ... + def setNormalZoom(self, short: int) -> None: ... + def setOptions(self, short: int) -> None: ... + def setPageBreakZoom(self, short: int) -> None: ... + def setPaged(self, boolean: bool) -> None: ... + def setReserved(self, int: int) -> None: ... + def setSavedInPageBreakPreview(self, boolean: bool) -> None: ... + def setSelected(self, boolean: bool) -> None: ... + def setTopRow(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class WriteAccessRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getUsername(self) -> java.lang.String: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setUsername(self, string: java.lang.String | str) -> None: ... + def toString(self) -> java.lang.String: ... + +class WriteProtectRecord(Record): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class CommonObjectDataSubRecord(SubRecord): + sid: typing.ClassVar[int] = ... + OBJECT_TYPE_GROUP: typing.ClassVar[int] = ... + OBJECT_TYPE_LINE: typing.ClassVar[int] = ... + OBJECT_TYPE_RECTANGLE: typing.ClassVar[int] = ... + OBJECT_TYPE_OVAL: typing.ClassVar[int] = ... + OBJECT_TYPE_ARC: typing.ClassVar[int] = ... + OBJECT_TYPE_CHART: typing.ClassVar[int] = ... + OBJECT_TYPE_TEXT: typing.ClassVar[int] = ... + OBJECT_TYPE_BUTTON: typing.ClassVar[int] = ... + OBJECT_TYPE_PICTURE: typing.ClassVar[int] = ... + OBJECT_TYPE_POLYGON: typing.ClassVar[int] = ... + OBJECT_TYPE_RESERVED1: typing.ClassVar[int] = ... + OBJECT_TYPE_CHECKBOX: typing.ClassVar[int] = ... + OBJECT_TYPE_OPTION_BUTTON: typing.ClassVar[int] = ... + OBJECT_TYPE_EDIT_BOX: typing.ClassVar[int] = ... + OBJECT_TYPE_LABEL: typing.ClassVar[int] = ... + OBJECT_TYPE_DIALOG_BOX: typing.ClassVar[int] = ... + OBJECT_TYPE_SPINNER: typing.ClassVar[int] = ... + OBJECT_TYPE_SCROLL_BAR: typing.ClassVar[int] = ... + OBJECT_TYPE_LIST_BOX: typing.ClassVar[int] = ... + OBJECT_TYPE_GROUP_BOX: typing.ClassVar[int] = ... + OBJECT_TYPE_COMBO_BOX: typing.ClassVar[int] = ... + OBJECT_TYPE_RESERVED2: typing.ClassVar[int] = ... + OBJECT_TYPE_RESERVED3: typing.ClassVar[int] = ... + OBJECT_TYPE_RESERVED4: typing.ClassVar[int] = ... + OBJECT_TYPE_RESERVED5: typing.ClassVar[int] = ... + OBJECT_TYPE_COMMENT: typing.ClassVar[int] = ... + OBJECT_TYPE_RESERVED6: typing.ClassVar[int] = ... + OBJECT_TYPE_RESERVED7: typing.ClassVar[int] = ... + OBJECT_TYPE_RESERVED8: typing.ClassVar[int] = ... + OBJECT_TYPE_RESERVED9: typing.ClassVar[int] = ... + OBJECT_TYPE_MICROSOFT_OFFICE_DRAWING: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getObjectId(self) -> int: ... + def getObjectType(self) -> int: ... + def getOption(self) -> int: ... + def getRecordSize(self) -> int: ... + def getReserved1(self) -> int: ... + def getReserved2(self) -> int: ... + def getReserved3(self) -> int: ... + def getSid(self) -> int: ... + def isAutofill(self) -> bool: ... + def isAutoline(self) -> bool: ... + def isLocked(self) -> bool: ... + def isPrintable(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setAutofill(self, boolean: bool) -> None: ... + def setAutoline(self, boolean: bool) -> None: ... + def setLocked(self, boolean: bool) -> None: ... + def setObjectId(self, short: int) -> None: ... + def setObjectType(self, short: int) -> None: ... + def setOption(self, short: int) -> None: ... + def setPrintable(self, boolean: bool) -> None: ... + def setReserved1(self, int: int) -> None: ... + def setReserved2(self, int: int) -> None: ... + def setReserved3(self, int: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class DrawingGroupRecord(AbstractEscherHolderRecord): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRawDataSize(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + +class DrawingRecordForBiffViewer(AbstractEscherHolderRecord): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getSid(self) -> int: ... + +class DrawingSelectionRecord(AbstractEscherHolderRecord): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getSid(self) -> int: ... + +class EmbeddedObjectRefSubRecord(SubRecord): + sid: typing.ClassVar[int] = ... + field_1_stream_id_offset: int = ... + field_2_unknown: typing.MutableSequence[int] = ... + field_3_unicode_len: int = ... + field_4_unicode_flag: bool = ... + field_5_ole_classname: java.lang.String = ... + field_6_stream_id: int = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def getStreamId(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class EndSubRecord(SubRecord): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class EscherAggregate(AbstractEscherHolderRecord): + sid: typing.ClassVar[int] = ... + ST_MIN: typing.ClassVar[int] = ... + ST_NOT_PRIMATIVE: typing.ClassVar[int] = ... + ST_RECTANGLE: typing.ClassVar[int] = ... + ST_ROUNDRECTANGLE: typing.ClassVar[int] = ... + ST_ELLIPSE: typing.ClassVar[int] = ... + ST_DIAMOND: typing.ClassVar[int] = ... + ST_ISOCELESTRIANGLE: typing.ClassVar[int] = ... + ST_RIGHTTRIANGLE: typing.ClassVar[int] = ... + ST_PARALLELOGRAM: typing.ClassVar[int] = ... + ST_TRAPEZOID: typing.ClassVar[int] = ... + ST_HEXAGON: typing.ClassVar[int] = ... + ST_OCTAGON: typing.ClassVar[int] = ... + ST_PLUS: typing.ClassVar[int] = ... + ST_STAR: typing.ClassVar[int] = ... + ST_ARROW: typing.ClassVar[int] = ... + ST_THICKARROW: typing.ClassVar[int] = ... + ST_HOMEPLATE: typing.ClassVar[int] = ... + ST_CUBE: typing.ClassVar[int] = ... + ST_BALLOON: typing.ClassVar[int] = ... + ST_SEAL: typing.ClassVar[int] = ... + ST_ARC: typing.ClassVar[int] = ... + ST_LINE: typing.ClassVar[int] = ... + ST_PLAQUE: typing.ClassVar[int] = ... + ST_CAN: typing.ClassVar[int] = ... + ST_DONUT: typing.ClassVar[int] = ... + ST_TEXTSIMPLE: typing.ClassVar[int] = ... + ST_TEXTOCTAGON: typing.ClassVar[int] = ... + ST_TEXTHEXAGON: typing.ClassVar[int] = ... + ST_TEXTCURVE: typing.ClassVar[int] = ... + ST_TEXTWAVE: typing.ClassVar[int] = ... + ST_TEXTRING: typing.ClassVar[int] = ... + ST_TEXTONCURVE: typing.ClassVar[int] = ... + ST_TEXTONRING: typing.ClassVar[int] = ... + ST_STRAIGHTCONNECTOR1: typing.ClassVar[int] = ... + ST_BENTCONNECTOR2: typing.ClassVar[int] = ... + ST_BENTCONNECTOR3: typing.ClassVar[int] = ... + ST_BENTCONNECTOR4: typing.ClassVar[int] = ... + ST_BENTCONNECTOR5: typing.ClassVar[int] = ... + ST_CURVEDCONNECTOR2: typing.ClassVar[int] = ... + ST_CURVEDCONNECTOR3: typing.ClassVar[int] = ... + ST_CURVEDCONNECTOR4: typing.ClassVar[int] = ... + ST_CURVEDCONNECTOR5: typing.ClassVar[int] = ... + ST_CALLOUT1: typing.ClassVar[int] = ... + ST_CALLOUT2: typing.ClassVar[int] = ... + ST_CALLOUT3: typing.ClassVar[int] = ... + ST_ACCENTCALLOUT1: typing.ClassVar[int] = ... + ST_ACCENTCALLOUT2: typing.ClassVar[int] = ... + ST_ACCENTCALLOUT3: typing.ClassVar[int] = ... + ST_BORDERCALLOUT1: typing.ClassVar[int] = ... + ST_BORDERCALLOUT2: typing.ClassVar[int] = ... + ST_BORDERCALLOUT3: typing.ClassVar[int] = ... + ST_ACCENTBORDERCALLOUT1: typing.ClassVar[int] = ... + ST_ACCENTBORDERCALLOUT2: typing.ClassVar[int] = ... + ST_ACCENTBORDERCALLOUT3: typing.ClassVar[int] = ... + ST_RIBBON: typing.ClassVar[int] = ... + ST_RIBBON2: typing.ClassVar[int] = ... + ST_CHEVRON: typing.ClassVar[int] = ... + ST_PENTAGON: typing.ClassVar[int] = ... + ST_NOSMOKING: typing.ClassVar[int] = ... + ST_SEAL8: typing.ClassVar[int] = ... + ST_SEAL16: typing.ClassVar[int] = ... + ST_SEAL32: typing.ClassVar[int] = ... + ST_WEDGERECTCALLOUT: typing.ClassVar[int] = ... + ST_WEDGERRECTCALLOUT: typing.ClassVar[int] = ... + ST_WEDGEELLIPSECALLOUT: typing.ClassVar[int] = ... + ST_WAVE: typing.ClassVar[int] = ... + ST_FOLDEDCORNER: typing.ClassVar[int] = ... + ST_LEFTARROW: typing.ClassVar[int] = ... + ST_DOWNARROW: typing.ClassVar[int] = ... + ST_UPARROW: typing.ClassVar[int] = ... + ST_LEFTRIGHTARROW: typing.ClassVar[int] = ... + ST_UPDOWNARROW: typing.ClassVar[int] = ... + ST_IRREGULARSEAL1: typing.ClassVar[int] = ... + ST_IRREGULARSEAL2: typing.ClassVar[int] = ... + ST_LIGHTNINGBOLT: typing.ClassVar[int] = ... + ST_HEART: typing.ClassVar[int] = ... + ST_PICTUREFRAME: typing.ClassVar[int] = ... + ST_QUADARROW: typing.ClassVar[int] = ... + ST_LEFTARROWCALLOUT: typing.ClassVar[int] = ... + ST_RIGHTARROWCALLOUT: typing.ClassVar[int] = ... + ST_UPARROWCALLOUT: typing.ClassVar[int] = ... + ST_DOWNARROWCALLOUT: typing.ClassVar[int] = ... + ST_LEFTRIGHTARROWCALLOUT: typing.ClassVar[int] = ... + ST_UPDOWNARROWCALLOUT: typing.ClassVar[int] = ... + ST_QUADARROWCALLOUT: typing.ClassVar[int] = ... + ST_BEVEL: typing.ClassVar[int] = ... + ST_LEFTBRACKET: typing.ClassVar[int] = ... + ST_RIGHTBRACKET: typing.ClassVar[int] = ... + ST_LEFTBRACE: typing.ClassVar[int] = ... + ST_RIGHTBRACE: typing.ClassVar[int] = ... + ST_LEFTUPARROW: typing.ClassVar[int] = ... + ST_BENTUPARROW: typing.ClassVar[int] = ... + ST_BENTARROW: typing.ClassVar[int] = ... + ST_SEAL24: typing.ClassVar[int] = ... + ST_STRIPEDRIGHTARROW: typing.ClassVar[int] = ... + ST_NOTCHEDRIGHTARROW: typing.ClassVar[int] = ... + ST_BLOCKARC: typing.ClassVar[int] = ... + ST_SMILEYFACE: typing.ClassVar[int] = ... + ST_VERTICALSCROLL: typing.ClassVar[int] = ... + ST_HORIZONTALSCROLL: typing.ClassVar[int] = ... + ST_CIRCULARARROW: typing.ClassVar[int] = ... + ST_NOTCHEDCIRCULARARROW: typing.ClassVar[int] = ... + ST_UTURNARROW: typing.ClassVar[int] = ... + ST_CURVEDRIGHTARROW: typing.ClassVar[int] = ... + ST_CURVEDLEFTARROW: typing.ClassVar[int] = ... + ST_CURVEDUPARROW: typing.ClassVar[int] = ... + ST_CURVEDDOWNARROW: typing.ClassVar[int] = ... + ST_CLOUDCALLOUT: typing.ClassVar[int] = ... + ST_ELLIPSERIBBON: typing.ClassVar[int] = ... + ST_ELLIPSERIBBON2: typing.ClassVar[int] = ... + ST_FLOWCHARTPROCESS: typing.ClassVar[int] = ... + ST_FLOWCHARTDECISION: typing.ClassVar[int] = ... + ST_FLOWCHARTINPUTOUTPUT: typing.ClassVar[int] = ... + ST_FLOWCHARTPREDEFINEDPROCESS: typing.ClassVar[int] = ... + ST_FLOWCHARTINTERNALSTORAGE: typing.ClassVar[int] = ... + ST_FLOWCHARTDOCUMENT: typing.ClassVar[int] = ... + ST_FLOWCHARTMULTIDOCUMENT: typing.ClassVar[int] = ... + ST_FLOWCHARTTERMINATOR: typing.ClassVar[int] = ... + ST_FLOWCHARTPREPARATION: typing.ClassVar[int] = ... + ST_FLOWCHARTMANUALINPUT: typing.ClassVar[int] = ... + ST_FLOWCHARTMANUALOPERATION: typing.ClassVar[int] = ... + ST_FLOWCHARTCONNECTOR: typing.ClassVar[int] = ... + ST_FLOWCHARTPUNCHEDCARD: typing.ClassVar[int] = ... + ST_FLOWCHARTPUNCHEDTAPE: typing.ClassVar[int] = ... + ST_FLOWCHARTSUMMINGJUNCTION: typing.ClassVar[int] = ... + ST_FLOWCHARTOR: typing.ClassVar[int] = ... + ST_FLOWCHARTCOLLATE: typing.ClassVar[int] = ... + ST_FLOWCHARTSORT: typing.ClassVar[int] = ... + ST_FLOWCHARTEXTRACT: typing.ClassVar[int] = ... + ST_FLOWCHARTMERGE: typing.ClassVar[int] = ... + ST_FLOWCHARTOFFLINESTORAGE: typing.ClassVar[int] = ... + ST_FLOWCHARTONLINESTORAGE: typing.ClassVar[int] = ... + ST_FLOWCHARTMAGNETICTAPE: typing.ClassVar[int] = ... + ST_FLOWCHARTMAGNETICDISK: typing.ClassVar[int] = ... + ST_FLOWCHARTMAGNETICDRUM: typing.ClassVar[int] = ... + ST_FLOWCHARTDISPLAY: typing.ClassVar[int] = ... + ST_FLOWCHARTDELAY: typing.ClassVar[int] = ... + ST_TEXTPLAINTEXT: typing.ClassVar[int] = ... + ST_TEXTSTOP: typing.ClassVar[int] = ... + ST_TEXTTRIANGLE: typing.ClassVar[int] = ... + ST_TEXTTRIANGLEINVERTED: typing.ClassVar[int] = ... + ST_TEXTCHEVRON: typing.ClassVar[int] = ... + ST_TEXTCHEVRONINVERTED: typing.ClassVar[int] = ... + ST_TEXTRINGINSIDE: typing.ClassVar[int] = ... + ST_TEXTRINGOUTSIDE: typing.ClassVar[int] = ... + ST_TEXTARCHUPCURVE: typing.ClassVar[int] = ... + ST_TEXTARCHDOWNCURVE: typing.ClassVar[int] = ... + ST_TEXTCIRCLECURVE: typing.ClassVar[int] = ... + ST_TEXTBUTTONCURVE: typing.ClassVar[int] = ... + ST_TEXTARCHUPPOUR: typing.ClassVar[int] = ... + ST_TEXTARCHDOWNPOUR: typing.ClassVar[int] = ... + ST_TEXTCIRCLEPOUR: typing.ClassVar[int] = ... + ST_TEXTBUTTONPOUR: typing.ClassVar[int] = ... + ST_TEXTCURVEUP: typing.ClassVar[int] = ... + ST_TEXTCURVEDOWN: typing.ClassVar[int] = ... + ST_TEXTCASCADEUP: typing.ClassVar[int] = ... + ST_TEXTCASCADEDOWN: typing.ClassVar[int] = ... + ST_TEXTWAVE1: typing.ClassVar[int] = ... + ST_TEXTWAVE2: typing.ClassVar[int] = ... + ST_TEXTWAVE3: typing.ClassVar[int] = ... + ST_TEXTWAVE4: typing.ClassVar[int] = ... + ST_TEXTINFLATE: typing.ClassVar[int] = ... + ST_TEXTDEFLATE: typing.ClassVar[int] = ... + ST_TEXTINFLATEBOTTOM: typing.ClassVar[int] = ... + ST_TEXTDEFLATEBOTTOM: typing.ClassVar[int] = ... + ST_TEXTINFLATETOP: typing.ClassVar[int] = ... + ST_TEXTDEFLATETOP: typing.ClassVar[int] = ... + ST_TEXTDEFLATEINFLATE: typing.ClassVar[int] = ... + ST_TEXTDEFLATEINFLATEDEFLATE: typing.ClassVar[int] = ... + ST_TEXTFADERIGHT: typing.ClassVar[int] = ... + ST_TEXTFADELEFT: typing.ClassVar[int] = ... + ST_TEXTFADEUP: typing.ClassVar[int] = ... + ST_TEXTFADEDOWN: typing.ClassVar[int] = ... + ST_TEXTSLANTUP: typing.ClassVar[int] = ... + ST_TEXTSLANTDOWN: typing.ClassVar[int] = ... + ST_TEXTCANUP: typing.ClassVar[int] = ... + ST_TEXTCANDOWN: typing.ClassVar[int] = ... + ST_FLOWCHARTALTERNATEPROCESS: typing.ClassVar[int] = ... + ST_FLOWCHARTOFFPAGECONNECTOR: typing.ClassVar[int] = ... + ST_CALLOUT90: typing.ClassVar[int] = ... + ST_ACCENTCALLOUT90: typing.ClassVar[int] = ... + ST_BORDERCALLOUT90: typing.ClassVar[int] = ... + ST_ACCENTBORDERCALLOUT90: typing.ClassVar[int] = ... + ST_LEFTRIGHTUPARROW: typing.ClassVar[int] = ... + ST_SUN: typing.ClassVar[int] = ... + ST_MOON: typing.ClassVar[int] = ... + ST_BRACKETPAIR: typing.ClassVar[int] = ... + ST_BRACEPAIR: typing.ClassVar[int] = ... + ST_SEAL4: typing.ClassVar[int] = ... + ST_DOUBLEWAVE: typing.ClassVar[int] = ... + ST_ACTIONBUTTONBLANK: typing.ClassVar[int] = ... + ST_ACTIONBUTTONHOME: typing.ClassVar[int] = ... + ST_ACTIONBUTTONHELP: typing.ClassVar[int] = ... + ST_ACTIONBUTTONINFORMATION: typing.ClassVar[int] = ... + ST_ACTIONBUTTONFORWARDNEXT: typing.ClassVar[int] = ... + ST_ACTIONBUTTONBACKPREVIOUS: typing.ClassVar[int] = ... + ST_ACTIONBUTTONEND: typing.ClassVar[int] = ... + ST_ACTIONBUTTONBEGINNING: typing.ClassVar[int] = ... + ST_ACTIONBUTTONRETURN: typing.ClassVar[int] = ... + ST_ACTIONBUTTONDOCUMENT: typing.ClassVar[int] = ... + ST_ACTIONBUTTONSOUND: typing.ClassVar[int] = ... + ST_ACTIONBUTTONMOVIE: typing.ClassVar[int] = ... + ST_HOSTCONTROL: typing.ClassVar[int] = ... + ST_TEXTBOX: typing.ClassVar[int] = ... + ST_NIL: typing.ClassVar[int] = ... + def __init__(self, drawingManager2: loci.poi.hssf.model.DrawingManager2): ... + def assoicateShapeToObjRecord( + self, escherRecord: loci.poi.ddf.EscherRecord, record: Record + ) -> typing.Any: ... + def clear(self) -> None: ... + @staticmethod + def createAggregate( + list: java.util.List, + int: int, + drawingManager2: loci.poi.hssf.model.DrawingManager2, + ) -> EscherAggregate: ... + def getPatriarch(self) -> loci.poi.hssf.usermodel.HSSFPatriarch: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setPatriarch( + self, hSSFPatriarch: loci.poi.hssf.usermodel.HSSFPatriarch + ) -> None: ... + def toString(self) -> java.lang.String: ... + +class GroupMarkerSubRecord(SubRecord): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class HorizontalPageBreakRecord(PageBreakRecord): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + @typing.overload + def __init__(self, short: int): ... + def getSid(self) -> int: ... + +class NoteStructureSubRecord(SubRecord): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def toString(self) -> java.lang.String: ... + +class TextObjectRecord(TextObjectBaseRecord): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + def getRecordSize(self) -> int: ... + def getStr(self) -> loci.poi.hssf.usermodel.HSSFRichTextString: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setStr( + self, hSSFRichTextString: loci.poi.hssf.usermodel.HSSFRichTextString + ) -> None: ... + def toString(self) -> java.lang.String: ... + +class VerticalPageBreakRecord(PageBreakRecord): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: RecordInputStream): ... + @typing.overload + def __init__(self, short: int): ... + def getSid(self) -> int: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.record")``. + + AbstractEscherHolderRecord: type[AbstractEscherHolderRecord] + AreaFormatRecord: type[AreaFormatRecord] + AreaRecord: type[AreaRecord] + AxisLineFormatRecord: type[AxisLineFormatRecord] + AxisOptionsRecord: type[AxisOptionsRecord] + AxisParentRecord: type[AxisParentRecord] + AxisRecord: type[AxisRecord] + AxisUsedRecord: type[AxisUsedRecord] + BOFRecord: type[BOFRecord] + BackupRecord: type[BackupRecord] + BarRecord: type[BarRecord] + BeginRecord: type[BeginRecord] + BlankRecord: type[BlankRecord] + BookBoolRecord: type[BookBoolRecord] + BoolErrRecord: type[BoolErrRecord] + BottomMarginRecord: type[BottomMarginRecord] + BoundSheetRecord: type[BoundSheetRecord] + CalcCountRecord: type[CalcCountRecord] + CalcModeRecord: type[CalcModeRecord] + CategorySeriesAxisRecord: type[CategorySeriesAxisRecord] + CellValueRecordInterface: type[CellValueRecordInterface] + ChartFormatRecord: type[ChartFormatRecord] + ChartRecord: type[ChartRecord] + CodepageRecord: type[CodepageRecord] + ColumnInfoRecord: type[ColumnInfoRecord] + CommonObjectDataSubRecord: type[CommonObjectDataSubRecord] + ContinueRecord: type[ContinueRecord] + CountryRecord: type[CountryRecord] + CustomField: type[CustomField] + DBCellRecord: type[DBCellRecord] + DSFRecord: type[DSFRecord] + DatRecord: type[DatRecord] + DataFormatRecord: type[DataFormatRecord] + DateWindow1904Record: type[DateWindow1904Record] + DefaultColWidthRecord: type[DefaultColWidthRecord] + DefaultDataLabelTextPropertiesRecord: type[DefaultDataLabelTextPropertiesRecord] + DefaultRowHeightRecord: type[DefaultRowHeightRecord] + DeltaRecord: type[DeltaRecord] + DimensionsRecord: type[DimensionsRecord] + DrawingGroupRecord: type[DrawingGroupRecord] + DrawingRecord: type[DrawingRecord] + DrawingRecordForBiffViewer: type[DrawingRecordForBiffViewer] + DrawingSelectionRecord: type[DrawingSelectionRecord] + EOFRecord: type[EOFRecord] + EmbeddedObjectRefSubRecord: type[EmbeddedObjectRefSubRecord] + EndRecord: type[EndRecord] + EndSubRecord: type[EndSubRecord] + EscherAggregate: type[EscherAggregate] + ExtSSTInfoSubRecord: type[ExtSSTInfoSubRecord] + ExtSSTRecord: type[ExtSSTRecord] + ExtendedFormatRecord: type[ExtendedFormatRecord] + ExternSheetRecord: type[ExternSheetRecord] + ExternSheetSubRecord: type[ExternSheetSubRecord] + FilePassRecord: type[FilePassRecord] + FileSharingRecord: type[FileSharingRecord] + FnGroupCountRecord: type[FnGroupCountRecord] + FontBasisRecord: type[FontBasisRecord] + FontIndexRecord: type[FontIndexRecord] + FontRecord: type[FontRecord] + FooterRecord: type[FooterRecord] + FormatRecord: type[FormatRecord] + FormulaRecord: type[FormulaRecord] + FrameRecord: type[FrameRecord] + GridsetRecord: type[GridsetRecord] + GroupMarkerSubRecord: type[GroupMarkerSubRecord] + GutsRecord: type[GutsRecord] + HCenterRecord: type[HCenterRecord] + HeaderRecord: type[HeaderRecord] + HideObjRecord: type[HideObjRecord] + HorizontalPageBreakRecord: type[HorizontalPageBreakRecord] + IndexRecord: type[IndexRecord] + InterfaceEndRecord: type[InterfaceEndRecord] + InterfaceHdrRecord: type[InterfaceHdrRecord] + IterationRecord: type[IterationRecord] + LabelRecord: type[LabelRecord] + LabelSSTRecord: type[LabelSSTRecord] + LeftMarginRecord: type[LeftMarginRecord] + LegendRecord: type[LegendRecord] + LineFormatRecord: type[LineFormatRecord] + LinkedDataFormulaField: type[LinkedDataFormulaField] + LinkedDataRecord: type[LinkedDataRecord] + MMSRecord: type[MMSRecord] + Margin: type[Margin] + MergeCellsRecord: type[MergeCellsRecord] + MulBlankRecord: type[MulBlankRecord] + MulRKRecord: type[MulRKRecord] + NameRecord: type[NameRecord] + NoteRecord: type[NoteRecord] + NoteStructureSubRecord: type[NoteStructureSubRecord] + NumberFormatIndexRecord: type[NumberFormatIndexRecord] + NumberRecord: type[NumberRecord] + ObjRecord: type[ObjRecord] + ObjectLinkRecord: type[ObjectLinkRecord] + ObjectProtectRecord: type[ObjectProtectRecord] + PageBreakRecord: type[PageBreakRecord] + PaletteRecord: type[PaletteRecord] + PaneRecord: type[PaneRecord] + PasswordRecord: type[PasswordRecord] + PasswordRev4Record: type[PasswordRev4Record] + PlotAreaRecord: type[PlotAreaRecord] + PlotGrowthRecord: type[PlotGrowthRecord] + PrecisionRecord: type[PrecisionRecord] + PrintGridlinesRecord: type[PrintGridlinesRecord] + PrintHeadersRecord: type[PrintHeadersRecord] + PrintSetupRecord: type[PrintSetupRecord] + ProtectRecord: type[ProtectRecord] + ProtectionRev4Record: type[ProtectionRev4Record] + RKRecord: type[RKRecord] + RecalcIdRecord: type[RecalcIdRecord] + Record: type[Record] + RecordFactory: type[RecordFactory] + RecordFormatException: type[RecordFormatException] + RecordInputStream: type[RecordInputStream] + RefModeRecord: type[RefModeRecord] + RefreshAllRecord: type[RefreshAllRecord] + RightMarginRecord: type[RightMarginRecord] + RowRecord: type[RowRecord] + SCLRecord: type[SCLRecord] + SSTRecord: type[SSTRecord] + SaveRecalcRecord: type[SaveRecalcRecord] + ScenarioProtectRecord: type[ScenarioProtectRecord] + SelectionRecord: type[SelectionRecord] + SeriesChartGroupIndexRecord: type[SeriesChartGroupIndexRecord] + SeriesIndexRecord: type[SeriesIndexRecord] + SeriesLabelsRecord: type[SeriesLabelsRecord] + SeriesListRecord: type[SeriesListRecord] + SeriesRecord: type[SeriesRecord] + SeriesTextRecord: type[SeriesTextRecord] + SeriesToChartGroupRecord: type[SeriesToChartGroupRecord] + SharedFormulaRecord: type[SharedFormulaRecord] + SheetPropertiesRecord: type[SheetPropertiesRecord] + StringRecord: type[StringRecord] + StyleRecord: type[StyleRecord] + SubRecord: type[SubRecord] + SupBookRecord: type[SupBookRecord] + TabIdRecord: type[TabIdRecord] + TextObjectBaseRecord: type[TextObjectBaseRecord] + TextObjectRecord: type[TextObjectRecord] + TextRecord: type[TextRecord] + TickRecord: type[TickRecord] + TopMarginRecord: type[TopMarginRecord] + UnicodeString: type[UnicodeString] + UnitsRecord: type[UnitsRecord] + UnknownRecord: type[UnknownRecord] + UseSelFSRecord: type[UseSelFSRecord] + VCenterRecord: type[VCenterRecord] + ValueRangeRecord: type[ValueRangeRecord] + VerticalPageBreakRecord: type[VerticalPageBreakRecord] + WSBoolRecord: type[WSBoolRecord] + WindowOneRecord: type[WindowOneRecord] + WindowProtectRecord: type[WindowProtectRecord] + WindowTwoRecord: type[WindowTwoRecord] + WriteAccessRecord: type[WriteAccessRecord] + WriteProtectRecord: type[WriteProtectRecord] + aggregates: loci.poi.hssf.record.aggregates.__module_protocol__ + formula: loci.poi.hssf.record.formula.__module_protocol__ diff --git a/typings/loci/poi/hssf/record/aggregates/__init__.pyi b/typings/loci/poi/hssf/record/aggregates/__init__.pyi new file mode 100644 index 0000000..e45e0fe --- /dev/null +++ b/typings/loci/poi/hssf/record/aggregates/__init__.pyi @@ -0,0 +1,194 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype +import loci.poi.hssf.record + +class ColumnInfoRecordsAggregate(loci.poi.hssf.record.Record): + def __init__(self): ... + def clone(self) -> typing.Any: ... + def collapseColInfoRecords(self, int: int) -> None: ... + def collapseColumn(self, short: int) -> None: ... + @staticmethod + def createColInfo() -> loci.poi.hssf.record.Record: ... + def expandColumn(self, short: int) -> None: ... + def findColumnIdx(self, int: int, int2: int) -> int: ... + def findEndOfColumnOutlineGroup(self, int: int) -> int: ... + def findStartOfColumnOutlineGroup(self, int: int) -> int: ... + def getColInfo(self, int: int) -> loci.poi.hssf.record.ColumnInfoRecord: ... + def getIterator(self) -> java.util.Iterator: ... + def getNumColumns(self) -> int: ... + def getRecordSize(self) -> int: ... + def getSid(self) -> int: ... + def groupColumnRange(self, short: int, short2: int, boolean: bool) -> None: ... + @typing.overload + def insertColumn( + self, int: int, columnInfoRecord: loci.poi.hssf.record.ColumnInfoRecord + ) -> None: ... + @typing.overload + def insertColumn( + self, columnInfoRecord: loci.poi.hssf.record.ColumnInfoRecord + ) -> None: ... + def isColumnGroupCollapsed(self, int: int) -> bool: ... + def isColumnGroupHiddenByParent(self, int: int) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColumn( + self, + short: int, + short2: int, + short3: int, + integer: int, + boolean: bool, + boolean2: bool, + ) -> None: ... + def writeHidden( + self, + columnInfoRecord: loci.poi.hssf.record.ColumnInfoRecord, + int: int, + boolean: bool, + ) -> loci.poi.hssf.record.ColumnInfoRecord: ... + +class FormulaRecordAggregate( + loci.poi.hssf.record.Record, + loci.poi.hssf.record.CellValueRecordInterface, + java.lang.Comparable, +): + sid: typing.ClassVar[int] = ... + def __init__( + self, + formulaRecord: loci.poi.hssf.record.FormulaRecord, + stringRecord: loci.poi.hssf.record.StringRecord, + ): ... + def clone(self) -> typing.Any: ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getColumn(self) -> int: ... + def getFormulaRecord(self) -> loci.poi.hssf.record.FormulaRecord: ... + def getRecordSize(self) -> int: ... + def getRow(self) -> int: ... + def getSid(self) -> int: ... + def getStringRecord(self) -> loci.poi.hssf.record.StringRecord: ... + def getStringValue(self) -> java.lang.String: ... + def getXFIndex(self) -> int: ... + def isAfter( + self, cellValueRecordInterface: loci.poi.hssf.record.CellValueRecordInterface + ) -> bool: ... + def isBefore( + self, cellValueRecordInterface: loci.poi.hssf.record.CellValueRecordInterface + ) -> bool: ... + def isEqual( + self, cellValueRecordInterface: loci.poi.hssf.record.CellValueRecordInterface + ) -> bool: ... + def isInValueSection(self) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def setColumn(self, short: int) -> None: ... + def setFormulaRecord( + self, formulaRecord: loci.poi.hssf.record.FormulaRecord + ) -> None: ... + def setRow(self, int: int) -> None: ... + def setStringRecord( + self, stringRecord: loci.poi.hssf.record.StringRecord + ) -> None: ... + def setXFIndex(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class RowRecordsAggregate(loci.poi.hssf.record.Record): + def __init__(self): ... + def clone(self) -> typing.Any: ... + def collapseRow(self, int: int) -> None: ... + @staticmethod + def createRow(int: int) -> loci.poi.hssf.record.RowRecord: ... + def expandRow(self, int: int) -> None: ... + def findEndOfRowOutlineGroup(self, int: int) -> int: ... + def findStartOfRowOutlineGroup(self, int: int) -> int: ... + def getEndRowNumberForBlock(self, int: int) -> int: ... + def getFirstRowNum(self) -> int: ... + def getIterator(self) -> java.util.Iterator: ... + def getLastRowNum(self) -> int: ... + def getPhysicalNumberOfRows(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRow(self, int: int) -> loci.poi.hssf.record.RowRecord: ... + def getRowBlockCount(self) -> int: ... + def getRowBlockSize(self, int: int) -> int: ... + def getRowCountForBlock(self, int: int) -> int: ... + def getSid(self) -> int: ... + def getStartRowNumberForBlock(self, int: int) -> int: ... + def insertRow(self, rowRecord: loci.poi.hssf.record.RowRecord) -> None: ... + def isRowGroupCollapsed(self, int: int) -> bool: ... + def isRowGroupHiddenByParent(self, int: int) -> bool: ... + def removeRow(self, rowRecord: loci.poi.hssf.record.RowRecord) -> None: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + @typing.overload + def serialize( + self, + int: int, + byteArray: list[int] | jpype.JArray | bytes, + valueRecordsAggregate: ValueRecordsAggregate, + ) -> int: ... + def writeHidden( + self, rowRecord: loci.poi.hssf.record.RowRecord, int: int, boolean: bool + ) -> int: ... + +class ValueRecordsAggregate(loci.poi.hssf.record.Record): + sid: typing.ClassVar[int] = ... + def __init__(self): ... + def clone(self) -> typing.Any: ... + def construct(self, int: int, list: java.util.List) -> int: ... + def getFirstCellNum(self) -> int: ... + def getIterator(self) -> java.util.Iterator: ... + def getLastCellNum(self) -> int: ... + def getPhysicalNumberOfCells(self) -> int: ... + def getRecordSize(self) -> int: ... + def getRowCellBlockSize(self, int: int, int2: int) -> int: ... + def getSid(self) -> int: ... + def insertCell( + self, cellValueRecordInterface: loci.poi.hssf.record.CellValueRecordInterface + ) -> None: ... + def removeCell( + self, cellValueRecordInterface: loci.poi.hssf.record.CellValueRecordInterface + ) -> None: ... + def rowHasCells(self, int: int) -> bool: ... + @typing.overload + def serialize(self) -> typing.MutableSequence[int]: ... + @typing.overload + def serialize( + self, int: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + def serializeCellRow( + self, int: int, int2: int, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + class MyIterator(java.util.Iterator): + @typing.overload + def __init__(self, valueRecordsAggregate: ValueRecordsAggregate): ... + @typing.overload + def __init__( + self, valueRecordsAggregate: ValueRecordsAggregate, int: int, int2: int + ): ... + def hasNext(self) -> bool: ... + def next(self) -> typing.Any: ... + def remove(self) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.record.aggregates")``. + + ColumnInfoRecordsAggregate: type[ColumnInfoRecordsAggregate] + FormulaRecordAggregate: type[FormulaRecordAggregate] + RowRecordsAggregate: type[RowRecordsAggregate] + ValueRecordsAggregate: type[ValueRecordsAggregate] diff --git a/typings/loci/poi/hssf/record/formula/__init__.pyi b/typings/loci/poi/hssf/record/formula/__init__.pyi new file mode 100644 index 0000000..f56960e --- /dev/null +++ b/typings/loci/poi/hssf/record/formula/__init__.pyi @@ -0,0 +1,1246 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype +import loci.poi.hssf.model +import loci.poi.hssf.record + +class Ptg: + CLASS_REF: typing.ClassVar[int] = ... + CLASS_VALUE: typing.ClassVar[int] = ... + CLASS_ARRAY: typing.ClassVar[int] = ... + def __init__(self): ... + def clone(self) -> typing.Any: ... + @staticmethod + def createParsedExpressionTokens( + short: int, recordInputStream: loci.poi.hssf.record.RecordInputStream + ) -> java.util.Stack: ... + @staticmethod + def createPtg(recordInputStream: loci.poi.hssf.record.RecordInputStream) -> Ptg: ... + def getBytes(self) -> typing.MutableSequence[int]: ... + def getDefaultOperandClass(self) -> int: ... + def getPtgClass(self) -> int: ... + def getSize(self) -> int: ... + @staticmethod + def serializePtgStack( + stack: java.util.Stack, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + def setClass(self, byte: int) -> None: ... + def toDebugString(self) -> java.lang.String: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class Area3DPtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str, short: int): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def equals(self, object: typing.Any) -> bool: ... + def getDefaultOperandClass(self) -> int: ... + def getExternSheetIndex(self) -> int: ... + def getFirstColumn(self) -> int: ... + def getFirstColumnRaw(self) -> int: ... + def getFirstRow(self) -> int: ... + def getLastColumn(self) -> int: ... + def getLastColumnRaw(self) -> int: ... + def getLastRow(self) -> int: ... + def getSize(self) -> int: ... + def hashCode(self) -> int: ... + def isFirstColRelative(self) -> bool: ... + def isFirstRowRelative(self) -> bool: ... + def isLastColRelative(self) -> bool: ... + def isLastRowRelative(self) -> bool: ... + def setArea(self, string: java.lang.String | str) -> None: ... + def setExternSheetIndex(self, short: int) -> None: ... + def setFirstColRelative(self, boolean: bool) -> None: ... + def setFirstColumn(self, short: int) -> None: ... + def setFirstColumnRaw(self, short: int) -> None: ... + def setFirstRow(self, short: int) -> None: ... + def setFirstRowRelative(self, boolean: bool) -> None: ... + def setLastColRelative(self, boolean: bool) -> None: ... + def setLastColumn(self, short: int) -> None: ... + def setLastColumnRaw(self, short: int) -> None: ... + def setLastRow(self, short: int) -> None: ... + def setLastRowRelative(self, boolean: bool) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class AreaPtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + @typing.overload + def __init__( + self, + short: int, + short2: int, + short3: int, + short4: int, + boolean: bool, + boolean2: bool, + boolean3: bool, + boolean4: bool, + ): ... + def clone(self) -> typing.Any: ... + def getAreaPtgName(self) -> java.lang.String: ... + def getDefaultOperandClass(self) -> int: ... + def getFirstColumn(self) -> int: ... + def getFirstColumnRaw(self) -> int: ... + def getFirstRow(self) -> int: ... + def getLastColumn(self) -> int: ... + def getLastColumnRaw(self) -> int: ... + def getLastRow(self) -> int: ... + def getSize(self) -> int: ... + def isFirstColRelative(self) -> bool: ... + def isFirstRowRelative(self) -> bool: ... + def isLastColRelative(self) -> bool: ... + def isLastRowRelative(self) -> bool: ... + def setFirstColRelative(self, boolean: bool) -> None: ... + def setFirstColumn(self, short: int) -> None: ... + def setFirstColumnRaw(self, short: int) -> None: ... + def setFirstRow(self, short: int) -> None: ... + def setFirstRowRelative(self, boolean: bool) -> None: ... + def setLastColRelative(self, boolean: bool) -> None: ... + def setLastColumn(self, short: int) -> None: ... + def setLastColumnRaw(self, short: int) -> None: ... + def setLastRow(self, short: int) -> None: ... + def setLastRowRelative(self, boolean: bool) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class ArrayPtg(Ptg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getColumnCount(self) -> int: ... + def getDefaultOperandClass(self) -> int: ... + def getRowCount(self) -> int: ... + def getSize(self) -> int: ... + def readTokenValues( + self, recordInputStream: loci.poi.hssf.record.RecordInputStream + ) -> None: ... + def setColumnCount(self, short: int) -> None: ... + def setRowCount(self, short: int) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + def writeTokenValueBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + +class BoolPtg(Ptg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getSize(self) -> int: ... + def getValue(self) -> bool: ... + def setValue(self, boolean: bool) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class ControlPtg(Ptg): + def __init__(self): ... + +class ErrPtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getSize(self) -> int: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class ExpPtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getColumn(self) -> int: ... + def getDefaultOperandClass(self) -> int: ... + def getRow(self) -> int: ... + def getSize(self) -> int: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class IntPtg(Ptg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getSize(self) -> int: ... + def getValue(self) -> int: ... + def setValue(self, short: int) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class MemAreaPtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getReserved(self) -> int: ... + def getSize(self) -> int: ... + def getSubexpressionLength(self) -> int: ... + def setReserved(self, int: int) -> None: ... + def setSubexpressionLength(self, short: int) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class MissingArgPtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getSize(self) -> int: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class NamePtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__( + self, string: java.lang.String | str, workbook: loci.poi.hssf.model.Workbook + ): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getSize(self) -> int: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class NameXPtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getSize(self) -> int: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class NumberPtg(Ptg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getSize(self) -> int: ... + def getValue(self) -> float: ... + def setValue(self, double: float) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class OperationPtg(Ptg): + TYPE_UNARY: typing.ClassVar[int] = ... + TYPE_BINARY: typing.ClassVar[int] = ... + TYPE_FUNCTION: typing.ClassVar[int] = ... + def __init__(self): ... + def getDefaultOperandClass(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + +class Ref3DPtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str, short: int): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getColumn(self) -> int: ... + def getColumnRaw(self) -> int: ... + def getDefaultOperandClass(self) -> int: ... + def getExternSheetIndex(self) -> int: ... + def getRow(self) -> int: ... + def getSize(self) -> int: ... + def isColRelative(self) -> bool: ... + def isRowRelative(self) -> bool: ... + def setArea(self, string: java.lang.String | str) -> None: ... + def setColRelative(self, boolean: bool) -> None: ... + def setColumn(self, short: int) -> None: ... + def setColumnRaw(self, short: int) -> None: ... + def setExternSheetIndex(self, short: int) -> None: ... + def setRow(self, short: int) -> None: ... + def setRowRelative(self, boolean: bool) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class RefErrorPtg(Ptg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getReserved(self) -> int: ... + def getSize(self) -> int: ... + def setReserved(self, int: int) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class ReferencePtg(Ptg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + @typing.overload + def __init__(self, short: int, short2: int, boolean: bool, boolean2: bool): ... + def clone(self) -> typing.Any: ... + def getColumn(self) -> int: ... + def getColumnRaw(self) -> int: ... + def getDefaultOperandClass(self) -> int: ... + def getRefPtgName(self) -> java.lang.String: ... + def getRow(self) -> int: ... + def getRowAsInt(self) -> int: ... + def getSize(self) -> int: ... + def isColRelative(self) -> bool: ... + def isRowRelative(self) -> bool: ... + def setColRelative(self, boolean: bool) -> None: ... + def setColumn(self, short: int) -> None: ... + def setColumnRaw(self, short: int) -> None: ... + @typing.overload + def setRow(self, int: int) -> None: ... + @typing.overload + def setRow(self, short: int) -> None: ... + def setRowRelative(self, boolean: bool) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class StringPtg(Ptg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getSize(self) -> int: ... + def getValue(self) -> java.lang.String: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class UnknownPtg(Ptg): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getSize(self) -> int: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class AbstractFunctionPtg(OperationPtg): + ATTR_NAME: typing.ClassVar[java.lang.String] = ... + INDEX_EXTERNAL: typing.ClassVar[int] = ... + def __init__(self): ... + def getDefaultOperandClass(self) -> int: ... + def getFunctionIndex(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getParameterClass(self, int: int) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class AddPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class AreaAPtg(AreaPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + @typing.overload + def __init__( + self, + short: int, + short2: int, + short3: int, + short4: int, + boolean: bool, + boolean2: bool, + boolean3: bool, + boolean4: bool, + ): ... + def clone(self) -> typing.Any: ... + def getAreaPtgName(self) -> java.lang.String: ... + +class AreaErrPtg(AreaPtg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class AreaNAPtg(AreaPtg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getAreaPtgName(self) -> java.lang.String: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class AreaNPtg(AreaPtg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getAreaPtgName(self) -> java.lang.String: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class AreaNVPtg(AreaPtg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getAreaPtgName(self) -> java.lang.String: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class AreaVPtg(AreaPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + @typing.overload + def __init__( + self, + short: int, + short2: int, + short3: int, + short4: int, + boolean: bool, + boolean2: bool, + boolean3: bool, + boolean4: bool, + ): ... + def clone(self) -> typing.Any: ... + def getAreaPtgName(self) -> java.lang.String: ... + +class ArrayPtgA(ArrayPtg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + +class ArrayPtgV(ArrayPtg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + +class AttrPtg(OperationPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getData(self) -> int: ... + def getDefaultOperandClass(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getOptions(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + def isBaxcel(self) -> bool: ... + def isGoto(self) -> bool: ... + def isOptimizedChoose(self) -> bool: ... + def isOptimizedIf(self) -> bool: ... + def isSemiVolatile(self) -> bool: ... + def isSpace(self) -> bool: ... + def isSum(self) -> bool: ... + def setData(self, short: int) -> None: ... + def setGoto(self, boolean: bool) -> None: ... + def setOptimizedIf(self, boolean: bool) -> None: ... + def setOptions(self, byte: int) -> None: ... + def setSum(self, boolean: bool) -> None: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class ConcatPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class DeletedArea3DPtg(Area3DPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str, short: int): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + +class DeletedRef3DPtg(Ref3DPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str, short: int): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + +class DividePtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class EqualPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class GreaterEqualPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class GreaterThanPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class IntersectionPtg(OperationPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class LessEqualPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class LessThanPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class MemErrPtg(MemAreaPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class MemFuncPtg(ControlPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getLenRefSubexpression(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def setLenRefSubexpression(self, int: int) -> None: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class MultiplyPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getStringLength(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, ptgArray: list[Ptg] | jpype.JArray + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class NotEqualPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class ParenthesisPtg(OperationPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class PercentPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class PowerPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class RangePtg(OperationPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class RefAPtg(ReferencePtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + @typing.overload + def __init__(self, short: int, short2: int, boolean: bool, boolean2: bool): ... + def clone(self) -> typing.Any: ... + def getRefPtgName(self) -> java.lang.String: ... + +class RefNAPtg(ReferencePtg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRefPtgName(self) -> java.lang.String: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class RefNPtg(ReferencePtg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRefPtgName(self) -> java.lang.String: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class RefNVPtg(ReferencePtg): + sid: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getRefPtgName(self) -> java.lang.String: ... + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class RefVPtg(ReferencePtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + @typing.overload + def __init__(self, short: int, short2: int, boolean: bool, boolean2: bool): ... + def clone(self) -> typing.Any: ... + def getRefPtgName(self) -> java.lang.String: ... + +class SubtractPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class UnaryMinusPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class UnaryPlusPtg(OperationPtg): + SIZE: typing.ClassVar[int] = ... + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getDefaultOperandClass(self) -> int: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class UnionPtg(OperationPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def getType(self) -> int: ... + @typing.overload + def toFormulaString( + self, stringArray: list[java.lang.String] | jpype.JArray + ) -> java.lang.String: ... + @typing.overload + def toFormulaString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class FuncPtg(AbstractFunctionPtg): + sid: typing.ClassVar[int] = ... + SIZE: typing.ClassVar[int] = ... + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class FuncVarPtg(AbstractFunctionPtg): + sid: typing.ClassVar[int] = ... + @typing.overload + def __init__(self, string: java.lang.String | str, byte: int): ... + @typing.overload + def __init__(self, recordInputStream: loci.poi.hssf.record.RecordInputStream): ... + def clone(self) -> typing.Any: ... + def getNumberOfOperands(self) -> int: ... + def getSize(self) -> int: ... + def toString(self) -> java.lang.String: ... + def writeBytes( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.record.formula")``. + + AbstractFunctionPtg: type[AbstractFunctionPtg] + AddPtg: type[AddPtg] + Area3DPtg: type[Area3DPtg] + AreaAPtg: type[AreaAPtg] + AreaErrPtg: type[AreaErrPtg] + AreaNAPtg: type[AreaNAPtg] + AreaNPtg: type[AreaNPtg] + AreaNVPtg: type[AreaNVPtg] + AreaPtg: type[AreaPtg] + AreaVPtg: type[AreaVPtg] + ArrayPtg: type[ArrayPtg] + ArrayPtgA: type[ArrayPtgA] + ArrayPtgV: type[ArrayPtgV] + AttrPtg: type[AttrPtg] + BoolPtg: type[BoolPtg] + ConcatPtg: type[ConcatPtg] + ControlPtg: type[ControlPtg] + DeletedArea3DPtg: type[DeletedArea3DPtg] + DeletedRef3DPtg: type[DeletedRef3DPtg] + DividePtg: type[DividePtg] + EqualPtg: type[EqualPtg] + ErrPtg: type[ErrPtg] + ExpPtg: type[ExpPtg] + FuncPtg: type[FuncPtg] + FuncVarPtg: type[FuncVarPtg] + GreaterEqualPtg: type[GreaterEqualPtg] + GreaterThanPtg: type[GreaterThanPtg] + IntPtg: type[IntPtg] + IntersectionPtg: type[IntersectionPtg] + LessEqualPtg: type[LessEqualPtg] + LessThanPtg: type[LessThanPtg] + MemAreaPtg: type[MemAreaPtg] + MemErrPtg: type[MemErrPtg] + MemFuncPtg: type[MemFuncPtg] + MissingArgPtg: type[MissingArgPtg] + MultiplyPtg: type[MultiplyPtg] + NamePtg: type[NamePtg] + NameXPtg: type[NameXPtg] + NotEqualPtg: type[NotEqualPtg] + NumberPtg: type[NumberPtg] + OperationPtg: type[OperationPtg] + ParenthesisPtg: type[ParenthesisPtg] + PercentPtg: type[PercentPtg] + PowerPtg: type[PowerPtg] + Ptg: type[Ptg] + RangePtg: type[RangePtg] + Ref3DPtg: type[Ref3DPtg] + RefAPtg: type[RefAPtg] + RefErrorPtg: type[RefErrorPtg] + RefNAPtg: type[RefNAPtg] + RefNPtg: type[RefNPtg] + RefNVPtg: type[RefNVPtg] + RefVPtg: type[RefVPtg] + ReferencePtg: type[ReferencePtg] + StringPtg: type[StringPtg] + SubtractPtg: type[SubtractPtg] + UnaryMinusPtg: type[UnaryMinusPtg] + UnaryPlusPtg: type[UnaryPlusPtg] + UnionPtg: type[UnionPtg] + UnknownPtg: type[UnknownPtg] diff --git a/typings/loci/poi/hssf/usermodel/__init__.pyi b/typings/loci/poi/hssf/usermodel/__init__.pyi new file mode 100644 index 0000000..ef4b84c --- /dev/null +++ b/typings/loci/poi/hssf/usermodel/__init__.pyi @@ -0,0 +1,1572 @@ +import typing +from typing import Protocol + +import java.awt +import java.awt.font +import java.awt.geom +import java.awt.image +import java.awt.image.renderable +import java.io +import java.lang +import java.text +import java.util +import jpype +import loci.common +import loci.poi +import loci.poi.hssf.model +import loci.poi.hssf.record +import loci.poi.hssf.util +import loci.poi.poifs.filesystem + +class DummyGraphics2d(java.awt.Graphics2D): + def __init__(self): ... + def addRenderingHints(self, map: java.util.Map | typing.Mapping) -> None: ... + def clearRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def clip(self, shape: java.awt.Shape) -> None: ... + def clipRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def copyArea( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def create(self) -> java.awt.Graphics: ... + @typing.overload + def create( + self, int: int, int2: int, int3: int, int4: int + ) -> java.awt.Graphics: ... + def dispose(self) -> None: ... + def draw(self, shape: java.awt.Shape) -> None: ... + def draw3DRect( + self, int: int, int2: int, int3: int, int4: int, boolean: bool + ) -> None: ... + def drawArc( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def drawBytes( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + int4: int, + ) -> None: ... + def drawChars( + self, + charArray: list[str] | jpype.JArray, + int: int, + int2: int, + int3: int, + int4: int, + ) -> None: ... + def drawGlyphVector( + self, glyphVector: java.awt.font.GlyphVector, float: float, float2: float + ) -> None: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + color: java.awt.Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + color: java.awt.Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + color: java.awt.Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + affineTransform: java.awt.geom.AffineTransform, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + bufferedImage: java.awt.image.BufferedImage, + bufferedImageOp: java.awt.image.BufferedImageOp, + int: int, + int2: int, + ) -> None: ... + def drawLine(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def drawOval(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def drawPolygon( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + @typing.overload + def drawPolygon(self, polygon: java.awt.Polygon) -> None: ... + def drawPolyline( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + def drawRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def drawRenderableImage( + self, + renderableImage: java.awt.image.renderable.RenderableImage, + affineTransform: java.awt.geom.AffineTransform, + ) -> None: ... + def drawRenderedImage( + self, + renderedImage: java.awt.image.RenderedImage, + affineTransform: java.awt.geom.AffineTransform, + ) -> None: ... + def drawRoundRect( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def drawString( + self, string: java.lang.String | str, float: float, float2: float + ) -> None: ... + @typing.overload + def drawString( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + @typing.overload + def drawString( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + float: float, + float2: float, + ) -> None: ... + @typing.overload + def drawString( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int: int, + int2: int, + ) -> None: ... + def fill(self, shape: java.awt.Shape) -> None: ... + def fill3DRect( + self, int: int, int2: int, int3: int, int4: int, boolean: bool + ) -> None: ... + def fillArc( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def fillOval(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def fillPolygon( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + @typing.overload + def fillPolygon(self, polygon: java.awt.Polygon) -> None: ... + def fillRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def fillRoundRect( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def finalize(self) -> None: ... + def getBackground(self) -> java.awt.Color: ... + def getClip(self) -> java.awt.Shape: ... + @typing.overload + def getClipBounds(self) -> java.awt.Rectangle: ... + @typing.overload + def getClipBounds(self, rectangle: java.awt.Rectangle) -> java.awt.Rectangle: ... + def getClipRect(self) -> java.awt.Rectangle: ... + def getColor(self) -> java.awt.Color: ... + def getComposite(self) -> java.awt.Composite: ... + def getDeviceConfiguration(self) -> java.awt.GraphicsConfiguration: ... + def getFont(self) -> java.awt.Font: ... + @typing.overload + def getFontMetrics(self) -> java.awt.FontMetrics: ... + @typing.overload + def getFontMetrics(self, font: java.awt.Font) -> java.awt.FontMetrics: ... + def getFontRenderContext(self) -> java.awt.font.FontRenderContext: ... + def getPaint(self) -> java.awt.Paint: ... + def getRenderingHint(self, key: java.awt.RenderingHints.Key) -> typing.Any: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + def getStroke(self) -> java.awt.Stroke: ... + def getTransform(self) -> java.awt.geom.AffineTransform: ... + def hit( + self, rectangle: java.awt.Rectangle, shape: java.awt.Shape, boolean: bool + ) -> bool: ... + def hitClip(self, int: int, int2: int, int3: int, int4: int) -> bool: ... + @typing.overload + def rotate(self, double: float) -> None: ... + @typing.overload + def rotate(self, double: float, double2: float, double3: float) -> None: ... + def scale(self, double: float, double2: float) -> None: ... + def setBackground(self, color: java.awt.Color) -> None: ... + @typing.overload + def setClip(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setClip(self, shape: java.awt.Shape) -> None: ... + def setColor(self, color: java.awt.Color) -> None: ... + def setComposite(self, composite: java.awt.Composite | typing.Callable) -> None: ... + def setFont(self, font: java.awt.Font) -> None: ... + def setPaint(self, paint: java.awt.Paint) -> None: ... + def setPaintMode(self) -> None: ... + def setRenderingHint( + self, key: java.awt.RenderingHints.Key, object: typing.Any + ) -> None: ... + def setRenderingHints(self, map: java.util.Map | typing.Mapping) -> None: ... + def setStroke(self, stroke: java.awt.Stroke | typing.Callable) -> None: ... + def setTransform(self, affineTransform: java.awt.geom.AffineTransform) -> None: ... + def setXORMode(self, color: java.awt.Color) -> None: ... + def shear(self, double: float, double2: float) -> None: ... + def toString(self) -> java.lang.String: ... + def transform(self, affineTransform: java.awt.geom.AffineTransform) -> None: ... + @typing.overload + def translate(self, double: float, double2: float) -> None: ... + @typing.overload + def translate(self, int: int, int2: int) -> None: ... + +class EscherGraphics(java.awt.Graphics): + def __init__( + self, + hSSFShapeGroup: HSSFShapeGroup, + hSSFWorkbook: HSSFWorkbook, + color: java.awt.Color, + float: float, + ): ... + def clearRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def clipRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def copyArea( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def create( + self, int: int, int2: int, int3: int, int4: int + ) -> java.awt.Graphics: ... + @typing.overload + def create(self) -> java.awt.Graphics: ... + def dispose(self) -> None: ... + def drawArc( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + color: java.awt.Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + color: java.awt.Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + color: java.awt.Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawLine(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def drawLine( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + def drawOval(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def drawPolygon(self, polygon: java.awt.Polygon) -> None: ... + @typing.overload + def drawPolygon( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + def drawPolyline( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + def drawRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def drawRoundRect( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def drawString( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + @typing.overload + def drawString( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int: int, + int2: int, + ) -> None: ... + def fillArc( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def fillOval(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def fillPolygon(self, polygon: java.awt.Polygon) -> None: ... + @typing.overload + def fillPolygon( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + def fillRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def fillRoundRect( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def getBackground(self) -> java.awt.Color: ... + def getClip(self) -> java.awt.Shape: ... + @typing.overload + def getClipBounds(self, rectangle: java.awt.Rectangle) -> java.awt.Rectangle: ... + @typing.overload + def getClipBounds(self) -> java.awt.Rectangle: ... + def getClipRect(self) -> java.awt.Rectangle: ... + def getColor(self) -> java.awt.Color: ... + def getFont(self) -> java.awt.Font: ... + @typing.overload + def getFontMetrics(self) -> java.awt.FontMetrics: ... + @typing.overload + def getFontMetrics(self, font: java.awt.Font) -> java.awt.FontMetrics: ... + def setBackground(self, color: java.awt.Color) -> None: ... + @typing.overload + def setClip(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setClip(self, shape: java.awt.Shape) -> None: ... + def setColor(self, color: java.awt.Color) -> None: ... + def setFont(self, font: java.awt.Font) -> None: ... + def setPaintMode(self) -> None: ... + def setXORMode(self, color: java.awt.Color) -> None: ... + def translate(self, int: int, int2: int) -> None: ... + +class EscherGraphics2d(java.awt.Graphics2D): + def __init__(self, escherGraphics: EscherGraphics): ... + def addRenderingHints(self, map: java.util.Map | typing.Mapping) -> None: ... + def clearRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def clip(self, shape: java.awt.Shape) -> None: ... + def clipRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def copyArea( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def create( + self, int: int, int2: int, int3: int, int4: int + ) -> java.awt.Graphics: ... + @typing.overload + def create(self) -> java.awt.Graphics: ... + def dispose(self) -> None: ... + def draw(self, shape: java.awt.Shape) -> None: ... + def drawArc( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def drawGlyphVector( + self, glyphVector: java.awt.font.GlyphVector, float: float, float2: float + ) -> None: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + color: java.awt.Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + color: java.awt.Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + int3: int, + int4: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + color: java.awt.Color, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + int: int, + int2: int, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + image: java.awt.Image, + affineTransform: java.awt.geom.AffineTransform, + imageObserver: java.awt.image.ImageObserver | typing.Callable, + ) -> bool: ... + @typing.overload + def drawImage( + self, + bufferedImage: java.awt.image.BufferedImage, + bufferedImageOp: java.awt.image.BufferedImageOp, + int: int, + int2: int, + ) -> None: ... + @typing.overload + def drawLine(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def drawLine( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + def drawOval(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def drawPolygon(self, polygon: java.awt.Polygon) -> None: ... + @typing.overload + def drawPolygon( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + def drawPolyline( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + def drawRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def drawRenderableImage( + self, + renderableImage: java.awt.image.renderable.RenderableImage, + affineTransform: java.awt.geom.AffineTransform, + ) -> None: ... + def drawRenderedImage( + self, + renderedImage: java.awt.image.RenderedImage, + affineTransform: java.awt.geom.AffineTransform, + ) -> None: ... + def drawRoundRect( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + @typing.overload + def drawString( + self, string: java.lang.String | str, float: float, float2: float + ) -> None: ... + @typing.overload + def drawString( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + @typing.overload + def drawString( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + float: float, + float2: float, + ) -> None: ... + @typing.overload + def drawString( + self, + attributedCharacterIterator: java.text.AttributedCharacterIterator, + int: int, + int2: int, + ) -> None: ... + def fill(self, shape: java.awt.Shape) -> None: ... + def fillArc( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def fillOval(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def fillPolygon(self, polygon: java.awt.Polygon) -> None: ... + @typing.overload + def fillPolygon( + self, + intArray: list[int] | jpype.JArray, + intArray2: list[int] | jpype.JArray, + int3: int, + ) -> None: ... + def fillRect(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def fillRoundRect( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> None: ... + def getBackground(self) -> java.awt.Color: ... + def getClip(self) -> java.awt.Shape: ... + @typing.overload + def getClipBounds(self, rectangle: java.awt.Rectangle) -> java.awt.Rectangle: ... + @typing.overload + def getClipBounds(self) -> java.awt.Rectangle: ... + def getColor(self) -> java.awt.Color: ... + def getComposite(self) -> java.awt.Composite: ... + def getDeviceConfiguration(self) -> java.awt.GraphicsConfiguration: ... + def getFont(self) -> java.awt.Font: ... + @typing.overload + def getFontMetrics(self) -> java.awt.FontMetrics: ... + @typing.overload + def getFontMetrics(self, font: java.awt.Font) -> java.awt.FontMetrics: ... + def getFontRenderContext(self) -> java.awt.font.FontRenderContext: ... + def getPaint(self) -> java.awt.Paint: ... + def getRenderingHint(self, key: java.awt.RenderingHints.Key) -> typing.Any: ... + def getRenderingHints(self) -> java.awt.RenderingHints: ... + def getStroke(self) -> java.awt.Stroke: ... + def getTransform(self) -> java.awt.geom.AffineTransform: ... + def hit( + self, rectangle: java.awt.Rectangle, shape: java.awt.Shape, boolean: bool + ) -> bool: ... + @typing.overload + def rotate(self, double: float) -> None: ... + @typing.overload + def rotate(self, double: float, double2: float, double3: float) -> None: ... + def scale(self, double: float, double2: float) -> None: ... + def setBackground(self, color: java.awt.Color) -> None: ... + @typing.overload + def setClip(self, int: int, int2: int, int3: int, int4: int) -> None: ... + @typing.overload + def setClip(self, shape: java.awt.Shape) -> None: ... + def setColor(self, color: java.awt.Color) -> None: ... + def setComposite(self, composite: java.awt.Composite | typing.Callable) -> None: ... + def setFont(self, font: java.awt.Font) -> None: ... + def setPaint(self, paint: java.awt.Paint) -> None: ... + def setPaintMode(self) -> None: ... + def setRenderingHint( + self, key: java.awt.RenderingHints.Key, object: typing.Any + ) -> None: ... + def setRenderingHints(self, map: java.util.Map | typing.Mapping) -> None: ... + def setStroke(self, stroke: java.awt.Stroke | typing.Callable) -> None: ... + def setTransform(self, affineTransform: java.awt.geom.AffineTransform) -> None: ... + def setXORMode(self, color: java.awt.Color) -> None: ... + def shear(self, double: float, double2: float) -> None: ... + def transform(self, affineTransform: java.awt.geom.AffineTransform) -> None: ... + @typing.overload + def translate(self, double: float, double2: float) -> None: ... + @typing.overload + def translate(self, int: int, int2: int) -> None: ... + +class FontDetails: + def __init__(self, string: java.lang.String | str, int: int): ... + def addChar(self, char: str, int: int) -> None: ... + def addChars( + self, charArray: list[str] | jpype.JArray, intArray: list[int] | jpype.JArray + ) -> None: ... + @staticmethod + def create( + string: java.lang.String | str, properties: java.util.Properties + ) -> FontDetails: ... + def getCharWidth(self, char: str) -> int: ... + def getFontName(self) -> java.lang.String: ... + def getHeight(self) -> int: ... + def getStringWidth(self, string: java.lang.String | str) -> int: ... + +class HSSFAnchor: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + def getDx1(self) -> int: ... + def getDx2(self) -> int: ... + def getDy1(self) -> int: ... + def getDy2(self) -> int: ... + def isHorizontallyFlipped(self) -> bool: ... + def isVerticallyFlipped(self) -> bool: ... + def setDx1(self, int: int) -> None: ... + def setDx2(self, int: int) -> None: ... + def setDy1(self, int: int) -> None: ... + def setDy2(self, int: int) -> None: ... + +class HSSFCell: + CELL_TYPE_NUMERIC: typing.ClassVar[int] = ... + CELL_TYPE_STRING: typing.ClassVar[int] = ... + CELL_TYPE_FORMULA: typing.ClassVar[int] = ... + CELL_TYPE_BLANK: typing.ClassVar[int] = ... + CELL_TYPE_BOOLEAN: typing.ClassVar[int] = ... + CELL_TYPE_ERROR: typing.ClassVar[int] = ... + ENCODING_UNCHANGED: typing.ClassVar[int] = ... + ENCODING_COMPRESSED_UNICODE: typing.ClassVar[int] = ... + ENCODING_UTF_16: typing.ClassVar[int] = ... + def getBooleanCellValue(self) -> bool: ... + def getCellComment(self) -> HSSFComment: ... + def getCellFormula(self) -> java.lang.String: ... + def getCellNum(self) -> int: ... + def getCellStyle(self) -> HSSFCellStyle: ... + def getCellType(self) -> int: ... + def getDateCellValue(self) -> java.util.Date: ... + def getEncoding(self) -> int: ... + def getErrorCellValue(self) -> int: ... + def getNumericCellValue(self) -> float: ... + def getRichStringCellValue(self) -> HSSFRichTextString: ... + def getStringCellValue(self) -> java.lang.String: ... + def setAsActiveCell(self) -> None: ... + def setCellComment(self, hSSFComment: HSSFComment) -> None: ... + def setCellErrorValue(self, byte: int) -> None: ... + def setCellFormula(self, string: java.lang.String | str) -> None: ... + def setCellNum(self, short: int) -> None: ... + def setCellStyle(self, hSSFCellStyle: HSSFCellStyle) -> None: ... + def setCellType(self, int: int) -> None: ... + @typing.overload + def setCellValue(self, boolean: bool) -> None: ... + @typing.overload + def setCellValue(self, double: float) -> None: ... + @typing.overload + def setCellValue(self, string: java.lang.String | str) -> None: ... + @typing.overload + def setCellValue(self, calendar: java.util.Calendar) -> None: ... + @typing.overload + def setCellValue(self, date: java.util.Date) -> None: ... + @typing.overload + def setCellValue(self, hSSFRichTextString: HSSFRichTextString) -> None: ... + def setEncoding(self, short: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class HSSFCellStyle: + ALIGN_GENERAL: typing.ClassVar[int] = ... + ALIGN_LEFT: typing.ClassVar[int] = ... + ALIGN_CENTER: typing.ClassVar[int] = ... + ALIGN_RIGHT: typing.ClassVar[int] = ... + ALIGN_FILL: typing.ClassVar[int] = ... + ALIGN_JUSTIFY: typing.ClassVar[int] = ... + ALIGN_CENTER_SELECTION: typing.ClassVar[int] = ... + VERTICAL_TOP: typing.ClassVar[int] = ... + VERTICAL_CENTER: typing.ClassVar[int] = ... + VERTICAL_BOTTOM: typing.ClassVar[int] = ... + VERTICAL_JUSTIFY: typing.ClassVar[int] = ... + BORDER_NONE: typing.ClassVar[int] = ... + BORDER_THIN: typing.ClassVar[int] = ... + BORDER_MEDIUM: typing.ClassVar[int] = ... + BORDER_DASHED: typing.ClassVar[int] = ... + BORDER_HAIR: typing.ClassVar[int] = ... + BORDER_THICK: typing.ClassVar[int] = ... + BORDER_DOUBLE: typing.ClassVar[int] = ... + BORDER_DOTTED: typing.ClassVar[int] = ... + BORDER_MEDIUM_DASHED: typing.ClassVar[int] = ... + BORDER_DASH_DOT: typing.ClassVar[int] = ... + BORDER_MEDIUM_DASH_DOT: typing.ClassVar[int] = ... + BORDER_DASH_DOT_DOT: typing.ClassVar[int] = ... + BORDER_MEDIUM_DASH_DOT_DOT: typing.ClassVar[int] = ... + BORDER_SLANTED_DASH_DOT: typing.ClassVar[int] = ... + NO_FILL: typing.ClassVar[int] = ... + SOLID_FOREGROUND: typing.ClassVar[int] = ... + FINE_DOTS: typing.ClassVar[int] = ... + ALT_BARS: typing.ClassVar[int] = ... + SPARSE_DOTS: typing.ClassVar[int] = ... + THICK_HORZ_BANDS: typing.ClassVar[int] = ... + THICK_VERT_BANDS: typing.ClassVar[int] = ... + THICK_BACKWARD_DIAG: typing.ClassVar[int] = ... + THICK_FORWARD_DIAG: typing.ClassVar[int] = ... + BIG_SPOTS: typing.ClassVar[int] = ... + BRICKS: typing.ClassVar[int] = ... + THIN_HORZ_BANDS: typing.ClassVar[int] = ... + THIN_VERT_BANDS: typing.ClassVar[int] = ... + THIN_BACKWARD_DIAG: typing.ClassVar[int] = ... + THIN_FORWARD_DIAG: typing.ClassVar[int] = ... + SQUARES: typing.ClassVar[int] = ... + DIAMONDS: typing.ClassVar[int] = ... + LESS_DOTS: typing.ClassVar[int] = ... + LEAST_DOTS: typing.ClassVar[int] = ... + def getAlignment(self) -> int: ... + def getBorderBottom(self) -> int: ... + def getBorderLeft(self) -> int: ... + def getBorderRight(self) -> int: ... + def getBorderTop(self) -> int: ... + def getBottomBorderColor(self) -> int: ... + def getDataFormat(self) -> int: ... + def getDataFormatString( + self, workbook: loci.poi.hssf.model.Workbook + ) -> java.lang.String: ... + def getFillBackgroundColor(self) -> int: ... + def getFillForegroundColor(self) -> int: ... + def getFillPattern(self) -> int: ... + def getFontIndex(self) -> int: ... + def getHidden(self) -> bool: ... + def getIndention(self) -> int: ... + def getIndex(self) -> int: ... + def getLeftBorderColor(self) -> int: ... + def getLocked(self) -> bool: ... + def getRightBorderColor(self) -> int: ... + def getRotation(self) -> int: ... + def getTopBorderColor(self) -> int: ... + def getVerticalAlignment(self) -> int: ... + def getWrapText(self) -> bool: ... + def setAlignment(self, short: int) -> None: ... + def setBorderBottom(self, short: int) -> None: ... + def setBorderLeft(self, short: int) -> None: ... + def setBorderRight(self, short: int) -> None: ... + def setBorderTop(self, short: int) -> None: ... + def setBottomBorderColor(self, short: int) -> None: ... + def setDataFormat(self, short: int) -> None: ... + def setFillBackgroundColor(self, short: int) -> None: ... + def setFillForegroundColor(self, short: int) -> None: ... + def setFillPattern(self, short: int) -> None: ... + def setFont(self, hSSFFont: HSSFFont) -> None: ... + def setHidden(self, boolean: bool) -> None: ... + def setIndention(self, short: int) -> None: ... + def setLeftBorderColor(self, short: int) -> None: ... + def setLocked(self, boolean: bool) -> None: ... + def setRightBorderColor(self, short: int) -> None: ... + def setRotation(self, short: int) -> None: ... + def setTopBorderColor(self, short: int) -> None: ... + def setVerticalAlignment(self, short: int) -> None: ... + def setWrapText(self, boolean: bool) -> None: ... + +class HSSFDataFormat: + def __init__(self, workbook: loci.poi.hssf.model.Workbook): ... + @typing.overload + @staticmethod + def getBuiltinFormat(short: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def getBuiltinFormat(string: java.lang.String | str) -> int: ... + @staticmethod + def getBuiltinFormats() -> java.util.List: ... + @typing.overload + def getFormat(self, short: int) -> java.lang.String: ... + @typing.overload + def getFormat(self, string: java.lang.String | str) -> int: ... + @staticmethod + def getNumberOfBuiltinBuiltinFormats() -> int: ... + +class HSSFDateUtil: + @staticmethod + def getExcelDate(date: java.util.Date) -> float: ... + @typing.overload + @staticmethod + def getJavaDate(double: float) -> java.util.Date: ... + @typing.overload + @staticmethod + def getJavaDate(double: float, boolean: bool) -> java.util.Date: ... + @staticmethod + def isADateFormat(int: int, string: java.lang.String | str) -> bool: ... + @staticmethod + def isCellDateFormatted(hSSFCell: HSSFCell) -> bool: ... + @staticmethod + def isCellInternalDateFormatted(hSSFCell: HSSFCell) -> bool: ... + @staticmethod + def isInternalDateFormat(int: int) -> bool: ... + @staticmethod + def isValidExcelDate(double: float) -> bool: ... + +class HSSFErrorConstants: + ERROR_NULL: typing.ClassVar[int] = ... + ERROR_DIV_0: typing.ClassVar[int] = ... + ERROR_VALUE: typing.ClassVar[int] = ... + ERROR_REF: typing.ClassVar[int] = ... + ERROR_NAME: typing.ClassVar[int] = ... + ERROR_NUM: typing.ClassVar[int] = ... + ERROR_NA: typing.ClassVar[int] = ... + +class HSSFFont: + FONT_ARIAL: typing.ClassVar[java.lang.String] = ... + BOLDWEIGHT_NORMAL: typing.ClassVar[int] = ... + BOLDWEIGHT_BOLD: typing.ClassVar[int] = ... + COLOR_NORMAL: typing.ClassVar[int] = ... + COLOR_RED: typing.ClassVar[int] = ... + SS_NONE: typing.ClassVar[int] = ... + SS_SUPER: typing.ClassVar[int] = ... + SS_SUB: typing.ClassVar[int] = ... + U_NONE: typing.ClassVar[int] = ... + U_SINGLE: typing.ClassVar[int] = ... + U_DOUBLE: typing.ClassVar[int] = ... + U_SINGLE_ACCOUNTING: typing.ClassVar[int] = ... + U_DOUBLE_ACCOUNTING: typing.ClassVar[int] = ... + ANSI_CHARSET: typing.ClassVar[int] = ... + DEFAULT_CHARSET: typing.ClassVar[int] = ... + SYMBOL_CHARSET: typing.ClassVar[int] = ... + def getBoldweight(self) -> int: ... + def getCharSet(self) -> int: ... + def getColor(self) -> int: ... + def getFontHeight(self) -> int: ... + def getFontHeightInPoints(self) -> int: ... + def getFontName(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getItalic(self) -> bool: ... + def getStrikeout(self) -> bool: ... + def getTypeOffset(self) -> int: ... + def getUnderline(self) -> int: ... + def setBoldweight(self, short: int) -> None: ... + def setCharSet(self, byte: int) -> None: ... + def setColor(self, short: int) -> None: ... + def setFontHeight(self, short: int) -> None: ... + def setFontHeightInPoints(self, short: int) -> None: ... + def setFontName(self, string: java.lang.String | str) -> None: ... + def setItalic(self, boolean: bool) -> None: ... + def setStrikeout(self, boolean: bool) -> None: ... + def setTypeOffset(self, short: int) -> None: ... + def setUnderline(self, byte: int) -> None: ... + def toString(self) -> java.lang.String: ... + +class HSSFFooter: + @staticmethod + def date() -> java.lang.String: ... + @staticmethod + def endDoubleUnderline() -> java.lang.String: ... + @staticmethod + def endUnderline() -> java.lang.String: ... + @staticmethod + def file() -> java.lang.String: ... + @staticmethod + def font( + string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @staticmethod + def fontSize(short: int) -> java.lang.String: ... + def getCenter(self) -> java.lang.String: ... + def getLeft(self) -> java.lang.String: ... + def getRight(self) -> java.lang.String: ... + @staticmethod + def numPages() -> java.lang.String: ... + @staticmethod + def page() -> java.lang.String: ... + def setCenter(self, string: java.lang.String | str) -> None: ... + def setLeft(self, string: java.lang.String | str) -> None: ... + def setRight(self, string: java.lang.String | str) -> None: ... + @staticmethod + def startDoubleUnderline() -> java.lang.String: ... + @staticmethod + def startUnderline() -> java.lang.String: ... + @staticmethod + def tab() -> java.lang.String: ... + @staticmethod + def time() -> java.lang.String: ... + +class HSSFHeader: + @staticmethod + def date() -> java.lang.String: ... + @staticmethod + def endDoubleUnderline() -> java.lang.String: ... + @staticmethod + def endUnderline() -> java.lang.String: ... + @staticmethod + def file() -> java.lang.String: ... + @staticmethod + def font( + string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + @staticmethod + def fontSize(short: int) -> java.lang.String: ... + def getCenter(self) -> java.lang.String: ... + def getLeft(self) -> java.lang.String: ... + def getRight(self) -> java.lang.String: ... + @staticmethod + def numPages() -> java.lang.String: ... + @staticmethod + def page() -> java.lang.String: ... + def setCenter(self, string: java.lang.String | str) -> None: ... + def setLeft(self, string: java.lang.String | str) -> None: ... + def setRight(self, string: java.lang.String | str) -> None: ... + @staticmethod + def startDoubleUnderline() -> java.lang.String: ... + @staticmethod + def startUnderline() -> java.lang.String: ... + @staticmethod + def tab() -> java.lang.String: ... + @staticmethod + def time() -> java.lang.String: ... + +class HSSFName: + def getNameName(self) -> java.lang.String: ... + def getReference(self) -> java.lang.String: ... + def getSheetName(self) -> java.lang.String: ... + def setNameName(self, string: java.lang.String | str) -> None: ... + def setReference(self, string: java.lang.String | str) -> None: ... + +class HSSFObjectData: + def __init__( + self, + objRecord: loci.poi.hssf.record.ObjRecord, + pOIFSFileSystem: loci.poi.poifs.filesystem.POIFSFileSystem, + ): ... + def getDirectory(self) -> loci.poi.poifs.filesystem.DirectoryEntry: ... + +class HSSFPalette: + def addColor( + self, byte: int, byte2: int, byte3: int + ) -> loci.poi.hssf.util.HSSFColor: ... + def findColor( + self, byte: int, byte2: int, byte3: int + ) -> loci.poi.hssf.util.HSSFColor: ... + def findSimilarColor( + self, byte: int, byte2: int, byte3: int + ) -> loci.poi.hssf.util.HSSFColor: ... + def getColor(self, short: int) -> loci.poi.hssf.util.HSSFColor: ... + def setColorAtIndex( + self, short: int, byte: int, byte2: int, byte3: int + ) -> None: ... + +class HSSFPictureData: + MSOBI_WMF: typing.ClassVar[int] = ... + MSOBI_EMF: typing.ClassVar[int] = ... + MSOBI_PICT: typing.ClassVar[int] = ... + MSOBI_PNG: typing.ClassVar[int] = ... + MSOBI_JPEG: typing.ClassVar[int] = ... + MSOBI_DIB: typing.ClassVar[int] = ... + FORMAT_MASK: typing.ClassVar[int] = ... + def getData(self) -> typing.MutableSequence[int]: ... + def suggestFileExtension(self) -> java.lang.String: ... + +class HSSFPrintSetup: + LETTER_PAPERSIZE: typing.ClassVar[int] = ... + LEGAL_PAPERSIZE: typing.ClassVar[int] = ... + EXECUTIVE_PAPERSIZE: typing.ClassVar[int] = ... + A4_PAPERSIZE: typing.ClassVar[int] = ... + A5_PAPERSIZE: typing.ClassVar[int] = ... + ENVELOPE_10_PAPERSIZE: typing.ClassVar[int] = ... + ENVELOPE_DL_PAPERSIZE: typing.ClassVar[int] = ... + ENVELOPE_CS_PAPERSIZE: typing.ClassVar[int] = ... + ENVELOPE_MONARCH_PAPERSIZE: typing.ClassVar[int] = ... + def getCopies(self) -> int: ... + def getDraft(self) -> bool: ... + def getFitHeight(self) -> int: ... + def getFitWidth(self) -> int: ... + def getFooterMargin(self) -> float: ... + def getHResolution(self) -> int: ... + def getHeaderMargin(self) -> float: ... + def getLandscape(self) -> bool: ... + def getLeftToRight(self) -> bool: ... + def getNoColor(self) -> bool: ... + def getNoOrientation(self) -> bool: ... + def getNotes(self) -> bool: ... + def getOptions(self) -> int: ... + def getPageStart(self) -> int: ... + def getPaperSize(self) -> int: ... + def getScale(self) -> int: ... + def getUsePage(self) -> bool: ... + def getVResolution(self) -> int: ... + def getValidSettings(self) -> bool: ... + def setCopies(self, short: int) -> None: ... + def setDraft(self, boolean: bool) -> None: ... + def setFitHeight(self, short: int) -> None: ... + def setFitWidth(self, short: int) -> None: ... + def setFooterMargin(self, double: float) -> None: ... + def setHResolution(self, short: int) -> None: ... + def setHeaderMargin(self, double: float) -> None: ... + def setLandscape(self, boolean: bool) -> None: ... + def setLeftToRight(self, boolean: bool) -> None: ... + def setNoColor(self, boolean: bool) -> None: ... + def setNoOrientation(self, boolean: bool) -> None: ... + def setNotes(self, boolean: bool) -> None: ... + def setOptions(self, short: int) -> None: ... + def setPageStart(self, short: int) -> None: ... + def setPaperSize(self, short: int) -> None: ... + def setScale(self, short: int) -> None: ... + def setUsePage(self, boolean: bool) -> None: ... + def setVResolution(self, short: int) -> None: ... + def setValidSettings(self, boolean: bool) -> None: ... + +class HSSFRichTextString(java.lang.Comparable): + NO_FONT: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def applyFont(self, int: int, int2: int, hSSFFont: HSSFFont) -> None: ... + @typing.overload + def applyFont(self, int: int, int2: int, short: int) -> None: ... + @typing.overload + def applyFont(self, hSSFFont: HSSFFont) -> None: ... + @typing.overload + def applyFont(self, short: int) -> None: ... + def clearFormatting(self) -> None: ... + def compareTo(self, object: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def getFontAtIndex(self, int: int) -> int: ... + def getFontOfFormattingRun(self, int: int) -> int: ... + def getIndexOfFormattingRun(self, int: int) -> int: ... + def getString(self) -> java.lang.String: ... + def length(self) -> int: ... + def numFormattingRuns(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class HSSFRow(java.lang.Comparable): + INITIAL_CAPACITY: typing.ClassVar[int] = ... + def cellIterator(self) -> java.util.Iterator: ... + def compareTo(self, object: typing.Any) -> int: ... + @typing.overload + def createCell(self, short: int) -> HSSFCell: ... + @typing.overload + def createCell(self, short: int, int: int) -> HSSFCell: ... + def equals(self, object: typing.Any) -> bool: ... + def getCell(self, short: int) -> HSSFCell: ... + def getFirstCellNum(self) -> int: ... + def getHeight(self) -> int: ... + def getHeightInPoints(self) -> float: ... + def getLastCellNum(self) -> int: ... + def getPhysicalNumberOfCells(self) -> int: ... + def getRowNum(self) -> int: ... + def getZeroHeight(self) -> bool: ... + def removeCell(self, hSSFCell: HSSFCell) -> None: ... + def setHeight(self, short: int) -> None: ... + def setHeightInPoints(self, float: float) -> None: ... + def setRowNum(self, int: int) -> None: ... + def setZeroHeight(self, boolean: bool) -> None: ... + +class HSSFShape: + LINEWIDTH_ONE_PT: typing.ClassVar[int] = ... + LINEWIDTH_DEFAULT: typing.ClassVar[int] = ... + LINESTYLE_SOLID: typing.ClassVar[int] = ... + LINESTYLE_DASHSYS: typing.ClassVar[int] = ... + LINESTYLE_DOTSYS: typing.ClassVar[int] = ... + LINESTYLE_DASHDOTSYS: typing.ClassVar[int] = ... + LINESTYLE_DASHDOTDOTSYS: typing.ClassVar[int] = ... + LINESTYLE_DOTGEL: typing.ClassVar[int] = ... + LINESTYLE_DASHGEL: typing.ClassVar[int] = ... + LINESTYLE_LONGDASHGEL: typing.ClassVar[int] = ... + LINESTYLE_DASHDOTGEL: typing.ClassVar[int] = ... + LINESTYLE_LONGDASHDOTGEL: typing.ClassVar[int] = ... + LINESTYLE_LONGDASHDOTDOTGEL: typing.ClassVar[int] = ... + LINESTYLE_NONE: typing.ClassVar[int] = ... + def countOfAllChildren(self) -> int: ... + def getAnchor(self) -> HSSFAnchor: ... + def getFillColor(self) -> int: ... + def getLineStyle(self) -> int: ... + def getLineStyleColor(self) -> int: ... + def getLineWidth(self) -> int: ... + def getParent(self) -> HSSFShape: ... + def isNoFill(self) -> bool: ... + def setAnchor(self, hSSFAnchor: HSSFAnchor) -> None: ... + @typing.overload + def setFillColor(self, int: int) -> None: ... + @typing.overload + def setFillColor(self, int: int, int2: int, int3: int) -> None: ... + def setLineStyle(self, int: int) -> None: ... + @typing.overload + def setLineStyleColor(self, int: int) -> None: ... + @typing.overload + def setLineStyleColor(self, int: int, int2: int, int3: int) -> None: ... + def setLineWidth(self, int: int) -> None: ... + def setNoFill(self, boolean: bool) -> None: ... + +class HSSFShapeContainer: + def getChildren(self) -> java.util.List: ... + +class HSSFSheet: + LeftMargin: typing.ClassVar[int] = ... + RightMargin: typing.ClassVar[int] = ... + TopMargin: typing.ClassVar[int] = ... + BottomMargin: typing.ClassVar[int] = ... + PANE_LOWER_RIGHT: typing.ClassVar[int] = ... + PANE_UPPER_RIGHT: typing.ClassVar[int] = ... + PANE_LOWER_LEFT: typing.ClassVar[int] = ... + PANE_UPPER_LEFT: typing.ClassVar[int] = ... + INITIAL_CAPACITY: typing.ClassVar[int] = ... + def addMergedRegion(self, region: loci.poi.hssf.util.Region) -> int: ... + def autoSizeColumn(self, short: int) -> None: ... + def createDrawingPatriarch(self) -> HSSFPatriarch: ... + @typing.overload + def createFreezePane(self, int: int, int2: int) -> None: ... + @typing.overload + def createFreezePane(self, int: int, int2: int, int3: int, int4: int) -> None: ... + def createRow(self, int: int) -> HSSFRow: ... + def createSplitPane( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + def dumpDrawingRecords(self, boolean: bool) -> None: ... + def getAlternateExpression(self) -> bool: ... + def getAlternateFormula(self) -> bool: ... + def getAutobreaks(self) -> bool: ... + def getCellComment(self, int: int, int2: int) -> HSSFComment: ... + def getColumnBreaks(self) -> typing.MutableSequence[int]: ... + def getColumnWidth(self, short: int) -> int: ... + def getDefaultColumnWidth(self) -> int: ... + def getDefaultRowHeight(self) -> int: ... + def getDefaultRowHeightInPoints(self) -> float: ... + def getDialog(self) -> bool: ... + def getDisplayGuts(self) -> bool: ... + def getFirstRowNum(self) -> int: ... + def getFitToPage(self) -> bool: ... + def getFooter(self) -> HSSFFooter: ... + def getHeader(self) -> HSSFHeader: ... + def getHorizontallyCenter(self) -> bool: ... + def getLastRowNum(self) -> int: ... + def getLeftCol(self) -> int: ... + def getMargin(self, short: int) -> float: ... + def getMergedRegionAt(self, int: int) -> loci.poi.hssf.util.Region: ... + def getNumMergedRegions(self) -> int: ... + def getObjectProtect(self) -> bool: ... + def getPaneInformation(self) -> loci.poi.hssf.util.PaneInformation: ... + def getPassword(self) -> int: ... + def getPhysicalNumberOfRows(self) -> int: ... + def getPrintSetup(self) -> HSSFPrintSetup: ... + def getProtect(self) -> bool: ... + def getRow(self, int: int) -> HSSFRow: ... + def getRowBreaks(self) -> typing.MutableSequence[int]: ... + def getRowSumsBelow(self) -> bool: ... + def getRowSumsRight(self) -> bool: ... + def getScenarioProtect(self) -> bool: ... + def getTopRow(self) -> int: ... + def getVerticallyCenter(self, boolean: bool) -> bool: ... + def groupColumn(self, short: int, short2: int) -> None: ... + def groupRow(self, int: int, int2: int) -> None: ... + def isColumnBroken(self, short: int) -> bool: ... + def isColumnHidden(self, short: int) -> bool: ... + def isDisplayFormulas(self) -> bool: ... + def isDisplayGridlines(self) -> bool: ... + def isDisplayRowColHeadings(self) -> bool: ... + def isGridsPrinted(self) -> bool: ... + def isPrintGridlines(self) -> bool: ... + def isRowBroken(self, int: int) -> bool: ... + def protectSheet(self, string: java.lang.String | str) -> None: ... + def removeColumnBreak(self, short: int) -> None: ... + def removeMergedRegion(self, int: int) -> None: ... + def removeRow(self, hSSFRow: HSSFRow) -> None: ... + def removeRowBreak(self, int: int) -> None: ... + def rowIterator(self) -> java.util.Iterator: ... + def setAlternativeExpression(self, boolean: bool) -> None: ... + def setAlternativeFormula(self, boolean: bool) -> None: ... + def setAutobreaks(self, boolean: bool) -> None: ... + def setColumnBreak(self, short: int) -> None: ... + def setColumnGroupCollapsed(self, short: int, boolean: bool) -> None: ... + def setColumnHidden(self, short: int, boolean: bool) -> None: ... + def setColumnWidth(self, short: int, short2: int) -> None: ... + def setDefaultColumnStyle( + self, short: int, hSSFCellStyle: HSSFCellStyle + ) -> None: ... + def setDefaultColumnWidth(self, short: int) -> None: ... + def setDefaultRowHeight(self, short: int) -> None: ... + def setDefaultRowHeightInPoints(self, float: float) -> None: ... + def setDialog(self, boolean: bool) -> None: ... + def setDisplayFormulas(self, boolean: bool) -> None: ... + def setDisplayGridlines(self, boolean: bool) -> None: ... + def setDisplayGuts(self, boolean: bool) -> None: ... + def setDisplayRowColHeadings(self, boolean: bool) -> None: ... + def setFitToPage(self, boolean: bool) -> None: ... + def setGridsPrinted(self, boolean: bool) -> None: ... + def setHorizontallyCenter(self, boolean: bool) -> None: ... + def setMargin(self, short: int, double: float) -> None: ... + def setPrintGridlines(self, boolean: bool) -> None: ... + def setProtect(self, boolean: bool) -> None: ... + def setRowBreak(self, int: int) -> None: ... + def setRowGroupCollapsed(self, int: int, boolean: bool) -> None: ... + def setRowSumsBelow(self, boolean: bool) -> None: ... + def setRowSumsRight(self, boolean: bool) -> None: ... + def setSelected(self, boolean: bool) -> None: ... + def setVerticallyCenter(self, boolean: bool) -> None: ... + def setZoom(self, int: int, int2: int) -> None: ... + @typing.overload + def shiftRows(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def shiftRows( + self, int: int, int2: int, int3: int, boolean: bool, boolean2: bool + ) -> None: ... + def showInPane(self, short: int, short2: int) -> None: ... + def ungroupColumn(self, short: int, short2: int) -> None: ... + def ungroupRow(self, int: int, int2: int) -> None: ... + +class HSSFWorkbook(loci.poi.POIDocument): + INITIAL_CAPACITY: typing.ClassVar[int] = ... + PICTURE_TYPE_EMF: typing.ClassVar[int] = ... + PICTURE_TYPE_WMF: typing.ClassVar[int] = ... + PICTURE_TYPE_PICT: typing.ClassVar[int] = ... + PICTURE_TYPE_JPEG: typing.ClassVar[int] = ... + PICTURE_TYPE_PNG: typing.ClassVar[int] = ... + PICTURE_TYPE_DIB: typing.ClassVar[int] = ... + ENCODING_COMPRESSED_UNICODE: typing.ClassVar[int] = ... + ENCODING_UTF_16: typing.ClassVar[int] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ): ... + @typing.overload + def __init__( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + boolean: bool, + ): ... + @typing.overload + def __init__(self, pOIFSFileSystem: loci.poi.poifs.filesystem.POIFSFileSystem): ... + @typing.overload + def __init__( + self, pOIFSFileSystem: loci.poi.poifs.filesystem.POIFSFileSystem, boolean: bool + ): ... + def addPicture( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + def addSSTString(self, string: java.lang.String | str) -> int: ... + def cloneSheet(self, int: int) -> HSSFSheet: ... + def createCellStyle(self) -> HSSFCellStyle: ... + def createDataFormat(self) -> HSSFDataFormat: ... + def createFont(self) -> HSSFFont: ... + def createName(self) -> HSSFName: ... + @typing.overload + def createSheet(self) -> HSSFSheet: ... + @typing.overload + def createSheet(self, string: java.lang.String | str) -> HSSFSheet: ... + def dumpDrawingGroupRecords(self, boolean: bool) -> None: ... + def findFont( + self, + short: int, + short2: int, + short3: int, + string: java.lang.String | str, + boolean: bool, + boolean2: bool, + short4: int, + byte: int, + ) -> HSSFFont: ... + def getAllEmbeddedObjects(self) -> java.util.List: ... + def getAllPictures(self) -> java.util.List: ... + def getBackupFlag(self) -> bool: ... + def getBytes(self) -> typing.MutableSequence[int]: ... + def getCellStyleAt(self, short: int) -> HSSFCellStyle: ... + def getCustomPalette(self) -> HSSFPalette: ... + def getDisplayedTab(self) -> int: ... + def getFontAt(self, short: int) -> HSSFFont: ... + def getNameAt(self, int: int) -> HSSFName: ... + def getNameIndex(self, string: java.lang.String | str) -> int: ... + def getNameName(self, int: int) -> java.lang.String: ... + def getNumCellStyles(self) -> int: ... + def getNumberOfFonts(self) -> int: ... + def getNumberOfNames(self) -> int: ... + def getNumberOfSheets(self) -> int: ... + def getPrintArea(self, int: int) -> java.lang.String: ... + def getSSTString(self, int: int) -> java.lang.String: ... + def getSelectedTab(self) -> int: ... + def getSheet(self, string: java.lang.String | str) -> HSSFSheet: ... + def getSheetAt(self, int: int) -> HSSFSheet: ... + @typing.overload + def getSheetIndex(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getSheetIndex(self, hSSFSheet: HSSFSheet) -> int: ... + def getSheetName(self, int: int) -> java.lang.String: ... + def insertChartRecord(self) -> None: ... + @typing.overload + def removeName(self, int: int) -> None: ... + @typing.overload + def removeName(self, string: java.lang.String | str) -> None: ... + def removePrintArea(self, int: int) -> None: ... + def removeSheetAt(self, int: int) -> None: ... + def setBackupFlag(self, boolean: bool) -> None: ... + def setDisplayedTab(self, short: int) -> None: ... + @typing.overload + def setPrintArea( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + @typing.overload + def setPrintArea(self, int: int, string: java.lang.String | str) -> None: ... + def setRepeatingRowsAndColumns( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> None: ... + def setSelectedTab(self, short: int) -> None: ... + @typing.overload + def setSheetName(self, int: int, string: java.lang.String | str) -> None: ... + @typing.overload + def setSheetName( + self, int: int, string: java.lang.String | str, short: int + ) -> None: ... + def setSheetOrder(self, string: java.lang.String | str, int: int) -> None: ... + def unwriteProtectWorkbook(self) -> None: ... + def write(self, outputStream: java.io.OutputStream) -> None: ... + def writeProtectWorkbook( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> None: ... + +class HSSFChildAnchor(HSSFAnchor): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + def isHorizontallyFlipped(self) -> bool: ... + def isVerticallyFlipped(self) -> bool: ... + def setAnchor(self, int: int, int2: int, int3: int, int4: int) -> None: ... + +class HSSFClientAnchor(HSSFAnchor): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + int: int, + int2: int, + int3: int, + int4: int, + short: int, + int5: int, + short2: int, + int6: int, + ): ... + def getAnchorHeightInPoints(self, hSSFSheet: HSSFSheet) -> float: ... + def getAnchorType(self) -> int: ... + def getCol1(self) -> int: ... + def getCol2(self) -> int: ... + def getRow1(self) -> int: ... + def getRow2(self) -> int: ... + def isHorizontallyFlipped(self) -> bool: ... + def isVerticallyFlipped(self) -> bool: ... + def setAnchor( + self, + short: int, + int: int, + int2: int, + int3: int, + short2: int, + int4: int, + int5: int, + int6: int, + ) -> None: ... + def setAnchorType(self, int: int) -> None: ... + def setCol1(self, short: int) -> None: ... + def setCol2(self, short: int) -> None: ... + def setRow1(self, int: int) -> None: ... + def setRow2(self, int: int) -> None: ... + +class HSSFPatriarch(HSSFShapeContainer): + def countOfAllChildren(self) -> int: ... + def createComment(self, hSSFAnchor: HSSFAnchor) -> HSSFComment: ... + def createGroup(self, hSSFClientAnchor: HSSFClientAnchor) -> HSSFShapeGroup: ... + def createPicture( + self, hSSFClientAnchor: HSSFClientAnchor, int: int + ) -> HSSFPicture: ... + def createPolygon(self, hSSFClientAnchor: HSSFClientAnchor) -> HSSFPolygon: ... + def createSimpleShape( + self, hSSFClientAnchor: HSSFClientAnchor + ) -> HSSFSimpleShape: ... + def createTextbox(self, hSSFClientAnchor: HSSFClientAnchor) -> HSSFTextbox: ... + def getChildren(self) -> java.util.List: ... + def getX1(self) -> int: ... + def getX2(self) -> int: ... + def getY1(self) -> int: ... + def getY2(self) -> int: ... + def setCoordinates(self, int: int, int2: int, int3: int, int4: int) -> None: ... + +class HSSFPolygon(HSSFShape): + def getDrawAreaHeight(self) -> int: ... + def getDrawAreaWidth(self) -> int: ... + def getXPoints(self) -> typing.MutableSequence[int]: ... + def getYPoints(self) -> typing.MutableSequence[int]: ... + def setPoints( + self, intArray: list[int] | jpype.JArray, intArray2: list[int] | jpype.JArray + ) -> None: ... + def setPolygonDrawArea(self, int: int, int2: int) -> None: ... + +class HSSFShapeGroup(HSSFShape, HSSFShapeContainer): + def __init__(self, hSSFShape: HSSFShape, hSSFAnchor: HSSFAnchor): ... + def countOfAllChildren(self) -> int: ... + def createGroup(self, hSSFChildAnchor: HSSFChildAnchor) -> HSSFShapeGroup: ... + def createPicture( + self, hSSFChildAnchor: HSSFChildAnchor, int: int + ) -> HSSFPicture: ... + def createPolygon(self, hSSFChildAnchor: HSSFChildAnchor) -> HSSFPolygon: ... + def createShape(self, hSSFChildAnchor: HSSFChildAnchor) -> HSSFSimpleShape: ... + def createTextbox(self, hSSFChildAnchor: HSSFChildAnchor) -> HSSFTextbox: ... + def getChildren(self) -> java.util.List: ... + def getX1(self) -> int: ... + def getX2(self) -> int: ... + def getY1(self) -> int: ... + def getY2(self) -> int: ... + def setCoordinates(self, int: int, int2: int, int3: int, int4: int) -> None: ... + +class HSSFSimpleShape(HSSFShape): + OBJECT_TYPE_LINE: typing.ClassVar[int] = ... + OBJECT_TYPE_RECTANGLE: typing.ClassVar[int] = ... + OBJECT_TYPE_OVAL: typing.ClassVar[int] = ... + OBJECT_TYPE_PICTURE: typing.ClassVar[int] = ... + OBJECT_TYPE_COMMENT: typing.ClassVar[int] = ... + def getShapeType(self) -> int: ... + def setShapeType(self, int: int) -> None: ... + +class HSSFPicture(HSSFSimpleShape): + PICTURE_TYPE_EMF: typing.ClassVar[int] = ... + PICTURE_TYPE_WMF: typing.ClassVar[int] = ... + PICTURE_TYPE_PICT: typing.ClassVar[int] = ... + PICTURE_TYPE_JPEG: typing.ClassVar[int] = ... + PICTURE_TYPE_PNG: typing.ClassVar[int] = ... + PICTURE_TYPE_DIB: typing.ClassVar[int] = ... + def getPictureIndex(self) -> int: ... + def getPreferredSize(self) -> HSSFClientAnchor: ... + def resize(self) -> None: ... + def setPictureIndex(self, int: int) -> None: ... + +class HSSFTextbox(HSSFSimpleShape): + OBJECT_TYPE_TEXT: typing.ClassVar[int] = ... + def __init__(self, hSSFShape: HSSFShape, hSSFAnchor: HSSFAnchor): ... + def getMarginBottom(self) -> int: ... + def getMarginLeft(self) -> int: ... + def getMarginRight(self) -> int: ... + def getMarginTop(self) -> int: ... + def getString(self) -> HSSFRichTextString: ... + def setMarginBottom(self, int: int) -> None: ... + def setMarginLeft(self, int: int) -> None: ... + def setMarginRight(self, int: int) -> None: ... + def setMarginTop(self, int: int) -> None: ... + def setString(self, hSSFRichTextString: HSSFRichTextString) -> None: ... + +class HSSFComment(HSSFTextbox): + def __init__(self, hSSFShape: HSSFShape, hSSFAnchor: HSSFAnchor): ... + def getAuthor(self) -> java.lang.String: ... + def getColumn(self) -> int: ... + def getRow(self) -> int: ... + def isVisible(self) -> bool: ... + def setAuthor(self, string: java.lang.String | str) -> None: ... + def setColumn(self, short: int) -> None: ... + def setRow(self, int: int) -> None: ... + def setString(self, hSSFRichTextString: HSSFRichTextString) -> None: ... + def setVisible(self, boolean: bool) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.usermodel")``. + + DummyGraphics2d: type[DummyGraphics2d] + EscherGraphics: type[EscherGraphics] + EscherGraphics2d: type[EscherGraphics2d] + FontDetails: type[FontDetails] + HSSFAnchor: type[HSSFAnchor] + HSSFCell: type[HSSFCell] + HSSFCellStyle: type[HSSFCellStyle] + HSSFChildAnchor: type[HSSFChildAnchor] + HSSFClientAnchor: type[HSSFClientAnchor] + HSSFComment: type[HSSFComment] + HSSFDataFormat: type[HSSFDataFormat] + HSSFDateUtil: type[HSSFDateUtil] + HSSFErrorConstants: type[HSSFErrorConstants] + HSSFFont: type[HSSFFont] + HSSFFooter: type[HSSFFooter] + HSSFHeader: type[HSSFHeader] + HSSFName: type[HSSFName] + HSSFObjectData: type[HSSFObjectData] + HSSFPalette: type[HSSFPalette] + HSSFPatriarch: type[HSSFPatriarch] + HSSFPicture: type[HSSFPicture] + HSSFPictureData: type[HSSFPictureData] + HSSFPolygon: type[HSSFPolygon] + HSSFPrintSetup: type[HSSFPrintSetup] + HSSFRichTextString: type[HSSFRichTextString] + HSSFRow: type[HSSFRow] + HSSFShape: type[HSSFShape] + HSSFShapeContainer: type[HSSFShapeContainer] + HSSFShapeGroup: type[HSSFShapeGroup] + HSSFSheet: type[HSSFSheet] + HSSFSimpleShape: type[HSSFSimpleShape] + HSSFTextbox: type[HSSFTextbox] + HSSFWorkbook: type[HSSFWorkbook] diff --git a/typings/loci/poi/hssf/util/__init__.pyi b/typings/loci/poi/hssf/util/__init__.pyi new file mode 100644 index 0000000..b0c3b17 --- /dev/null +++ b/typings/loci/poi/hssf/util/__init__.pyi @@ -0,0 +1,587 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import loci +import loci.poi.hssf.record + +class AreaReference: + def __init__(self, string: java.lang.String | str): ... + def getCells(self) -> typing.MutableSequence[CellReference]: ... + def getDim(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class CellReference: + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, int: int, int2: int, boolean: bool, boolean2: bool): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def getCol(self) -> int: ... + def getRow(self) -> int: ... + def getSheetName(self) -> java.lang.String: ... + def isColAbsolute(self) -> bool: ... + def isRowAbsolute(self) -> bool: ... + def toString(self) -> java.lang.String: ... + +class PaneInformation: + PANE_LOWER_RIGHT: typing.ClassVar[int] = ... + PANE_UPPER_RIGHT: typing.ClassVar[int] = ... + PANE_LOWER_LEFT: typing.ClassVar[int] = ... + PANE_UPPER_LEFT: typing.ClassVar[int] = ... + def __init__( + self, + short: int, + short2: int, + short3: int, + short4: int, + byte: int, + boolean: bool, + ): ... + def getActivePane(self) -> int: ... + def getHorizontalSplitPosition(self) -> int: ... + def getHorizontalSplitTopRow(self) -> int: ... + def getVerticalSplitLeftColumn(self) -> int: ... + def getVerticalSplitPosition(self) -> int: ... + def isFreezePane(self) -> bool: ... + +class RKUtil: + @staticmethod + def decodeNumber(int: int) -> float: ... + +class RangeAddress: + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + def get26Sys(self, string: java.lang.String | str) -> int: ... + def getAddress(self) -> java.lang.String: ... + def getCharPart(self, string: java.lang.String | str) -> java.lang.String: ... + def getDigitPart(self, string: java.lang.String | str) -> java.lang.String: ... + def getFromCell(self) -> java.lang.String: ... + def getHeight(self) -> int: ... + def getRange(self) -> java.lang.String: ... + def getSheetName(self) -> java.lang.String: ... + def getToCell(self) -> java.lang.String: ... + def getWidth(self) -> int: ... + def getXPosition(self, string: java.lang.String | str) -> int: ... + def getYPosition(self, string: java.lang.String | str) -> int: ... + def hasCell(self) -> bool: ... + def hasRange(self) -> bool: ... + def hasSheetName(self) -> bool: ... + def isCellOk(self, string: java.lang.String | str) -> bool: ... + @typing.overload + def isSheetNameOk(self) -> bool: ... + @typing.overload + @staticmethod + def isSheetNameOk(string: java.lang.String | str) -> bool: ... + def numTo26Sys(self, int: int) -> java.lang.String: ... + def removeString( + self, string: java.lang.String | str, string2: java.lang.String | str + ) -> java.lang.String: ... + def replaceString( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + ) -> java.lang.String: ... + def setSize(self, int: int, int2: int) -> None: ... + +class Region(java.lang.Comparable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int, short: int, int2: int, short2: int): ... + @typing.overload + def __init__( + self, mergedRegion: loci.poi.hssf.record.MergeCellsRecord.MergedRegion + ): ... + @typing.overload + def compareTo(self, object: typing.Any) -> int: ... + @typing.overload + def compareTo(self, region: Region) -> int: ... + def contains(self, int: int, short: int) -> bool: ... + @typing.overload + def equals(self, object: typing.Any) -> bool: ... + @typing.overload + def equals(self, region: Region) -> bool: ... + def getArea(self) -> int: ... + def getColumnFrom(self) -> int: ... + def getColumnTo(self) -> int: ... + def getRowFrom(self) -> int: ... + def getRowTo(self) -> int: ... + def setColumnFrom(self, short: int) -> None: ... + def setColumnTo(self, short: int) -> None: ... + def setRowFrom(self, int: int) -> None: ... + def setRowTo(self, int: int) -> None: ... + +class SheetReferences: + def __init__(self): ... + def addSheetReference(self, string: java.lang.String | str, int: int) -> None: ... + def getSheetName(self, int: int) -> java.lang.String: ... + +class HSSFColor: + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + @staticmethod + def getIndexHash() -> java.util.Hashtable: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + @staticmethod + def getTripletHash() -> java.util.Hashtable: ... + class AQUA(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class AUTOMATIC(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + @staticmethod + def getInstance() -> HSSFColor: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class BLACK(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class BLUE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class BLUE_GREY(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class BRIGHT_GREEN(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class BROWN(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class CORAL(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class CORNFLOWER_BLUE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class DARK_BLUE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class DARK_GREEN(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class DARK_RED(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class DARK_TEAL(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class DARK_YELLOW(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class GOLD(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class GREEN(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class GREY_25_PERCENT(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class GREY_40_PERCENT(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class GREY_50_PERCENT(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class GREY_80_PERCENT(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class INDIGO(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class LAVENDER(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class LEMON_CHIFFON(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class LIGHT_BLUE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class LIGHT_CORNFLOWER_BLUE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class LIGHT_GREEN(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class LIGHT_ORANGE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class LIGHT_TURQUOISE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class LIGHT_YELLOW(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class LIME(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class MAROON(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class OLIVE_GREEN(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class ORANGE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class ORCHID(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class PALE_BLUE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class PINK(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class PLUM(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class RED(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class ROSE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class ROYAL_BLUE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class SEA_GREEN(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class SKY_BLUE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class TAN(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class TEAL(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class TURQUOISE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class VIOLET(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class WHITE(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + + class YELLOW(loci.poi.hssf.util.HSSFColor): + index: typing.ClassVar[int] = ... + index2: typing.ClassVar[int] = ... + triplet: typing.ClassVar[typing.MutableSequence[int]] = ... + hexString: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def getHexString(self) -> java.lang.String: ... + def getIndex(self) -> int: ... + def getTriplet(self) -> typing.MutableSequence[int]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.hssf.util")``. + + AreaReference: type[AreaReference] + CellReference: type[CellReference] + HSSFColor: type[HSSFColor] + PaneInformation: type[PaneInformation] + RKUtil: type[RKUtil] + RangeAddress: type[RangeAddress] + Region: type[Region] + SheetReferences: type[SheetReferences] diff --git a/typings/loci/poi/poifs/__init__.pyi b/typings/loci/poi/poifs/__init__.pyi new file mode 100644 index 0000000..b3316fd --- /dev/null +++ b/typings/loci/poi/poifs/__init__.pyi @@ -0,0 +1,18 @@ +from typing import Protocol + +import loci.poi.poifs.common +import loci.poi.poifs.dev +import loci.poi.poifs.eventfilesystem +import loci.poi.poifs.filesystem +import loci.poi.poifs.property +import loci.poi.poifs.storage + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.poifs")``. + + common: loci.poi.poifs.common.__module_protocol__ + dev: loci.poi.poifs.dev.__module_protocol__ + eventfilesystem: loci.poi.poifs.eventfilesystem.__module_protocol__ + filesystem: loci.poi.poifs.filesystem.__module_protocol__ + property: loci.poi.poifs.property.__module_protocol__ + storage: loci.poi.poifs.storage.__module_protocol__ diff --git a/typings/loci/poi/poifs/common/__init__.pyi b/typings/loci/poi/poifs/common/__init__.pyi new file mode 100644 index 0000000..872a245 --- /dev/null +++ b/typings/loci/poi/poifs/common/__init__.pyi @@ -0,0 +1,12 @@ +import typing +from typing import Protocol + +class POIFSConstants: + END_OF_CHAIN: typing.ClassVar[int] = ... + PROPERTY_SIZE: typing.ClassVar[int] = ... + UNUSED_BLOCK: typing.ClassVar[int] = ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.poifs.common")``. + + POIFSConstants: type[POIFSConstants] diff --git a/typings/loci/poi/poifs/dev/__init__.pyi b/typings/loci/poi/poifs/dev/__init__.pyi new file mode 100644 index 0000000..9c1ae2e --- /dev/null +++ b/typings/loci/poi/poifs/dev/__init__.pyi @@ -0,0 +1,31 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype + +class POIFSViewEngine: + def __init__(self): ... + @staticmethod + def inspectViewable( + object: typing.Any, boolean: bool, int: int, string: java.lang.String | str + ) -> java.util.List: ... + +class POIFSViewable: + def getShortDescription(self) -> java.lang.String: ... + def getViewableArray(self) -> typing.MutableSequence[typing.Any]: ... + def getViewableIterator(self) -> java.util.Iterator: ... + def preferArray(self) -> bool: ... + +class POIFSViewer: + def __init__(self): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.poifs.dev")``. + + POIFSViewEngine: type[POIFSViewEngine] + POIFSViewable: type[POIFSViewable] + POIFSViewer: type[POIFSViewer] diff --git a/typings/loci/poi/poifs/eventfilesystem/__init__.pyi b/typings/loci/poi/poifs/eventfilesystem/__init__.pyi new file mode 100644 index 0000000..b02f012 --- /dev/null +++ b/typings/loci/poi/poifs/eventfilesystem/__init__.pyi @@ -0,0 +1,47 @@ +import typing +from typing import Protocol + +import java.lang +import jpype +import loci.common +import loci.poi.poifs.filesystem + +class POIFSReader: + def __init__(self): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def read( + self, randomAccessInputStream: loci.common.RandomAccessInputStream, int: int + ) -> None: ... + @typing.overload + def registerListener( + self, pOIFSReaderListener: POIFSReaderListener | typing.Callable + ) -> None: ... + @typing.overload + def registerListener( + self, + pOIFSReaderListener: POIFSReaderListener | typing.Callable, + string: java.lang.String | str, + ) -> None: ... + @typing.overload + def registerListener( + self, + pOIFSReaderListener: POIFSReaderListener | typing.Callable, + pOIFSDocumentPath: loci.poi.poifs.filesystem.POIFSDocumentPath, + string: java.lang.String | str, + ) -> None: ... + +class POIFSReaderEvent: + def getName(self) -> java.lang.String: ... + def getPath(self) -> loci.poi.poifs.filesystem.POIFSDocumentPath: ... + def getStream(self) -> loci.poi.poifs.filesystem.DocumentInputStream: ... + +class POIFSReaderListener: + def processPOIFSReaderEvent(self, pOIFSReaderEvent: POIFSReaderEvent) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.poifs.eventfilesystem")``. + + POIFSReader: type[POIFSReader] + POIFSReaderEvent: type[POIFSReaderEvent] + POIFSReaderListener: type[POIFSReaderListener] diff --git a/typings/loci/poi/poifs/filesystem/__init__.pyi b/typings/loci/poi/poifs/filesystem/__init__.pyi new file mode 100644 index 0000000..fefb4a9 --- /dev/null +++ b/typings/loci/poi/poifs/filesystem/__init__.pyi @@ -0,0 +1,283 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import jpype +import loci.common +import loci.poi.hpsf +import loci.poi.poifs.dev +import loci.poi.poifs.storage + +class BATManaged: + def countBlocks(self) -> int: ... + def setStartBlock(self, int: int) -> None: ... + +class DocumentDescriptor: + def __init__( + self, pOIFSDocumentPath: POIFSDocumentPath, string: java.lang.String | str + ): ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class DocumentInputStream(java.io.InputStream): + @typing.overload + def __init__( + self, + documentEntry: DocumentEntry, + randomAccessInputStream: loci.common.RandomAccessInputStream, + ): ... + @typing.overload + def __init__( + self, + pOIFSDocument: POIFSDocument, + randomAccessInputStream: loci.common.RandomAccessInputStream, + ): ... + def available(self) -> int: ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class DocumentOutputStream(java.io.OutputStream): + def close(self) -> None: ... + def flush(self) -> None: ... + @typing.overload + def write(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def write( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + def write(self, int: int) -> None: ... + +class Entry: + def delete(self) -> bool: ... + def getName(self) -> java.lang.String: ... + def getParent(self) -> DirectoryEntry: ... + def isDirectoryEntry(self) -> bool: ... + def isDocumentEntry(self) -> bool: ... + def renameTo(self, string: java.lang.String | str) -> bool: ... + +class OfficeXmlFileException(java.lang.IllegalArgumentException): + def __init__(self, string: java.lang.String | str): ... + +class POIFSDocumentPath: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, stringArray: list[java.lang.String] | jpype.JArray): ... + @typing.overload + def __init__( + self, + pOIFSDocumentPath: POIFSDocumentPath, + stringArray: list[java.lang.String] | jpype.JArray, + ): ... + def equals(self, object: typing.Any) -> bool: ... + def getComponent(self, int: int) -> java.lang.String: ... + def getParent(self) -> POIFSDocumentPath: ... + def hashCode(self) -> int: ... + def length(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class POIFSFileSystem(loci.poi.poifs.dev.POIFSViewable): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream, int: int + ): ... + def createDirectory(self, string: java.lang.String | str) -> DirectoryEntry: ... + @typing.overload + def createDocument( + self, + string: java.lang.String | str, + int: int, + pOIFSWriterListener: POIFSWriterListener | typing.Callable, + ) -> DocumentEntry: ... + @typing.overload + def createDocument( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + string: java.lang.String | str, + ) -> DocumentEntry: ... + def createDocumentInputStream( + self, string: java.lang.String | str + ) -> DocumentInputStream: ... + def getRoot(self) -> DirectoryEntry: ... + def getShortDescription(self) -> java.lang.String: ... + def getViewableArray(self) -> typing.MutableSequence[typing.Any]: ... + def getViewableIterator(self) -> java.util.Iterator: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def preferArray(self) -> bool: ... + def writeFilesystem(self, outputStream: java.io.OutputStream) -> None: ... + +class POIFSWriterEvent: + def getLimit(self) -> int: ... + def getName(self) -> java.lang.String: ... + def getPath(self) -> POIFSDocumentPath: ... + def getStream(self) -> DocumentOutputStream: ... + +class POIFSWriterListener: + def processPOIFSWriterEvent(self, pOIFSWriterEvent: POIFSWriterEvent) -> None: ... + +class DirectoryEntry(Entry): + def createDirectory(self, string: java.lang.String | str) -> DirectoryEntry: ... + @typing.overload + def createDocument( + self, + string: java.lang.String | str, + int: int, + pOIFSWriterListener: POIFSWriterListener | typing.Callable, + ) -> DocumentEntry: ... + @typing.overload + def createDocument( + self, + string: java.lang.String | str, + randomAccessInputStream: loci.common.RandomAccessInputStream, + ) -> DocumentEntry: ... + def getEntries(self) -> java.util.Iterator: ... + def getEntry(self, string: java.lang.String | str) -> Entry: ... + def getEntryCount(self) -> int: ... + def getStorageClsid(self) -> loci.poi.hpsf.ClassID: ... + def isEmpty(self) -> bool: ... + def setStorageClsid(self, classID: loci.poi.hpsf.ClassID) -> None: ... + +class DocumentEntry(Entry): + def getSize(self) -> int: ... + +class EntryNode(Entry): + def delete(self) -> bool: ... + def getName(self) -> java.lang.String: ... + def getParent(self) -> DirectoryEntry: ... + def isDirectoryEntry(self) -> bool: ... + def isDocumentEntry(self) -> bool: ... + def renameTo(self, string: java.lang.String | str) -> bool: ... + +class POIFSDocument( + BATManaged, loci.poi.poifs.storage.BlockWritable, loci.poi.poifs.dev.POIFSViewable +): + @typing.overload + def __init__( + self, + string: java.lang.String | str, + int: int, + pOIFSDocumentPath: POIFSDocumentPath, + pOIFSWriterListener: POIFSWriterListener | typing.Callable, + int2: int, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + listManagedBlockArray: list[loci.poi.poifs.storage.ListManagedBlock] + | jpype.JArray, + int: int, + int2: int, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + rawDataBlockArray: list[loci.poi.poifs.storage.RawDataBlock] | jpype.JArray, + int: int, + ): ... + @typing.overload + def __init__( + self, + string: java.lang.String | str, + smallDocumentBlockArray: list[loci.poi.poifs.storage.SmallDocumentBlock] + | jpype.JArray, + int: int, + ): ... + def countBlocks(self) -> int: ... + def getBigBlockSize(self) -> int: ... + def getBigBlocks( + self, + ) -> typing.MutableSequence[loci.poi.poifs.storage.DocumentBlock]: ... + def getShortDescription(self) -> java.lang.String: ... + def getSize(self) -> int: ... + def getSmallBlocks( + self, + ) -> typing.MutableSequence[loci.poi.poifs.storage.BlockWritable]: ... + def getViewableArray(self) -> typing.MutableSequence[typing.Any]: ... + def getViewableIterator(self) -> java.util.Iterator: ... + def preferArray(self) -> bool: ... + def setStartBlock(self, int: int) -> None: ... + def writeBlocks(self, outputStream: java.io.OutputStream) -> None: ... + +class DirectoryNode(EntryNode, DirectoryEntry, loci.poi.poifs.dev.POIFSViewable): + def createDirectory(self, string: java.lang.String | str) -> DirectoryEntry: ... + @typing.overload + def createDocument( + self, + string: java.lang.String | str, + int: int, + pOIFSWriterListener: POIFSWriterListener | typing.Callable, + ) -> DocumentEntry: ... + @typing.overload + def createDocument( + self, + string: java.lang.String | str, + randomAccessInputStream: loci.common.RandomAccessInputStream, + ) -> DocumentEntry: ... + def getEntries(self) -> java.util.Iterator: ... + def getEntry(self, string: java.lang.String | str) -> Entry: ... + def getEntryCount(self) -> int: ... + def getPath(self) -> POIFSDocumentPath: ... + def getShortDescription(self) -> java.lang.String: ... + def getStorageClsid(self) -> loci.poi.hpsf.ClassID: ... + def getViewableArray(self) -> typing.MutableSequence[typing.Any]: ... + def getViewableIterator(self) -> java.util.Iterator: ... + def isDirectoryEntry(self) -> bool: ... + def isEmpty(self) -> bool: ... + def preferArray(self) -> bool: ... + def setStorageClsid(self, classID: loci.poi.hpsf.ClassID) -> None: ... + +class DocumentNode(EntryNode, DocumentEntry, loci.poi.poifs.dev.POIFSViewable): + def getDocument(self) -> POIFSDocument: ... + def getShortDescription(self) -> java.lang.String: ... + def getSize(self) -> int: ... + def getViewableArray(self) -> typing.MutableSequence[typing.Any]: ... + def getViewableIterator(self) -> java.util.Iterator: ... + def isDocumentEntry(self) -> bool: ... + def preferArray(self) -> bool: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.poifs.filesystem")``. + + BATManaged: type[BATManaged] + DirectoryEntry: type[DirectoryEntry] + DirectoryNode: type[DirectoryNode] + DocumentDescriptor: type[DocumentDescriptor] + DocumentEntry: type[DocumentEntry] + DocumentInputStream: type[DocumentInputStream] + DocumentNode: type[DocumentNode] + DocumentOutputStream: type[DocumentOutputStream] + Entry: type[Entry] + EntryNode: type[EntryNode] + OfficeXmlFileException: type[OfficeXmlFileException] + POIFSDocument: type[POIFSDocument] + POIFSDocumentPath: type[POIFSDocumentPath] + POIFSFileSystem: type[POIFSFileSystem] + POIFSWriterEvent: type[POIFSWriterEvent] + POIFSWriterListener: type[POIFSWriterListener] diff --git a/typings/loci/poi/poifs/property/__init__.pyi b/typings/loci/poi/poifs/property/__init__.pyi new file mode 100644 index 0000000..ecee8e8 --- /dev/null +++ b/typings/loci/poi/poifs/property/__init__.pyi @@ -0,0 +1,105 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import loci.poi.hpsf +import loci.poi.poifs.dev +import loci.poi.poifs.filesystem +import loci.poi.poifs.storage + +class Child: + def getNextChild(self) -> Child: ... + def getPreviousChild(self) -> Child: ... + def setNextChild(self, child: Child) -> None: ... + def setPreviousChild(self, child: Child) -> None: ... + +class PropertyConstants: + PROPERTY_TYPE_OFFSET: typing.ClassVar[int] = ... + DIRECTORY_TYPE: typing.ClassVar[int] = ... + DOCUMENT_TYPE: typing.ClassVar[int] = ... + ROOT_TYPE: typing.ClassVar[int] = ... + +class PropertyTable( + loci.poi.poifs.filesystem.BATManaged, loci.poi.poifs.storage.BlockWritable +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, int: int, rawDataBlockList: loci.poi.poifs.storage.RawDataBlockList + ): ... + def addProperty(self, property: Property) -> None: ... + def countBlocks(self) -> int: ... + def getRoot(self) -> RootProperty: ... + def getStartBlock(self) -> int: ... + def preWrite(self) -> None: ... + def removeProperty(self, property: Property) -> None: ... + def setStartBlock(self, int: int) -> None: ... + def writeBlocks(self, outputStream: java.io.OutputStream) -> None: ... + +class Parent(Child): + def addChild(self, property: Property) -> None: ... + def getChildren(self) -> java.util.Iterator: ... + def setNextChild(self, child: Child) -> None: ... + def setPreviousChild(self, child: Child) -> None: ... + +class Property(Child, loci.poi.poifs.dev.POIFSViewable): + def getName(self) -> java.lang.String: ... + def getNextChild(self) -> Child: ... + def getPreviousChild(self) -> Child: ... + def getShortDescription(self) -> java.lang.String: ... + def getSize(self) -> int: ... + def getStartBlock(self) -> int: ... + def getStorageClsid(self) -> loci.poi.hpsf.ClassID: ... + def getViewableArray(self) -> typing.MutableSequence[typing.Any]: ... + def getViewableIterator(self) -> java.util.Iterator: ... + def isDirectory(self) -> bool: ... + @staticmethod + def isSmall(int: int) -> bool: ... + def preferArray(self) -> bool: ... + def setNextChild(self, child: Child) -> None: ... + def setPreviousChild(self, child: Child) -> None: ... + def setStartBlock(self, int: int) -> None: ... + def setStorageClsid(self, classID: loci.poi.hpsf.ClassID) -> None: ... + def shouldUseSmallBlocks(self) -> bool: ... + def writeData(self, outputStream: java.io.OutputStream) -> None: ... + +class DirectoryProperty(Property, Parent): + def __init__(self, string: java.lang.String | str): ... + def addChild(self, property: Property) -> None: ... + def changeName( + self, property: Property, string: java.lang.String | str + ) -> bool: ... + def deleteChild(self, property: Property) -> bool: ... + def getChildren(self) -> java.util.Iterator: ... + def isDirectory(self) -> bool: ... + class PropertyComparator(java.util.Comparator): + def __init__(self): ... + def compare(self, object: typing.Any, object2: typing.Any) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + +class DocumentProperty(Property): + def __init__(self, string: java.lang.String | str, int: int): ... + def getDocument(self) -> loci.poi.poifs.filesystem.POIFSDocument: ... + def isDirectory(self) -> bool: ... + def setDocument( + self, pOIFSDocument: loci.poi.poifs.filesystem.POIFSDocument + ) -> None: ... + def shouldUseSmallBlocks(self) -> bool: ... + +class RootProperty(DirectoryProperty): + def setSize(self, int: int) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.poifs.property")``. + + Child: type[Child] + DirectoryProperty: type[DirectoryProperty] + DocumentProperty: type[DocumentProperty] + Parent: type[Parent] + Property: type[Property] + PropertyConstants: type[PropertyConstants] + PropertyTable: type[PropertyTable] + RootProperty: type[RootProperty] diff --git a/typings/loci/poi/poifs/storage/__init__.pyi b/typings/loci/poi/poifs/storage/__init__.pyi new file mode 100644 index 0000000..6d79949 --- /dev/null +++ b/typings/loci/poi/poifs/storage/__init__.pyi @@ -0,0 +1,229 @@ +import typing +from typing import Protocol + +import java.io +import java.util +import jpype +import loci +import loci.common +import loci.poi.poifs.filesystem +import loci.poi.poifs.property + +class BlockAllocationTableReader: + def __init__( + self, + int: int, + intArray: list[int] | jpype.JArray, + int3: int, + int4: int, + blockList: BlockList, + int5: int, + ): ... + +class BlockList: + def fetchBlocks(self, int: int) -> typing.MutableSequence[ListManagedBlock]: ... + def remove(self, int: int) -> ListManagedBlock: ... + def setBAT( + self, blockAllocationTableReader: BlockAllocationTableReader + ) -> None: ... + def zap(self, int: int) -> None: ... + +class BlockWritable: + def writeBlocks(self, outputStream: java.io.OutputStream) -> None: ... + +class HeaderBlockConstants: + _signature: typing.ClassVar[int] = ... + _bat_array_offset: typing.ClassVar[int] = ... + _signature_offset: typing.ClassVar[int] = ... + _bat_count_offset: typing.ClassVar[int] = ... + _property_start_offset: typing.ClassVar[int] = ... + _sbat_start_offset: typing.ClassVar[int] = ... + _sbat_block_count_offset: typing.ClassVar[int] = ... + _xbat_start_offset: typing.ClassVar[int] = ... + _xbat_count_offset: typing.ClassVar[int] = ... + +class ListManagedBlock: + def getData(self) -> typing.MutableSequence[int]: ... + +class SmallBlockTableReader: + def __init__(self): ... + @staticmethod + def getSmallDocumentBlocks( + rawDataBlockList: RawDataBlockList, + rootProperty: loci.poi.poifs.property.RootProperty, + int: int, + ) -> BlockList: ... + +class BlockAllocationTableWriter(BlockWritable, loci.poi.poifs.filesystem.BATManaged): + def __init__(self): ... + def allocateSpace(self, int: int) -> int: ... + def countBlocks(self) -> int: ... + def createBlocks(self, int: int) -> int: ... + def getStartBlock(self) -> int: ... + def setStartBlock(self, int: int) -> None: ... + def writeBlocks(self, outputStream: java.io.OutputStream) -> None: ... + +class HeaderBlockReader(HeaderBlockConstants): + def __init__(self, inputStream: java.io.InputStream, int: int): ... + def getBATArray(self) -> typing.MutableSequence[int]: ... + def getBATCount(self) -> int: ... + def getPropertyStart(self) -> int: ... + def getSBATStart(self) -> int: ... + def getXBATCount(self) -> int: ... + def getXBATIndex(self) -> int: ... + +class RawDataBlock(ListManagedBlock): + def __init__( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + long: int, + ): ... + def eof(self) -> bool: ... + def getBlockSize(self) -> int: ... + def getData(self) -> typing.MutableSequence[int]: ... + def getLength(self) -> int: ... + def getOffset(self) -> int: ... + +class SmallBlockTableWriter(BlockWritable, loci.poi.poifs.filesystem.BATManaged): + def __init__( + self, list: java.util.List, rootProperty: loci.poi.poifs.property.RootProperty + ): ... + def countBlocks(self) -> int: ... + def getSBAT(self) -> BlockAllocationTableWriter: ... + def getSBATBlockCount(self) -> int: ... + def setStartBlock(self, int: int) -> None: ... + def writeBlocks(self, outputStream: java.io.OutputStream) -> None: ... + +class SmallDocumentBlock(BlockWritable, ListManagedBlock): + @staticmethod + def calcSize(int: int) -> int: ... + @typing.overload + @staticmethod + def convert( + byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> typing.MutableSequence[SmallDocumentBlock]: ... + @typing.overload + @staticmethod + def convert( + blockWritableArray: list[BlockWritable] | jpype.JArray, int: int + ) -> typing.MutableSequence[SmallDocumentBlock]: ... + @staticmethod + def extract( + listManagedBlockArray: list[ListManagedBlock] | jpype.JArray, int: int + ) -> java.util.List: ... + @staticmethod + def fill(list: java.util.List, int: int) -> int: ... + def getBigBlockSize(self) -> int: ... + def getData(self) -> typing.MutableSequence[int]: ... + @staticmethod + def read( + blockWritableArray: list[BlockWritable] | jpype.JArray, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + ) -> None: ... + def writeBlocks(self, outputStream: java.io.OutputStream) -> None: ... + +class BATBlock(loci.poi.poifs.storage.BigBlock): + @staticmethod + def calculateStorageRequirements(int: int, int2: int) -> int: ... + @staticmethod + def calculateXBATStorageRequirements(int: int, int2: int) -> int: ... + @staticmethod + def createBATBlocks( + intArray: list[int] | jpype.JArray, int2: int + ) -> typing.MutableSequence[BATBlock]: ... + @staticmethod + def createXBATBlocks( + intArray: list[int] | jpype.JArray, int2: int, int3: int + ) -> typing.MutableSequence[BATBlock]: ... + @staticmethod + def entriesPerBlock(int: int) -> int: ... + @staticmethod + def entriesPerXBATBlock(int: int) -> int: ... + def getBigBlockSize(self) -> int: ... + @staticmethod + def getXBATChainOffset(int: int) -> int: ... + +class DocumentBlock(loci.poi.poifs.storage.BigBlock): + @typing.overload + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream, int: int + ): ... + @typing.overload + def __init__(self, rawDataBlock: RawDataBlock, int: int): ... + @staticmethod + def convert( + long: int, + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + int2: int, + int3: int, + ) -> typing.MutableSequence[DocumentBlock]: ... + def getBigBlockSize(self) -> int: ... + @staticmethod + def getFillByte() -> int: ... + def partiallyRead(self) -> bool: ... + @staticmethod + def read( + documentBlockArray: list[DocumentBlock] | jpype.JArray, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + randomAccessInputStream: loci.common.RandomAccessInputStream, + ) -> None: ... + def size(self) -> int: ... + +class HeaderBlockWriter(loci.poi.poifs.storage.BigBlock, HeaderBlockConstants): + def __init__(self, int: int): ... + def getBigBlockSize(self) -> int: ... + def setBATBlocks( + self, int: int, int2: int, int3: int + ) -> typing.MutableSequence[BATBlock]: ... + def setPropertyStart(self, int: int) -> None: ... + def setSBATBlockCount(self, int: int) -> None: ... + def setSBATStart(self, int: int) -> None: ... + +class PropertyBlock(loci.poi.poifs.storage.BigBlock): + @staticmethod + def createPropertyBlockArray( + list: java.util.List, int: int + ) -> typing.MutableSequence[BlockWritable]: ... + def getBigBlockSize(self) -> int: ... + +class RawDataBlockList(loci.poi.poifs.storage.BlockListImpl): + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream, int: int + ): ... + def getBigBlockSize(self) -> int: ... + def getBlocks(self) -> typing.MutableSequence[ListManagedBlock]: ... + +class SmallDocumentBlockList(loci.poi.poifs.storage.BlockListImpl): + def __init__(self, list: java.util.List): ... + def getBlocks(self) -> typing.MutableSequence[ListManagedBlock]: ... + +class BigBlock: ... +class BlockListImpl: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.poifs.storage")``. + + BATBlock: type[BATBlock] + BigBlock: type[BigBlock] + BlockAllocationTableReader: type[BlockAllocationTableReader] + BlockAllocationTableWriter: type[BlockAllocationTableWriter] + BlockList: type[BlockList] + BlockListImpl: type[BlockListImpl] + BlockWritable: type[BlockWritable] + DocumentBlock: type[DocumentBlock] + HeaderBlockConstants: type[HeaderBlockConstants] + HeaderBlockReader: type[HeaderBlockReader] + HeaderBlockWriter: type[HeaderBlockWriter] + ListManagedBlock: type[ListManagedBlock] + PropertyBlock: type[PropertyBlock] + RawDataBlock: type[RawDataBlock] + RawDataBlockList: type[RawDataBlockList] + SmallBlockTableReader: type[SmallBlockTableReader] + SmallBlockTableWriter: type[SmallBlockTableWriter] + SmallDocumentBlock: type[SmallDocumentBlock] + SmallDocumentBlockList: type[SmallDocumentBlockList] diff --git a/typings/loci/poi/util/__init__.pyi b/typings/loci/poi/util/__init__.pyi new file mode 100644 index 0000000..26e96d0 --- /dev/null +++ b/typings/loci/poi/util/__init__.pyi @@ -0,0 +1,1305 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.util +import jpype + +class ArrayUtil: + def __init__(self): ... + @staticmethod + def arrayMoveWithin( + objectArray: list[typing.Any] | jpype.JArray, int: int, int2: int, int3: int + ) -> None: ... + @staticmethod + def arraycopy( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + byteArray2: list[int] | jpype.JArray | bytes, + int2: int, + int3: int, + ) -> None: ... + +class BinaryTree(java.util.AbstractMap): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, map: java.util.Map | typing.Mapping): ... + def clear(self) -> None: ... + def containsKey(self, object: typing.Any) -> bool: ... + def containsValue(self, object: typing.Any) -> bool: ... + def entrySet(self) -> java.util.Set: ... + def entrySetByValue(self) -> java.util.Set: ... + def get(self, object: typing.Any) -> typing.Any: ... + def getKeyForValue(self, object: typing.Any) -> typing.Any: ... + def keySet(self) -> java.util.Set: ... + def keySetByValue(self) -> java.util.Set: ... + def put(self, object: typing.Any, object2: typing.Any) -> typing.Any: ... + @typing.overload + def remove(self, object: typing.Any, object2: typing.Any) -> bool: ... + @typing.overload + def remove(self, object: typing.Any) -> typing.Any: ... + def removeValue(self, object: typing.Any) -> typing.Any: ... + def size(self) -> int: ... + def values(self) -> java.util.Collection: ... + def valuesByValue(self) -> java.util.Collection: ... + +class BitField: + def __init__(self, int: int): ... + def clear(self, int: int) -> int: ... + def clearByte(self, byte: int) -> int: ... + def clearShort(self, short: int) -> int: ... + def getRawValue(self, int: int) -> int: ... + def getShortRawValue(self, short: int) -> int: ... + def getShortValue(self, short: int) -> int: ... + def getValue(self, int: int) -> int: ... + def isAllSet(self, int: int) -> bool: ... + def isSet(self, int: int) -> bool: ... + def set(self, int: int) -> int: ... + def setBoolean(self, int: int, boolean: bool) -> int: ... + def setByte(self, byte: int) -> int: ... + def setByteBoolean(self, byte: int, boolean: bool) -> int: ... + def setShort(self, short: int) -> int: ... + def setShortBoolean(self, short: int, boolean: bool) -> int: ... + def setShortValue(self, short: int, short2: int) -> int: ... + def setValue(self, int: int, int2: int) -> int: ... + +class BitFieldFactory: + def __init__(self): ... + @staticmethod + def getInstance(int: int) -> BitField: ... + +class BlockingInputStream(java.io.InputStream): + def __init__(self, inputStream: java.io.InputStream): ... + def available(self) -> int: ... + def close(self) -> None: ... + def mark(self, int: int) -> None: ... + def markSupported(self) -> bool: ... + @typing.overload + def read(self) -> int: ... + @typing.overload + def read(self, byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + def read( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> int: ... + def reset(self) -> None: ... + def skip(self, long: int) -> int: ... + +class DoubleList: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, doubleList: DoubleList): ... + @typing.overload + def add(self, double: float) -> bool: ... + @typing.overload + def add(self, int: int, double: float) -> None: ... + @typing.overload + def addAll(self, int: int, doubleList: DoubleList) -> bool: ... + @typing.overload + def addAll(self, doubleList: DoubleList) -> bool: ... + def clear(self) -> None: ... + def contains(self, double: float) -> bool: ... + def containsAll(self, doubleList: DoubleList) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, int: int) -> float: ... + def hashCode(self) -> int: ... + def indexOf(self, double: float) -> int: ... + def isEmpty(self) -> bool: ... + def lastIndexOf(self, double: float) -> int: ... + def remove(self, int: int) -> float: ... + def removeAll(self, doubleList: DoubleList) -> bool: ... + def removeValue(self, double: float) -> bool: ... + def retainAll(self, doubleList: DoubleList) -> bool: ... + def set(self, int: int, double: float) -> float: ... + def size(self) -> int: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[float]: ... + @typing.overload + def toArray( + self, doubleArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + +class DoubleList2d: + def __init__(self): ... + def get(self, int: int, int2: int) -> float: ... + def set(self, int: int, int2: int, double: float) -> None: ... + +class DrawingDump: + def __init__(self): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + +class FixedField: + def readFromBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def readFromStream(self, inputStream: java.io.InputStream) -> None: ... + def toString(self) -> java.lang.String: ... + def writeToBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + +class HexDump: + EOL: typing.ClassVar[java.lang.String] = ... + @typing.overload + @staticmethod + def dump( + byteArray: list[int] | jpype.JArray | bytes, long: int, int: int + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def dump( + byteArray: list[int] | jpype.JArray | bytes, + long: int, + outputStream: java.io.OutputStream, + int: int, + ) -> None: ... + @typing.overload + @staticmethod + def dump( + byteArray: list[int] | jpype.JArray | bytes, + long: int, + outputStream: java.io.OutputStream, + int: int, + int2: int, + ) -> None: ... + @typing.overload + @staticmethod + def dump( + inputStream: java.io.InputStream, + printStream: java.io.PrintStream, + int: int, + int2: int, + ) -> None: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + @typing.overload + @staticmethod + def toHex(byte: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def toHex(byteArray: list[int] | jpype.JArray | bytes) -> java.lang.String: ... + @typing.overload + @staticmethod + def toHex( + byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def toHex(int: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def toHex(long: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def toHex(short: int) -> java.lang.String: ... + @typing.overload + @staticmethod + def toHex(shortArray: list[int] | jpype.JArray) -> java.lang.String: ... + +class HexRead: + def __init__(self): ... + @typing.overload + @staticmethod + def readData( + inputStream: java.io.InputStream, int: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def readData(string: java.lang.String | str) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def readData( + string: java.lang.String | str, string2: java.lang.String | str + ) -> typing.MutableSequence[int]: ... + @staticmethod + def readFromString( + string: java.lang.String | str, + ) -> typing.MutableSequence[int]: ... + +class IOUtils: + @typing.overload + @staticmethod + def readFully( + inputStream: java.io.InputStream, byteArray: list[int] | jpype.JArray | bytes + ) -> int: ... + @typing.overload + @staticmethod + def readFully( + inputStream: java.io.InputStream, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + ) -> int: ... + +class IntList: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, intList: IntList): ... + @typing.overload + def add(self, int: int) -> bool: ... + @typing.overload + def add(self, int: int, int2: int) -> None: ... + @typing.overload + def addAll(self, int: int, intList: IntList) -> bool: ... + @typing.overload + def addAll(self, intList: IntList) -> bool: ... + def clear(self) -> None: ... + def contains(self, int: int) -> bool: ... + def containsAll(self, intList: IntList) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, int: int) -> int: ... + def hashCode(self) -> int: ... + def indexOf(self, int: int) -> int: ... + def isEmpty(self) -> bool: ... + def lastIndexOf(self, int: int) -> int: ... + def remove(self, int: int) -> int: ... + def removeAll(self, intList: IntList) -> bool: ... + def removeValue(self, int: int) -> bool: ... + def retainAll(self, intList: IntList) -> bool: ... + def set(self, int: int, int2: int) -> int: ... + def size(self) -> int: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[int]: ... + @typing.overload + def toArray( + self, intArray: list[int] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + +class IntList2d: + def __init__(self): ... + def get(self, int: int, int2: int) -> int: ... + def isAllocated(self, int: int, int2: int) -> bool: ... + def set(self, int: int, int2: int, int3: int) -> None: ... + +class IntMapper: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + def add(self, object: typing.Any) -> bool: ... + def get(self, int: int) -> typing.Any: ... + def getIndex(self, object: typing.Any) -> int: ... + def iterator(self) -> java.util.Iterator: ... + def size(self) -> int: ... + +class List2d: + def __init__(self): ... + def get(self, int: int, int2: int) -> typing.Any: ... + def set(self, int: int, int2: int, object: typing.Any) -> None: ... + +class LittleEndianConsts: + BYTE_SIZE: typing.ClassVar[int] = ... + SHORT_SIZE: typing.ClassVar[int] = ... + INT_SIZE: typing.ClassVar[int] = ... + LONG_SIZE: typing.ClassVar[int] = ... + DOUBLE_SIZE: typing.ClassVar[int] = ... + +class POILogFactory: + @typing.overload + @staticmethod + def getLogger(class_: type) -> POILogger: ... + @typing.overload + @staticmethod + def getLogger(string: java.lang.String | str) -> POILogger: ... + +class POILogger: + DEBUG: typing.ClassVar[int] = ... + INFO: typing.ClassVar[int] = ... + WARN: typing.ClassVar[int] = ... + ERROR: typing.ClassVar[int] = ... + FATAL: typing.ClassVar[int] = ... + def check(self, int: int) -> bool: ... + def initialize(self, string: java.lang.String | str) -> None: ... + @typing.overload + def log(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def log(self, int: int, object: typing.Any, object2: typing.Any) -> None: ... + @typing.overload + def log( + self, int: int, object: typing.Any, object2: typing.Any, object3: typing.Any + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + object8: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + object8: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, int: int, object: typing.Any, throwable: java.lang.Throwable + ) -> None: ... + @typing.overload + def logFormatted( + self, int: int, string: java.lang.String | str, object: typing.Any + ) -> None: ... + @typing.overload + def logFormatted( + self, + int: int, + string: java.lang.String | str, + object: typing.Any, + object2: typing.Any, + ) -> None: ... + @typing.overload + def logFormatted( + self, + int: int, + string: java.lang.String | str, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + ) -> None: ... + @typing.overload + def logFormatted( + self, + int: int, + string: java.lang.String | str, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + ) -> None: ... + +class ShortList: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, shortList: ShortList): ... + @typing.overload + def add(self, short: int) -> bool: ... + @typing.overload + def add(self, int: int, short: int) -> None: ... + @typing.overload + def addAll(self, int: int, shortList: ShortList) -> bool: ... + @typing.overload + def addAll(self, shortList: ShortList) -> bool: ... + def clear(self) -> None: ... + def contains(self, short: int) -> bool: ... + def containsAll(self, shortList: ShortList) -> bool: ... + def equals(self, object: typing.Any) -> bool: ... + def get(self, int: int) -> int: ... + def hashCode(self) -> int: ... + def indexOf(self, short: int) -> int: ... + def isEmpty(self) -> bool: ... + def lastIndexOf(self, short: int) -> int: ... + def remove(self, int: int) -> int: ... + def removeAll(self, shortList: ShortList) -> bool: ... + def removeValue(self, short: int) -> bool: ... + def retainAll(self, shortList: ShortList) -> bool: ... + def set(self, int: int, short: int) -> int: ... + def size(self) -> int: ... + @typing.overload + def toArray(self) -> typing.MutableSequence[int]: ... + @typing.overload + def toArray( + self, shortArray: list[int] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + +class StringUtil: + @staticmethod + def format( + string: java.lang.String | str, objectArray: list[typing.Any] | jpype.JArray + ) -> java.lang.String: ... + @staticmethod + def getFromCompressedUnicode( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def getFromUnicodeBE( + byteArray: list[int] | jpype.JArray | bytes, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def getFromUnicodeBE( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def getFromUnicodeLE( + byteArray: list[int] | jpype.JArray | bytes, + ) -> java.lang.String: ... + @typing.overload + @staticmethod + def getFromUnicodeLE( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> java.lang.String: ... + @staticmethod + def getPreferredEncoding() -> java.lang.String: ... + @staticmethod + def hasMultibyte(string: java.lang.String | str) -> bool: ... + @staticmethod + def isUnicodeString(string: java.lang.String | str) -> bool: ... + @staticmethod + def putCompressedUnicode( + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + ) -> None: ... + @staticmethod + def putUnicodeBE( + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + ) -> None: ... + @staticmethod + def putUnicodeLE( + string: java.lang.String | str, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + ) -> None: ... + +class TempFile: + def __init__(self): ... + @staticmethod + def createTempFile( + string: java.lang.String | str, string2: java.lang.String | str + ) -> java.io.File: ... + +class ByteField(FixedField): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, byte: int): ... + @typing.overload + def __init__( + self, int: int, byte: int, byteArray: list[int] | jpype.JArray | bytes + ): ... + @typing.overload + def __init__(self, int: int, byteArray: list[int] | jpype.JArray | bytes): ... + def get(self) -> int: ... + def readFromBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def readFromStream(self, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def set(self, byte: int) -> None: ... + @typing.overload + def set(self, byte: int, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + def writeToBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + +class CommonsLogger(POILogger): + def __init__(self): ... + def check(self, int: int) -> bool: ... + def initialize(self, string: java.lang.String | str) -> None: ... + @typing.overload + def log(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def log(self, int: int, object: typing.Any, object2: typing.Any) -> None: ... + @typing.overload + def log( + self, int: int, object: typing.Any, object2: typing.Any, object3: typing.Any + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + object8: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + object8: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, int: int, object: typing.Any, throwable: java.lang.Throwable + ) -> None: ... + +class IntegerField(FixedField): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__( + self, int: int, int2: int, byteArray: list[int] | jpype.JArray | bytes + ): ... + def get(self) -> int: ... + def readFromBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def readFromStream(self, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def set(self, int: int) -> None: ... + @typing.overload + def set(self, int: int, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + def writeToBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + +class LittleEndian(LittleEndianConsts): + @staticmethod + def getByteArray( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def getDouble(byteArray: list[int] | jpype.JArray | bytes) -> float: ... + @typing.overload + @staticmethod + def getDouble(byteArray: list[int] | jpype.JArray | bytes, int: int) -> float: ... + @typing.overload + @staticmethod + def getInt(byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + @staticmethod + def getInt(byteArray: list[int] | jpype.JArray | bytes, int: int) -> int: ... + @typing.overload + @staticmethod + def getLong(byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + @staticmethod + def getLong(byteArray: list[int] | jpype.JArray | bytes, int: int) -> int: ... + @typing.overload + @staticmethod + def getShort(byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + @staticmethod + def getShort(byteArray: list[int] | jpype.JArray | bytes, int: int) -> int: ... + @staticmethod + def getShortArray( + byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> typing.MutableSequence[int]: ... + @staticmethod + def getSimpleShortArray( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def getUInt(byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + @staticmethod + def getUInt(byteArray: list[int] | jpype.JArray | bytes, int: int) -> int: ... + @staticmethod + def getULong(byteArray: list[int] | jpype.JArray | bytes, int: int) -> int: ... + @typing.overload + @staticmethod + def getUShort(byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + @staticmethod + def getUShort(byteArray: list[int] | jpype.JArray | bytes, int: int) -> int: ... + @typing.overload + @staticmethod + def getUnsignedByte(byteArray: list[int] | jpype.JArray | bytes) -> int: ... + @typing.overload + @staticmethod + def getUnsignedByte( + byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> int: ... + @typing.overload + @staticmethod + def putDouble( + byteArray: list[int] | jpype.JArray | bytes, double: float + ) -> None: ... + @typing.overload + @staticmethod + def putDouble( + byteArray: list[int] | jpype.JArray | bytes, int: int, double: float + ) -> None: ... + @typing.overload + @staticmethod + def putInt(byteArray: list[int] | jpype.JArray | bytes, int: int) -> None: ... + @typing.overload + @staticmethod + def putInt( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @typing.overload + @staticmethod + def putLong( + byteArray: list[int] | jpype.JArray | bytes, int: int, long: int + ) -> None: ... + @typing.overload + @staticmethod + def putLong(byteArray: list[int] | jpype.JArray | bytes, long: int) -> None: ... + @typing.overload + @staticmethod + def putShort( + byteArray: list[int] | jpype.JArray | bytes, int: int, short: int + ) -> None: ... + @typing.overload + @staticmethod + def putShort(byteArray: list[int] | jpype.JArray | bytes, short: int) -> None: ... + @staticmethod + def putShortArray( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + shortArray: list[int] | jpype.JArray, + ) -> None: ... + @staticmethod + def putUShort( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + @staticmethod + def readFromStream( + inputStream: java.io.InputStream, int: int + ) -> typing.MutableSequence[int]: ... + @staticmethod + def readInt(inputStream: java.io.InputStream) -> int: ... + @staticmethod + def readLong(inputStream: java.io.InputStream) -> int: ... + @staticmethod + def readShort(inputStream: java.io.InputStream) -> int: ... + @staticmethod + def ubyteToInt(byte: int) -> int: ... + class BufferUnderrunException(java.io.IOException): ... + +class LongField(FixedField): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, int: int, long: int): ... + @typing.overload + def __init__( + self, int: int, long: int, byteArray: list[int] | jpype.JArray | bytes + ): ... + def get(self) -> int: ... + def readFromBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def readFromStream(self, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def set(self, long: int) -> None: ... + @typing.overload + def set(self, long: int, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + def writeToBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + +class NullLogger(POILogger): + def __init__(self): ... + def check(self, int: int) -> bool: ... + def initialize(self, string: java.lang.String | str) -> None: ... + @typing.overload + def log(self, int: int, object: typing.Any) -> None: ... + @typing.overload + def log(self, int: int, object: typing.Any, object2: typing.Any) -> None: ... + @typing.overload + def log( + self, int: int, object: typing.Any, object2: typing.Any, object3: typing.Any + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + object8: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + object8: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, int: int, object: typing.Any, throwable: java.lang.Throwable + ) -> None: ... + @typing.overload + def logFormatted( + self, int: int, string: java.lang.String | str, object: typing.Any + ) -> None: ... + @typing.overload + def logFormatted( + self, + int: int, + string: java.lang.String | str, + object: typing.Any, + object2: typing.Any, + ) -> None: ... + @typing.overload + def logFormatted( + self, + int: int, + string: java.lang.String | str, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + ) -> None: ... + @typing.overload + def logFormatted( + self, + int: int, + string: java.lang.String | str, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + ) -> None: ... + +class ShortField(FixedField): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, int: int, short: int): ... + @typing.overload + def __init__( + self, int: int, short: int, byteArray: list[int] | jpype.JArray | bytes + ): ... + def get(self) -> int: ... + def readFromBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def readFromStream(self, inputStream: java.io.InputStream) -> None: ... + @typing.overload + def set(self, short: int) -> None: ... + @typing.overload + def set(self, short: int, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def toString(self) -> java.lang.String: ... + def writeToBytes(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + +class SystemOutLogger(POILogger): + def __init__(self): ... + def check(self, int: int) -> bool: ... + def initialize(self, string: java.lang.String | str) -> None: ... + @typing.overload + def log(self, int: int, object: typing.Any, object2: typing.Any) -> None: ... + @typing.overload + def log( + self, int: int, object: typing.Any, object2: typing.Any, object3: typing.Any + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + object8: typing.Any, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + object8: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + object7: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + object6: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + object5: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + object4: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + object3: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, + int: int, + object: typing.Any, + object2: typing.Any, + throwable: java.lang.Throwable, + ) -> None: ... + @typing.overload + def log( + self, int: int, object: typing.Any, throwable: java.lang.Throwable + ) -> None: ... + @typing.overload + def log(self, int: int, object: typing.Any) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("loci.poi.util")``. + + ArrayUtil: type[ArrayUtil] + BinaryTree: type[BinaryTree] + BitField: type[BitField] + BitFieldFactory: type[BitFieldFactory] + BlockingInputStream: type[BlockingInputStream] + ByteField: type[ByteField] + CommonsLogger: type[CommonsLogger] + DoubleList: type[DoubleList] + DoubleList2d: type[DoubleList2d] + DrawingDump: type[DrawingDump] + FixedField: type[FixedField] + HexDump: type[HexDump] + HexRead: type[HexRead] + IOUtils: type[IOUtils] + IntList: type[IntList] + IntList2d: type[IntList2d] + IntMapper: type[IntMapper] + IntegerField: type[IntegerField] + List2d: type[List2d] + LittleEndian: type[LittleEndian] + LittleEndianConsts: type[LittleEndianConsts] + LongField: type[LongField] + NullLogger: type[NullLogger] + POILogFactory: type[POILogFactory] + POILogger: type[POILogger] + ShortField: type[ShortField] + ShortList: type[ShortList] + StringUtil: type[StringUtil] + SystemOutLogger: type[SystemOutLogger] + TempFile: type[TempFile] diff --git a/typings/ome/__init__.pyi b/typings/ome/__init__.pyi new file mode 100644 index 0000000..1245c2b --- /dev/null +++ b/typings/ome/__init__.pyi @@ -0,0 +1,18 @@ +from typing import Protocol + +import ome.codecs +import ome.jxrlib +import ome.metakit +import ome.specification +import ome.units +import ome.xml + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome")``. + + codecs: ome.codecs.__module_protocol__ + jxrlib: ome.jxrlib.__module_protocol__ + metakit: ome.metakit.__module_protocol__ + specification: ome.specification.__module_protocol__ + units: ome.units.__module_protocol__ + xml: ome.xml.__module_protocol__ diff --git a/typings/ome/codecs/__init__.pyi b/typings/ome/codecs/__init__.pyi new file mode 100644 index 0000000..6dee785 --- /dev/null +++ b/typings/ome/codecs/__init__.pyi @@ -0,0 +1,1176 @@ +import typing +from typing import Protocol + +import java.awt.image +import java.lang +import java.nio +import jpype +import loci.common +import loci.common.enumeration +import ome.codecs.gui +import ome.codecs.services + +class BitBuffer: + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + def getBits(self, int: int) -> int: ... + def getByteBuffer(self) -> typing.MutableSequence[int]: ... + def isBitOnByteBoundary(self) -> bool: ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def skipBits(self, long: int) -> None: ... + +class BitWriter: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, int: int): ... + @staticmethod + def main(stringArray: list[java.lang.String] | jpype.JArray) -> None: ... + def toByteArray(self) -> typing.MutableSequence[int]: ... + @typing.overload + def write(self, int: int, int2: int) -> None: ... + @typing.overload + def write(self, string: java.lang.String | str) -> None: ... + +class ByteVector: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def add(self, byte: int) -> None: ... + @typing.overload + def add(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + @typing.overload + def add( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def clear(self) -> None: ... + def get(self, int: int) -> int: ... + def size(self) -> int: ... + def toByteArray(self) -> typing.MutableSequence[int]: ... + +class Codec: + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class CodecException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class CodecOptions: + width: int = ... + height: int = ... + channels: int = ... + bitsPerSample: int = ... + littleEndian: bool = ... + interleaved: bool = ... + signed: bool = ... + tileWidth: int = ... + tileHeight: int = ... + tileGridXOffset: int = ... + tileGridYOffset: int = ... + maxBytes: int = ... + previousImage: typing.MutableSequence[int] = ... + lossless: bool = ... + colorModel: java.awt.image.ColorModel = ... + quality: float = ... + ycbcr: bool = ... + disableChromaSubsampling: bool = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, codecOptions: CodecOptions): ... + @staticmethod + def getDefaultOptions() -> CodecOptions: ... + +class CompressionType( + java.lang.Enum["CompressionType"], loci.common.enumeration.CodedEnum +): + UNCOMPRESSED: typing.ClassVar[CompressionType] = ... + ZLIB: typing.ClassVar[CompressionType] = ... + CINEPAK: typing.ClassVar[CompressionType] = ... + ANIMATION: typing.ClassVar[CompressionType] = ... + H_263: typing.ClassVar[CompressionType] = ... + SORENSON: typing.ClassVar[CompressionType] = ... + SORENSON_3: typing.ClassVar[CompressionType] = ... + MPEG_4: typing.ClassVar[CompressionType] = ... + LZW: typing.ClassVar[CompressionType] = ... + J2K: typing.ClassVar[CompressionType] = ... + J2K_LOSSY: typing.ClassVar[CompressionType] = ... + JPEG: typing.ClassVar[CompressionType] = ... + @staticmethod + def get(int: int) -> CompressionType: ... + def getCode(self) -> int: ... + def getCompression(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> CompressionType: ... + @staticmethod + def values() -> typing.MutableSequence[CompressionType]: ... + +class JPEG2000BoxType( + java.lang.Enum["JPEG2000BoxType"], loci.common.enumeration.CodedEnum +): + SIGNATURE: typing.ClassVar[JPEG2000BoxType] = ... + SIGNATURE_WRONG_ENDIANNESS: typing.ClassVar[JPEG2000BoxType] = ... + FILE: typing.ClassVar[JPEG2000BoxType] = ... + HEADER: typing.ClassVar[JPEG2000BoxType] = ... + IMAGE_HEADER: typing.ClassVar[JPEG2000BoxType] = ... + BITS_PER_COMPONENT: typing.ClassVar[JPEG2000BoxType] = ... + COLOUR_SPECIFICATION: typing.ClassVar[JPEG2000BoxType] = ... + PALETTE: typing.ClassVar[JPEG2000BoxType] = ... + COMPONENT_MAPPING: typing.ClassVar[JPEG2000BoxType] = ... + CHANNEL_DEFINITION: typing.ClassVar[JPEG2000BoxType] = ... + RESOLUTION: typing.ClassVar[JPEG2000BoxType] = ... + CAPTURE_RESOLUTION: typing.ClassVar[JPEG2000BoxType] = ... + DEFAULT_DISPLAY_RESOLUTION: typing.ClassVar[JPEG2000BoxType] = ... + CONTIGUOUS_CODESTREAM: typing.ClassVar[JPEG2000BoxType] = ... + INTELLECTUAL_PROPERTY: typing.ClassVar[JPEG2000BoxType] = ... + XML: typing.ClassVar[JPEG2000BoxType] = ... + UUID: typing.ClassVar[JPEG2000BoxType] = ... + UUID_INFO: typing.ClassVar[JPEG2000BoxType] = ... + UUID_LIST: typing.ClassVar[JPEG2000BoxType] = ... + URL: typing.ClassVar[JPEG2000BoxType] = ... + ASSOCIATION: typing.ClassVar[JPEG2000BoxType] = ... + LABEL: typing.ClassVar[JPEG2000BoxType] = ... + PLACEHOLDER: typing.ClassVar[JPEG2000BoxType] = ... + @staticmethod + def get(int: int) -> JPEG2000BoxType: ... + def getCode(self) -> int: ... + def getName(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> JPEG2000BoxType: ... + @staticmethod + def values() -> typing.MutableSequence[JPEG2000BoxType]: ... + +class JPEG2000SegmentMarker( + java.lang.Enum["JPEG2000SegmentMarker"], loci.common.enumeration.CodedEnum +): + RESERVED_DELIMITER_MARKER_MIN: typing.ClassVar[JPEG2000SegmentMarker] = ... + RESERVED_DELIMITER_MARKER_MAX: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOC: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOC_WRONG_ENDIANNESS: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOT: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOD: typing.ClassVar[JPEG2000SegmentMarker] = ... + EOC: typing.ClassVar[JPEG2000SegmentMarker] = ... + SIZ: typing.ClassVar[JPEG2000SegmentMarker] = ... + COD: typing.ClassVar[JPEG2000SegmentMarker] = ... + COC: typing.ClassVar[JPEG2000SegmentMarker] = ... + RGN: typing.ClassVar[JPEG2000SegmentMarker] = ... + QCD: typing.ClassVar[JPEG2000SegmentMarker] = ... + QCC: typing.ClassVar[JPEG2000SegmentMarker] = ... + POC: typing.ClassVar[JPEG2000SegmentMarker] = ... + TLM: typing.ClassVar[JPEG2000SegmentMarker] = ... + PLM: typing.ClassVar[JPEG2000SegmentMarker] = ... + PLT: typing.ClassVar[JPEG2000SegmentMarker] = ... + PPM: typing.ClassVar[JPEG2000SegmentMarker] = ... + PPT: typing.ClassVar[JPEG2000SegmentMarker] = ... + SOP: typing.ClassVar[JPEG2000SegmentMarker] = ... + EPH: typing.ClassVar[JPEG2000SegmentMarker] = ... + CRG: typing.ClassVar[JPEG2000SegmentMarker] = ... + COM: typing.ClassVar[JPEG2000SegmentMarker] = ... + @staticmethod + def get(int: int) -> JPEG2000SegmentMarker: ... + def getCode(self) -> int: ... + def getName(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> JPEG2000SegmentMarker: ... + @staticmethod + def values() -> typing.MutableSequence[JPEG2000SegmentMarker]: ... + +class JPEGTileDecoder(java.lang.AutoCloseable): + def __init__(self): ... + def close(self) -> None: ... + def getHeight(self) -> int: ... + def getScanline(self, int: int) -> typing.MutableSequence[int]: ... + def getWidth(self) -> int: ... + @typing.overload + def initialize(self, string: java.lang.String | str, int: int) -> None: ... + @typing.overload + def initialize( + self, randomAccessInputStream: loci.common.RandomAccessInputStream, int: int + ) -> None: ... + @typing.overload + def initialize( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + int2: int, + int3: int, + ) -> None: ... + def preprocess( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ) -> typing.MutableSequence[int]: ... + +class BaseCodec(Codec): + def __init__(self): ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + def test(self) -> None: ... + +class HuffmanCodecOptions(CodecOptions): + table: typing.MutableSequence[int] = ... + def __init__(self): ... + +class JPEG2000CodecOptions(CodecOptions): + codeBlockSize: typing.MutableSequence[int] = ... + numDecompositionLevels: int = ... + resolution: int = ... + writeBox: bool = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, codecOptions: CodecOptions): ... + @typing.overload + @staticmethod + def getDefaultOptions() -> CodecOptions: ... + @typing.overload + @staticmethod + def getDefaultOptions() -> JPEG2000CodecOptions: ... + @typing.overload + @staticmethod + def getDefaultOptions(codecOptions: CodecOptions) -> JPEG2000CodecOptions: ... + +class MJPBCodecOptions(CodecOptions): + interlaced: bool = ... + def __init__(self): ... + +class MissingLibraryException(CodecException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class UnsupportedCompressionException(CodecException): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class Base64Codec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class HuffmanCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def getSample( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> int: ... + @typing.overload + def getSample(self, bitBuffer: BitBuffer, codecOptions: CodecOptions) -> int: ... + +class JPEG2000Codec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class JPEGCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class LZ4Codec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class LZOCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class LZWCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class LosslessJPEGCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class MJPBCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class MSRLECodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class MSVideoCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class PackbitsCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class PassthroughCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class QTRLECodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class RPZACodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class ZlibCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class ZstdCodec(BaseCodec): + def __init__(self): ... + @typing.overload + def compress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def compress( + self, + byteBuffer: java.nio.ByteBuffer, + byteArray: list[int] | jpype.JArray | bytes, + codecOptions: CodecOptions, + ) -> java.nio.ByteBuffer: ... + @typing.overload + def decompress( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, byteArray: list[int] | jpype.JArray | bytes, codecOptions: CodecOptions + ) -> typing.MutableSequence[int]: ... + @typing.overload + def decompress( + self, + randomAccessInputStream: loci.common.RandomAccessInputStream, + codecOptions: CodecOptions, + ) -> typing.MutableSequence[int]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.codecs")``. + + Base64Codec: type[Base64Codec] + BaseCodec: type[BaseCodec] + BitBuffer: type[BitBuffer] + BitWriter: type[BitWriter] + ByteVector: type[ByteVector] + Codec: type[Codec] + CodecException: type[CodecException] + CodecOptions: type[CodecOptions] + CompressionType: type[CompressionType] + HuffmanCodec: type[HuffmanCodec] + HuffmanCodecOptions: type[HuffmanCodecOptions] + JPEG2000BoxType: type[JPEG2000BoxType] + JPEG2000Codec: type[JPEG2000Codec] + JPEG2000CodecOptions: type[JPEG2000CodecOptions] + JPEG2000SegmentMarker: type[JPEG2000SegmentMarker] + JPEGCodec: type[JPEGCodec] + JPEGTileDecoder: type[JPEGTileDecoder] + LZ4Codec: type[LZ4Codec] + LZOCodec: type[LZOCodec] + LZWCodec: type[LZWCodec] + LosslessJPEGCodec: type[LosslessJPEGCodec] + MJPBCodec: type[MJPBCodec] + MJPBCodecOptions: type[MJPBCodecOptions] + MSRLECodec: type[MSRLECodec] + MSVideoCodec: type[MSVideoCodec] + MissingLibraryException: type[MissingLibraryException] + PackbitsCodec: type[PackbitsCodec] + PassthroughCodec: type[PassthroughCodec] + QTRLECodec: type[QTRLECodec] + RPZACodec: type[RPZACodec] + UnsupportedCompressionException: type[UnsupportedCompressionException] + ZlibCodec: type[ZlibCodec] + ZstdCodec: type[ZstdCodec] + gui: ome.codecs.gui.__module_protocol__ + services: ome.codecs.services.__module_protocol__ diff --git a/typings/ome/codecs/gui/__init__.pyi b/typings/ome/codecs/gui/__init__.pyi new file mode 100644 index 0000000..5de60d7 --- /dev/null +++ b/typings/ome/codecs/gui/__init__.pyi @@ -0,0 +1,492 @@ +import typing +from typing import Protocol + +import java.awt.color +import java.awt.image +import java.lang +import jpype + +class AWTImageTools: + @typing.overload + @staticmethod + def constructImage( + int: int, + int2: int, + int3: int, + int4: int, + boolean: bool, + boolean2: bool, + dataBuffer: java.awt.image.DataBuffer, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def constructImage( + int: int, + int2: int, + int3: int, + int4: int, + boolean: bool, + boolean2: bool, + dataBuffer: java.awt.image.DataBuffer, + colorModel: java.awt.image.ColorModel, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def getBytes( + bufferedImage: java.awt.image.BufferedImage, boolean: bool + ) -> typing.MutableSequence[int]: ... + @typing.overload + @staticmethod + def getBytes( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getBytes( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getBytes( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getDoubles( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getDoubles( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getDoubles( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getFloats( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getFloats( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getFloats( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + @typing.overload + @staticmethod + def getInts( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getInts( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getInts( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getPixelBytes( + bufferedImage: java.awt.image.BufferedImage, boolean: bool + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getPixelBytes( + bufferedImage: java.awt.image.BufferedImage, + boolean: bool, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getPixelBytes( + writableRaster: java.awt.image.WritableRaster, boolean: bool + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getPixelBytes( + writableRaster: java.awt.image.WritableRaster, + boolean: bool, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getPixels(bufferedImage: java.awt.image.BufferedImage) -> typing.Any: ... + @typing.overload + @staticmethod + def getPixels( + bufferedImage: java.awt.image.BufferedImage, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.Any: ... + @typing.overload + @staticmethod + def getPixels(writableRaster: java.awt.image.WritableRaster) -> typing.Any: ... + @typing.overload + @staticmethod + def getPixels( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.Any: ... + @typing.overload + @staticmethod + def getShorts( + bufferedImage: java.awt.image.BufferedImage, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getShorts( + writableRaster: java.awt.image.WritableRaster, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @typing.overload + @staticmethod + def getShorts( + writableRaster: java.awt.image.WritableRaster, + int: int, + int2: int, + int3: int, + int4: int, + ) -> typing.MutableSequence[typing.MutableSequence[int]]: ... + @staticmethod + def makeColorModel(int: int, int2: int) -> java.awt.image.ColorModel: ... + @staticmethod + def makeColorSpace(int: int) -> java.awt.color.ColorSpace: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int, boolean: bool + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + boolean: bool, + boolean2: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + boolean: bool, + int4: int, + boolean2: bool, + boolean3: bool, + boolean4: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + int2: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + int2: int, + int3: int, + boolean: bool, + boolean2: bool, + boolean3: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + doubleArray: list[float] | jpype.JArray, int: int, int2: int + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + doubleArray: list[float] | jpype.JArray, + int: int, + int2: int, + int3: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + doubleArray: list[typing.MutableSequence[float]] | jpype.JArray, + int: int, + int2: int, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + floatArray: list[float] | jpype.JArray, int: int, int2: int + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + floatArray: list[float] | jpype.JArray, + int: int, + int2: int, + int3: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + floatArray: list[typing.MutableSequence[float]] | jpype.JArray, + int: int, + int2: int, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + intArray: list[int] | jpype.JArray, int2: int, int3: int, boolean: bool + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + intArray: list[int] | jpype.JArray, + int2: int, + int3: int, + int4: int, + boolean: bool, + boolean2: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + intArray: list[typing.MutableSequence[int]] | jpype.JArray, + int2: int, + int3: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + shortArray: list[int] | jpype.JArray, int: int, int2: int, boolean: bool + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + shortArray: list[int] | jpype.JArray, + int: int, + int2: int, + int3: int, + boolean: bool, + boolean2: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeImage( + shortArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + int2: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeRGBImage( + byteArray: list[int] | jpype.JArray | bytes, + int: int, + int2: int, + int3: int, + boolean: bool, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + @staticmethod + def makeRGBImage( + byteArray: list[typing.MutableSequence[int]] | jpype.JArray, int: int, int2: int + ) -> java.awt.image.BufferedImage: ... + +class SignedByteBuffer(java.awt.image.DataBuffer): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes, int: int): ... + @typing.overload + def __init__( + self, byteArray: list[typing.MutableSequence[int]] | jpype.JArray, int: int + ): ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + +class SignedShortBuffer(java.awt.image.DataBuffer): + @typing.overload + def __init__(self, int: int): ... + @typing.overload + def __init__(self, int: int, int2: int): ... + @typing.overload + def __init__(self, shortArray: list[int] | jpype.JArray, int: int): ... + @typing.overload + def __init__(self, shortArray: list[int] | jpype.JArray, int: int, int2: int): ... + @typing.overload + def __init__( + self, shortArray: list[typing.MutableSequence[int]] | jpype.JArray, int: int + ): ... + @typing.overload + def __init__( + self, + shortArray: list[typing.MutableSequence[int]] | jpype.JArray, + int: int, + intArray: list[int] | jpype.JArray, + ): ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + +class TwoChannelColorSpace(java.awt.color.ColorSpace): + CS_2C: typing.ClassVar[int] = ... + def fromCIEXYZ( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def fromRGB( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + @staticmethod + def getInstance(int: int) -> java.awt.color.ColorSpace: ... + def getName(self, int: int) -> java.lang.String: ... + def getNumComponents(self) -> int: ... + def getType(self) -> int: ... + def isCS_sRGB(self) -> bool: ... + def toCIEXYZ( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + def toRGB( + self, floatArray: list[float] | jpype.JArray + ) -> typing.MutableSequence[float]: ... + +class UnsignedIntBuffer(java.awt.image.DataBuffer): + @typing.overload + def __init__(self, intArray: list[int] | jpype.JArray, int2: int): ... + @typing.overload + def __init__( + self, intArray: list[typing.MutableSequence[int]] | jpype.JArray, int2: int + ): ... + @typing.overload + def getData(self) -> typing.MutableSequence[int]: ... + @typing.overload + def getData(self, int: int) -> typing.MutableSequence[int]: ... + @typing.overload + def getElem(self, int: int) -> int: ... + @typing.overload + def getElem(self, int: int, int2: int) -> int: ... + @typing.overload + def getElemDouble(self, int: int) -> float: ... + @typing.overload + def getElemDouble(self, int: int, int2: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int) -> float: ... + @typing.overload + def getElemFloat(self, int: int, int2: int) -> float: ... + @typing.overload + def setElem(self, int: int, int2: int) -> None: ... + @typing.overload + def setElem(self, int: int, int2: int, int3: int) -> None: ... + @typing.overload + def setElemDouble(self, int: int, double: float) -> None: ... + @typing.overload + def setElemDouble(self, int: int, int2: int, double: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, float: float) -> None: ... + @typing.overload + def setElemFloat(self, int: int, int2: int, float: float) -> None: ... + +class UnsignedIntColorModel(java.awt.image.ColorModel): + def __init__(self, int: int, int2: int, int3: int): ... + def createCompatibleWritableRaster( + self, int: int, int2: int + ) -> java.awt.image.WritableRaster: ... + @typing.overload + def getAlpha(self, int: int) -> int: ... + @typing.overload + def getAlpha(self, object: typing.Any) -> int: ... + @typing.overload + def getBlue(self, int: int) -> int: ... + @typing.overload + def getBlue(self, object: typing.Any) -> int: ... + @typing.overload + def getDataElements( + self, floatArray: list[float] | jpype.JArray, int: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements( + self, intArray: list[int] | jpype.JArray, int2: int, object: typing.Any + ) -> typing.Any: ... + @typing.overload + def getDataElements(self, int: int, object: typing.Any) -> typing.Any: ... + @typing.overload + def getGreen(self, int: int) -> int: ... + @typing.overload + def getGreen(self, object: typing.Any) -> int: ... + @typing.overload + def getRed(self, int: int) -> int: ... + @typing.overload + def getRed(self, object: typing.Any) -> int: ... + def isCompatibleRaster(self, raster: java.awt.image.Raster) -> bool: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.codecs.gui")``. + + AWTImageTools: type[AWTImageTools] + SignedByteBuffer: type[SignedByteBuffer] + SignedShortBuffer: type[SignedShortBuffer] + TwoChannelColorSpace: type[TwoChannelColorSpace] + UnsignedIntBuffer: type[UnsignedIntBuffer] + UnsignedIntColorModel: type[UnsignedIntColorModel] diff --git a/typings/ome/codecs/services/__init__.pyi b/typings/ome/codecs/services/__init__.pyi new file mode 100644 index 0000000..7821647 --- /dev/null +++ b/typings/ome/codecs/services/__init__.pyi @@ -0,0 +1,68 @@ +import typing +from typing import Protocol + +import java.awt.image +import java.io +import java.lang +import loci.common.services +import ome.codecs + +class JAIIIOService(loci.common.services.Service): + @typing.overload + def readImage( + self, inputStream: java.io.InputStream + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def readImage( + self, + inputStream: java.io.InputStream, + jPEG2000CodecOptions: ome.codecs.JPEG2000CodecOptions, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def readRaster(self, inputStream: java.io.InputStream) -> java.awt.image.Raster: ... + @typing.overload + def readRaster( + self, + inputStream: java.io.InputStream, + jPEG2000CodecOptions: ome.codecs.JPEG2000CodecOptions, + ) -> java.awt.image.Raster: ... + def writeImage( + self, + outputStream: java.io.OutputStream, + bufferedImage: java.awt.image.BufferedImage, + jPEG2000CodecOptions: ome.codecs.JPEG2000CodecOptions, + ) -> None: ... + +class JAIIIOServiceImpl(loci.common.services.AbstractService, JAIIIOService): + NO_J2K_MSG: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def readImage( + self, inputStream: java.io.InputStream + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def readImage( + self, + inputStream: java.io.InputStream, + jPEG2000CodecOptions: ome.codecs.JPEG2000CodecOptions, + ) -> java.awt.image.BufferedImage: ... + @typing.overload + def readRaster(self, inputStream: java.io.InputStream) -> java.awt.image.Raster: ... + @typing.overload + def readRaster( + self, + inputStream: java.io.InputStream, + jPEG2000CodecOptions: ome.codecs.JPEG2000CodecOptions, + ) -> java.awt.image.Raster: ... + def writeImage( + self, + outputStream: java.io.OutputStream, + bufferedImage: java.awt.image.BufferedImage, + jPEG2000CodecOptions: ome.codecs.JPEG2000CodecOptions, + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.codecs.services")``. + + JAIIIOService: type[JAIIIOService] + JAIIIOServiceImpl: type[JAIIIOServiceImpl] diff --git a/typings/ome/jxrlib/__init__.pyi b/typings/ome/jxrlib/__init__.pyi new file mode 100644 index 0000000..38b3f06 --- /dev/null +++ b/typings/ome/jxrlib/__init__.pyi @@ -0,0 +1,78 @@ +import typing +from typing import Protocol + +import java.io +import java.lang +import java.nio +import jpype +import jpype.protocol +import ome + +class DecodeContext: + def __init__(self): ... + def decodeFirstFrame( + self, byteArray: list[int] | jpype.JArray | bytes, long: int, long2: int + ) -> typing.MutableSequence[int]: ... + def delete(self) -> None: ... + +class DecodeException(java.lang.Exception): + def __init__(self, string: java.lang.String | str): ... + +class FormatError(java.lang.Exception): + def __init__(self, string: java.lang.String | str): ... + def delete(self) -> None: ... + def getMessage(self) -> java.lang.String: ... + +class GUID: + def __init__(self): ... + def delete(self) -> None: ... + def getData1(self) -> int: ... + def getData2(self) -> int: ... + def getData3(self) -> int: ... + def getData4(self) -> typing.MutableSequence[int]: ... + def setData1(self, long: int) -> None: ... + def setData2(self, int: int) -> None: ... + def setData3(self, int: int) -> None: ... + def setData4(self, shortArray: list[int] | jpype.JArray) -> None: ... + +class ImageData: + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, long: int): ... + def add(self, char: str) -> None: ... + def capacity(self) -> int: ... + def clear(self) -> None: ... + def delete(self) -> None: ... + def get(self, int: int) -> str: ... + def isEmpty(self) -> bool: ... + def reserve(self, long: int) -> None: ... + def set(self, int: int, char: str) -> None: ... + def size(self) -> int: ... + +class Decode(ome.jxrlib.AbstractDecode): + @typing.overload + def __init__(self, byteArray: list[int] | jpype.JArray | bytes): ... + @typing.overload + def __init__(self, file: java.io.File | jpype.protocol.SupportsPath): ... + @typing.overload + def __init__(self, byteBuffer: java.nio.ByteBuffer): ... + @typing.overload + def __init__(self, byteBuffer: java.nio.ByteBuffer, int: int, int2: int): ... + @staticmethod + def decodeFirstFrame( + byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> typing.MutableSequence[int]: ... + +class AbstractDecode: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.jxrlib")``. + + AbstractDecode: type[AbstractDecode] + Decode: type[Decode] + DecodeContext: type[DecodeContext] + DecodeException: type[DecodeException] + FormatError: type[FormatError] + GUID: type[GUID] + ImageData: type[ImageData] diff --git a/typings/ome/metakit/__init__.pyi b/typings/ome/metakit/__init__.pyi new file mode 100644 index 0000000..61147c1 --- /dev/null +++ b/typings/ome/metakit/__init__.pyi @@ -0,0 +1,96 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import loci.common + +class Column: + def __init__(self, string: java.lang.String | str): ... + def getName(self) -> java.lang.String: ... + def getType(self) -> type: ... + def getTypeString(self) -> java.lang.String: ... + +class ColumnMap: + def __init__( + self, + column: Column, + randomAccessInputStream: loci.common.RandomAccessInputStream, + int: int, + ): ... + def getValueList(self) -> java.util.ArrayList: ... + def getValues(self) -> typing.MutableSequence[typing.Any]: ... + def isFixedMap(self) -> bool: ... + +class MetakitException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class MetakitReader: + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, randomAccessInputStream: loci.common.RandomAccessInputStream + ): ... + def close(self) -> None: ... + @typing.overload + def getColumnNames(self, int: int) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getColumnNames( + self, string: java.lang.String | str + ) -> typing.MutableSequence[java.lang.String]: ... + @typing.overload + def getColumnTypes(self, int: int) -> typing.MutableSequence[type]: ... + @typing.overload + def getColumnTypes( + self, string: java.lang.String | str + ) -> typing.MutableSequence[type]: ... + @typing.overload + def getRowCount(self, int: int) -> int: ... + @typing.overload + def getRowCount(self, string: java.lang.String | str) -> int: ... + @typing.overload + def getRowData(self, int: int, int2: int) -> typing.MutableSequence[typing.Any]: ... + @typing.overload + def getRowData( + self, int: int, string: java.lang.String | str + ) -> typing.MutableSequence[typing.Any]: ... + def getTableCount(self) -> int: ... + @typing.overload + def getTableData( + self, int: int + ) -> typing.MutableSequence[typing.MutableSequence[typing.Any]]: ... + @typing.overload + def getTableData( + self, string: java.lang.String | str + ) -> typing.MutableSequence[typing.MutableSequence[typing.Any]]: ... + def getTableNames(self) -> typing.MutableSequence[java.lang.String]: ... + +class MetakitTools: + def __init__(self): ... + @staticmethod + def readBpInt( + randomAccessInputStream: loci.common.RandomAccessInputStream, + ) -> int: ... + @staticmethod + def readPString( + randomAccessInputStream: loci.common.RandomAccessInputStream, + ) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.metakit")``. + + Column: type[Column] + ColumnMap: type[ColumnMap] + MetakitException: type[MetakitException] + MetakitReader: type[MetakitReader] + MetakitTools: type[MetakitTools] diff --git a/typings/ome/specification/__init__.pyi b/typings/ome/specification/__init__.pyi new file mode 100644 index 0000000..eca2890 --- /dev/null +++ b/typings/ome/specification/__init__.pyi @@ -0,0 +1,309 @@ +import typing +from typing import Protocol + +import java.awt +import java.io +import java.lang +import javax.xml.transform.stream +import jpype +import jpype.protocol +import ome.xml.model +import ome.xml.model.enums +import org.w3c.dom +import org.w3c.dom.ls + +class OmeValidator: + JAXP_SCHEMA_LANGUAGE: typing.ClassVar[java.lang.String] = ... + W3C_XML_SCHEMA: typing.ClassVar[java.lang.String] = ... + JAXP_SCHEMA_SOURCE: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def isValidFile( + self, + file: java.io.File | jpype.protocol.SupportsPath, + file2: java.io.File | jpype.protocol.SupportsPath, + ) -> bool: ... + @typing.overload + def isValidFile( + self, + file: java.io.File | jpype.protocol.SupportsPath, + streamSourceArray: list[javax.xml.transform.stream.StreamSource] | jpype.JArray, + ) -> bool: ... + @typing.overload + def parseFile( + self, file: java.io.File | jpype.protocol.SupportsPath + ) -> org.w3c.dom.Document: ... + @typing.overload + def parseFile( + self, + file: java.io.File | jpype.protocol.SupportsPath, + file2: java.io.File | jpype.protocol.SupportsPath, + ) -> org.w3c.dom.Document: ... + def parseFileWithStreamArray( + self, + file: java.io.File | jpype.protocol.SupportsPath, + streamSourceArray: list[javax.xml.transform.stream.StreamSource] | jpype.JArray, + ) -> org.w3c.dom.Document: ... + def parseFileWithStreamArrayToSdtErr( + self, + file: java.io.File | jpype.protocol.SupportsPath, + streamSourceArray: list[javax.xml.transform.stream.StreamSource] | jpype.JArray, + ) -> org.w3c.dom.Document: ... + @typing.overload + def validateFile( + self, + file: java.io.File | jpype.protocol.SupportsPath, + file2: java.io.File | jpype.protocol.SupportsPath, + ) -> None: ... + @typing.overload + def validateFile( + self, + file: java.io.File | jpype.protocol.SupportsPath, + streamSourceArray: list[javax.xml.transform.stream.StreamSource] | jpype.JArray, + ) -> None: ... + def validateFileToStdError( + self, + file: java.io.File | jpype.protocol.SupportsPath, + streamSourceArray: list[javax.xml.transform.stream.StreamSource] | jpype.JArray, + ) -> None: ... + +class SchemaResolver(org.w3c.dom.ls.LSResourceResolver): + def __init__(self): ... + def resolveResource( + self, + string: java.lang.String | str, + string2: java.lang.String | str, + string3: java.lang.String | str, + string4: java.lang.String | str, + string5: java.lang.String | str, + ) -> org.w3c.dom.ls.LSInput: ... + +class XMLMockObjects: + DEFAULT_COLOR: typing.ClassVar[java.awt.Color] = ... + LIGHTSOURCE_POWER: typing.ClassVar[float] = ... + COMPONENT_MODEL: typing.ClassVar[java.lang.String] = ... + COMPONENT_MANUFACTURER: typing.ClassVar[java.lang.String] = ... + COMPONENT_SERIAL_NUMBER: typing.ClassVar[java.lang.String] = ... + COMPONENT_LOT_NUMBER: typing.ClassVar[java.lang.String] = ... + LASER_TYPE: typing.ClassVar[ome.xml.model.enums.LaserType] = ... + ARC_TYPE: typing.ClassVar[ome.xml.model.enums.ArcType] = ... + FILAMENT_TYPE: typing.ClassVar[ome.xml.model.enums.FilamentType] = ... + DETECTOR_TYPE: typing.ClassVar[ome.xml.model.enums.DetectorType] = ... + CORRECTION: typing.ClassVar[ome.xml.model.enums.Correction] = ... + IMMERSION: typing.ClassVar[ome.xml.model.enums.Immersion] = ... + FILTER_TYPE: typing.ClassVar[ome.xml.model.enums.FilterType] = ... + MICROSCOPE_TYPE: typing.ClassVar[ome.xml.model.enums.MicroscopeType] = ... + EXPERIMENT_TYPE: typing.ClassVar[ome.xml.model.enums.ExperimentType] = ... + MICROBEAM_MANIPULATION_TYPE: typing.ClassVar[ + ome.xml.model.enums.MicrobeamManipulationType + ] = ... + BINNING: typing.ClassVar[ome.xml.model.enums.Binning] = ... + MEDIUM: typing.ClassVar[ome.xml.model.enums.Medium] = ... + LASER_MEDIUM: typing.ClassVar[ome.xml.model.enums.LaserMedium] = ... + SIZE_X: typing.ClassVar[int] = ... + SIZE_Y: typing.ClassVar[int] = ... + SIZE_Z: typing.ClassVar[int] = ... + SIZE_C: typing.ClassVar[int] = ... + SIZE_T: typing.ClassVar[int] = ... + BYTES_PER_PIXEL: typing.ClassVar[int] = ... + ROWS: typing.ClassVar[int] = ... + COLUMNS: typing.ClassVar[int] = ... + FIELDS: typing.ClassVar[int] = ... + LIGHT_SOURCES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + SHAPES: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + ANNOTATIONS: typing.ClassVar[typing.MutableSequence[java.lang.String]] = ... + ROW_NAMING_CONVENTION: typing.ClassVar[ome.xml.model.enums.NamingConvention] = ... + COLUMN_NAMING_CONVENTION: typing.ClassVar[ + ome.xml.model.enums.NamingConvention + ] = ... + DIMENSION_ORDER: typing.ClassVar[ome.xml.model.enums.DimensionOrder] = ... + PIXEL_TYPE: typing.ClassVar[ome.xml.model.enums.PixelType] = ... + NUMBER_OF_DECTECTORS: typing.ClassVar[int] = ... + NUMBER_OF_OBJECTIVES: typing.ClassVar[int] = ... + NUMBER_OF_FILTERS: typing.ClassVar[int] = ... + NUMBER_OF_DICHROICS: typing.ClassVar[int] = ... + POINTS: typing.ClassVar[java.lang.String] = ... + TIME: typing.ClassVar[java.lang.String] = ... + CUT_IN: typing.ClassVar[float] = ... + CUT_OUT: typing.ClassVar[float] = ... + def __init__(self): ... + def createAnnotatedImage(self) -> ome.xml.model.OME: ... + def createAnnotation( + self, + string: java.lang.String | str, + oMEModelObject: ome.xml.model.OMEModelObject, + int: int, + ) -> ome.xml.model.Annotation: ... + def createBasicPlate(self, int: int) -> ome.xml.model.Plate: ... + def createBasicPlateWithReagent(self) -> ome.xml.model.OME: ... + def createBinData( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.BinData: ... + def createBinaryFile(self) -> ome.xml.model.BinaryFile: ... + def createChannel(self, int: int) -> ome.xml.model.Channel: ... + def createDataset(self, int: int) -> ome.xml.model.Dataset: ... + def createDetector(self, int: int) -> ome.xml.model.Detector: ... + def createDetectorSettings(self, int: int) -> ome.xml.model.DetectorSettings: ... + def createDichroic(self, int: int) -> ome.xml.model.Dichroic: ... + def createExperiment(self, int: int) -> ome.xml.model.Experiment: ... + def createExperimentWithMicrobeam(self, int: int) -> ome.xml.model.Experiment: ... + def createExperimenter(self, int: int) -> ome.xml.model.Experimenter: ... + def createFilter( + self, int: int, double: float, double2: float + ) -> ome.xml.model.Filter: ... + def createFilterSet(self, int: int) -> ome.xml.model.FilterSet: ... + def createFullPopulatedPlate(self, int: int) -> ome.xml.model.OME: ... + @typing.overload + def createImage(self, int: int) -> ome.xml.model.Image: ... + @typing.overload + def createImage(self, int: int, boolean: bool) -> ome.xml.model.Image: ... + @typing.overload + def createImage(self) -> ome.xml.model.OME: ... + @typing.overload + def createImage(self, boolean: bool) -> ome.xml.model.OME: ... + def createImageEnvironment(self) -> ome.xml.model.ImagingEnvironment: ... + def createImageWithAcquisitionData(self) -> ome.xml.model.OME: ... + def createImageWithAnnotatedAcquisitionData(self) -> ome.xml.model.OME: ... + def createImageWithExperiment( + self, int: int, boolean: bool, experiment: ome.xml.model.Experiment + ) -> ome.xml.model.Image: ... + def createImageWithROI(self) -> ome.xml.model.OME: ... + def createInstrument(self, boolean: bool) -> ome.xml.model.Instrument: ... + def createLightPath(self) -> ome.xml.model.LightPath: ... + def createLightSource( + self, string: java.lang.String | str, int: int + ) -> ome.xml.model.LightSource: ... + def createLightSourceSettings( + self, int: int + ) -> ome.xml.model.LightSourceSettings: ... + def createMicrobeamManipulation( + self, int: int + ) -> ome.xml.model.MicrobeamManipulation: ... + def createMicroscope(self) -> ome.xml.model.Microscope: ... + def createObjective(self, int: int) -> ome.xml.model.Objective: ... + def createObjectiveSettings(self, int: int) -> ome.xml.model.ObjectiveSettings: ... + def createPlane(self, int: int, int2: int, int3: int) -> ome.xml.model.Plane: ... + @typing.overload + def createPlate(self, int: int, int2: int, int3: int) -> ome.xml.model.Plate: ... + @typing.overload + def createPlate( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> ome.xml.model.Plate: ... + @typing.overload + def createPlate( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + boolean: bool, + ) -> ome.xml.model.Plate: ... + @typing.overload + def createPlate( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + ) -> ome.xml.model.Plate: ... + @typing.overload + def createPlate( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + int7: int, + int8: int, + boolean: bool, + ) -> ome.xml.model.Plate: ... + @typing.overload + def createPopulatedPlate(self, int: int) -> ome.xml.model.OME: ... + @typing.overload + def createPopulatedPlate(self, int: int, int2: int) -> ome.xml.model.OME: ... + @typing.overload + def createPopulatedPlate( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> ome.xml.model.OME: ... + @typing.overload + def createPopulatedPlate( + self, int: int, int2: int, int3: int, int4: int, int5: int, boolean: bool + ) -> ome.xml.model.OME: ... + @typing.overload + def createPopulatedScreen(self) -> ome.xml.model.OME: ... + @typing.overload + def createPopulatedScreen( + self, int: int, int2: int, int3: int, int4: int, int5: int + ) -> ome.xml.model.OME: ... + @typing.overload + def createPopulatedScreen( + self, int: int, int2: int, int3: int, int4: int, int5: int, int6: int + ) -> ome.xml.model.OME: ... + @typing.overload + def createPopulatedScreen( + self, + int: int, + int2: int, + int3: int, + int4: int, + int5: int, + int6: int, + boolean: bool, + ) -> ome.xml.model.OME: ... + def createProject(self, int: int) -> ome.xml.model.Project: ... + def createROI( + self, int: int, int2: int, int3: int, int4: int + ) -> ome.xml.model.ROI: ... + def createReagent(self, int: int) -> ome.xml.model.Reagent: ... + def createScreen(self, int: int) -> ome.xml.model.Screen: ... + def createShape( + self, int: int, string: java.lang.String | str, int2: int, int3: int, int4: int + ) -> ome.xml.model.Shape: ... + def createStageLabel(self) -> ome.xml.model.StageLabel: ... + def getRoot(self) -> ome.xml.model.OME: ... + +class XMLWriter: + ID_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + NAME_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + DIMENSION_ORDER_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + PIXELS_TYPE_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + SIZE_C_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + SIZE_T_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + SIZE_Z_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + SIZE_X_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + SIZE_Y_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + COMPRESSION_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + BIG_ENDIAN_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + LENGTH_ATTRIBUTE: typing.ClassVar[java.lang.String] = ... + OME_TAG: typing.ClassVar[java.lang.String] = ... + IMAGE_TAG: typing.ClassVar[java.lang.String] = ... + PIXELS_TAG: typing.ClassVar[java.lang.String] = ... + BIN_DATA_TAG: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + @typing.overload + def writeFile( + self, file: java.io.File | jpype.protocol.SupportsPath, oME: ome.xml.model.OME + ) -> None: ... + @typing.overload + def writeFile( + self, + file: java.io.File | jpype.protocol.SupportsPath, + oME: ome.xml.model.OME, + boolean: bool, + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.specification")``. + + OmeValidator: type[OmeValidator] + SchemaResolver: type[SchemaResolver] + XMLMockObjects: type[XMLMockObjects] + XMLWriter: type[XMLWriter] diff --git a/typings/ome/units/__init__.pyi b/typings/ome/units/__init__.pyi new file mode 100644 index 0000000..bcf96de --- /dev/null +++ b/typings/ome/units/__init__.pyi @@ -0,0 +1,427 @@ +import typing +from typing import Protocol + +import java.lang +import ome.units.quantity +import ome.units.unit + +class UNITS: + RADIAN: typing.ClassVar[ome.units.unit.Unit] = ... + VOLT: typing.ClassVar[ome.units.unit.Unit] = ... + HERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + METRE: typing.ClassVar[ome.units.unit.Unit] = ... + INCH: typing.ClassVar[ome.units.unit.Unit] = ... + WATT: typing.ClassVar[ome.units.unit.Unit] = ... + PASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + KELVIN: typing.ClassVar[ome.units.unit.Unit] = ... + SECOND: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + EXAHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + PETAHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + TERAHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + KILOHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + HECTOHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + DECAHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + DECIHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + CENTIHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + MILLIHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + MICROHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + NANOHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + PICOHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + FEMTOHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + ATTOHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + ZEPTOHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + YOCTOHERTZ: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAHZ: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAHZ: typing.ClassVar[ome.units.unit.Unit] = ... + EXAHZ: typing.ClassVar[ome.units.unit.Unit] = ... + PETAHZ: typing.ClassVar[ome.units.unit.Unit] = ... + TERAHZ: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAHZ: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAHZ: typing.ClassVar[ome.units.unit.Unit] = ... + KHZ: typing.ClassVar[ome.units.unit.Unit] = ... + HHZ: typing.ClassVar[ome.units.unit.Unit] = ... + DAHZ: typing.ClassVar[ome.units.unit.Unit] = ... + HZ: typing.ClassVar[ome.units.unit.Unit] = ... + DHZ: typing.ClassVar[ome.units.unit.Unit] = ... + CHZ: typing.ClassVar[ome.units.unit.Unit] = ... + MHZ: typing.ClassVar[ome.units.unit.Unit] = ... + MICROHZ: typing.ClassVar[ome.units.unit.Unit] = ... + NHZ: typing.ClassVar[ome.units.unit.Unit] = ... + PHZ: typing.ClassVar[ome.units.unit.Unit] = ... + FHZ: typing.ClassVar[ome.units.unit.Unit] = ... + AHZ: typing.ClassVar[ome.units.unit.Unit] = ... + ZHZ: typing.ClassVar[ome.units.unit.Unit] = ... + YHZ: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + EXAMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + PETAMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + TERAMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + KILOMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + HECTOMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + DECAMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + DECIMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + CENTIMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + MILLIMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + MICROMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + NANOMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + PICOMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + FEMTOMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + ATTOMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + ZEPTOMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + YOCTOMETRE: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAMETER: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAMETER: typing.ClassVar[ome.units.unit.Unit] = ... + EXAMETER: typing.ClassVar[ome.units.unit.Unit] = ... + PETAMETER: typing.ClassVar[ome.units.unit.Unit] = ... + TERAMETER: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAMETER: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAMETER: typing.ClassVar[ome.units.unit.Unit] = ... + KILOMETER: typing.ClassVar[ome.units.unit.Unit] = ... + HECTOMETER: typing.ClassVar[ome.units.unit.Unit] = ... + DECAMETER: typing.ClassVar[ome.units.unit.Unit] = ... + METER: typing.ClassVar[ome.units.unit.Unit] = ... + DECIMETER: typing.ClassVar[ome.units.unit.Unit] = ... + CENTIMETER: typing.ClassVar[ome.units.unit.Unit] = ... + MILLIMETER: typing.ClassVar[ome.units.unit.Unit] = ... + MICROMETER: typing.ClassVar[ome.units.unit.Unit] = ... + NANOMETER: typing.ClassVar[ome.units.unit.Unit] = ... + PICOMETER: typing.ClassVar[ome.units.unit.Unit] = ... + FEMTOMETER: typing.ClassVar[ome.units.unit.Unit] = ... + ATTOMETER: typing.ClassVar[ome.units.unit.Unit] = ... + ZEPTOMETER: typing.ClassVar[ome.units.unit.Unit] = ... + YOCTOMETER: typing.ClassVar[ome.units.unit.Unit] = ... + ANGSTROM: typing.ClassVar[ome.units.unit.Unit] = ... + THOU: typing.ClassVar[ome.units.unit.Unit] = ... + LINE: typing.ClassVar[ome.units.unit.Unit] = ... + FOOT: typing.ClassVar[ome.units.unit.Unit] = ... + YARD: typing.ClassVar[ome.units.unit.Unit] = ... + MILE: typing.ClassVar[ome.units.unit.Unit] = ... + ASTRONOMICALUNIT: typing.ClassVar[ome.units.unit.Unit] = ... + LIGHTYEAR: typing.ClassVar[ome.units.unit.Unit] = ... + PARSEC: typing.ClassVar[ome.units.unit.Unit] = ... + POINT: typing.ClassVar[ome.units.unit.Unit] = ... + PIXEL: typing.ClassVar[ome.units.unit.Unit] = ... + REFERENCEFRAME: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAM: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAM: typing.ClassVar[ome.units.unit.Unit] = ... + EXAM: typing.ClassVar[ome.units.unit.Unit] = ... + PETAM: typing.ClassVar[ome.units.unit.Unit] = ... + TERAM: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAM: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAM: typing.ClassVar[ome.units.unit.Unit] = ... + KM: typing.ClassVar[ome.units.unit.Unit] = ... + HM: typing.ClassVar[ome.units.unit.Unit] = ... + DAM: typing.ClassVar[ome.units.unit.Unit] = ... + M: typing.ClassVar[ome.units.unit.Unit] = ... + DM: typing.ClassVar[ome.units.unit.Unit] = ... + CM: typing.ClassVar[ome.units.unit.Unit] = ... + MM: typing.ClassVar[ome.units.unit.Unit] = ... + MICROM: typing.ClassVar[ome.units.unit.Unit] = ... + NM: typing.ClassVar[ome.units.unit.Unit] = ... + PM: typing.ClassVar[ome.units.unit.Unit] = ... + FM: typing.ClassVar[ome.units.unit.Unit] = ... + AM: typing.ClassVar[ome.units.unit.Unit] = ... + ZM: typing.ClassVar[ome.units.unit.Unit] = ... + YM: typing.ClassVar[ome.units.unit.Unit] = ... + LI: typing.ClassVar[ome.units.unit.Unit] = ... + IN: typing.ClassVar[ome.units.unit.Unit] = ... + FT: typing.ClassVar[ome.units.unit.Unit] = ... + YD: typing.ClassVar[ome.units.unit.Unit] = ... + MI: typing.ClassVar[ome.units.unit.Unit] = ... + UA: typing.ClassVar[ome.units.unit.Unit] = ... + LY: typing.ClassVar[ome.units.unit.Unit] = ... + PC: typing.ClassVar[ome.units.unit.Unit] = ... + PT: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAWATT: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAWATT: typing.ClassVar[ome.units.unit.Unit] = ... + EXAWATT: typing.ClassVar[ome.units.unit.Unit] = ... + PETAWATT: typing.ClassVar[ome.units.unit.Unit] = ... + TERAWATT: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAWATT: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAWATT: typing.ClassVar[ome.units.unit.Unit] = ... + KILOWATT: typing.ClassVar[ome.units.unit.Unit] = ... + HECTOWATT: typing.ClassVar[ome.units.unit.Unit] = ... + DECAWATT: typing.ClassVar[ome.units.unit.Unit] = ... + DECIWATT: typing.ClassVar[ome.units.unit.Unit] = ... + CENTIWATT: typing.ClassVar[ome.units.unit.Unit] = ... + MILLIWATT: typing.ClassVar[ome.units.unit.Unit] = ... + MICROWATT: typing.ClassVar[ome.units.unit.Unit] = ... + NANOWATT: typing.ClassVar[ome.units.unit.Unit] = ... + PICOWATT: typing.ClassVar[ome.units.unit.Unit] = ... + FEMTOWATT: typing.ClassVar[ome.units.unit.Unit] = ... + ATTOWATT: typing.ClassVar[ome.units.unit.Unit] = ... + ZEPTOWATT: typing.ClassVar[ome.units.unit.Unit] = ... + YOCTOWATT: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAW: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAW: typing.ClassVar[ome.units.unit.Unit] = ... + EXAW: typing.ClassVar[ome.units.unit.Unit] = ... + PETAW: typing.ClassVar[ome.units.unit.Unit] = ... + TERAW: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAW: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAW: typing.ClassVar[ome.units.unit.Unit] = ... + KW: typing.ClassVar[ome.units.unit.Unit] = ... + HW: typing.ClassVar[ome.units.unit.Unit] = ... + DAW: typing.ClassVar[ome.units.unit.Unit] = ... + W: typing.ClassVar[ome.units.unit.Unit] = ... + DW: typing.ClassVar[ome.units.unit.Unit] = ... + CW: typing.ClassVar[ome.units.unit.Unit] = ... + MW: typing.ClassVar[ome.units.unit.Unit] = ... + MICROW: typing.ClassVar[ome.units.unit.Unit] = ... + NW: typing.ClassVar[ome.units.unit.Unit] = ... + PW: typing.ClassVar[ome.units.unit.Unit] = ... + FW: typing.ClassVar[ome.units.unit.Unit] = ... + AW: typing.ClassVar[ome.units.unit.Unit] = ... + ZW: typing.ClassVar[ome.units.unit.Unit] = ... + YW: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + EXAPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + PETAPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + TERAPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + KILOPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + HECTOPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + DECAPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + DECIPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + CENTIPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + MILLIPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + MICROPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + NANOPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + PICOPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + FEMTOPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + ATTOPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + ZEPTOPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + YOCTOPASCAL: typing.ClassVar[ome.units.unit.Unit] = ... + BAR: typing.ClassVar[ome.units.unit.Unit] = ... + MEGABAR: typing.ClassVar[ome.units.unit.Unit] = ... + KILOBAR: typing.ClassVar[ome.units.unit.Unit] = ... + DECIBAR: typing.ClassVar[ome.units.unit.Unit] = ... + CENTIBAR: typing.ClassVar[ome.units.unit.Unit] = ... + MILLIBAR: typing.ClassVar[ome.units.unit.Unit] = ... + ATMOSPHERE: typing.ClassVar[ome.units.unit.Unit] = ... + PSI: typing.ClassVar[ome.units.unit.Unit] = ... + TORR: typing.ClassVar[ome.units.unit.Unit] = ... + MILLITORR: typing.ClassVar[ome.units.unit.Unit] = ... + MMHG: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAPA: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAPA: typing.ClassVar[ome.units.unit.Unit] = ... + EXAPA: typing.ClassVar[ome.units.unit.Unit] = ... + PETAPA: typing.ClassVar[ome.units.unit.Unit] = ... + TERAPA: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAPA: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAPA: typing.ClassVar[ome.units.unit.Unit] = ... + KPA: typing.ClassVar[ome.units.unit.Unit] = ... + HPA: typing.ClassVar[ome.units.unit.Unit] = ... + DAPA: typing.ClassVar[ome.units.unit.Unit] = ... + PA: typing.ClassVar[ome.units.unit.Unit] = ... + DPA: typing.ClassVar[ome.units.unit.Unit] = ... + CPA: typing.ClassVar[ome.units.unit.Unit] = ... + MPA: typing.ClassVar[ome.units.unit.Unit] = ... + MICROPA: typing.ClassVar[ome.units.unit.Unit] = ... + NPA: typing.ClassVar[ome.units.unit.Unit] = ... + PPA: typing.ClassVar[ome.units.unit.Unit] = ... + FPA: typing.ClassVar[ome.units.unit.Unit] = ... + APA: typing.ClassVar[ome.units.unit.Unit] = ... + ZPA: typing.ClassVar[ome.units.unit.Unit] = ... + YPA: typing.ClassVar[ome.units.unit.Unit] = ... + KBAR: typing.ClassVar[ome.units.unit.Unit] = ... + DBAR: typing.ClassVar[ome.units.unit.Unit] = ... + CBAR: typing.ClassVar[ome.units.unit.Unit] = ... + MBAR: typing.ClassVar[ome.units.unit.Unit] = ... + ATM: typing.ClassVar[ome.units.unit.Unit] = ... + MTORR: typing.ClassVar[ome.units.unit.Unit] = ... + CELSIUS: typing.ClassVar[ome.units.unit.Unit] = ... + RANKINE: typing.ClassVar[ome.units.unit.Unit] = ... + FAHRENHEIT: typing.ClassVar[ome.units.unit.Unit] = ... + DEGREEC: typing.ClassVar[ome.units.unit.Unit] = ... + K: typing.ClassVar[ome.units.unit.Unit] = ... + DEGREER: typing.ClassVar[ome.units.unit.Unit] = ... + DEGREEF: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTASECOND: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTASECOND: typing.ClassVar[ome.units.unit.Unit] = ... + EXASECOND: typing.ClassVar[ome.units.unit.Unit] = ... + PETASECOND: typing.ClassVar[ome.units.unit.Unit] = ... + TERASECOND: typing.ClassVar[ome.units.unit.Unit] = ... + GIGASECOND: typing.ClassVar[ome.units.unit.Unit] = ... + MEGASECOND: typing.ClassVar[ome.units.unit.Unit] = ... + KILOSECOND: typing.ClassVar[ome.units.unit.Unit] = ... + HECTOSECOND: typing.ClassVar[ome.units.unit.Unit] = ... + DECASECOND: typing.ClassVar[ome.units.unit.Unit] = ... + DECISECOND: typing.ClassVar[ome.units.unit.Unit] = ... + CENTISECOND: typing.ClassVar[ome.units.unit.Unit] = ... + MILLISECOND: typing.ClassVar[ome.units.unit.Unit] = ... + MICROSECOND: typing.ClassVar[ome.units.unit.Unit] = ... + NANOSECOND: typing.ClassVar[ome.units.unit.Unit] = ... + PICOSECOND: typing.ClassVar[ome.units.unit.Unit] = ... + FEMTOSECOND: typing.ClassVar[ome.units.unit.Unit] = ... + ATTOSECOND: typing.ClassVar[ome.units.unit.Unit] = ... + ZEPTOSECOND: typing.ClassVar[ome.units.unit.Unit] = ... + YOCTOSECOND: typing.ClassVar[ome.units.unit.Unit] = ... + MINUTE: typing.ClassVar[ome.units.unit.Unit] = ... + HOUR: typing.ClassVar[ome.units.unit.Unit] = ... + DAY: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAS: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAS: typing.ClassVar[ome.units.unit.Unit] = ... + EXAS: typing.ClassVar[ome.units.unit.Unit] = ... + PETAS: typing.ClassVar[ome.units.unit.Unit] = ... + TERAS: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAS: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAS: typing.ClassVar[ome.units.unit.Unit] = ... + KS: typing.ClassVar[ome.units.unit.Unit] = ... + HS: typing.ClassVar[ome.units.unit.Unit] = ... + DAS: typing.ClassVar[ome.units.unit.Unit] = ... + S: typing.ClassVar[ome.units.unit.Unit] = ... + DS: typing.ClassVar[ome.units.unit.Unit] = ... + CS: typing.ClassVar[ome.units.unit.Unit] = ... + MS: typing.ClassVar[ome.units.unit.Unit] = ... + MICROS: typing.ClassVar[ome.units.unit.Unit] = ... + NS: typing.ClassVar[ome.units.unit.Unit] = ... + PS: typing.ClassVar[ome.units.unit.Unit] = ... + FS: typing.ClassVar[ome.units.unit.Unit] = ... + AS: typing.ClassVar[ome.units.unit.Unit] = ... + ZS: typing.ClassVar[ome.units.unit.Unit] = ... + YS: typing.ClassVar[ome.units.unit.Unit] = ... + MIN: typing.ClassVar[ome.units.unit.Unit] = ... + H: typing.ClassVar[ome.units.unit.Unit] = ... + D: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + EXAVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + PETAVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + TERAVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + KILOVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + HECTOVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + DECAVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + DECIVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + CENTIVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + MILLIVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + MICROVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + NANOVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + PICOVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + FEMTOVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + ATTOVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + ZEPTOVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + YOCTOVOLT: typing.ClassVar[ome.units.unit.Unit] = ... + YOTTAV: typing.ClassVar[ome.units.unit.Unit] = ... + ZETTAV: typing.ClassVar[ome.units.unit.Unit] = ... + EXAV: typing.ClassVar[ome.units.unit.Unit] = ... + PETAV: typing.ClassVar[ome.units.unit.Unit] = ... + TERAV: typing.ClassVar[ome.units.unit.Unit] = ... + GIGAV: typing.ClassVar[ome.units.unit.Unit] = ... + MEGAV: typing.ClassVar[ome.units.unit.Unit] = ... + KV: typing.ClassVar[ome.units.unit.Unit] = ... + HV: typing.ClassVar[ome.units.unit.Unit] = ... + DAV: typing.ClassVar[ome.units.unit.Unit] = ... + V: typing.ClassVar[ome.units.unit.Unit] = ... + DV: typing.ClassVar[ome.units.unit.Unit] = ... + CV: typing.ClassVar[ome.units.unit.Unit] = ... + MV: typing.ClassVar[ome.units.unit.Unit] = ... + MICROV: typing.ClassVar[ome.units.unit.Unit] = ... + NV: typing.ClassVar[ome.units.unit.Unit] = ... + PV: typing.ClassVar[ome.units.unit.Unit] = ... + FV: typing.ClassVar[ome.units.unit.Unit] = ... + AV: typing.ClassVar[ome.units.unit.Unit] = ... + ZV: typing.ClassVar[ome.units.unit.Unit] = ... + YV: typing.ClassVar[ome.units.unit.Unit] = ... + DEGREE: typing.ClassVar[ome.units.unit.Unit] = ... + GRADIAN: typing.ClassVar[ome.units.unit.Unit] = ... + DEG: typing.ClassVar[ome.units.unit.Unit] = ... + RAD: typing.ClassVar[ome.units.unit.Unit] = ... + GON: typing.ClassVar[ome.units.unit.Unit] = ... + def __init__(self): ... + _ATTO__T = typing.TypeVar("_ATTO__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def ATTO(unit: ome.units.unit.Unit[_ATTO__T]) -> ome.units.unit.Unit[_ATTO__T]: ... + _CENTI__T = typing.TypeVar("_CENTI__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def CENTI( + unit: ome.units.unit.Unit[_CENTI__T], + ) -> ome.units.unit.Unit[_CENTI__T]: ... + _DECA__T = typing.TypeVar("_DECA__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def DECA(unit: ome.units.unit.Unit[_DECA__T]) -> ome.units.unit.Unit[_DECA__T]: ... + _DECI__T = typing.TypeVar("_DECI__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def DECI(unit: ome.units.unit.Unit[_DECI__T]) -> ome.units.unit.Unit[_DECI__T]: ... + _EXA__T = typing.TypeVar("_EXA__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def EXA(unit: ome.units.unit.Unit[_EXA__T]) -> ome.units.unit.Unit[_EXA__T]: ... + _FEMTO__T = typing.TypeVar("_FEMTO__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def FEMTO( + unit: ome.units.unit.Unit[_FEMTO__T], + ) -> ome.units.unit.Unit[_FEMTO__T]: ... + _GIGA__T = typing.TypeVar("_GIGA__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def GIGA(unit: ome.units.unit.Unit[_GIGA__T]) -> ome.units.unit.Unit[_GIGA__T]: ... + _HECTO__T = typing.TypeVar("_HECTO__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def HECTO( + unit: ome.units.unit.Unit[_HECTO__T], + ) -> ome.units.unit.Unit[_HECTO__T]: ... + _KILO__T = typing.TypeVar("_KILO__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def KILO(unit: ome.units.unit.Unit[_KILO__T]) -> ome.units.unit.Unit[_KILO__T]: ... + _MEGA__T = typing.TypeVar("_MEGA__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def MEGA(unit: ome.units.unit.Unit[_MEGA__T]) -> ome.units.unit.Unit[_MEGA__T]: ... + _MICRO__T = typing.TypeVar("_MICRO__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def MICRO( + unit: ome.units.unit.Unit[_MICRO__T], + ) -> ome.units.unit.Unit[_MICRO__T]: ... + _MILLI__T = typing.TypeVar("_MILLI__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def MILLI( + unit: ome.units.unit.Unit[_MILLI__T], + ) -> ome.units.unit.Unit[_MILLI__T]: ... + _NANO__T = typing.TypeVar("_NANO__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def NANO(unit: ome.units.unit.Unit[_NANO__T]) -> ome.units.unit.Unit[_NANO__T]: ... + _PETA__T = typing.TypeVar("_PETA__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def PETA(unit: ome.units.unit.Unit[_PETA__T]) -> ome.units.unit.Unit[_PETA__T]: ... + _PICO__T = typing.TypeVar("_PICO__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def PICO(unit: ome.units.unit.Unit[_PICO__T]) -> ome.units.unit.Unit[_PICO__T]: ... + _TERA__T = typing.TypeVar("_TERA__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def TERA(unit: ome.units.unit.Unit[_TERA__T]) -> ome.units.unit.Unit[_TERA__T]: ... + _YOCTO__T = typing.TypeVar("_YOCTO__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def YOCTO( + unit: ome.units.unit.Unit[_YOCTO__T], + ) -> ome.units.unit.Unit[_YOCTO__T]: ... + _YOTTA__T = typing.TypeVar("_YOTTA__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def YOTTA( + unit: ome.units.unit.Unit[_YOTTA__T], + ) -> ome.units.unit.Unit[_YOTTA__T]: ... + _ZEPTO__T = typing.TypeVar("_ZEPTO__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def ZEPTO( + unit: ome.units.unit.Unit[_ZEPTO__T], + ) -> ome.units.unit.Unit[_ZEPTO__T]: ... + _ZETTA__T = typing.TypeVar("_ZETTA__T", bound=ome.units.quantity.Quantity) # + @staticmethod + def ZETTA( + unit: ome.units.unit.Unit[_ZETTA__T], + ) -> ome.units.unit.Unit[_ZETTA__T]: ... + def getName(self) -> java.lang.String: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.units")``. + + UNITS: type[UNITS] + quantity: ome.units.quantity.__module_protocol__ + unit: ome.units.unit.__module_protocol__ diff --git a/typings/ome/units/quantity/__init__.pyi b/typings/ome/units/quantity/__init__.pyi new file mode 100644 index 0000000..1c94be8 --- /dev/null +++ b/typings/ome/units/quantity/__init__.pyi @@ -0,0 +1,178 @@ +import typing +from typing import Protocol + +import _jpype +import java.lang +import ome.units.unit + +class Quantity: + def __init__(self): ... + def unit(self) -> ome.units.unit.Unit[Quantity]: ... + def value(self) -> java.lang.Number: ... + +class Angle(Quantity, java.lang.Comparable["Angle"]): + def __init__( + self, + number: _jpype._JNumberLong + | _jpype._JNumberFloat + | typing.SupportsIndex + | typing.SupportsFloat, + unit: ome.units.unit.Unit[Angle], + ): ... + def compareTo(self, angle: Angle) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def unit(self) -> ome.units.unit.Unit[Angle]: ... + @typing.overload + def value(self) -> java.lang.Number: ... + @typing.overload + def value(self, unit: ome.units.unit.Unit[Angle]) -> java.lang.Number: ... + +class ElectricPotential(Quantity, java.lang.Comparable["ElectricPotential"]): + def __init__( + self, + number: _jpype._JNumberLong + | _jpype._JNumberFloat + | typing.SupportsIndex + | typing.SupportsFloat, + unit: ome.units.unit.Unit[ElectricPotential], + ): ... + def compareTo(self, electricPotential: ElectricPotential) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def unit(self) -> ome.units.unit.Unit[ElectricPotential]: ... + @typing.overload + def value(self) -> java.lang.Number: ... + @typing.overload + def value( + self, unit: ome.units.unit.Unit[ElectricPotential] + ) -> java.lang.Number: ... + +class Frequency(Quantity, java.lang.Comparable["Frequency"]): + def __init__( + self, + number: _jpype._JNumberLong + | _jpype._JNumberFloat + | typing.SupportsIndex + | typing.SupportsFloat, + unit: ome.units.unit.Unit[Frequency], + ): ... + def compareTo(self, frequency: Frequency) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def unit(self) -> ome.units.unit.Unit[Frequency]: ... + @typing.overload + def value(self) -> java.lang.Number: ... + @typing.overload + def value(self, unit: ome.units.unit.Unit[Frequency]) -> java.lang.Number: ... + +class Length(Quantity, java.lang.Comparable["Length"]): + def __init__( + self, + number: _jpype._JNumberLong + | _jpype._JNumberFloat + | typing.SupportsIndex + | typing.SupportsFloat, + unit: ome.units.unit.Unit[Length], + ): ... + def compareTo(self, length: Length) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def unit(self) -> ome.units.unit.Unit[Length]: ... + @typing.overload + def value(self) -> java.lang.Number: ... + @typing.overload + def value(self, unit: ome.units.unit.Unit[Length]) -> java.lang.Number: ... + +class Power(Quantity, java.lang.Comparable["Power"]): + def __init__( + self, + number: _jpype._JNumberLong + | _jpype._JNumberFloat + | typing.SupportsIndex + | typing.SupportsFloat, + unit: ome.units.unit.Unit[Power], + ): ... + def compareTo(self, power: Power) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def unit(self) -> ome.units.unit.Unit[Power]: ... + @typing.overload + def value(self) -> java.lang.Number: ... + @typing.overload + def value(self, unit: ome.units.unit.Unit[Power]) -> java.lang.Number: ... + +class Pressure(Quantity, java.lang.Comparable["Pressure"]): + def __init__( + self, + number: _jpype._JNumberLong + | _jpype._JNumberFloat + | typing.SupportsIndex + | typing.SupportsFloat, + unit: ome.units.unit.Unit[Pressure], + ): ... + def compareTo(self, pressure: Pressure) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def unit(self) -> ome.units.unit.Unit[Pressure]: ... + @typing.overload + def value(self) -> java.lang.Number: ... + @typing.overload + def value(self, unit: ome.units.unit.Unit[Pressure]) -> java.lang.Number: ... + +class Temperature(Quantity, java.lang.Comparable["Temperature"]): + def __init__( + self, + number: _jpype._JNumberLong + | _jpype._JNumberFloat + | typing.SupportsIndex + | typing.SupportsFloat, + unit: ome.units.unit.Unit[Temperature], + ): ... + def compareTo(self, temperature: Temperature) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def unit(self) -> ome.units.unit.Unit[Temperature]: ... + @typing.overload + def value(self) -> java.lang.Number: ... + @typing.overload + def value(self, unit: ome.units.unit.Unit[Temperature]) -> java.lang.Number: ... + +class Time(Quantity, java.lang.Comparable["Time"]): + def __init__( + self, + number: _jpype._JNumberLong + | _jpype._JNumberFloat + | typing.SupportsIndex + | typing.SupportsFloat, + unit: ome.units.unit.Unit[Time], + ): ... + def compareTo(self, time: Time) -> int: ... + def equals(self, object: typing.Any) -> bool: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + def unit(self) -> ome.units.unit.Unit[Time]: ... + @typing.overload + def value(self) -> java.lang.Number: ... + @typing.overload + def value(self, unit: ome.units.unit.Unit[Time]) -> java.lang.Number: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.units.quantity")``. + + Angle: type[Angle] + ElectricPotential: type[ElectricPotential] + Frequency: type[Frequency] + Length: type[Length] + Power: type[Power] + Pressure: type[Pressure] + Quantity: type[Quantity] + Temperature: type[Temperature] + Time: type[Time] diff --git a/typings/ome/units/unit/__init__.pyi b/typings/ome/units/unit/__init__.pyi new file mode 100644 index 0000000..a1fe8a0 --- /dev/null +++ b/typings/ome/units/unit/__init__.pyi @@ -0,0 +1,48 @@ +import typing +from typing import Protocol + +import _jpype +import java.lang +import ome.units.quantity + +_Unit__Q = typing.TypeVar("_Unit__Q", bound=ome.units.quantity.Quantity) # + +class Unit(typing.Generic[_Unit__Q]): + _CreateBaseUnit__Q = typing.TypeVar( + "_CreateBaseUnit__Q", bound=ome.units.quantity.Quantity + ) # + @staticmethod + def CreateBaseUnit( + string: java.lang.String | str, string2: java.lang.String | str + ) -> Unit[_CreateBaseUnit__Q]: ... + @typing.overload + def add(self, double: float) -> Unit[_Unit__Q]: ... + @typing.overload + def add(self, integer: int) -> Unit[_Unit__Q]: ... + def convertValue( + self, + number: _jpype._JNumberLong + | _jpype._JNumberFloat + | typing.SupportsIndex + | typing.SupportsFloat, + unit: Unit[_Unit__Q], + ) -> float: ... + @typing.overload + def divide(self, double: float) -> Unit[_Unit__Q]: ... + @typing.overload + def divide(self, integer: int) -> Unit[_Unit__Q]: ... + def getOffset(self) -> float: ... + def getScaleFactor(self) -> float: ... + def getSymbol(self) -> java.lang.String: ... + def isConvertible(self, unit: Unit[_Unit__Q]) -> bool: ... + @typing.overload + def multiply(self, double: float) -> Unit[_Unit__Q]: ... + @typing.overload + def multiply(self, integer: int) -> Unit[_Unit__Q]: ... + def prefixSymbol(self, string: java.lang.String | str) -> Unit[_Unit__Q]: ... + def setSymbol(self, string: java.lang.String | str) -> Unit[_Unit__Q]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.units.unit")``. + + Unit: type[Unit] diff --git a/typings/ome/xml/__init__.pyi b/typings/ome/xml/__init__.pyi new file mode 100644 index 0000000..963f6b4 --- /dev/null +++ b/typings/ome/xml/__init__.pyi @@ -0,0 +1,10 @@ +from typing import Protocol + +import ome.xml.meta +import ome.xml.model + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.xml")``. + + meta: ome.xml.meta.__module_protocol__ + model: ome.xml.model.__module_protocol__ diff --git a/typings/ome/xml/meta/__init__.pyi b/typings/ome/xml/meta/__init__.pyi new file mode 100644 index 0000000..f844b3a --- /dev/null +++ b/typings/ome/xml/meta/__init__.pyi @@ -0,0 +1,10461 @@ +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype +import ome.units.quantity +import ome.xml.model +import ome.xml.model.enums +import ome.xml.model.primitives +import org.w3c.dom + +class BaseMetadata: ... +class MetadataRoot: ... + +class MetadataRetrieve(BaseMetadata): + def getArcAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getArcID(self, int: int, int2: int) -> java.lang.String: ... + def getArcLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getArcManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getArcModel(self, int: int, int2: int) -> java.lang.String: ... + def getArcPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getArcSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getArcType(self, int: int, int2: int) -> ome.xml.model.enums.ArcType: ... + def getBinaryFileBinData(self, int: int) -> typing.MutableSequence[int]: ... + def getBinaryFileBinDataBigEndian(self, int: int) -> bool: ... + def getBinaryFileBinDataCompression( + self, int: int + ) -> ome.xml.model.enums.Compression: ... + def getBinaryFileBinDataLength( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getBinaryFileFileName(self, int: int) -> java.lang.String: ... + def getBinaryFileMIMEType(self, int: int) -> java.lang.String: ... + def getBinaryFileSize( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getBinaryOnlyMetadataFile(self) -> java.lang.String: ... + def getBinaryOnlyUUID(self) -> java.lang.String: ... + def getBooleanAnnotationAnnotationCount(self, int: int) -> int: ... + def getBooleanAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getBooleanAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationCount(self) -> int: ... + def getBooleanAnnotationDescription(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationID(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationValue(self, int: int) -> bool: ... + def getChannelAcquisitionMode( + self, int: int, int2: int + ) -> ome.xml.model.enums.AcquisitionMode: ... + def getChannelAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getChannelAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getChannelColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getChannelContrastMethod( + self, int: int, int2: int + ) -> ome.xml.model.enums.ContrastMethod: ... + def getChannelCount(self, int: int) -> int: ... + def getChannelEmissionWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelExcitationWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelFilterSetRef(self, int: int, int2: int) -> java.lang.String: ... + def getChannelFluor(self, int: int, int2: int) -> java.lang.String: ... + def getChannelID(self, int: int, int2: int) -> java.lang.String: ... + def getChannelIlluminationType( + self, int: int, int2: int + ) -> ome.xml.model.enums.IlluminationType: ... + def getChannelLightSourceSettingsAttenuation( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getChannelLightSourceSettingsID( + self, int: int, int2: int + ) -> java.lang.String: ... + def getChannelLightSourceSettingsWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelNDFilter(self, int: int, int2: int) -> float: ... + def getChannelName(self, int: int, int2: int) -> java.lang.String: ... + def getChannelPinholeSize( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelPockelCellSetting(self, int: int, int2: int) -> int: ... + def getChannelSamplesPerPixel( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getCommentAnnotationAnnotationCount(self, int: int) -> int: ... + def getCommentAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getCommentAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getCommentAnnotationCount(self) -> int: ... + def getCommentAnnotationDescription(self, int: int) -> java.lang.String: ... + def getCommentAnnotationID(self, int: int) -> java.lang.String: ... + def getCommentAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getCommentAnnotationValue(self, int: int) -> java.lang.String: ... + def getCreator(self) -> java.lang.String: ... + def getDatasetAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getDatasetAnnotationRefCount(self, int: int) -> int: ... + def getDatasetCount(self) -> int: ... + def getDatasetDescription(self, int: int) -> java.lang.String: ... + def getDatasetExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getDatasetExperimenterRef(self, int: int) -> java.lang.String: ... + def getDatasetID(self, int: int) -> java.lang.String: ... + def getDatasetImageRef(self, int: int, int2: int) -> java.lang.String: ... + def getDatasetImageRefCount(self, int: int) -> int: ... + def getDatasetName(self, int: int) -> java.lang.String: ... + def getDatasetRefCount(self, int: int) -> int: ... + def getDetectorAmplificationGain(self, int: int, int2: int) -> float: ... + def getDetectorAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getDetectorAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getDetectorCount(self, int: int) -> int: ... + def getDetectorGain(self, int: int, int2: int) -> float: ... + def getDetectorID(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorModel(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorOffset(self, int: int, int2: int) -> float: ... + def getDetectorSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorSettingsBinning( + self, int: int, int2: int + ) -> ome.xml.model.enums.Binning: ... + def getDetectorSettingsGain(self, int: int, int2: int) -> float: ... + def getDetectorSettingsID(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorSettingsIntegration( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getDetectorSettingsOffset(self, int: int, int2: int) -> float: ... + def getDetectorSettingsReadOutRate( + self, int: int, int2: int + ) -> ome.units.quantity.Frequency: ... + def getDetectorSettingsVoltage( + self, int: int, int2: int + ) -> ome.units.quantity.ElectricPotential: ... + def getDetectorSettingsZoom(self, int: int, int2: int) -> float: ... + def getDetectorType( + self, int: int, int2: int + ) -> ome.xml.model.enums.DetectorType: ... + def getDetectorVoltage( + self, int: int, int2: int + ) -> ome.units.quantity.ElectricPotential: ... + def getDetectorZoom(self, int: int, int2: int) -> float: ... + def getDichroicAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getDichroicAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getDichroicCount(self, int: int) -> int: ... + def getDichroicID(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicModel(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDoubleAnnotationAnnotationCount(self, int: int) -> int: ... + def getDoubleAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getDoubleAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationCount(self) -> int: ... + def getDoubleAnnotationDescription(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationID(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationValue(self, int: int) -> float: ... + def getEllipseAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getEllipseFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getEllipseFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getEllipseFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getEllipseFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getEllipseFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getEllipseID(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseLocked(self, int: int, int2: int) -> bool: ... + def getEllipseRadiusX(self, int: int, int2: int) -> float: ... + def getEllipseRadiusY(self, int: int, int2: int) -> float: ... + def getEllipseStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getEllipseStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getEllipseText(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getEllipseX(self, int: int, int2: int) -> float: ... + def getEllipseY(self, int: int, int2: int) -> float: ... + def getExperimentCount(self) -> int: ... + def getExperimentDescription(self, int: int) -> java.lang.String: ... + def getExperimentExperimenterRef(self, int: int) -> java.lang.String: ... + def getExperimentID(self, int: int) -> java.lang.String: ... + def getExperimentType(self, int: int) -> ome.xml.model.enums.ExperimentType: ... + def getExperimenterAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getExperimenterAnnotationRefCount(self, int: int) -> int: ... + def getExperimenterCount(self) -> int: ... + def getExperimenterEmail(self, int: int) -> java.lang.String: ... + def getExperimenterFirstName(self, int: int) -> java.lang.String: ... + def getExperimenterGroupAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getExperimenterGroupAnnotationRefCount(self, int: int) -> int: ... + def getExperimenterGroupCount(self) -> int: ... + def getExperimenterGroupDescription(self, int: int) -> java.lang.String: ... + def getExperimenterGroupExperimenterRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getExperimenterGroupExperimenterRefCount(self, int: int) -> int: ... + def getExperimenterGroupID(self, int: int) -> java.lang.String: ... + def getExperimenterGroupLeader(self, int: int, int2: int) -> java.lang.String: ... + def getExperimenterGroupName(self, int: int) -> java.lang.String: ... + def getExperimenterID(self, int: int) -> java.lang.String: ... + def getExperimenterInstitution(self, int: int) -> java.lang.String: ... + def getExperimenterLastName(self, int: int) -> java.lang.String: ... + def getExperimenterMiddleName(self, int: int) -> java.lang.String: ... + def getExperimenterUserName(self, int: int) -> java.lang.String: ... + def getFilamentAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilamentID(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getFilamentSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentType( + self, int: int, int2: int + ) -> ome.xml.model.enums.FilamentType: ... + def getFileAnnotationAnnotationCount(self, int: int) -> int: ... + def getFileAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getFileAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getFileAnnotationCount(self) -> int: ... + def getFileAnnotationDescription(self, int: int) -> java.lang.String: ... + def getFileAnnotationID(self, int: int) -> java.lang.String: ... + def getFileAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getFilterAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getFilterCount(self, int: int) -> int: ... + def getFilterFilterWheel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterID(self, int: int, int2: int) -> java.lang.String: ... + def getFilterLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilterModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetCount(self, int: int) -> int: ... + def getFilterSetDichroicRef(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetEmissionFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterSetEmissionFilterRefCount(self, int: int, int2: int) -> int: ... + def getFilterSetExcitationFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterSetExcitationFilterRefCount(self, int: int, int2: int) -> int: ... + def getFilterSetID(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterType(self, int: int, int2: int) -> ome.xml.model.enums.FilterType: ... + def getFolderAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderAnnotationRefCount(self, int: int) -> int: ... + def getFolderCount(self) -> int: ... + def getFolderDescription(self, int: int) -> java.lang.String: ... + def getFolderFolderRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderID(self, int: int) -> java.lang.String: ... + def getFolderImageRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderImageRefCount(self, int: int) -> int: ... + def getFolderName(self, int: int) -> java.lang.String: ... + def getFolderROIRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderROIRefCount(self, int: int) -> int: ... + def getFolderRefCount(self, int: int) -> int: ... + def getGenericExcitationSourceAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getGenericExcitationSourceID(self, int: int, int2: int) -> java.lang.String: ... + def getGenericExcitationSourceLotNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourceManufacturer( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourceMap( + self, int: int, int2: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getGenericExcitationSourceModel( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourcePower( + self, int: int, int2: int + ) -> ome.units.quantity.Power: ... + def getGenericExcitationSourceSerialNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getImageAcquisitionDate( + self, int: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getImageAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getImageAnnotationRefCount(self, int: int) -> int: ... + def getImageCount(self) -> int: ... + def getImageDescription(self, int: int) -> java.lang.String: ... + def getImageExperimentRef(self, int: int) -> java.lang.String: ... + def getImageExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getImageExperimenterRef(self, int: int) -> java.lang.String: ... + def getImageID(self, int: int) -> java.lang.String: ... + def getImageInstrumentRef(self, int: int) -> java.lang.String: ... + def getImageMicrobeamManipulationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getImageName(self, int: int) -> java.lang.String: ... + def getImageROIRef(self, int: int, int2: int) -> java.lang.String: ... + def getImageROIRefCount(self, int: int) -> int: ... + def getImagingEnvironmentAirPressure( + self, int: int + ) -> ome.units.quantity.Pressure: ... + def getImagingEnvironmentCO2Percent( + self, int: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getImagingEnvironmentHumidity( + self, int: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getImagingEnvironmentMap( + self, int: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getImagingEnvironmentTemperature( + self, int: int + ) -> ome.units.quantity.Temperature: ... + def getInstrumentAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getInstrumentAnnotationRefCount(self, int: int) -> int: ... + def getInstrumentCount(self) -> int: ... + def getInstrumentID(self, int: int) -> java.lang.String: ... + def getLabelAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLabelFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLabelFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getLabelFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getLabelFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLabelFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getLabelID(self, int: int, int2: int) -> java.lang.String: ... + def getLabelLocked(self, int: int, int2: int) -> bool: ... + def getLabelStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLabelStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getLabelStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLabelText(self, int: int, int2: int) -> java.lang.String: ... + def getLabelTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getLabelX(self, int: int, int2: int) -> float: ... + def getLabelY(self, int: int, int2: int) -> float: ... + def getLaserAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLaserFrequencyMultiplication( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getLaserID(self, int: int, int2: int) -> java.lang.String: ... + def getLaserLaserMedium( + self, int: int, int2: int + ) -> ome.xml.model.enums.LaserMedium: ... + def getLaserLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getLaserManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getLaserModel(self, int: int, int2: int) -> java.lang.String: ... + def getLaserPockelCell(self, int: int, int2: int) -> bool: ... + def getLaserPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getLaserPulse(self, int: int, int2: int) -> ome.xml.model.enums.Pulse: ... + def getLaserPump(self, int: int, int2: int) -> java.lang.String: ... + def getLaserRepetitionRate( + self, int: int, int2: int + ) -> ome.units.quantity.Frequency: ... + def getLaserSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getLaserTuneable(self, int: int, int2: int) -> bool: ... + def getLaserType(self, int: int, int2: int) -> ome.xml.model.enums.LaserType: ... + def getLaserWavelength(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLeaderCount(self, int: int) -> int: ... + def getLightEmittingDiodeAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightEmittingDiodeID(self, int: int, int2: int) -> java.lang.String: ... + def getLightEmittingDiodeLotNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightEmittingDiodeManufacturer( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightEmittingDiodeModel(self, int: int, int2: int) -> java.lang.String: ... + def getLightEmittingDiodePower( + self, int: int, int2: int + ) -> ome.units.quantity.Power: ... + def getLightEmittingDiodeSerialNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightPathAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getLightPathDichroicRef(self, int: int, int2: int) -> java.lang.String: ... + def getLightPathEmissionFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathEmissionFilterRefCount(self, int: int, int2: int) -> int: ... + def getLightPathExcitationFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathExcitationFilterRefCount(self, int: int, int2: int) -> int: ... + def getLightSourceAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getLightSourceCount(self, int: int) -> int: ... + def getLightSourceType(self, int: int, int2: int) -> java.lang.String: ... + def getLineAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLineFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLineFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getLineFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getLineFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLineFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getLineID(self, int: int, int2: int) -> java.lang.String: ... + def getLineLocked(self, int: int, int2: int) -> bool: ... + def getLineMarkerEnd(self, int: int, int2: int) -> ome.xml.model.enums.Marker: ... + def getLineMarkerStart(self, int: int, int2: int) -> ome.xml.model.enums.Marker: ... + def getLineStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLineStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getLineStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLineText(self, int: int, int2: int) -> java.lang.String: ... + def getLineTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getLineX1(self, int: int, int2: int) -> float: ... + def getLineX2(self, int: int, int2: int) -> float: ... + def getLineY1(self, int: int, int2: int) -> float: ... + def getLineY2(self, int: int, int2: int) -> float: ... + def getListAnnotationAnnotationCount(self, int: int) -> int: ... + def getListAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getListAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getListAnnotationCount(self) -> int: ... + def getListAnnotationDescription(self, int: int) -> java.lang.String: ... + def getListAnnotationID(self, int: int) -> java.lang.String: ... + def getListAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getLongAnnotationAnnotationCount(self, int: int) -> int: ... + def getLongAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLongAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getLongAnnotationCount(self) -> int: ... + def getLongAnnotationDescription(self, int: int) -> java.lang.String: ... + def getLongAnnotationID(self, int: int) -> java.lang.String: ... + def getLongAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getLongAnnotationValue(self, int: int) -> int: ... + def getMapAnnotationAnnotationCount(self, int: int) -> int: ... + def getMapAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMapAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getMapAnnotationCount(self) -> int: ... + def getMapAnnotationDescription(self, int: int) -> java.lang.String: ... + def getMapAnnotationID(self, int: int) -> java.lang.String: ... + def getMapAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getMapAnnotationValue( + self, int: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getMaskAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMaskBinData(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getMaskBinDataBigEndian(self, int: int, int2: int) -> bool: ... + def getMaskBinDataCompression( + self, int: int, int2: int + ) -> ome.xml.model.enums.Compression: ... + def getMaskBinDataLength( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getMaskFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getMaskFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getMaskFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getMaskFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getMaskFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getMaskHeight(self, int: int, int2: int) -> float: ... + def getMaskID(self, int: int, int2: int) -> java.lang.String: ... + def getMaskLocked(self, int: int, int2: int) -> bool: ... + def getMaskStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getMaskStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getMaskStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getMaskText(self, int: int, int2: int) -> java.lang.String: ... + def getMaskTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getMaskWidth(self, int: int, int2: int) -> float: ... + def getMaskX(self, int: int, int2: int) -> float: ... + def getMaskY(self, int: int, int2: int) -> float: ... + def getMicrobeamManipulationCount(self, int: int) -> int: ... + def getMicrobeamManipulationDescription( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMicrobeamManipulationExperimenterRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMicrobeamManipulationID(self, int: int, int2: int) -> java.lang.String: ... + def getMicrobeamManipulationLightSourceSettingsAttenuation( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getMicrobeamManipulationLightSourceSettingsCount( + self, int: int, int2: int + ) -> int: ... + def getMicrobeamManipulationLightSourceSettingsID( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMicrobeamManipulationLightSourceSettingsWavelength( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getMicrobeamManipulationROIRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMicrobeamManipulationROIRefCount(self, int: int, int2: int) -> int: ... + def getMicrobeamManipulationRefCount(self, int: int) -> int: ... + def getMicrobeamManipulationType( + self, int: int, int2: int + ) -> ome.xml.model.enums.MicrobeamManipulationType: ... + def getMicroscopeLotNumber(self, int: int) -> java.lang.String: ... + def getMicroscopeManufacturer(self, int: int) -> java.lang.String: ... + def getMicroscopeModel(self, int: int) -> java.lang.String: ... + def getMicroscopeSerialNumber(self, int: int) -> java.lang.String: ... + def getMicroscopeType(self, int: int) -> ome.xml.model.enums.MicroscopeType: ... + def getObjectiveAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getObjectiveAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getObjectiveCalibratedMagnification(self, int: int, int2: int) -> float: ... + def getObjectiveCorrection( + self, int: int, int2: int + ) -> ome.xml.model.enums.Correction: ... + def getObjectiveCount(self, int: int) -> int: ... + def getObjectiveID(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveImmersion( + self, int: int, int2: int + ) -> ome.xml.model.enums.Immersion: ... + def getObjectiveIris(self, int: int, int2: int) -> bool: ... + def getObjectiveLensNA(self, int: int, int2: int) -> float: ... + def getObjectiveLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveModel(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveNominalMagnification(self, int: int, int2: int) -> float: ... + def getObjectiveSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveSettingsCorrectionCollar(self, int: int) -> float: ... + def getObjectiveSettingsID(self, int: int) -> java.lang.String: ... + def getObjectiveSettingsMedium(self, int: int) -> ome.xml.model.enums.Medium: ... + def getObjectiveSettingsRefractiveIndex(self, int: int) -> float: ... + def getObjectiveWorkingDistance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPixelsBigEndian(self, int: int) -> bool: ... + def getPixelsBinData(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getPixelsBinDataBigEndian(self, int: int, int2: int) -> bool: ... + def getPixelsBinDataCompression( + self, int: int, int2: int + ) -> ome.xml.model.enums.Compression: ... + def getPixelsBinDataCount(self, int: int) -> int: ... + def getPixelsBinDataLength( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getPixelsDimensionOrder( + self, int: int + ) -> ome.xml.model.enums.DimensionOrder: ... + def getPixelsID(self, int: int) -> java.lang.String: ... + def getPixelsInterleaved(self, int: int) -> bool: ... + def getPixelsPhysicalSizeX(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsPhysicalSizeY(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsPhysicalSizeZ(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsSignificantBits( + self, int: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeC(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeT(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeX(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeY(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeZ(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsTimeIncrement(self, int: int) -> ome.units.quantity.Time: ... + def getPixelsType(self, int: int) -> ome.xml.model.enums.PixelType: ... + def getPlaneAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlaneAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getPlaneCount(self, int: int) -> int: ... + def getPlaneDeltaT(self, int: int, int2: int) -> ome.units.quantity.Time: ... + def getPlaneExposureTime(self, int: int, int2: int) -> ome.units.quantity.Time: ... + def getPlaneHashSHA1(self, int: int, int2: int) -> java.lang.String: ... + def getPlanePositionX(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlanePositionY(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlanePositionZ(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlaneTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlaneTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlaneTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlateAcquisitionAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlateAcquisitionAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getPlateAcquisitionCount(self, int: int) -> int: ... + def getPlateAcquisitionDescription( + self, int: int, int2: int + ) -> java.lang.String: ... + def getPlateAcquisitionEndTime( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getPlateAcquisitionID(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAcquisitionMaximumFieldCount( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateAcquisitionName(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAcquisitionStartTime( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getPlateAcquisitionWellSampleRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlateAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAnnotationRefCount(self, int: int) -> int: ... + def getPlateColumnNamingConvention( + self, int: int + ) -> ome.xml.model.enums.NamingConvention: ... + def getPlateColumns(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateCount(self) -> int: ... + def getPlateDescription(self, int: int) -> java.lang.String: ... + def getPlateExternalIdentifier(self, int: int) -> java.lang.String: ... + def getPlateFieldIndex( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlateID(self, int: int) -> java.lang.String: ... + def getPlateName(self, int: int) -> java.lang.String: ... + def getPlateRefCount(self, int: int) -> int: ... + def getPlateRowNamingConvention( + self, int: int + ) -> ome.xml.model.enums.NamingConvention: ... + def getPlateRows(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateStatus(self, int: int) -> java.lang.String: ... + def getPlateWellOriginX(self, int: int) -> ome.units.quantity.Length: ... + def getPlateWellOriginY(self, int: int) -> ome.units.quantity.Length: ... + def getPointAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPointFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPointFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getPointFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPointFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPointFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPointID(self, int: int, int2: int) -> java.lang.String: ... + def getPointLocked(self, int: int, int2: int) -> bool: ... + def getPointStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPointStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPointStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPointText(self, int: int, int2: int) -> java.lang.String: ... + def getPointTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getPointX(self, int: int, int2: int) -> float: ... + def getPointY(self, int: int, int2: int) -> float: ... + def getPolygonAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPolygonFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolygonFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getPolygonFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPolygonFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPolygonFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPolygonID(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonLocked(self, int: int, int2: int) -> bool: ... + def getPolygonPoints(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolygonStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPolygonText(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getPolylineAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPolylineFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolylineFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getPolylineFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPolylineFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPolylineFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPolylineID(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineLocked(self, int: int, int2: int) -> bool: ... + def getPolylineMarkerEnd( + self, int: int, int2: int + ) -> ome.xml.model.enums.Marker: ... + def getPolylineMarkerStart( + self, int: int, int2: int + ) -> ome.xml.model.enums.Marker: ... + def getPolylinePoints(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolylineStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPolylineText(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getProjectAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getProjectAnnotationRefCount(self, int: int) -> int: ... + def getProjectCount(self) -> int: ... + def getProjectDatasetRef(self, int: int, int2: int) -> java.lang.String: ... + def getProjectDescription(self, int: int) -> java.lang.String: ... + def getProjectExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getProjectExperimenterRef(self, int: int) -> java.lang.String: ... + def getProjectID(self, int: int) -> java.lang.String: ... + def getProjectName(self, int: int) -> java.lang.String: ... + def getROIAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getROIAnnotationRefCount(self, int: int) -> int: ... + def getROICount(self) -> int: ... + def getROIDescription(self, int: int) -> java.lang.String: ... + def getROIID(self, int: int) -> java.lang.String: ... + def getROIName(self, int: int) -> java.lang.String: ... + def getReagentAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getReagentAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getReagentCount(self, int: int) -> int: ... + def getReagentDescription(self, int: int, int2: int) -> java.lang.String: ... + def getReagentID(self, int: int, int2: int) -> java.lang.String: ... + def getReagentName(self, int: int, int2: int) -> java.lang.String: ... + def getReagentReagentIdentifier(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getRectangleFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getRectangleFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getRectangleFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getRectangleFontSize( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getRectangleFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getRectangleHeight(self, int: int, int2: int) -> float: ... + def getRectangleID(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleLocked(self, int: int, int2: int) -> bool: ... + def getRectangleStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getRectangleStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getRectangleText(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getRectangleWidth(self, int: int, int2: int) -> float: ... + def getRectangleX(self, int: int, int2: int) -> float: ... + def getRectangleY(self, int: int, int2: int) -> float: ... + def getRightsRightsHeld(self) -> java.lang.String: ... + def getRightsRightsHolder(self) -> java.lang.String: ... + def getScreenAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getScreenAnnotationRefCount(self, int: int) -> int: ... + def getScreenCount(self) -> int: ... + def getScreenDescription(self, int: int) -> java.lang.String: ... + def getScreenID(self, int: int) -> java.lang.String: ... + def getScreenName(self, int: int) -> java.lang.String: ... + def getScreenPlateRef(self, int: int, int2: int) -> java.lang.String: ... + def getScreenProtocolDescription(self, int: int) -> java.lang.String: ... + def getScreenProtocolIdentifier(self, int: int) -> java.lang.String: ... + def getScreenReagentSetDescription(self, int: int) -> java.lang.String: ... + def getScreenReagentSetIdentifier(self, int: int) -> java.lang.String: ... + def getScreenType(self, int: int) -> java.lang.String: ... + def getShapeAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getShapeCount(self, int: int) -> int: ... + def getShapeType(self, int: int, int2: int) -> java.lang.String: ... + def getStageLabelName(self, int: int) -> java.lang.String: ... + def getStageLabelX(self, int: int) -> ome.units.quantity.Length: ... + def getStageLabelY(self, int: int) -> ome.units.quantity.Length: ... + def getStageLabelZ(self, int: int) -> ome.units.quantity.Length: ... + def getTagAnnotationAnnotationCount(self, int: int) -> int: ... + def getTagAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTagAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTagAnnotationCount(self) -> int: ... + def getTagAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTagAnnotationID(self, int: int) -> java.lang.String: ... + def getTagAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTagAnnotationValue(self, int: int) -> java.lang.String: ... + def getTermAnnotationAnnotationCount(self, int: int) -> int: ... + def getTermAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTermAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTermAnnotationCount(self) -> int: ... + def getTermAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTermAnnotationID(self, int: int) -> java.lang.String: ... + def getTermAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTermAnnotationValue(self, int: int) -> java.lang.String: ... + def getTiffDataCount(self, int: int) -> int: ... + def getTiffDataFirstC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataFirstT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataFirstZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataIFD( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataPlaneCount( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTimestampAnnotationAnnotationCount(self, int: int) -> int: ... + def getTimestampAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTimestampAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationCount(self) -> int: ... + def getTimestampAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationID(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationValue( + self, int: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getTransmittanceRangeCutIn( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutInTolerance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutOut( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutOutTolerance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeTransmittance( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getUUID(self) -> java.lang.String: ... + def getUUIDFileName(self, int: int, int2: int) -> java.lang.String: ... + def getUUIDValue(self, int: int, int2: int) -> java.lang.String: ... + def getWellAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getWellAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getWellColor(self, int: int, int2: int) -> ome.xml.model.primitives.Color: ... + def getWellColumn( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellCount(self, int: int) -> int: ... + def getWellExternalDescription(self, int: int, int2: int) -> java.lang.String: ... + def getWellExternalIdentifier(self, int: int, int2: int) -> java.lang.String: ... + def getWellID(self, int: int, int2: int) -> java.lang.String: ... + def getWellReagentRef(self, int: int, int2: int) -> java.lang.String: ... + def getWellRow( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellSampleCount(self, int: int, int2: int) -> int: ... + def getWellSampleID(self, int: int, int2: int, int3: int) -> java.lang.String: ... + def getWellSampleImageRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getWellSampleIndex( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellSamplePositionX( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getWellSamplePositionY( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getWellSampleRefCount(self, int: int, int2: int) -> int: ... + def getWellSampleTimepoint( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getWellType(self, int: int, int2: int) -> java.lang.String: ... + def getXMLAnnotationAnnotationCount(self, int: int) -> int: ... + def getXMLAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getXMLAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getXMLAnnotationCount(self) -> int: ... + def getXMLAnnotationDescription(self, int: int) -> java.lang.String: ... + def getXMLAnnotationID(self, int: int) -> java.lang.String: ... + def getXMLAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getXMLAnnotationValue(self, int: int) -> java.lang.String: ... + +class MetadataStore(BaseMetadata): + def createRoot(self) -> None: ... + def getRoot(self) -> MetadataRoot: ... + def setArcAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setArcID(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + def setArcLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setArcSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcType( + self, arcType: ome.xml.model.enums.ArcType, int: int, int2: int + ) -> None: ... + def setBinaryFileBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + def setBinaryFileBinDataBigEndian(self, boolean: bool, int: int) -> None: ... + def setBinaryFileBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int + ) -> None: ... + def setBinaryFileBinDataLength( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, int: int + ) -> None: ... + def setBinaryFileFileName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBinaryFileMIMEType( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBinaryFileSize( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, int: int + ) -> None: ... + def setBinaryOnlyMetadataFile(self, string: java.lang.String | str) -> None: ... + def setBinaryOnlyUUID(self, string: java.lang.String | str) -> None: ... + def setBooleanAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setBooleanAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationValue(self, boolean: bool, int: int) -> None: ... + def setChannelAcquisitionMode( + self, acquisitionMode: ome.xml.model.enums.AcquisitionMode, int: int, int2: int + ) -> None: ... + def setChannelAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setChannelColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setChannelContrastMethod( + self, contrastMethod: ome.xml.model.enums.ContrastMethod, int: int, int2: int + ) -> None: ... + def setChannelEmissionWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelExcitationWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelFilterSetRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelFluor( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelIlluminationType( + self, + illuminationType: ome.xml.model.enums.IlluminationType, + int: int, + int2: int, + ) -> None: ... + def setChannelLightSourceSettingsAttenuation( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + ) -> None: ... + def setChannelLightSourceSettingsID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelLightSourceSettingsWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelNDFilter(self, double: float, int: int, int2: int) -> None: ... + def setChannelName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelPinholeSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelPockelCellSetting( + self, integer: int, int2: int, int3: int + ) -> None: ... + def setChannelSamplesPerPixel( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setCommentAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setCommentAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCreator(self, string: java.lang.String | str) -> None: ... + def setDatasetAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDatasetDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetID(self, string: java.lang.String | str, int: int) -> None: ... + def setDatasetImageRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDatasetName(self, string: java.lang.String | str, int: int) -> None: ... + def setDetectorAmplificationGain( + self, double: float, int: int, int2: int + ) -> None: ... + def setDetectorAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setDetectorGain(self, double: float, int: int, int2: int) -> None: ... + def setDetectorID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorOffset(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorSettingsBinning( + self, binning: ome.xml.model.enums.Binning, int: int, int2: int + ) -> None: ... + def setDetectorSettingsGain(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSettingsID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorSettingsIntegration( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setDetectorSettingsOffset(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSettingsReadOutRate( + self, frequency: ome.units.quantity.Frequency, int: int, int2: int + ) -> None: ... + def setDetectorSettingsVoltage( + self, + electricPotential: ome.units.quantity.ElectricPotential, + int: int, + int2: int, + ) -> None: ... + def setDetectorSettingsZoom(self, double: float, int: int, int2: int) -> None: ... + def setDetectorType( + self, detectorType: ome.xml.model.enums.DetectorType, int: int, int2: int + ) -> None: ... + def setDetectorVoltage( + self, + electricPotential: ome.units.quantity.ElectricPotential, + int: int, + int2: int, + ) -> None: ... + def setDetectorZoom(self, double: float, int: int, int2: int) -> None: ... + def setDichroicAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setDichroicID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDoubleAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDoubleAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationValue(self, double: float, int: int) -> None: ... + def setEllipseAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setEllipseFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setEllipseFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setEllipseFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setEllipseFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setEllipseFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setEllipseID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setEllipseRadiusX(self, double: float, int: int, int2: int) -> None: ... + def setEllipseRadiusY(self, double: float, int: int, int2: int) -> None: ... + def setEllipseStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setEllipseStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setEllipseText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setEllipseX(self, double: float, int: int, int2: int) -> None: ... + def setEllipseY(self, double: float, int: int, int2: int) -> None: ... + def setExperimentDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimentExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimentID(self, string: java.lang.String | str, int: int) -> None: ... + def setExperimentType( + self, experimentType: ome.xml.model.enums.ExperimentType, int: int + ) -> None: ... + def setExperimenterAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterEmail( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterFirstName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupExperimenterRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupLeader( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterID(self, string: java.lang.String | str, int: int) -> None: ... + def setExperimenterInstitution( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterLastName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterMiddleName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterUserName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFilamentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilamentID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setFilamentSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentType( + self, filamentType: ome.xml.model.enums.FilamentType, int: int, int2: int + ) -> None: ... + def setFileAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFileAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFileAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFileAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setFileAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFilterAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterFilterWheel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetDichroicRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetEmissionFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterSetExcitationFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterSetID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterType( + self, filterType: ome.xml.model.enums.FilterType, int: int, int2: int + ) -> None: ... + def setFolderAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFolderFolderRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderID(self, string: java.lang.String | str, int: int) -> None: ... + def setFolderImageRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderName(self, string: java.lang.String | str, int: int) -> None: ... + def setFolderROIRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setGenericExcitationSourceID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceMap( + self, list: java.util.List[ome.xml.model.MapPair], int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourcePower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageAcquisitionDate( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int + ) -> None: ... + def setImageAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setImageExperimentRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageID(self, string: java.lang.String | str, int: int) -> None: ... + def setImageInstrumentRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageMicrobeamManipulationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageName(self, string: java.lang.String | str, int: int) -> None: ... + def setImageROIRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImagingEnvironmentAirPressure( + self, pressure: ome.units.quantity.Pressure, int: int + ) -> None: ... + def setImagingEnvironmentCO2Percent( + self, percentFraction: ome.xml.model.primitives.PercentFraction, int: int + ) -> None: ... + def setImagingEnvironmentHumidity( + self, percentFraction: ome.xml.model.primitives.PercentFraction, int: int + ) -> None: ... + def setImagingEnvironmentMap( + self, list: java.util.List[ome.xml.model.MapPair], int: int + ) -> None: ... + def setImagingEnvironmentTemperature( + self, temperature: ome.units.quantity.Temperature, int: int + ) -> None: ... + def setInstrumentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setInstrumentID(self, string: java.lang.String | str, int: int) -> None: ... + def setLabelAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLabelFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLabelFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setLabelFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setLabelFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLabelFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setLabelID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setLabelStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLabelStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLabelText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setLabelX(self, double: float, int: int, int2: int) -> None: ... + def setLabelY(self, double: float, int: int, int2: int) -> None: ... + def setLaserAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLaserFrequencyMultiplication( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setLaserID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserLaserMedium( + self, laserMedium: ome.xml.model.enums.LaserMedium, int: int, int2: int + ) -> None: ... + def setLaserLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserPockelCell(self, boolean: bool, int: int, int2: int) -> None: ... + def setLaserPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setLaserPulse( + self, pulse: ome.xml.model.enums.Pulse, int: int, int2: int + ) -> None: ... + def setLaserPump( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserRepetitionRate( + self, frequency: ome.units.quantity.Frequency, int: int, int2: int + ) -> None: ... + def setLaserSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserTuneable(self, boolean: bool, int: int, int2: int) -> None: ... + def setLaserType( + self, laserType: ome.xml.model.enums.LaserType, int: int, int2: int + ) -> None: ... + def setLaserWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightEmittingDiodeID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodePower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightPathAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightPathDichroicRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightPathEmissionFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightPathExcitationFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLineAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLineFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLineFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setLineFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setLineFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLineFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setLineID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setLineMarkerEnd( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setLineMarkerStart( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setLineStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLineStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLineText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setLineX1(self, double: float, int: int, int2: int) -> None: ... + def setLineX2(self, double: float, int: int, int2: int) -> None: ... + def setLineY1(self, double: float, int: int, int2: int) -> None: ... + def setLineY2(self, double: float, int: int, int2: int) -> None: ... + def setListAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setListAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setListAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setListAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setListAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLongAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setLongAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationValue(self, long: int, int: int) -> None: ... + def setMapAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMapAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setMapAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationValue( + self, list: java.util.List[ome.xml.model.MapPair], int: int + ) -> None: ... + def setMaskAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMaskBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def setMaskBinDataBigEndian(self, boolean: bool, int: int, int2: int) -> None: ... + def setMaskBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int, int2: int + ) -> None: ... + def setMaskBinDataLength( + self, + nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, + int: int, + int2: int, + ) -> None: ... + def setMaskFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setMaskFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setMaskFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setMaskFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setMaskFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setMaskHeight(self, double: float, int: int, int2: int) -> None: ... + def setMaskID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setMaskStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setMaskStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setMaskText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setMaskWidth(self, double: float, int: int, int2: int) -> None: ... + def setMaskX(self, double: float, int: int, int2: int) -> None: ... + def setMaskY(self, double: float, int: int, int2: int) -> None: ... + def setMicrobeamManipulationDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationExperimenterRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsAttenuation( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsID( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationROIRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationType( + self, + microbeamManipulationType: ome.xml.model.enums.MicrobeamManipulationType, + int: int, + int2: int, + ) -> None: ... + def setMicroscopeLotNumber( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeManufacturer( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeModel(self, string: java.lang.String | str, int: int) -> None: ... + def setMicroscopeSerialNumber( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeType( + self, microscopeType: ome.xml.model.enums.MicroscopeType, int: int + ) -> None: ... + def setObjectiveAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setObjectiveCalibratedMagnification( + self, double: float, int: int, int2: int + ) -> None: ... + def setObjectiveCorrection( + self, correction: ome.xml.model.enums.Correction, int: int, int2: int + ) -> None: ... + def setObjectiveID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveImmersion( + self, immersion: ome.xml.model.enums.Immersion, int: int, int2: int + ) -> None: ... + def setObjectiveIris(self, boolean: bool, int: int, int2: int) -> None: ... + def setObjectiveLensNA(self, double: float, int: int, int2: int) -> None: ... + def setObjectiveLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveNominalMagnification( + self, double: float, int: int, int2: int + ) -> None: ... + def setObjectiveSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveSettingsCorrectionCollar(self, double: float, int: int) -> None: ... + def setObjectiveSettingsID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setObjectiveSettingsMedium( + self, medium: ome.xml.model.enums.Medium, int: int + ) -> None: ... + def setObjectiveSettingsRefractiveIndex(self, double: float, int: int) -> None: ... + def setObjectiveWorkingDistance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPixelsBigEndian(self, boolean: bool, int: int) -> None: ... + def setPixelsBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def setPixelsBinDataBigEndian(self, boolean: bool, int: int, int2: int) -> None: ... + def setPixelsBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int, int2: int + ) -> None: ... + def setPixelsBinDataLength( + self, + nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, + int: int, + int2: int, + ) -> None: ... + def setPixelsDimensionOrder( + self, dimensionOrder: ome.xml.model.enums.DimensionOrder, int: int + ) -> None: ... + def setPixelsID(self, string: java.lang.String | str, int: int) -> None: ... + def setPixelsInterleaved(self, boolean: bool, int: int) -> None: ... + def setPixelsPhysicalSizeX( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsPhysicalSizeY( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsPhysicalSizeZ( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsSignificantBits( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeC( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeT( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeX( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeY( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeZ( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsTimeIncrement( + self, time: ome.units.quantity.Time, int: int + ) -> None: ... + def setPixelsType( + self, pixelType: ome.xml.model.enums.PixelType, int: int + ) -> None: ... + def setPlaneAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlaneDeltaT( + self, time: ome.units.quantity.Time, int: int, int2: int + ) -> None: ... + def setPlaneExposureTime( + self, time: ome.units.quantity.Time, int: int, int2: int + ) -> None: ... + def setPlaneHashSHA1( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlanePositionX( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlanePositionY( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlanePositionZ( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlaneTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlaneTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlaneTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlateAcquisitionAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlateAcquisitionDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionEndTime( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionMaximumFieldCount( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setPlateAcquisitionName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionStartTime( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionWellSampleRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlateAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateColumnNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention, int: int + ) -> None: ... + def setPlateColumns( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPlateDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateExternalIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setPlateFieldIndex( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, int: int + ) -> None: ... + def setPlateID(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateName(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateRowNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention, int: int + ) -> None: ... + def setPlateRows( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPlateStatus(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateWellOriginX( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPlateWellOriginY( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPointAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPointFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPointFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPointFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPointFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPointFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPointID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPointStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPointStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPointText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setPointX(self, double: float, int: int, int2: int) -> None: ... + def setPointY(self, double: float, int: int, int2: int) -> None: ... + def setPolygonAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPolygonFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolygonFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPolygonFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPolygonFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolygonFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPolygonID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPolygonPoints( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolygonStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolygonText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setPolylineAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPolylineFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolylineFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPolylineFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPolylineFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolylineFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPolylineID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPolylineMarkerEnd( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setPolylineMarkerStart( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setPolylinePoints( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolylineStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolylineText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setProjectAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setProjectDatasetRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setProjectDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectID(self, string: java.lang.String | str, int: int) -> None: ... + def setProjectName(self, string: java.lang.String | str, int: int) -> None: ... + def setROIAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setROIDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setROIID(self, string: java.lang.String | str, int: int) -> None: ... + def setROIName(self, string: java.lang.String | str, int: int) -> None: ... + def setReagentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setReagentDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentReagentIdentifier( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setRectangleFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setRectangleFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setRectangleFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setRectangleFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setRectangleFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setRectangleHeight(self, double: float, int: int, int2: int) -> None: ... + def setRectangleID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setRectangleStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setRectangleStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setRectangleText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setRectangleWidth(self, double: float, int: int, int2: int) -> None: ... + def setRectangleX(self, double: float, int: int, int2: int) -> None: ... + def setRectangleY(self, double: float, int: int, int2: int) -> None: ... + def setRightsRightsHeld(self, string: java.lang.String | str) -> None: ... + def setRightsRightsHolder(self, string: java.lang.String | str) -> None: ... + def setRoot(self, metadataRoot: MetadataRoot) -> None: ... + def setScreenAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setScreenDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenID(self, string: java.lang.String | str, int: int) -> None: ... + def setScreenName(self, string: java.lang.String | str, int: int) -> None: ... + def setScreenPlateRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setScreenProtocolDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenProtocolIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenReagentSetDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenReagentSetIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenType(self, string: java.lang.String | str, int: int) -> None: ... + def setStageLabelName(self, string: java.lang.String | str, int: int) -> None: ... + def setStageLabelX(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setStageLabelY(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setStageLabelZ(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setTagAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTagAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setTagAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTermAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setTermAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTiffDataFirstC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataFirstT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataFirstZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataIFD( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataPlaneCount( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTimestampAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTimestampAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationValue( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int + ) -> None: ... + def setTransmittanceRangeCutIn( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutInTolerance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutOut( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutOutTolerance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeTransmittance( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + ) -> None: ... + def setUUID(self, string: java.lang.String | str) -> None: ... + def setUUIDFileName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setUUIDValue( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setWellColumn( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setWellExternalDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellExternalIdentifier( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellReagentRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellRow( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setWellSampleID( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleImageRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleIndex( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setWellSamplePositionX( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setWellSamplePositionY( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleTimepoint( + self, + timestamp: ome.xml.model.primitives.Timestamp, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setWellType( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setXMLAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setXMLAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setXMLAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + +class OMEXMLMetadataRoot(ome.xml.model.OME, MetadataRoot): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, oME: ome.xml.model.OME): ... + @typing.overload + def __init__( + self, element: org.w3c.dom.Element, oMEModel: ome.xml.model.OMEModel + ): ... + +class IMetadata(MetadataRetrieve, MetadataStore): ... + +class AggregateMetadata(IMetadata): + def __init__(self, list: java.util.List[BaseMetadata]): ... + def createRoot(self) -> None: ... + def getArcAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getArcID(self, int: int, int2: int) -> java.lang.String: ... + def getArcLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getArcManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getArcModel(self, int: int, int2: int) -> java.lang.String: ... + def getArcPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getArcSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getArcType(self, int: int, int2: int) -> ome.xml.model.enums.ArcType: ... + def getBinaryFileBinData(self, int: int) -> typing.MutableSequence[int]: ... + def getBinaryFileBinDataBigEndian(self, int: int) -> bool: ... + def getBinaryFileBinDataCompression( + self, int: int + ) -> ome.xml.model.enums.Compression: ... + def getBinaryFileBinDataLength( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getBinaryFileFileName(self, int: int) -> java.lang.String: ... + def getBinaryFileMIMEType(self, int: int) -> java.lang.String: ... + def getBinaryFileSize( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getBinaryOnlyMetadataFile(self) -> java.lang.String: ... + def getBinaryOnlyUUID(self) -> java.lang.String: ... + def getBooleanAnnotationAnnotationCount(self, int: int) -> int: ... + def getBooleanAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getBooleanAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationCount(self) -> int: ... + def getBooleanAnnotationDescription(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationID(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationValue(self, int: int) -> bool: ... + def getChannelAcquisitionMode( + self, int: int, int2: int + ) -> ome.xml.model.enums.AcquisitionMode: ... + def getChannelAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getChannelAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getChannelColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getChannelContrastMethod( + self, int: int, int2: int + ) -> ome.xml.model.enums.ContrastMethod: ... + def getChannelCount(self, int: int) -> int: ... + def getChannelEmissionWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelExcitationWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelFilterSetRef(self, int: int, int2: int) -> java.lang.String: ... + def getChannelFluor(self, int: int, int2: int) -> java.lang.String: ... + def getChannelID(self, int: int, int2: int) -> java.lang.String: ... + def getChannelIlluminationType( + self, int: int, int2: int + ) -> ome.xml.model.enums.IlluminationType: ... + def getChannelLightSourceSettingsAttenuation( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getChannelLightSourceSettingsID( + self, int: int, int2: int + ) -> java.lang.String: ... + def getChannelLightSourceSettingsWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelNDFilter(self, int: int, int2: int) -> float: ... + def getChannelName(self, int: int, int2: int) -> java.lang.String: ... + def getChannelPinholeSize( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelPockelCellSetting(self, int: int, int2: int) -> int: ... + def getChannelSamplesPerPixel( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getCommentAnnotationAnnotationCount(self, int: int) -> int: ... + def getCommentAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getCommentAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getCommentAnnotationCount(self) -> int: ... + def getCommentAnnotationDescription(self, int: int) -> java.lang.String: ... + def getCommentAnnotationID(self, int: int) -> java.lang.String: ... + def getCommentAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getCommentAnnotationValue(self, int: int) -> java.lang.String: ... + def getCreator(self) -> java.lang.String: ... + def getDatasetAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getDatasetAnnotationRefCount(self, int: int) -> int: ... + def getDatasetCount(self) -> int: ... + def getDatasetDescription(self, int: int) -> java.lang.String: ... + def getDatasetExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getDatasetExperimenterRef(self, int: int) -> java.lang.String: ... + def getDatasetID(self, int: int) -> java.lang.String: ... + def getDatasetImageRef(self, int: int, int2: int) -> java.lang.String: ... + def getDatasetImageRefCount(self, int: int) -> int: ... + def getDatasetName(self, int: int) -> java.lang.String: ... + def getDatasetRefCount(self, int: int) -> int: ... + def getDetectorAmplificationGain(self, int: int, int2: int) -> float: ... + def getDetectorAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getDetectorAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getDetectorCount(self, int: int) -> int: ... + def getDetectorGain(self, int: int, int2: int) -> float: ... + def getDetectorID(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorModel(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorOffset(self, int: int, int2: int) -> float: ... + def getDetectorSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorSettingsBinning( + self, int: int, int2: int + ) -> ome.xml.model.enums.Binning: ... + def getDetectorSettingsGain(self, int: int, int2: int) -> float: ... + def getDetectorSettingsID(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorSettingsIntegration( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getDetectorSettingsOffset(self, int: int, int2: int) -> float: ... + def getDetectorSettingsReadOutRate( + self, int: int, int2: int + ) -> ome.units.quantity.Frequency: ... + def getDetectorSettingsVoltage( + self, int: int, int2: int + ) -> ome.units.quantity.ElectricPotential: ... + def getDetectorSettingsZoom(self, int: int, int2: int) -> float: ... + def getDetectorType( + self, int: int, int2: int + ) -> ome.xml.model.enums.DetectorType: ... + def getDetectorVoltage( + self, int: int, int2: int + ) -> ome.units.quantity.ElectricPotential: ... + def getDetectorZoom(self, int: int, int2: int) -> float: ... + def getDichroicAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getDichroicAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getDichroicCount(self, int: int) -> int: ... + def getDichroicID(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicModel(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDoubleAnnotationAnnotationCount(self, int: int) -> int: ... + def getDoubleAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getDoubleAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationCount(self) -> int: ... + def getDoubleAnnotationDescription(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationID(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationValue(self, int: int) -> float: ... + def getEllipseAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getEllipseFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getEllipseFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getEllipseFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getEllipseFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getEllipseFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getEllipseID(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseLocked(self, int: int, int2: int) -> bool: ... + def getEllipseRadiusX(self, int: int, int2: int) -> float: ... + def getEllipseRadiusY(self, int: int, int2: int) -> float: ... + def getEllipseStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getEllipseStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getEllipseText(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getEllipseX(self, int: int, int2: int) -> float: ... + def getEllipseY(self, int: int, int2: int) -> float: ... + def getExperimentCount(self) -> int: ... + def getExperimentDescription(self, int: int) -> java.lang.String: ... + def getExperimentExperimenterRef(self, int: int) -> java.lang.String: ... + def getExperimentID(self, int: int) -> java.lang.String: ... + def getExperimentType(self, int: int) -> ome.xml.model.enums.ExperimentType: ... + def getExperimenterAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getExperimenterAnnotationRefCount(self, int: int) -> int: ... + def getExperimenterCount(self) -> int: ... + def getExperimenterEmail(self, int: int) -> java.lang.String: ... + def getExperimenterFirstName(self, int: int) -> java.lang.String: ... + def getExperimenterGroupAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getExperimenterGroupAnnotationRefCount(self, int: int) -> int: ... + def getExperimenterGroupCount(self) -> int: ... + def getExperimenterGroupDescription(self, int: int) -> java.lang.String: ... + def getExperimenterGroupExperimenterRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getExperimenterGroupExperimenterRefCount(self, int: int) -> int: ... + def getExperimenterGroupID(self, int: int) -> java.lang.String: ... + def getExperimenterGroupLeader(self, int: int, int2: int) -> java.lang.String: ... + def getExperimenterGroupName(self, int: int) -> java.lang.String: ... + def getExperimenterID(self, int: int) -> java.lang.String: ... + def getExperimenterInstitution(self, int: int) -> java.lang.String: ... + def getExperimenterLastName(self, int: int) -> java.lang.String: ... + def getExperimenterMiddleName(self, int: int) -> java.lang.String: ... + def getExperimenterUserName(self, int: int) -> java.lang.String: ... + def getFilamentAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilamentID(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getFilamentSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentType( + self, int: int, int2: int + ) -> ome.xml.model.enums.FilamentType: ... + def getFileAnnotationAnnotationCount(self, int: int) -> int: ... + def getFileAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getFileAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getFileAnnotationCount(self) -> int: ... + def getFileAnnotationDescription(self, int: int) -> java.lang.String: ... + def getFileAnnotationID(self, int: int) -> java.lang.String: ... + def getFileAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getFilterAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getFilterCount(self, int: int) -> int: ... + def getFilterFilterWheel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterID(self, int: int, int2: int) -> java.lang.String: ... + def getFilterLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilterModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetCount(self, int: int) -> int: ... + def getFilterSetDichroicRef(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetEmissionFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterSetEmissionFilterRefCount(self, int: int, int2: int) -> int: ... + def getFilterSetExcitationFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterSetExcitationFilterRefCount(self, int: int, int2: int) -> int: ... + def getFilterSetID(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterType(self, int: int, int2: int) -> ome.xml.model.enums.FilterType: ... + def getFolderAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderAnnotationRefCount(self, int: int) -> int: ... + def getFolderCount(self) -> int: ... + def getFolderDescription(self, int: int) -> java.lang.String: ... + def getFolderFolderRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderID(self, int: int) -> java.lang.String: ... + def getFolderImageRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderImageRefCount(self, int: int) -> int: ... + def getFolderName(self, int: int) -> java.lang.String: ... + def getFolderROIRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderROIRefCount(self, int: int) -> int: ... + def getFolderRefCount(self, int: int) -> int: ... + def getGenericExcitationSourceAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getGenericExcitationSourceID(self, int: int, int2: int) -> java.lang.String: ... + def getGenericExcitationSourceLotNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourceManufacturer( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourceMap( + self, int: int, int2: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getGenericExcitationSourceModel( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourcePower( + self, int: int, int2: int + ) -> ome.units.quantity.Power: ... + def getGenericExcitationSourceSerialNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getImageAcquisitionDate( + self, int: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getImageAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getImageAnnotationRefCount(self, int: int) -> int: ... + def getImageCount(self) -> int: ... + def getImageDescription(self, int: int) -> java.lang.String: ... + def getImageExperimentRef(self, int: int) -> java.lang.String: ... + def getImageExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getImageExperimenterRef(self, int: int) -> java.lang.String: ... + def getImageID(self, int: int) -> java.lang.String: ... + def getImageInstrumentRef(self, int: int) -> java.lang.String: ... + def getImageMicrobeamManipulationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getImageName(self, int: int) -> java.lang.String: ... + def getImageROIRef(self, int: int, int2: int) -> java.lang.String: ... + def getImageROIRefCount(self, int: int) -> int: ... + def getImagingEnvironmentAirPressure( + self, int: int + ) -> ome.units.quantity.Pressure: ... + def getImagingEnvironmentCO2Percent( + self, int: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getImagingEnvironmentHumidity( + self, int: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getImagingEnvironmentMap( + self, int: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getImagingEnvironmentTemperature( + self, int: int + ) -> ome.units.quantity.Temperature: ... + def getInstrumentAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getInstrumentAnnotationRefCount(self, int: int) -> int: ... + def getInstrumentCount(self) -> int: ... + def getInstrumentID(self, int: int) -> java.lang.String: ... + def getLabelAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLabelFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLabelFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getLabelFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getLabelFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLabelFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getLabelID(self, int: int, int2: int) -> java.lang.String: ... + def getLabelLocked(self, int: int, int2: int) -> bool: ... + def getLabelStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLabelStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getLabelStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLabelText(self, int: int, int2: int) -> java.lang.String: ... + def getLabelTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getLabelX(self, int: int, int2: int) -> float: ... + def getLabelY(self, int: int, int2: int) -> float: ... + def getLaserAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLaserFrequencyMultiplication( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getLaserID(self, int: int, int2: int) -> java.lang.String: ... + def getLaserLaserMedium( + self, int: int, int2: int + ) -> ome.xml.model.enums.LaserMedium: ... + def getLaserLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getLaserManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getLaserModel(self, int: int, int2: int) -> java.lang.String: ... + def getLaserPockelCell(self, int: int, int2: int) -> bool: ... + def getLaserPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getLaserPulse(self, int: int, int2: int) -> ome.xml.model.enums.Pulse: ... + def getLaserPump(self, int: int, int2: int) -> java.lang.String: ... + def getLaserRepetitionRate( + self, int: int, int2: int + ) -> ome.units.quantity.Frequency: ... + def getLaserSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getLaserTuneable(self, int: int, int2: int) -> bool: ... + def getLaserType(self, int: int, int2: int) -> ome.xml.model.enums.LaserType: ... + def getLaserWavelength(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLeaderCount(self, int: int) -> int: ... + def getLightEmittingDiodeAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightEmittingDiodeID(self, int: int, int2: int) -> java.lang.String: ... + def getLightEmittingDiodeLotNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightEmittingDiodeManufacturer( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightEmittingDiodeModel(self, int: int, int2: int) -> java.lang.String: ... + def getLightEmittingDiodePower( + self, int: int, int2: int + ) -> ome.units.quantity.Power: ... + def getLightEmittingDiodeSerialNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightPathAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getLightPathDichroicRef(self, int: int, int2: int) -> java.lang.String: ... + def getLightPathEmissionFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathEmissionFilterRefCount(self, int: int, int2: int) -> int: ... + def getLightPathExcitationFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathExcitationFilterRefCount(self, int: int, int2: int) -> int: ... + def getLightSourceAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getLightSourceCount(self, int: int) -> int: ... + def getLightSourceType(self, int: int, int2: int) -> java.lang.String: ... + def getLineAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLineFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLineFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getLineFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getLineFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLineFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getLineID(self, int: int, int2: int) -> java.lang.String: ... + def getLineLocked(self, int: int, int2: int) -> bool: ... + def getLineMarkerEnd(self, int: int, int2: int) -> ome.xml.model.enums.Marker: ... + def getLineMarkerStart(self, int: int, int2: int) -> ome.xml.model.enums.Marker: ... + def getLineStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLineStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getLineStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLineText(self, int: int, int2: int) -> java.lang.String: ... + def getLineTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getLineX1(self, int: int, int2: int) -> float: ... + def getLineX2(self, int: int, int2: int) -> float: ... + def getLineY1(self, int: int, int2: int) -> float: ... + def getLineY2(self, int: int, int2: int) -> float: ... + def getListAnnotationAnnotationCount(self, int: int) -> int: ... + def getListAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getListAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getListAnnotationCount(self) -> int: ... + def getListAnnotationDescription(self, int: int) -> java.lang.String: ... + def getListAnnotationID(self, int: int) -> java.lang.String: ... + def getListAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getLongAnnotationAnnotationCount(self, int: int) -> int: ... + def getLongAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLongAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getLongAnnotationCount(self) -> int: ... + def getLongAnnotationDescription(self, int: int) -> java.lang.String: ... + def getLongAnnotationID(self, int: int) -> java.lang.String: ... + def getLongAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getLongAnnotationValue(self, int: int) -> int: ... + def getMapAnnotationAnnotationCount(self, int: int) -> int: ... + def getMapAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMapAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getMapAnnotationCount(self) -> int: ... + def getMapAnnotationDescription(self, int: int) -> java.lang.String: ... + def getMapAnnotationID(self, int: int) -> java.lang.String: ... + def getMapAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getMapAnnotationValue( + self, int: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getMaskAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMaskBinData(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getMaskBinDataBigEndian(self, int: int, int2: int) -> bool: ... + def getMaskBinDataCompression( + self, int: int, int2: int + ) -> ome.xml.model.enums.Compression: ... + def getMaskBinDataLength( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getMaskFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getMaskFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getMaskFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getMaskFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getMaskFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getMaskHeight(self, int: int, int2: int) -> float: ... + def getMaskID(self, int: int, int2: int) -> java.lang.String: ... + def getMaskLocked(self, int: int, int2: int) -> bool: ... + def getMaskStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getMaskStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getMaskStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getMaskText(self, int: int, int2: int) -> java.lang.String: ... + def getMaskTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getMaskWidth(self, int: int, int2: int) -> float: ... + def getMaskX(self, int: int, int2: int) -> float: ... + def getMaskY(self, int: int, int2: int) -> float: ... + def getMicrobeamManipulationCount(self, int: int) -> int: ... + def getMicrobeamManipulationDescription( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMicrobeamManipulationExperimenterRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMicrobeamManipulationID(self, int: int, int2: int) -> java.lang.String: ... + def getMicrobeamManipulationLightSourceSettingsAttenuation( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getMicrobeamManipulationLightSourceSettingsCount( + self, int: int, int2: int + ) -> int: ... + def getMicrobeamManipulationLightSourceSettingsID( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMicrobeamManipulationLightSourceSettingsWavelength( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getMicrobeamManipulationROIRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMicrobeamManipulationROIRefCount(self, int: int, int2: int) -> int: ... + def getMicrobeamManipulationRefCount(self, int: int) -> int: ... + def getMicrobeamManipulationType( + self, int: int, int2: int + ) -> ome.xml.model.enums.MicrobeamManipulationType: ... + def getMicroscopeLotNumber(self, int: int) -> java.lang.String: ... + def getMicroscopeManufacturer(self, int: int) -> java.lang.String: ... + def getMicroscopeModel(self, int: int) -> java.lang.String: ... + def getMicroscopeSerialNumber(self, int: int) -> java.lang.String: ... + def getMicroscopeType(self, int: int) -> ome.xml.model.enums.MicroscopeType: ... + def getObjectiveAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getObjectiveAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getObjectiveCalibratedMagnification(self, int: int, int2: int) -> float: ... + def getObjectiveCorrection( + self, int: int, int2: int + ) -> ome.xml.model.enums.Correction: ... + def getObjectiveCount(self, int: int) -> int: ... + def getObjectiveID(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveImmersion( + self, int: int, int2: int + ) -> ome.xml.model.enums.Immersion: ... + def getObjectiveIris(self, int: int, int2: int) -> bool: ... + def getObjectiveLensNA(self, int: int, int2: int) -> float: ... + def getObjectiveLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveModel(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveNominalMagnification(self, int: int, int2: int) -> float: ... + def getObjectiveSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveSettingsCorrectionCollar(self, int: int) -> float: ... + def getObjectiveSettingsID(self, int: int) -> java.lang.String: ... + def getObjectiveSettingsMedium(self, int: int) -> ome.xml.model.enums.Medium: ... + def getObjectiveSettingsRefractiveIndex(self, int: int) -> float: ... + def getObjectiveWorkingDistance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPixelsBigEndian(self, int: int) -> bool: ... + def getPixelsBinData(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getPixelsBinDataBigEndian(self, int: int, int2: int) -> bool: ... + def getPixelsBinDataCompression( + self, int: int, int2: int + ) -> ome.xml.model.enums.Compression: ... + def getPixelsBinDataCount(self, int: int) -> int: ... + def getPixelsBinDataLength( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getPixelsDimensionOrder( + self, int: int + ) -> ome.xml.model.enums.DimensionOrder: ... + def getPixelsID(self, int: int) -> java.lang.String: ... + def getPixelsInterleaved(self, int: int) -> bool: ... + def getPixelsPhysicalSizeX(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsPhysicalSizeY(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsPhysicalSizeZ(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsSignificantBits( + self, int: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeC(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeT(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeX(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeY(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeZ(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsTimeIncrement(self, int: int) -> ome.units.quantity.Time: ... + def getPixelsType(self, int: int) -> ome.xml.model.enums.PixelType: ... + def getPlaneAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlaneAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getPlaneCount(self, int: int) -> int: ... + def getPlaneDeltaT(self, int: int, int2: int) -> ome.units.quantity.Time: ... + def getPlaneExposureTime(self, int: int, int2: int) -> ome.units.quantity.Time: ... + def getPlaneHashSHA1(self, int: int, int2: int) -> java.lang.String: ... + def getPlanePositionX(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlanePositionY(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlanePositionZ(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlaneTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlaneTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlaneTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlateAcquisitionAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlateAcquisitionAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getPlateAcquisitionCount(self, int: int) -> int: ... + def getPlateAcquisitionDescription( + self, int: int, int2: int + ) -> java.lang.String: ... + def getPlateAcquisitionEndTime( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getPlateAcquisitionID(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAcquisitionMaximumFieldCount( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateAcquisitionName(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAcquisitionStartTime( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getPlateAcquisitionWellSampleRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlateAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAnnotationRefCount(self, int: int) -> int: ... + def getPlateColumnNamingConvention( + self, int: int + ) -> ome.xml.model.enums.NamingConvention: ... + def getPlateColumns(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateCount(self) -> int: ... + def getPlateDescription(self, int: int) -> java.lang.String: ... + def getPlateExternalIdentifier(self, int: int) -> java.lang.String: ... + def getPlateFieldIndex( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlateID(self, int: int) -> java.lang.String: ... + def getPlateName(self, int: int) -> java.lang.String: ... + def getPlateRefCount(self, int: int) -> int: ... + def getPlateRowNamingConvention( + self, int: int + ) -> ome.xml.model.enums.NamingConvention: ... + def getPlateRows(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateStatus(self, int: int) -> java.lang.String: ... + def getPlateWellOriginX(self, int: int) -> ome.units.quantity.Length: ... + def getPlateWellOriginY(self, int: int) -> ome.units.quantity.Length: ... + def getPointAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPointFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPointFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getPointFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPointFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPointFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPointID(self, int: int, int2: int) -> java.lang.String: ... + def getPointLocked(self, int: int, int2: int) -> bool: ... + def getPointStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPointStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPointStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPointText(self, int: int, int2: int) -> java.lang.String: ... + def getPointTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getPointX(self, int: int, int2: int) -> float: ... + def getPointY(self, int: int, int2: int) -> float: ... + def getPolygonAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPolygonFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolygonFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getPolygonFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPolygonFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPolygonFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPolygonID(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonLocked(self, int: int, int2: int) -> bool: ... + def getPolygonPoints(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolygonStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPolygonText(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getPolylineAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPolylineFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolylineFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getPolylineFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPolylineFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPolylineFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPolylineID(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineLocked(self, int: int, int2: int) -> bool: ... + def getPolylineMarkerEnd( + self, int: int, int2: int + ) -> ome.xml.model.enums.Marker: ... + def getPolylineMarkerStart( + self, int: int, int2: int + ) -> ome.xml.model.enums.Marker: ... + def getPolylinePoints(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolylineStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPolylineText(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getProjectAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getProjectAnnotationRefCount(self, int: int) -> int: ... + def getProjectCount(self) -> int: ... + def getProjectDatasetRef(self, int: int, int2: int) -> java.lang.String: ... + def getProjectDescription(self, int: int) -> java.lang.String: ... + def getProjectExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getProjectExperimenterRef(self, int: int) -> java.lang.String: ... + def getProjectID(self, int: int) -> java.lang.String: ... + def getProjectName(self, int: int) -> java.lang.String: ... + def getROIAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getROIAnnotationRefCount(self, int: int) -> int: ... + def getROICount(self) -> int: ... + def getROIDescription(self, int: int) -> java.lang.String: ... + def getROIID(self, int: int) -> java.lang.String: ... + def getROIName(self, int: int) -> java.lang.String: ... + def getReagentAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getReagentAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getReagentCount(self, int: int) -> int: ... + def getReagentDescription(self, int: int, int2: int) -> java.lang.String: ... + def getReagentID(self, int: int, int2: int) -> java.lang.String: ... + def getReagentName(self, int: int, int2: int) -> java.lang.String: ... + def getReagentReagentIdentifier(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getRectangleFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getRectangleFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getRectangleFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getRectangleFontSize( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getRectangleFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getRectangleHeight(self, int: int, int2: int) -> float: ... + def getRectangleID(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleLocked(self, int: int, int2: int) -> bool: ... + def getRectangleStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getRectangleStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getRectangleText(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getRectangleWidth(self, int: int, int2: int) -> float: ... + def getRectangleX(self, int: int, int2: int) -> float: ... + def getRectangleY(self, int: int, int2: int) -> float: ... + def getRightsRightsHeld(self) -> java.lang.String: ... + def getRightsRightsHolder(self) -> java.lang.String: ... + def getRoot(self) -> MetadataRoot: ... + def getScreenAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getScreenAnnotationRefCount(self, int: int) -> int: ... + def getScreenCount(self) -> int: ... + def getScreenDescription(self, int: int) -> java.lang.String: ... + def getScreenID(self, int: int) -> java.lang.String: ... + def getScreenName(self, int: int) -> java.lang.String: ... + def getScreenPlateRef(self, int: int, int2: int) -> java.lang.String: ... + def getScreenProtocolDescription(self, int: int) -> java.lang.String: ... + def getScreenProtocolIdentifier(self, int: int) -> java.lang.String: ... + def getScreenReagentSetDescription(self, int: int) -> java.lang.String: ... + def getScreenReagentSetIdentifier(self, int: int) -> java.lang.String: ... + def getScreenType(self, int: int) -> java.lang.String: ... + def getShapeAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getShapeCount(self, int: int) -> int: ... + def getShapeType(self, int: int, int2: int) -> java.lang.String: ... + def getStageLabelName(self, int: int) -> java.lang.String: ... + def getStageLabelX(self, int: int) -> ome.units.quantity.Length: ... + def getStageLabelY(self, int: int) -> ome.units.quantity.Length: ... + def getStageLabelZ(self, int: int) -> ome.units.quantity.Length: ... + def getTagAnnotationAnnotationCount(self, int: int) -> int: ... + def getTagAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTagAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTagAnnotationCount(self) -> int: ... + def getTagAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTagAnnotationID(self, int: int) -> java.lang.String: ... + def getTagAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTagAnnotationValue(self, int: int) -> java.lang.String: ... + def getTermAnnotationAnnotationCount(self, int: int) -> int: ... + def getTermAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTermAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTermAnnotationCount(self) -> int: ... + def getTermAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTermAnnotationID(self, int: int) -> java.lang.String: ... + def getTermAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTermAnnotationValue(self, int: int) -> java.lang.String: ... + def getTiffDataCount(self, int: int) -> int: ... + def getTiffDataFirstC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataFirstT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataFirstZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataIFD( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataPlaneCount( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTimestampAnnotationAnnotationCount(self, int: int) -> int: ... + def getTimestampAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTimestampAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationCount(self) -> int: ... + def getTimestampAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationID(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationValue( + self, int: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getTransmittanceRangeCutIn( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutInTolerance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutOut( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutOutTolerance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeTransmittance( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getUUID(self) -> java.lang.String: ... + def getUUIDFileName(self, int: int, int2: int) -> java.lang.String: ... + def getUUIDValue(self, int: int, int2: int) -> java.lang.String: ... + def getWellAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getWellAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getWellColor(self, int: int, int2: int) -> ome.xml.model.primitives.Color: ... + def getWellColumn( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellCount(self, int: int) -> int: ... + def getWellExternalDescription(self, int: int, int2: int) -> java.lang.String: ... + def getWellExternalIdentifier(self, int: int, int2: int) -> java.lang.String: ... + def getWellID(self, int: int, int2: int) -> java.lang.String: ... + def getWellReagentRef(self, int: int, int2: int) -> java.lang.String: ... + def getWellRow( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellSampleCount(self, int: int, int2: int) -> int: ... + def getWellSampleID(self, int: int, int2: int, int3: int) -> java.lang.String: ... + def getWellSampleImageRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getWellSampleIndex( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellSamplePositionX( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getWellSamplePositionY( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getWellSampleRefCount(self, int: int, int2: int) -> int: ... + def getWellSampleTimepoint( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getWellType(self, int: int, int2: int) -> java.lang.String: ... + def getXMLAnnotationAnnotationCount(self, int: int) -> int: ... + def getXMLAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getXMLAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getXMLAnnotationCount(self) -> int: ... + def getXMLAnnotationDescription(self, int: int) -> java.lang.String: ... + def getXMLAnnotationID(self, int: int) -> java.lang.String: ... + def getXMLAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getXMLAnnotationValue(self, int: int) -> java.lang.String: ... + def setArcAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setArcID(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + def setArcLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setArcSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcType( + self, arcType: ome.xml.model.enums.ArcType, int: int, int2: int + ) -> None: ... + def setBinaryFileBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + def setBinaryFileBinDataBigEndian(self, boolean: bool, int: int) -> None: ... + def setBinaryFileBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int + ) -> None: ... + def setBinaryFileBinDataLength( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, int: int + ) -> None: ... + def setBinaryFileFileName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBinaryFileMIMEType( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBinaryFileSize( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, int: int + ) -> None: ... + def setBinaryOnlyMetadataFile(self, string: java.lang.String | str) -> None: ... + def setBinaryOnlyUUID(self, string: java.lang.String | str) -> None: ... + def setBooleanAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setBooleanAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationValue(self, boolean: bool, int: int) -> None: ... + def setChannelAcquisitionMode( + self, acquisitionMode: ome.xml.model.enums.AcquisitionMode, int: int, int2: int + ) -> None: ... + def setChannelAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setChannelColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setChannelContrastMethod( + self, contrastMethod: ome.xml.model.enums.ContrastMethod, int: int, int2: int + ) -> None: ... + def setChannelEmissionWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelExcitationWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelFilterSetRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelFluor( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelIlluminationType( + self, + illuminationType: ome.xml.model.enums.IlluminationType, + int: int, + int2: int, + ) -> None: ... + def setChannelLightSourceSettingsAttenuation( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + ) -> None: ... + def setChannelLightSourceSettingsID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelLightSourceSettingsWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelNDFilter(self, double: float, int: int, int2: int) -> None: ... + def setChannelName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelPinholeSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelPockelCellSetting( + self, integer: int, int2: int, int3: int + ) -> None: ... + def setChannelSamplesPerPixel( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setCommentAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setCommentAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCreator(self, string: java.lang.String | str) -> None: ... + def setDatasetAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDatasetDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetID(self, string: java.lang.String | str, int: int) -> None: ... + def setDatasetImageRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDatasetName(self, string: java.lang.String | str, int: int) -> None: ... + def setDetectorAmplificationGain( + self, double: float, int: int, int2: int + ) -> None: ... + def setDetectorAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setDetectorGain(self, double: float, int: int, int2: int) -> None: ... + def setDetectorID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorOffset(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorSettingsBinning( + self, binning: ome.xml.model.enums.Binning, int: int, int2: int + ) -> None: ... + def setDetectorSettingsGain(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSettingsID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorSettingsIntegration( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setDetectorSettingsOffset(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSettingsReadOutRate( + self, frequency: ome.units.quantity.Frequency, int: int, int2: int + ) -> None: ... + def setDetectorSettingsVoltage( + self, + electricPotential: ome.units.quantity.ElectricPotential, + int: int, + int2: int, + ) -> None: ... + def setDetectorSettingsZoom(self, double: float, int: int, int2: int) -> None: ... + def setDetectorType( + self, detectorType: ome.xml.model.enums.DetectorType, int: int, int2: int + ) -> None: ... + def setDetectorVoltage( + self, + electricPotential: ome.units.quantity.ElectricPotential, + int: int, + int2: int, + ) -> None: ... + def setDetectorZoom(self, double: float, int: int, int2: int) -> None: ... + def setDichroicAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setDichroicID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDoubleAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDoubleAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationValue(self, double: float, int: int) -> None: ... + def setEllipseAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setEllipseFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setEllipseFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setEllipseFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setEllipseFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setEllipseFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setEllipseID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setEllipseRadiusX(self, double: float, int: int, int2: int) -> None: ... + def setEllipseRadiusY(self, double: float, int: int, int2: int) -> None: ... + def setEllipseStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setEllipseStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setEllipseText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setEllipseX(self, double: float, int: int, int2: int) -> None: ... + def setEllipseY(self, double: float, int: int, int2: int) -> None: ... + def setExperimentDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimentExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimentID(self, string: java.lang.String | str, int: int) -> None: ... + def setExperimentType( + self, experimentType: ome.xml.model.enums.ExperimentType, int: int + ) -> None: ... + def setExperimenterAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterEmail( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterFirstName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupExperimenterRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupLeader( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterID(self, string: java.lang.String | str, int: int) -> None: ... + def setExperimenterInstitution( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterLastName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterMiddleName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterUserName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFilamentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilamentID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setFilamentSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentType( + self, filamentType: ome.xml.model.enums.FilamentType, int: int, int2: int + ) -> None: ... + def setFileAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFileAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFileAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFileAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setFileAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFilterAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterFilterWheel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetDichroicRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetEmissionFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterSetExcitationFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterSetID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterType( + self, filterType: ome.xml.model.enums.FilterType, int: int, int2: int + ) -> None: ... + def setFolderAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFolderFolderRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderID(self, string: java.lang.String | str, int: int) -> None: ... + def setFolderImageRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderName(self, string: java.lang.String | str, int: int) -> None: ... + def setFolderROIRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setGenericExcitationSourceID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceMap( + self, list: java.util.List[ome.xml.model.MapPair], int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourcePower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageAcquisitionDate( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int + ) -> None: ... + def setImageAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setImageExperimentRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageID(self, string: java.lang.String | str, int: int) -> None: ... + def setImageInstrumentRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageMicrobeamManipulationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageName(self, string: java.lang.String | str, int: int) -> None: ... + def setImageROIRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImagingEnvironmentAirPressure( + self, pressure: ome.units.quantity.Pressure, int: int + ) -> None: ... + def setImagingEnvironmentCO2Percent( + self, percentFraction: ome.xml.model.primitives.PercentFraction, int: int + ) -> None: ... + def setImagingEnvironmentHumidity( + self, percentFraction: ome.xml.model.primitives.PercentFraction, int: int + ) -> None: ... + def setImagingEnvironmentMap( + self, list: java.util.List[ome.xml.model.MapPair], int: int + ) -> None: ... + def setImagingEnvironmentTemperature( + self, temperature: ome.units.quantity.Temperature, int: int + ) -> None: ... + def setInstrumentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setInstrumentID(self, string: java.lang.String | str, int: int) -> None: ... + def setLabelAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLabelFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLabelFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setLabelFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setLabelFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLabelFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setLabelID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setLabelStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLabelStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLabelText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setLabelX(self, double: float, int: int, int2: int) -> None: ... + def setLabelY(self, double: float, int: int, int2: int) -> None: ... + def setLaserAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLaserFrequencyMultiplication( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setLaserID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserLaserMedium( + self, laserMedium: ome.xml.model.enums.LaserMedium, int: int, int2: int + ) -> None: ... + def setLaserLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserPockelCell(self, boolean: bool, int: int, int2: int) -> None: ... + def setLaserPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setLaserPulse( + self, pulse: ome.xml.model.enums.Pulse, int: int, int2: int + ) -> None: ... + def setLaserPump( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserRepetitionRate( + self, frequency: ome.units.quantity.Frequency, int: int, int2: int + ) -> None: ... + def setLaserSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserTuneable(self, boolean: bool, int: int, int2: int) -> None: ... + def setLaserType( + self, laserType: ome.xml.model.enums.LaserType, int: int, int2: int + ) -> None: ... + def setLaserWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightEmittingDiodeID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodePower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightPathAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightPathDichroicRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightPathEmissionFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightPathExcitationFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLineAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLineFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLineFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setLineFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setLineFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLineFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setLineID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setLineMarkerEnd( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setLineMarkerStart( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setLineStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLineStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLineText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setLineX1(self, double: float, int: int, int2: int) -> None: ... + def setLineX2(self, double: float, int: int, int2: int) -> None: ... + def setLineY1(self, double: float, int: int, int2: int) -> None: ... + def setLineY2(self, double: float, int: int, int2: int) -> None: ... + def setListAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setListAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setListAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setListAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setListAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLongAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setLongAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationValue(self, long: int, int: int) -> None: ... + def setMapAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMapAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setMapAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationValue( + self, list: java.util.List[ome.xml.model.MapPair], int: int + ) -> None: ... + def setMaskAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMaskBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def setMaskBinDataBigEndian(self, boolean: bool, int: int, int2: int) -> None: ... + def setMaskBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int, int2: int + ) -> None: ... + def setMaskBinDataLength( + self, + nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, + int: int, + int2: int, + ) -> None: ... + def setMaskFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setMaskFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setMaskFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setMaskFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setMaskFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setMaskHeight(self, double: float, int: int, int2: int) -> None: ... + def setMaskID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setMaskStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setMaskStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setMaskText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setMaskWidth(self, double: float, int: int, int2: int) -> None: ... + def setMaskX(self, double: float, int: int, int2: int) -> None: ... + def setMaskY(self, double: float, int: int, int2: int) -> None: ... + def setMicrobeamManipulationDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationExperimenterRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsAttenuation( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsID( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationROIRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationType( + self, + microbeamManipulationType: ome.xml.model.enums.MicrobeamManipulationType, + int: int, + int2: int, + ) -> None: ... + def setMicroscopeLotNumber( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeManufacturer( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeModel(self, string: java.lang.String | str, int: int) -> None: ... + def setMicroscopeSerialNumber( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeType( + self, microscopeType: ome.xml.model.enums.MicroscopeType, int: int + ) -> None: ... + def setObjectiveAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setObjectiveCalibratedMagnification( + self, double: float, int: int, int2: int + ) -> None: ... + def setObjectiveCorrection( + self, correction: ome.xml.model.enums.Correction, int: int, int2: int + ) -> None: ... + def setObjectiveID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveImmersion( + self, immersion: ome.xml.model.enums.Immersion, int: int, int2: int + ) -> None: ... + def setObjectiveIris(self, boolean: bool, int: int, int2: int) -> None: ... + def setObjectiveLensNA(self, double: float, int: int, int2: int) -> None: ... + def setObjectiveLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveNominalMagnification( + self, double: float, int: int, int2: int + ) -> None: ... + def setObjectiveSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveSettingsCorrectionCollar(self, double: float, int: int) -> None: ... + def setObjectiveSettingsID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setObjectiveSettingsMedium( + self, medium: ome.xml.model.enums.Medium, int: int + ) -> None: ... + def setObjectiveSettingsRefractiveIndex(self, double: float, int: int) -> None: ... + def setObjectiveWorkingDistance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPixelsBigEndian(self, boolean: bool, int: int) -> None: ... + def setPixelsBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def setPixelsBinDataBigEndian(self, boolean: bool, int: int, int2: int) -> None: ... + def setPixelsBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int, int2: int + ) -> None: ... + def setPixelsBinDataLength( + self, + nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, + int: int, + int2: int, + ) -> None: ... + def setPixelsDimensionOrder( + self, dimensionOrder: ome.xml.model.enums.DimensionOrder, int: int + ) -> None: ... + def setPixelsID(self, string: java.lang.String | str, int: int) -> None: ... + def setPixelsInterleaved(self, boolean: bool, int: int) -> None: ... + def setPixelsPhysicalSizeX( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsPhysicalSizeY( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsPhysicalSizeZ( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsSignificantBits( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeC( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeT( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeX( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeY( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeZ( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsTimeIncrement( + self, time: ome.units.quantity.Time, int: int + ) -> None: ... + def setPixelsType( + self, pixelType: ome.xml.model.enums.PixelType, int: int + ) -> None: ... + def setPlaneAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlaneDeltaT( + self, time: ome.units.quantity.Time, int: int, int2: int + ) -> None: ... + def setPlaneExposureTime( + self, time: ome.units.quantity.Time, int: int, int2: int + ) -> None: ... + def setPlaneHashSHA1( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlanePositionX( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlanePositionY( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlanePositionZ( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlaneTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlaneTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlaneTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlateAcquisitionAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlateAcquisitionDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionEndTime( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionMaximumFieldCount( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setPlateAcquisitionName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionStartTime( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionWellSampleRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlateAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateColumnNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention, int: int + ) -> None: ... + def setPlateColumns( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPlateDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateExternalIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setPlateFieldIndex( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, int: int + ) -> None: ... + def setPlateID(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateName(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateRowNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention, int: int + ) -> None: ... + def setPlateRows( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPlateStatus(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateWellOriginX( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPlateWellOriginY( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPointAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPointFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPointFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPointFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPointFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPointFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPointID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPointStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPointStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPointText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setPointX(self, double: float, int: int, int2: int) -> None: ... + def setPointY(self, double: float, int: int, int2: int) -> None: ... + def setPolygonAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPolygonFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolygonFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPolygonFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPolygonFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolygonFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPolygonID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPolygonPoints( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolygonStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolygonText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setPolylineAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPolylineFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolylineFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPolylineFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPolylineFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolylineFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPolylineID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPolylineMarkerEnd( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setPolylineMarkerStart( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setPolylinePoints( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolylineStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolylineText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setProjectAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setProjectDatasetRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setProjectDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectID(self, string: java.lang.String | str, int: int) -> None: ... + def setProjectName(self, string: java.lang.String | str, int: int) -> None: ... + def setROIAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setROIDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setROIID(self, string: java.lang.String | str, int: int) -> None: ... + def setROIName(self, string: java.lang.String | str, int: int) -> None: ... + def setReagentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setReagentDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentReagentIdentifier( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setRectangleFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setRectangleFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setRectangleFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setRectangleFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setRectangleFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setRectangleHeight(self, double: float, int: int, int2: int) -> None: ... + def setRectangleID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setRectangleStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setRectangleStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setRectangleText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setRectangleWidth(self, double: float, int: int, int2: int) -> None: ... + def setRectangleX(self, double: float, int: int, int2: int) -> None: ... + def setRectangleY(self, double: float, int: int, int2: int) -> None: ... + def setRightsRightsHeld(self, string: java.lang.String | str) -> None: ... + def setRightsRightsHolder(self, string: java.lang.String | str) -> None: ... + def setRoot(self, metadataRoot: MetadataRoot) -> None: ... + def setScreenAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setScreenDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenID(self, string: java.lang.String | str, int: int) -> None: ... + def setScreenName(self, string: java.lang.String | str, int: int) -> None: ... + def setScreenPlateRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setScreenProtocolDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenProtocolIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenReagentSetDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenReagentSetIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenType(self, string: java.lang.String | str, int: int) -> None: ... + def setStageLabelName(self, string: java.lang.String | str, int: int) -> None: ... + def setStageLabelX(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setStageLabelY(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setStageLabelZ(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setTagAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTagAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setTagAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTermAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setTermAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTiffDataFirstC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataFirstT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataFirstZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataIFD( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataPlaneCount( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTimestampAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTimestampAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationValue( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int + ) -> None: ... + def setTransmittanceRangeCutIn( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutInTolerance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutOut( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutOutTolerance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeTransmittance( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + ) -> None: ... + def setUUID(self, string: java.lang.String | str) -> None: ... + def setUUIDFileName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setUUIDValue( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setWellColumn( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setWellExternalDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellExternalIdentifier( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellReagentRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellRow( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setWellSampleID( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleImageRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleIndex( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setWellSamplePositionX( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setWellSamplePositionY( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleTimepoint( + self, + timestamp: ome.xml.model.primitives.Timestamp, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setWellType( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setXMLAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setXMLAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setXMLAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + +class DummyMetadata(IMetadata): + def __init__(self): ... + def createRoot(self) -> None: ... + def getArcAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getArcID(self, int: int, int2: int) -> java.lang.String: ... + def getArcLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getArcManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getArcModel(self, int: int, int2: int) -> java.lang.String: ... + def getArcPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getArcSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getArcType(self, int: int, int2: int) -> ome.xml.model.enums.ArcType: ... + def getBinaryFileBinData(self, int: int) -> typing.MutableSequence[int]: ... + def getBinaryFileBinDataBigEndian(self, int: int) -> bool: ... + def getBinaryFileBinDataCompression( + self, int: int + ) -> ome.xml.model.enums.Compression: ... + def getBinaryFileBinDataLength( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getBinaryFileFileName(self, int: int) -> java.lang.String: ... + def getBinaryFileMIMEType(self, int: int) -> java.lang.String: ... + def getBinaryFileSize( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getBinaryOnlyMetadataFile(self) -> java.lang.String: ... + def getBinaryOnlyUUID(self) -> java.lang.String: ... + def getBooleanAnnotationAnnotationCount(self, int: int) -> int: ... + def getBooleanAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getBooleanAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationCount(self) -> int: ... + def getBooleanAnnotationDescription(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationID(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationValue(self, int: int) -> bool: ... + def getChannelAcquisitionMode( + self, int: int, int2: int + ) -> ome.xml.model.enums.AcquisitionMode: ... + def getChannelAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getChannelAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getChannelColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getChannelContrastMethod( + self, int: int, int2: int + ) -> ome.xml.model.enums.ContrastMethod: ... + def getChannelCount(self, int: int) -> int: ... + def getChannelEmissionWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelExcitationWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelFilterSetRef(self, int: int, int2: int) -> java.lang.String: ... + def getChannelFluor(self, int: int, int2: int) -> java.lang.String: ... + def getChannelID(self, int: int, int2: int) -> java.lang.String: ... + def getChannelIlluminationType( + self, int: int, int2: int + ) -> ome.xml.model.enums.IlluminationType: ... + def getChannelLightSourceSettingsAttenuation( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getChannelLightSourceSettingsID( + self, int: int, int2: int + ) -> java.lang.String: ... + def getChannelLightSourceSettingsWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelNDFilter(self, int: int, int2: int) -> float: ... + def getChannelName(self, int: int, int2: int) -> java.lang.String: ... + def getChannelPinholeSize( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelPockelCellSetting(self, int: int, int2: int) -> int: ... + def getChannelSamplesPerPixel( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getCommentAnnotationAnnotationCount(self, int: int) -> int: ... + def getCommentAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getCommentAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getCommentAnnotationCount(self) -> int: ... + def getCommentAnnotationDescription(self, int: int) -> java.lang.String: ... + def getCommentAnnotationID(self, int: int) -> java.lang.String: ... + def getCommentAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getCommentAnnotationValue(self, int: int) -> java.lang.String: ... + def getDatasetAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getDatasetAnnotationRefCount(self, int: int) -> int: ... + def getDatasetCount(self) -> int: ... + def getDatasetDescription(self, int: int) -> java.lang.String: ... + def getDatasetExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getDatasetExperimenterRef(self, int: int) -> java.lang.String: ... + def getDatasetID(self, int: int) -> java.lang.String: ... + def getDatasetImageRef(self, int: int, int2: int) -> java.lang.String: ... + def getDatasetImageRefCount(self, int: int) -> int: ... + def getDatasetName(self, int: int) -> java.lang.String: ... + def getDatasetRefCount(self, int: int) -> int: ... + def getDetectorAmplificationGain(self, int: int, int2: int) -> float: ... + def getDetectorAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getDetectorAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getDetectorCount(self, int: int) -> int: ... + def getDetectorGain(self, int: int, int2: int) -> float: ... + def getDetectorID(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorModel(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorOffset(self, int: int, int2: int) -> float: ... + def getDetectorSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorSettingsBinning( + self, int: int, int2: int + ) -> ome.xml.model.enums.Binning: ... + def getDetectorSettingsGain(self, int: int, int2: int) -> float: ... + def getDetectorSettingsID(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorSettingsIntegration( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getDetectorSettingsOffset(self, int: int, int2: int) -> float: ... + def getDetectorSettingsReadOutRate( + self, int: int, int2: int + ) -> ome.units.quantity.Frequency: ... + def getDetectorSettingsVoltage( + self, int: int, int2: int + ) -> ome.units.quantity.ElectricPotential: ... + def getDetectorSettingsZoom(self, int: int, int2: int) -> float: ... + def getDetectorType( + self, int: int, int2: int + ) -> ome.xml.model.enums.DetectorType: ... + def getDetectorVoltage( + self, int: int, int2: int + ) -> ome.units.quantity.ElectricPotential: ... + def getDetectorZoom(self, int: int, int2: int) -> float: ... + def getDichroicAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getDichroicAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getDichroicCount(self, int: int) -> int: ... + def getDichroicID(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicModel(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDoubleAnnotationAnnotationCount(self, int: int) -> int: ... + def getDoubleAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getDoubleAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationCount(self) -> int: ... + def getDoubleAnnotationDescription(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationID(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationValue(self, int: int) -> float: ... + def getEllipseAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getEllipseFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getEllipseFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getEllipseFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getEllipseFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getEllipseFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getEllipseID(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseLocked(self, int: int, int2: int) -> bool: ... + def getEllipseRadiusX(self, int: int, int2: int) -> float: ... + def getEllipseRadiusY(self, int: int, int2: int) -> float: ... + def getEllipseStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getEllipseStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getEllipseText(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getEllipseX(self, int: int, int2: int) -> float: ... + def getEllipseY(self, int: int, int2: int) -> float: ... + def getExperimentCount(self) -> int: ... + def getExperimentDescription(self, int: int) -> java.lang.String: ... + def getExperimentExperimenterRef(self, int: int) -> java.lang.String: ... + def getExperimentID(self, int: int) -> java.lang.String: ... + def getExperimentType(self, int: int) -> ome.xml.model.enums.ExperimentType: ... + def getExperimenterAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getExperimenterAnnotationRefCount(self, int: int) -> int: ... + def getExperimenterCount(self) -> int: ... + def getExperimenterEmail(self, int: int) -> java.lang.String: ... + def getExperimenterFirstName(self, int: int) -> java.lang.String: ... + def getExperimenterGroupAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getExperimenterGroupAnnotationRefCount(self, int: int) -> int: ... + def getExperimenterGroupCount(self) -> int: ... + def getExperimenterGroupDescription(self, int: int) -> java.lang.String: ... + def getExperimenterGroupExperimenterRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getExperimenterGroupExperimenterRefCount(self, int: int) -> int: ... + def getExperimenterGroupID(self, int: int) -> java.lang.String: ... + def getExperimenterGroupLeader(self, int: int, int2: int) -> java.lang.String: ... + def getExperimenterGroupName(self, int: int) -> java.lang.String: ... + def getExperimenterID(self, int: int) -> java.lang.String: ... + def getExperimenterInstitution(self, int: int) -> java.lang.String: ... + def getExperimenterLastName(self, int: int) -> java.lang.String: ... + def getExperimenterMiddleName(self, int: int) -> java.lang.String: ... + def getExperimenterUserName(self, int: int) -> java.lang.String: ... + def getFilamentAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilamentID(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getFilamentSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentType( + self, int: int, int2: int + ) -> ome.xml.model.enums.FilamentType: ... + def getFileAnnotationAnnotationCount(self, int: int) -> int: ... + def getFileAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getFileAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getFileAnnotationCount(self) -> int: ... + def getFileAnnotationDescription(self, int: int) -> java.lang.String: ... + def getFileAnnotationID(self, int: int) -> java.lang.String: ... + def getFileAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getFilterAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getFilterCount(self, int: int) -> int: ... + def getFilterFilterWheel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterID(self, int: int, int2: int) -> java.lang.String: ... + def getFilterLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilterModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetCount(self, int: int) -> int: ... + def getFilterSetDichroicRef(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetEmissionFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterSetEmissionFilterRefCount(self, int: int, int2: int) -> int: ... + def getFilterSetExcitationFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterSetExcitationFilterRefCount(self, int: int, int2: int) -> int: ... + def getFilterSetID(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterType(self, int: int, int2: int) -> ome.xml.model.enums.FilterType: ... + def getFolderAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderAnnotationRefCount(self, int: int) -> int: ... + def getFolderCount(self) -> int: ... + def getFolderDescription(self, int: int) -> java.lang.String: ... + def getFolderFolderRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderID(self, int: int) -> java.lang.String: ... + def getFolderImageRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderImageRefCount(self, int: int) -> int: ... + def getFolderName(self, int: int) -> java.lang.String: ... + def getFolderROIRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderROIRefCount(self, int: int) -> int: ... + def getFolderRefCount(self, int: int) -> int: ... + def getGenericExcitationSourceAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getGenericExcitationSourceID(self, int: int, int2: int) -> java.lang.String: ... + def getGenericExcitationSourceLotNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourceManufacturer( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourceMap( + self, int: int, int2: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getGenericExcitationSourceModel( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourcePower( + self, int: int, int2: int + ) -> ome.units.quantity.Power: ... + def getGenericExcitationSourceSerialNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getImageAcquisitionDate( + self, int: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getImageAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getImageAnnotationRefCount(self, int: int) -> int: ... + def getImageCount(self) -> int: ... + def getImageDescription(self, int: int) -> java.lang.String: ... + def getImageExperimentRef(self, int: int) -> java.lang.String: ... + def getImageExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getImageExperimenterRef(self, int: int) -> java.lang.String: ... + def getImageID(self, int: int) -> java.lang.String: ... + def getImageInstrumentRef(self, int: int) -> java.lang.String: ... + def getImageMicrobeamManipulationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getImageName(self, int: int) -> java.lang.String: ... + def getImageROIRef(self, int: int, int2: int) -> java.lang.String: ... + def getImageROIRefCount(self, int: int) -> int: ... + def getImagingEnvironmentAirPressure( + self, int: int + ) -> ome.units.quantity.Pressure: ... + def getImagingEnvironmentCO2Percent( + self, int: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getImagingEnvironmentHumidity( + self, int: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getImagingEnvironmentMap( + self, int: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getImagingEnvironmentTemperature( + self, int: int + ) -> ome.units.quantity.Temperature: ... + def getInstrumentAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getInstrumentAnnotationRefCount(self, int: int) -> int: ... + def getInstrumentCount(self) -> int: ... + def getInstrumentID(self, int: int) -> java.lang.String: ... + def getLabelAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLabelFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLabelFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getLabelFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getLabelFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLabelFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getLabelID(self, int: int, int2: int) -> java.lang.String: ... + def getLabelLocked(self, int: int, int2: int) -> bool: ... + def getLabelStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLabelStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getLabelStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLabelText(self, int: int, int2: int) -> java.lang.String: ... + def getLabelTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getLabelX(self, int: int, int2: int) -> float: ... + def getLabelY(self, int: int, int2: int) -> float: ... + def getLaserAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLaserFrequencyMultiplication( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getLaserID(self, int: int, int2: int) -> java.lang.String: ... + def getLaserLaserMedium( + self, int: int, int2: int + ) -> ome.xml.model.enums.LaserMedium: ... + def getLaserLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getLaserManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getLaserModel(self, int: int, int2: int) -> java.lang.String: ... + def getLaserPockelCell(self, int: int, int2: int) -> bool: ... + def getLaserPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getLaserPulse(self, int: int, int2: int) -> ome.xml.model.enums.Pulse: ... + def getLaserPump(self, int: int, int2: int) -> java.lang.String: ... + def getLaserRepetitionRate( + self, int: int, int2: int + ) -> ome.units.quantity.Frequency: ... + def getLaserSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getLaserTuneable(self, int: int, int2: int) -> bool: ... + def getLaserType(self, int: int, int2: int) -> ome.xml.model.enums.LaserType: ... + def getLaserWavelength(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLeaderCount(self, int: int) -> int: ... + def getLightEmittingDiodeAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightEmittingDiodeID(self, int: int, int2: int) -> java.lang.String: ... + def getLightEmittingDiodeLotNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightEmittingDiodeManufacturer( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightEmittingDiodeModel(self, int: int, int2: int) -> java.lang.String: ... + def getLightEmittingDiodePower( + self, int: int, int2: int + ) -> ome.units.quantity.Power: ... + def getLightEmittingDiodeSerialNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightPathAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getLightPathDichroicRef(self, int: int, int2: int) -> java.lang.String: ... + def getLightPathEmissionFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathEmissionFilterRefCount(self, int: int, int2: int) -> int: ... + def getLightPathExcitationFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathExcitationFilterRefCount(self, int: int, int2: int) -> int: ... + def getLightSourceAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getLightSourceCount(self, int: int) -> int: ... + def getLightSourceType(self, int: int, int2: int) -> java.lang.String: ... + def getLineAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLineFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLineFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getLineFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getLineFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLineFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getLineID(self, int: int, int2: int) -> java.lang.String: ... + def getLineLocked(self, int: int, int2: int) -> bool: ... + def getLineMarkerEnd(self, int: int, int2: int) -> ome.xml.model.enums.Marker: ... + def getLineMarkerStart(self, int: int, int2: int) -> ome.xml.model.enums.Marker: ... + def getLineStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLineStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getLineStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLineText(self, int: int, int2: int) -> java.lang.String: ... + def getLineTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getLineX1(self, int: int, int2: int) -> float: ... + def getLineX2(self, int: int, int2: int) -> float: ... + def getLineY1(self, int: int, int2: int) -> float: ... + def getLineY2(self, int: int, int2: int) -> float: ... + def getListAnnotationAnnotationCount(self, int: int) -> int: ... + def getListAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getListAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getListAnnotationCount(self) -> int: ... + def getListAnnotationDescription(self, int: int) -> java.lang.String: ... + def getListAnnotationID(self, int: int) -> java.lang.String: ... + def getListAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getLongAnnotationAnnotationCount(self, int: int) -> int: ... + def getLongAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLongAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getLongAnnotationCount(self) -> int: ... + def getLongAnnotationDescription(self, int: int) -> java.lang.String: ... + def getLongAnnotationID(self, int: int) -> java.lang.String: ... + def getLongAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getLongAnnotationValue(self, int: int) -> int: ... + def getMapAnnotationAnnotationCount(self, int: int) -> int: ... + def getMapAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMapAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getMapAnnotationCount(self) -> int: ... + def getMapAnnotationDescription(self, int: int) -> java.lang.String: ... + def getMapAnnotationID(self, int: int) -> java.lang.String: ... + def getMapAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getMapAnnotationValue( + self, int: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getMaskAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMaskBinData(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getMaskBinDataBigEndian(self, int: int, int2: int) -> bool: ... + def getMaskBinDataCompression( + self, int: int, int2: int + ) -> ome.xml.model.enums.Compression: ... + def getMaskBinDataLength( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getMaskFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getMaskFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getMaskFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getMaskFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getMaskFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getMaskHeight(self, int: int, int2: int) -> float: ... + def getMaskID(self, int: int, int2: int) -> java.lang.String: ... + def getMaskLocked(self, int: int, int2: int) -> bool: ... + def getMaskStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getMaskStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getMaskStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getMaskText(self, int: int, int2: int) -> java.lang.String: ... + def getMaskTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getMaskWidth(self, int: int, int2: int) -> float: ... + def getMaskX(self, int: int, int2: int) -> float: ... + def getMaskY(self, int: int, int2: int) -> float: ... + def getMicrobeamManipulationCount(self, int: int) -> int: ... + def getMicrobeamManipulationDescription( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMicrobeamManipulationExperimenterRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMicrobeamManipulationID(self, int: int, int2: int) -> java.lang.String: ... + def getMicrobeamManipulationLightSourceSettingsAttenuation( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getMicrobeamManipulationLightSourceSettingsCount( + self, int: int, int2: int + ) -> int: ... + def getMicrobeamManipulationLightSourceSettingsID( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMicrobeamManipulationLightSourceSettingsWavelength( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getMicrobeamManipulationROIRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMicrobeamManipulationROIRefCount(self, int: int, int2: int) -> int: ... + def getMicrobeamManipulationRefCount(self, int: int) -> int: ... + def getMicrobeamManipulationType( + self, int: int, int2: int + ) -> ome.xml.model.enums.MicrobeamManipulationType: ... + def getMicroscopeLotNumber(self, int: int) -> java.lang.String: ... + def getMicroscopeManufacturer(self, int: int) -> java.lang.String: ... + def getMicroscopeModel(self, int: int) -> java.lang.String: ... + def getMicroscopeSerialNumber(self, int: int) -> java.lang.String: ... + def getMicroscopeType(self, int: int) -> ome.xml.model.enums.MicroscopeType: ... + def getObjectiveAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getObjectiveAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getObjectiveCalibratedMagnification(self, int: int, int2: int) -> float: ... + def getObjectiveCorrection( + self, int: int, int2: int + ) -> ome.xml.model.enums.Correction: ... + def getObjectiveCount(self, int: int) -> int: ... + def getObjectiveID(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveImmersion( + self, int: int, int2: int + ) -> ome.xml.model.enums.Immersion: ... + def getObjectiveIris(self, int: int, int2: int) -> bool: ... + def getObjectiveLensNA(self, int: int, int2: int) -> float: ... + def getObjectiveLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveModel(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveNominalMagnification(self, int: int, int2: int) -> float: ... + def getObjectiveSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveSettingsCorrectionCollar(self, int: int) -> float: ... + def getObjectiveSettingsID(self, int: int) -> java.lang.String: ... + def getObjectiveSettingsMedium(self, int: int) -> ome.xml.model.enums.Medium: ... + def getObjectiveSettingsRefractiveIndex(self, int: int) -> float: ... + def getObjectiveWorkingDistance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPixelsBigEndian(self, int: int) -> bool: ... + def getPixelsBinData(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getPixelsBinDataBigEndian(self, int: int, int2: int) -> bool: ... + def getPixelsBinDataCompression( + self, int: int, int2: int + ) -> ome.xml.model.enums.Compression: ... + def getPixelsBinDataCount(self, int: int) -> int: ... + def getPixelsBinDataLength( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getPixelsDimensionOrder( + self, int: int + ) -> ome.xml.model.enums.DimensionOrder: ... + def getPixelsID(self, int: int) -> java.lang.String: ... + def getPixelsInterleaved(self, int: int) -> bool: ... + def getPixelsPhysicalSizeX(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsPhysicalSizeY(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsPhysicalSizeZ(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsSignificantBits( + self, int: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeC(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeT(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeX(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeY(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeZ(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsTimeIncrement(self, int: int) -> ome.units.quantity.Time: ... + def getPixelsType(self, int: int) -> ome.xml.model.enums.PixelType: ... + def getPlaneAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlaneAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getPlaneCount(self, int: int) -> int: ... + def getPlaneDeltaT(self, int: int, int2: int) -> ome.units.quantity.Time: ... + def getPlaneExposureTime(self, int: int, int2: int) -> ome.units.quantity.Time: ... + def getPlaneHashSHA1(self, int: int, int2: int) -> java.lang.String: ... + def getPlanePositionX(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlanePositionY(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlanePositionZ(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlaneTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlaneTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlaneTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlateAcquisitionAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlateAcquisitionAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getPlateAcquisitionCount(self, int: int) -> int: ... + def getPlateAcquisitionDescription( + self, int: int, int2: int + ) -> java.lang.String: ... + def getPlateAcquisitionEndTime( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getPlateAcquisitionID(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAcquisitionMaximumFieldCount( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateAcquisitionName(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAcquisitionStartTime( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getPlateAcquisitionWellSampleRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlateAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAnnotationRefCount(self, int: int) -> int: ... + def getPlateColumnNamingConvention( + self, int: int + ) -> ome.xml.model.enums.NamingConvention: ... + def getPlateColumns(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateCount(self) -> int: ... + def getPlateDescription(self, int: int) -> java.lang.String: ... + def getPlateExternalIdentifier(self, int: int) -> java.lang.String: ... + def getPlateFieldIndex( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlateID(self, int: int) -> java.lang.String: ... + def getPlateName(self, int: int) -> java.lang.String: ... + def getPlateRefCount(self, int: int) -> int: ... + def getPlateRowNamingConvention( + self, int: int + ) -> ome.xml.model.enums.NamingConvention: ... + def getPlateRows(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateStatus(self, int: int) -> java.lang.String: ... + def getPlateWellOriginX(self, int: int) -> ome.units.quantity.Length: ... + def getPlateWellOriginY(self, int: int) -> ome.units.quantity.Length: ... + def getPointAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPointFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPointFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getPointFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPointFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPointFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPointID(self, int: int, int2: int) -> java.lang.String: ... + def getPointLocked(self, int: int, int2: int) -> bool: ... + def getPointStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPointStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPointStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPointText(self, int: int, int2: int) -> java.lang.String: ... + def getPointTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getPointX(self, int: int, int2: int) -> float: ... + def getPointY(self, int: int, int2: int) -> float: ... + def getPolygonAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPolygonFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolygonFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getPolygonFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPolygonFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPolygonFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPolygonID(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonLocked(self, int: int, int2: int) -> bool: ... + def getPolygonPoints(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolygonStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPolygonText(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getPolylineAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPolylineFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolylineFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getPolylineFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPolylineFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPolylineFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPolylineID(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineLocked(self, int: int, int2: int) -> bool: ... + def getPolylineMarkerEnd( + self, int: int, int2: int + ) -> ome.xml.model.enums.Marker: ... + def getPolylineMarkerStart( + self, int: int, int2: int + ) -> ome.xml.model.enums.Marker: ... + def getPolylinePoints(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolylineStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPolylineText(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getProjectAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getProjectAnnotationRefCount(self, int: int) -> int: ... + def getProjectCount(self) -> int: ... + def getProjectDatasetRef(self, int: int, int2: int) -> java.lang.String: ... + def getProjectDescription(self, int: int) -> java.lang.String: ... + def getProjectExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getProjectExperimenterRef(self, int: int) -> java.lang.String: ... + def getProjectID(self, int: int) -> java.lang.String: ... + def getProjectName(self, int: int) -> java.lang.String: ... + def getROIAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getROIAnnotationRefCount(self, int: int) -> int: ... + def getROICount(self) -> int: ... + def getROIDescription(self, int: int) -> java.lang.String: ... + def getROIID(self, int: int) -> java.lang.String: ... + def getROIName(self, int: int) -> java.lang.String: ... + def getReagentAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getReagentAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getReagentCount(self, int: int) -> int: ... + def getReagentDescription(self, int: int, int2: int) -> java.lang.String: ... + def getReagentID(self, int: int, int2: int) -> java.lang.String: ... + def getReagentName(self, int: int, int2: int) -> java.lang.String: ... + def getReagentReagentIdentifier(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getRectangleFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getRectangleFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getRectangleFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getRectangleFontSize( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getRectangleFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getRectangleHeight(self, int: int, int2: int) -> float: ... + def getRectangleID(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleLocked(self, int: int, int2: int) -> bool: ... + def getRectangleStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getRectangleStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getRectangleText(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getRectangleWidth(self, int: int, int2: int) -> float: ... + def getRectangleX(self, int: int, int2: int) -> float: ... + def getRectangleY(self, int: int, int2: int) -> float: ... + def getRightsRightsHeld(self) -> java.lang.String: ... + def getRightsRightsHolder(self) -> java.lang.String: ... + def getRoot(self) -> MetadataRoot: ... + def getScreenAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getScreenAnnotationRefCount(self, int: int) -> int: ... + def getScreenCount(self) -> int: ... + def getScreenDescription(self, int: int) -> java.lang.String: ... + def getScreenID(self, int: int) -> java.lang.String: ... + def getScreenName(self, int: int) -> java.lang.String: ... + def getScreenPlateRef(self, int: int, int2: int) -> java.lang.String: ... + def getScreenProtocolDescription(self, int: int) -> java.lang.String: ... + def getScreenProtocolIdentifier(self, int: int) -> java.lang.String: ... + def getScreenReagentSetDescription(self, int: int) -> java.lang.String: ... + def getScreenReagentSetIdentifier(self, int: int) -> java.lang.String: ... + def getScreenType(self, int: int) -> java.lang.String: ... + def getShapeAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getShapeCount(self, int: int) -> int: ... + def getShapeType(self, int: int, int2: int) -> java.lang.String: ... + def getStageLabelName(self, int: int) -> java.lang.String: ... + def getStageLabelX(self, int: int) -> ome.units.quantity.Length: ... + def getStageLabelY(self, int: int) -> ome.units.quantity.Length: ... + def getStageLabelZ(self, int: int) -> ome.units.quantity.Length: ... + def getTagAnnotationAnnotationCount(self, int: int) -> int: ... + def getTagAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTagAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTagAnnotationCount(self) -> int: ... + def getTagAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTagAnnotationID(self, int: int) -> java.lang.String: ... + def getTagAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTagAnnotationValue(self, int: int) -> java.lang.String: ... + def getTermAnnotationAnnotationCount(self, int: int) -> int: ... + def getTermAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTermAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTermAnnotationCount(self) -> int: ... + def getTermAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTermAnnotationID(self, int: int) -> java.lang.String: ... + def getTermAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTermAnnotationValue(self, int: int) -> java.lang.String: ... + def getTiffDataCount(self, int: int) -> int: ... + def getTiffDataFirstC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataFirstT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataFirstZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataIFD( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataPlaneCount( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTimestampAnnotationAnnotationCount(self, int: int) -> int: ... + def getTimestampAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTimestampAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationCount(self) -> int: ... + def getTimestampAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationID(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationValue( + self, int: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getTransmittanceRangeCutIn( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutInTolerance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutOut( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutOutTolerance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeTransmittance( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getUUID(self) -> java.lang.String: ... + def getUUIDFileName(self, int: int, int2: int) -> java.lang.String: ... + def getUUIDValue(self, int: int, int2: int) -> java.lang.String: ... + def getWellAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getWellAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getWellColor(self, int: int, int2: int) -> ome.xml.model.primitives.Color: ... + def getWellColumn( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellCount(self, int: int) -> int: ... + def getWellExternalDescription(self, int: int, int2: int) -> java.lang.String: ... + def getWellExternalIdentifier(self, int: int, int2: int) -> java.lang.String: ... + def getWellID(self, int: int, int2: int) -> java.lang.String: ... + def getWellReagentRef(self, int: int, int2: int) -> java.lang.String: ... + def getWellRow( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellSampleCount(self, int: int, int2: int) -> int: ... + def getWellSampleID(self, int: int, int2: int, int3: int) -> java.lang.String: ... + def getWellSampleImageRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getWellSampleIndex( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellSamplePositionX( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getWellSamplePositionY( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getWellSampleRefCount(self, int: int, int2: int) -> int: ... + def getWellSampleTimepoint( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getWellType(self, int: int, int2: int) -> java.lang.String: ... + def getXMLAnnotationAnnotationCount(self, int: int) -> int: ... + def getXMLAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getXMLAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getXMLAnnotationCount(self) -> int: ... + def getXMLAnnotationDescription(self, int: int) -> java.lang.String: ... + def getXMLAnnotationID(self, int: int) -> java.lang.String: ... + def getXMLAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getXMLAnnotationValue(self, int: int) -> java.lang.String: ... + def setArcAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setArcID(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + def setArcLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setArcSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcType( + self, arcType: ome.xml.model.enums.ArcType, int: int, int2: int + ) -> None: ... + def setBinaryFileBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + def setBinaryFileBinDataBigEndian(self, boolean: bool, int: int) -> None: ... + def setBinaryFileBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int + ) -> None: ... + def setBinaryFileBinDataLength( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, int: int + ) -> None: ... + def setBinaryFileFileName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBinaryFileMIMEType( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBinaryFileSize( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, int: int + ) -> None: ... + def setBinaryOnlyMetadataFile(self, string: java.lang.String | str) -> None: ... + def setBinaryOnlyUUID(self, string: java.lang.String | str) -> None: ... + def setBooleanAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setBooleanAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationValue(self, boolean: bool, int: int) -> None: ... + def setChannelAcquisitionMode( + self, acquisitionMode: ome.xml.model.enums.AcquisitionMode, int: int, int2: int + ) -> None: ... + def setChannelAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setChannelColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setChannelContrastMethod( + self, contrastMethod: ome.xml.model.enums.ContrastMethod, int: int, int2: int + ) -> None: ... + def setChannelEmissionWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelExcitationWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelFilterSetRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelFluor( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelIlluminationType( + self, + illuminationType: ome.xml.model.enums.IlluminationType, + int: int, + int2: int, + ) -> None: ... + def setChannelLightSourceSettingsAttenuation( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + ) -> None: ... + def setChannelLightSourceSettingsID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelLightSourceSettingsWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelNDFilter(self, double: float, int: int, int2: int) -> None: ... + def setChannelName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelPinholeSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelPockelCellSetting( + self, integer: int, int2: int, int3: int + ) -> None: ... + def setChannelSamplesPerPixel( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setCommentAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setCommentAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDatasetDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetID(self, string: java.lang.String | str, int: int) -> None: ... + def setDatasetImageRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDatasetName(self, string: java.lang.String | str, int: int) -> None: ... + def setDetectorAmplificationGain( + self, double: float, int: int, int2: int + ) -> None: ... + def setDetectorAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setDetectorGain(self, double: float, int: int, int2: int) -> None: ... + def setDetectorID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorOffset(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorSettingsBinning( + self, binning: ome.xml.model.enums.Binning, int: int, int2: int + ) -> None: ... + def setDetectorSettingsGain(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSettingsID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorSettingsIntegration( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setDetectorSettingsOffset(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSettingsReadOutRate( + self, frequency: ome.units.quantity.Frequency, int: int, int2: int + ) -> None: ... + def setDetectorSettingsVoltage( + self, + electricPotential: ome.units.quantity.ElectricPotential, + int: int, + int2: int, + ) -> None: ... + def setDetectorSettingsZoom(self, double: float, int: int, int2: int) -> None: ... + def setDetectorType( + self, detectorType: ome.xml.model.enums.DetectorType, int: int, int2: int + ) -> None: ... + def setDetectorVoltage( + self, + electricPotential: ome.units.quantity.ElectricPotential, + int: int, + int2: int, + ) -> None: ... + def setDetectorZoom(self, double: float, int: int, int2: int) -> None: ... + def setDichroicAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setDichroicID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDoubleAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDoubleAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationValue(self, double: float, int: int) -> None: ... + def setEllipseAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setEllipseFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setEllipseFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setEllipseFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setEllipseFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setEllipseFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setEllipseID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setEllipseRadiusX(self, double: float, int: int, int2: int) -> None: ... + def setEllipseRadiusY(self, double: float, int: int, int2: int) -> None: ... + def setEllipseStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setEllipseStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setEllipseText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setEllipseX(self, double: float, int: int, int2: int) -> None: ... + def setEllipseY(self, double: float, int: int, int2: int) -> None: ... + def setExperimentDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimentExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimentID(self, string: java.lang.String | str, int: int) -> None: ... + def setExperimentType( + self, experimentType: ome.xml.model.enums.ExperimentType, int: int + ) -> None: ... + def setExperimenterAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterEmail( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterFirstName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupExperimenterRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupLeader( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterID(self, string: java.lang.String | str, int: int) -> None: ... + def setExperimenterInstitution( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterLastName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterMiddleName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterUserName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFilamentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilamentID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setFilamentSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentType( + self, filamentType: ome.xml.model.enums.FilamentType, int: int, int2: int + ) -> None: ... + def setFileAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFileAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFileAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFileAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setFileAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFilterAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterFilterWheel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetDichroicRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetEmissionFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterSetExcitationFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterSetID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterType( + self, filterType: ome.xml.model.enums.FilterType, int: int, int2: int + ) -> None: ... + def setFolderAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFolderFolderRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderID(self, string: java.lang.String | str, int: int) -> None: ... + def setFolderImageRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderName(self, string: java.lang.String | str, int: int) -> None: ... + def setFolderROIRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setGenericExcitationSourceID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceMap( + self, list: java.util.List[ome.xml.model.MapPair], int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourcePower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageAcquisitionDate( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int + ) -> None: ... + def setImageAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setImageExperimentRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageID(self, string: java.lang.String | str, int: int) -> None: ... + def setImageInstrumentRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageMicrobeamManipulationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageName(self, string: java.lang.String | str, int: int) -> None: ... + def setImageROIRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImagingEnvironmentAirPressure( + self, pressure: ome.units.quantity.Pressure, int: int + ) -> None: ... + def setImagingEnvironmentCO2Percent( + self, percentFraction: ome.xml.model.primitives.PercentFraction, int: int + ) -> None: ... + def setImagingEnvironmentHumidity( + self, percentFraction: ome.xml.model.primitives.PercentFraction, int: int + ) -> None: ... + def setImagingEnvironmentMap( + self, list: java.util.List[ome.xml.model.MapPair], int: int + ) -> None: ... + def setImagingEnvironmentTemperature( + self, temperature: ome.units.quantity.Temperature, int: int + ) -> None: ... + def setInstrumentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setInstrumentID(self, string: java.lang.String | str, int: int) -> None: ... + def setLabelAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLabelFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLabelFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setLabelFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setLabelFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLabelFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setLabelID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setLabelStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLabelStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLabelText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setLabelX(self, double: float, int: int, int2: int) -> None: ... + def setLabelY(self, double: float, int: int, int2: int) -> None: ... + def setLaserAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLaserFrequencyMultiplication( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setLaserID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserLaserMedium( + self, laserMedium: ome.xml.model.enums.LaserMedium, int: int, int2: int + ) -> None: ... + def setLaserLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserPockelCell(self, boolean: bool, int: int, int2: int) -> None: ... + def setLaserPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setLaserPulse( + self, pulse: ome.xml.model.enums.Pulse, int: int, int2: int + ) -> None: ... + def setLaserPump( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserRepetitionRate( + self, frequency: ome.units.quantity.Frequency, int: int, int2: int + ) -> None: ... + def setLaserSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserTuneable(self, boolean: bool, int: int, int2: int) -> None: ... + def setLaserType( + self, laserType: ome.xml.model.enums.LaserType, int: int, int2: int + ) -> None: ... + def setLaserWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightEmittingDiodeID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodePower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightPathAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightPathDichroicRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightPathEmissionFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightPathExcitationFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLineAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLineFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLineFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setLineFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setLineFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLineFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setLineID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setLineMarkerEnd( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setLineMarkerStart( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setLineStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLineStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLineText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setLineX1(self, double: float, int: int, int2: int) -> None: ... + def setLineX2(self, double: float, int: int, int2: int) -> None: ... + def setLineY1(self, double: float, int: int, int2: int) -> None: ... + def setLineY2(self, double: float, int: int, int2: int) -> None: ... + def setListAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setListAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setListAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setListAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setListAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLongAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setLongAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationValue(self, long: int, int: int) -> None: ... + def setMapAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMapAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setMapAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationValue( + self, list: java.util.List[ome.xml.model.MapPair], int: int + ) -> None: ... + def setMaskAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMaskBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def setMaskBinDataBigEndian(self, boolean: bool, int: int, int2: int) -> None: ... + def setMaskBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int, int2: int + ) -> None: ... + def setMaskBinDataLength( + self, + nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, + int: int, + int2: int, + ) -> None: ... + def setMaskFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setMaskFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setMaskFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setMaskFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setMaskFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setMaskHeight(self, double: float, int: int, int2: int) -> None: ... + def setMaskID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setMaskStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setMaskStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setMaskText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setMaskWidth(self, double: float, int: int, int2: int) -> None: ... + def setMaskX(self, double: float, int: int, int2: int) -> None: ... + def setMaskY(self, double: float, int: int, int2: int) -> None: ... + def setMicrobeamManipulationDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationExperimenterRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsAttenuation( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsID( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationROIRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationType( + self, + microbeamManipulationType: ome.xml.model.enums.MicrobeamManipulationType, + int: int, + int2: int, + ) -> None: ... + def setMicroscopeLotNumber( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeManufacturer( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeModel(self, string: java.lang.String | str, int: int) -> None: ... + def setMicroscopeSerialNumber( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeType( + self, microscopeType: ome.xml.model.enums.MicroscopeType, int: int + ) -> None: ... + def setObjectiveAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setObjectiveCalibratedMagnification( + self, double: float, int: int, int2: int + ) -> None: ... + def setObjectiveCorrection( + self, correction: ome.xml.model.enums.Correction, int: int, int2: int + ) -> None: ... + def setObjectiveID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveImmersion( + self, immersion: ome.xml.model.enums.Immersion, int: int, int2: int + ) -> None: ... + def setObjectiveIris(self, boolean: bool, int: int, int2: int) -> None: ... + def setObjectiveLensNA(self, double: float, int: int, int2: int) -> None: ... + def setObjectiveLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveNominalMagnification( + self, double: float, int: int, int2: int + ) -> None: ... + def setObjectiveSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveSettingsCorrectionCollar(self, double: float, int: int) -> None: ... + def setObjectiveSettingsID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setObjectiveSettingsMedium( + self, medium: ome.xml.model.enums.Medium, int: int + ) -> None: ... + def setObjectiveSettingsRefractiveIndex(self, double: float, int: int) -> None: ... + def setObjectiveWorkingDistance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPixelsBigEndian(self, boolean: bool, int: int) -> None: ... + def setPixelsBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def setPixelsBinDataBigEndian(self, boolean: bool, int: int, int2: int) -> None: ... + def setPixelsBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int, int2: int + ) -> None: ... + def setPixelsBinDataLength( + self, + nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, + int: int, + int2: int, + ) -> None: ... + def setPixelsDimensionOrder( + self, dimensionOrder: ome.xml.model.enums.DimensionOrder, int: int + ) -> None: ... + def setPixelsID(self, string: java.lang.String | str, int: int) -> None: ... + def setPixelsInterleaved(self, boolean: bool, int: int) -> None: ... + def setPixelsPhysicalSizeX( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsPhysicalSizeY( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsPhysicalSizeZ( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsSignificantBits( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeC( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeT( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeX( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeY( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeZ( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsTimeIncrement( + self, time: ome.units.quantity.Time, int: int + ) -> None: ... + def setPixelsType( + self, pixelType: ome.xml.model.enums.PixelType, int: int + ) -> None: ... + def setPlaneAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlaneDeltaT( + self, time: ome.units.quantity.Time, int: int, int2: int + ) -> None: ... + def setPlaneExposureTime( + self, time: ome.units.quantity.Time, int: int, int2: int + ) -> None: ... + def setPlaneHashSHA1( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlanePositionX( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlanePositionY( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlanePositionZ( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlaneTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlaneTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlaneTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlateAcquisitionAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlateAcquisitionDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionEndTime( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionMaximumFieldCount( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setPlateAcquisitionName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionStartTime( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionWellSampleRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlateAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateColumnNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention, int: int + ) -> None: ... + def setPlateColumns( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPlateDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateExternalIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setPlateFieldIndex( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, int: int + ) -> None: ... + def setPlateID(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateName(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateRowNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention, int: int + ) -> None: ... + def setPlateRows( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPlateStatus(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateWellOriginX( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPlateWellOriginY( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPointAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPointFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPointFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPointFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPointFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPointFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPointID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPointStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPointStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPointText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setPointX(self, double: float, int: int, int2: int) -> None: ... + def setPointY(self, double: float, int: int, int2: int) -> None: ... + def setPolygonAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPolygonFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolygonFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPolygonFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPolygonFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolygonFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPolygonID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPolygonPoints( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolygonStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolygonText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setPolylineAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPolylineFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolylineFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPolylineFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPolylineFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolylineFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPolylineID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPolylineMarkerEnd( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setPolylineMarkerStart( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setPolylinePoints( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolylineStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolylineText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setProjectAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setProjectDatasetRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setProjectDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectID(self, string: java.lang.String | str, int: int) -> None: ... + def setProjectName(self, string: java.lang.String | str, int: int) -> None: ... + def setROIAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setROIDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setROIID(self, string: java.lang.String | str, int: int) -> None: ... + def setROIName(self, string: java.lang.String | str, int: int) -> None: ... + def setReagentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setReagentDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentReagentIdentifier( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setRectangleFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setRectangleFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setRectangleFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setRectangleFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setRectangleFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setRectangleHeight(self, double: float, int: int, int2: int) -> None: ... + def setRectangleID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setRectangleStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setRectangleStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setRectangleText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setRectangleWidth(self, double: float, int: int, int2: int) -> None: ... + def setRectangleX(self, double: float, int: int, int2: int) -> None: ... + def setRectangleY(self, double: float, int: int, int2: int) -> None: ... + def setRightsRightsHeld(self, string: java.lang.String | str) -> None: ... + def setRightsRightsHolder(self, string: java.lang.String | str) -> None: ... + def setRoot(self, metadataRoot: MetadataRoot) -> None: ... + def setScreenAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setScreenDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenID(self, string: java.lang.String | str, int: int) -> None: ... + def setScreenName(self, string: java.lang.String | str, int: int) -> None: ... + def setScreenPlateRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setScreenProtocolDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenProtocolIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenReagentSetDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenReagentSetIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenType(self, string: java.lang.String | str, int: int) -> None: ... + def setStageLabelName(self, string: java.lang.String | str, int: int) -> None: ... + def setStageLabelX(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setStageLabelY(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setStageLabelZ(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setTagAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTagAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setTagAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTermAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setTermAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTiffDataFirstC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataFirstT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataFirstZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataIFD( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataPlaneCount( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTimestampAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTimestampAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationValue( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int + ) -> None: ... + def setTransmittanceRangeCutIn( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutInTolerance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutOut( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutOutTolerance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeTransmittance( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + ) -> None: ... + def setUUID(self, string: java.lang.String | str) -> None: ... + def setUUIDFileName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setUUIDValue( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setWellColumn( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setWellExternalDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellExternalIdentifier( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellReagentRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellRow( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setWellSampleID( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleImageRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleIndex( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setWellSamplePositionX( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setWellSamplePositionY( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleTimepoint( + self, + timestamp: ome.xml.model.primitives.Timestamp, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setWellType( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setXMLAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setXMLAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setXMLAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + +class OMEXMLMetadata(IMetadata): + def dumpXML(self) -> java.lang.String: ... + def resolveReferences(self) -> int: ... + +class AbstractOMEXMLMetadata(OMEXMLMetadata): + XSI_NS: typing.ClassVar[java.lang.String] = ... + SCHEMA: typing.ClassVar[java.lang.String] = ... + def __init__(self): ... + def createNewDocument(self) -> org.w3c.dom.Document: ... + def dumpXML(self) -> java.lang.String: ... + +class OMEXMLMetadataImpl(AbstractOMEXMLMetadata): + def __init__(self): ... + def createRoot(self) -> None: ... + def dumpXML(self) -> java.lang.String: ... + def getArcAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getArcID(self, int: int, int2: int) -> java.lang.String: ... + def getArcLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getArcManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getArcModel(self, int: int, int2: int) -> java.lang.String: ... + def getArcPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getArcSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getArcType(self, int: int, int2: int) -> ome.xml.model.enums.ArcType: ... + def getBinaryFileBinData(self, int: int) -> typing.MutableSequence[int]: ... + def getBinaryFileBinDataBigEndian(self, int: int) -> bool: ... + def getBinaryFileBinDataCompression( + self, int: int + ) -> ome.xml.model.enums.Compression: ... + def getBinaryFileBinDataLength( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getBinaryFileFileName(self, int: int) -> java.lang.String: ... + def getBinaryFileMIMEType(self, int: int) -> java.lang.String: ... + def getBinaryFileSize( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getBinaryOnlyMetadataFile(self) -> java.lang.String: ... + def getBinaryOnlyUUID(self) -> java.lang.String: ... + def getBooleanAnnotationAnnotationCount(self, int: int) -> int: ... + def getBooleanAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getBooleanAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationCount(self) -> int: ... + def getBooleanAnnotationDescription(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationID(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getBooleanAnnotationValue(self, int: int) -> bool: ... + def getChannelAcquisitionMode( + self, int: int, int2: int + ) -> ome.xml.model.enums.AcquisitionMode: ... + def getChannelAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getChannelAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getChannelColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getChannelContrastMethod( + self, int: int, int2: int + ) -> ome.xml.model.enums.ContrastMethod: ... + def getChannelCount(self, int: int) -> int: ... + def getChannelEmissionWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelExcitationWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelFilterSetRef(self, int: int, int2: int) -> java.lang.String: ... + def getChannelFluor(self, int: int, int2: int) -> java.lang.String: ... + def getChannelID(self, int: int, int2: int) -> java.lang.String: ... + def getChannelIlluminationType( + self, int: int, int2: int + ) -> ome.xml.model.enums.IlluminationType: ... + def getChannelLightSourceSettingsAttenuation( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getChannelLightSourceSettingsID( + self, int: int, int2: int + ) -> java.lang.String: ... + def getChannelLightSourceSettingsWavelength( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelNDFilter(self, int: int, int2: int) -> float: ... + def getChannelName(self, int: int, int2: int) -> java.lang.String: ... + def getChannelPinholeSize( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getChannelPockelCellSetting(self, int: int, int2: int) -> int: ... + def getChannelSamplesPerPixel( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getCommentAnnotationAnnotationCount(self, int: int) -> int: ... + def getCommentAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getCommentAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getCommentAnnotationCount(self) -> int: ... + def getCommentAnnotationDescription(self, int: int) -> java.lang.String: ... + def getCommentAnnotationID(self, int: int) -> java.lang.String: ... + def getCommentAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getCommentAnnotationValue(self, int: int) -> java.lang.String: ... + def getCreator(self) -> java.lang.String: ... + def getDatasetAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getDatasetAnnotationRefCount(self, int: int) -> int: ... + def getDatasetCount(self) -> int: ... + def getDatasetDescription(self, int: int) -> java.lang.String: ... + def getDatasetExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getDatasetExperimenterRef(self, int: int) -> java.lang.String: ... + def getDatasetID(self, int: int) -> java.lang.String: ... + def getDatasetImageRef(self, int: int, int2: int) -> java.lang.String: ... + def getDatasetImageRefCount(self, int: int) -> int: ... + def getDatasetName(self, int: int) -> java.lang.String: ... + def getDatasetRefCount(self, int: int) -> int: ... + def getDetectorAmplificationGain(self, int: int, int2: int) -> float: ... + def getDetectorAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getDetectorAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getDetectorCount(self, int: int) -> int: ... + def getDetectorGain(self, int: int, int2: int) -> float: ... + def getDetectorID(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorModel(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorOffset(self, int: int, int2: int) -> float: ... + def getDetectorSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorSettingsBinning( + self, int: int, int2: int + ) -> ome.xml.model.enums.Binning: ... + def getDetectorSettingsGain(self, int: int, int2: int) -> float: ... + def getDetectorSettingsID(self, int: int, int2: int) -> java.lang.String: ... + def getDetectorSettingsIntegration( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getDetectorSettingsOffset(self, int: int, int2: int) -> float: ... + def getDetectorSettingsReadOutRate( + self, int: int, int2: int + ) -> ome.units.quantity.Frequency: ... + def getDetectorSettingsVoltage( + self, int: int, int2: int + ) -> ome.units.quantity.ElectricPotential: ... + def getDetectorSettingsZoom(self, int: int, int2: int) -> float: ... + def getDetectorType( + self, int: int, int2: int + ) -> ome.xml.model.enums.DetectorType: ... + def getDetectorVoltage( + self, int: int, int2: int + ) -> ome.units.quantity.ElectricPotential: ... + def getDetectorZoom(self, int: int, int2: int) -> float: ... + def getDichroicAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getDichroicAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getDichroicCount(self, int: int) -> int: ... + def getDichroicID(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicModel(self, int: int, int2: int) -> java.lang.String: ... + def getDichroicSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getDoubleAnnotationAnnotationCount(self, int: int) -> int: ... + def getDoubleAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getDoubleAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationCount(self) -> int: ... + def getDoubleAnnotationDescription(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationID(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getDoubleAnnotationValue(self, int: int) -> float: ... + def getEllipseAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getEllipseFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getEllipseFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getEllipseFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getEllipseFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getEllipseFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getEllipseID(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseLocked(self, int: int, int2: int) -> bool: ... + def getEllipseRadiusX(self, int: int, int2: int) -> float: ... + def getEllipseRadiusY(self, int: int, int2: int) -> float: ... + def getEllipseStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getEllipseStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getEllipseText(self, int: int, int2: int) -> java.lang.String: ... + def getEllipseTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getEllipseTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getEllipseX(self, int: int, int2: int) -> float: ... + def getEllipseY(self, int: int, int2: int) -> float: ... + def getExperimentCount(self) -> int: ... + def getExperimentDescription(self, int: int) -> java.lang.String: ... + def getExperimentExperimenterRef(self, int: int) -> java.lang.String: ... + def getExperimentID(self, int: int) -> java.lang.String: ... + def getExperimentType(self, int: int) -> ome.xml.model.enums.ExperimentType: ... + def getExperimenterAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getExperimenterAnnotationRefCount(self, int: int) -> int: ... + def getExperimenterCount(self) -> int: ... + def getExperimenterEmail(self, int: int) -> java.lang.String: ... + def getExperimenterFirstName(self, int: int) -> java.lang.String: ... + def getExperimenterGroupAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getExperimenterGroupAnnotationRefCount(self, int: int) -> int: ... + def getExperimenterGroupCount(self) -> int: ... + def getExperimenterGroupDescription(self, int: int) -> java.lang.String: ... + def getExperimenterGroupExperimenterRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getExperimenterGroupExperimenterRefCount(self, int: int) -> int: ... + def getExperimenterGroupID(self, int: int) -> java.lang.String: ... + def getExperimenterGroupLeader(self, int: int, int2: int) -> java.lang.String: ... + def getExperimenterGroupName(self, int: int) -> java.lang.String: ... + def getExperimenterID(self, int: int) -> java.lang.String: ... + def getExperimenterInstitution(self, int: int) -> java.lang.String: ... + def getExperimenterLastName(self, int: int) -> java.lang.String: ... + def getExperimenterMiddleName(self, int: int) -> java.lang.String: ... + def getExperimenterUserName(self, int: int) -> java.lang.String: ... + def getFilamentAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilamentID(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getFilamentSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilamentType( + self, int: int, int2: int + ) -> ome.xml.model.enums.FilamentType: ... + def getFileAnnotationAnnotationCount(self, int: int) -> int: ... + def getFileAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getFileAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getFileAnnotationCount(self) -> int: ... + def getFileAnnotationDescription(self, int: int) -> java.lang.String: ... + def getFileAnnotationID(self, int: int) -> java.lang.String: ... + def getFileAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getFilterAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getFilterCount(self, int: int) -> int: ... + def getFilterFilterWheel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterID(self, int: int, int2: int) -> java.lang.String: ... + def getFilterLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilterModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetCount(self, int: int) -> int: ... + def getFilterSetDichroicRef(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetEmissionFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterSetEmissionFilterRefCount(self, int: int, int2: int) -> int: ... + def getFilterSetExcitationFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getFilterSetExcitationFilterRefCount(self, int: int, int2: int) -> int: ... + def getFilterSetID(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetModel(self, int: int, int2: int) -> java.lang.String: ... + def getFilterSetSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getFilterType(self, int: int, int2: int) -> ome.xml.model.enums.FilterType: ... + def getFolderAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderAnnotationRefCount(self, int: int) -> int: ... + def getFolderCount(self) -> int: ... + def getFolderDescription(self, int: int) -> java.lang.String: ... + def getFolderFolderRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderID(self, int: int) -> java.lang.String: ... + def getFolderImageRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderImageRefCount(self, int: int) -> int: ... + def getFolderName(self, int: int) -> java.lang.String: ... + def getFolderROIRef(self, int: int, int2: int) -> java.lang.String: ... + def getFolderROIRefCount(self, int: int) -> int: ... + def getFolderRefCount(self, int: int) -> int: ... + def getGenericExcitationSourceAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getGenericExcitationSourceID(self, int: int, int2: int) -> java.lang.String: ... + def getGenericExcitationSourceLotNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourceManufacturer( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourceMap( + self, int: int, int2: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getGenericExcitationSourceModel( + self, int: int, int2: int + ) -> java.lang.String: ... + def getGenericExcitationSourcePower( + self, int: int, int2: int + ) -> ome.units.quantity.Power: ... + def getGenericExcitationSourceSerialNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getImageAcquisitionDate( + self, int: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getImageAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getImageAnnotationRefCount(self, int: int) -> int: ... + def getImageCount(self) -> int: ... + def getImageDescription(self, int: int) -> java.lang.String: ... + def getImageExperimentRef(self, int: int) -> java.lang.String: ... + def getImageExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getImageExperimenterRef(self, int: int) -> java.lang.String: ... + def getImageID(self, int: int) -> java.lang.String: ... + def getImageInstrumentRef(self, int: int) -> java.lang.String: ... + def getImageMicrobeamManipulationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getImageName(self, int: int) -> java.lang.String: ... + def getImageROIRef(self, int: int, int2: int) -> java.lang.String: ... + def getImageROIRefCount(self, int: int) -> int: ... + def getImagingEnvironmentAirPressure( + self, int: int + ) -> ome.units.quantity.Pressure: ... + def getImagingEnvironmentCO2Percent( + self, int: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getImagingEnvironmentHumidity( + self, int: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getImagingEnvironmentMap( + self, int: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getImagingEnvironmentTemperature( + self, int: int + ) -> ome.units.quantity.Temperature: ... + def getInstrumentAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getInstrumentAnnotationRefCount(self, int: int) -> int: ... + def getInstrumentCount(self) -> int: ... + def getInstrumentID(self, int: int) -> java.lang.String: ... + def getLabelAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLabelFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLabelFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getLabelFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getLabelFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLabelFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getLabelID(self, int: int, int2: int) -> java.lang.String: ... + def getLabelLocked(self, int: int, int2: int) -> bool: ... + def getLabelStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLabelStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getLabelStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLabelText(self, int: int, int2: int) -> java.lang.String: ... + def getLabelTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLabelTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getLabelX(self, int: int, int2: int) -> float: ... + def getLabelY(self, int: int, int2: int) -> float: ... + def getLaserAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLaserFrequencyMultiplication( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getLaserID(self, int: int, int2: int) -> java.lang.String: ... + def getLaserLaserMedium( + self, int: int, int2: int + ) -> ome.xml.model.enums.LaserMedium: ... + def getLaserLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getLaserManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getLaserModel(self, int: int, int2: int) -> java.lang.String: ... + def getLaserPockelCell(self, int: int, int2: int) -> bool: ... + def getLaserPower(self, int: int, int2: int) -> ome.units.quantity.Power: ... + def getLaserPulse(self, int: int, int2: int) -> ome.xml.model.enums.Pulse: ... + def getLaserPump(self, int: int, int2: int) -> java.lang.String: ... + def getLaserRepetitionRate( + self, int: int, int2: int + ) -> ome.units.quantity.Frequency: ... + def getLaserSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getLaserTuneable(self, int: int, int2: int) -> bool: ... + def getLaserType(self, int: int, int2: int) -> ome.xml.model.enums.LaserType: ... + def getLaserWavelength(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLeaderCount(self, int: int) -> int: ... + def getLightEmittingDiodeAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightEmittingDiodeID(self, int: int, int2: int) -> java.lang.String: ... + def getLightEmittingDiodeLotNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightEmittingDiodeManufacturer( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightEmittingDiodeModel(self, int: int, int2: int) -> java.lang.String: ... + def getLightEmittingDiodePower( + self, int: int, int2: int + ) -> ome.units.quantity.Power: ... + def getLightEmittingDiodeSerialNumber( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLightPathAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getLightPathDichroicRef(self, int: int, int2: int) -> java.lang.String: ... + def getLightPathEmissionFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathEmissionFilterRefCount(self, int: int, int2: int) -> int: ... + def getLightPathExcitationFilterRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLightPathExcitationFilterRefCount(self, int: int, int2: int) -> int: ... + def getLightSourceAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getLightSourceCount(self, int: int) -> int: ... + def getLightSourceType(self, int: int, int2: int) -> java.lang.String: ... + def getLineAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getLineFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLineFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getLineFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getLineFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLineFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getLineID(self, int: int, int2: int) -> java.lang.String: ... + def getLineLocked(self, int: int, int2: int) -> bool: ... + def getLineMarkerEnd(self, int: int, int2: int) -> ome.xml.model.enums.Marker: ... + def getLineMarkerStart(self, int: int, int2: int) -> ome.xml.model.enums.Marker: ... + def getLineStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getLineStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getLineStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getLineText(self, int: int, int2: int) -> java.lang.String: ... + def getLineTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLineTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getLineX1(self, int: int, int2: int) -> float: ... + def getLineX2(self, int: int, int2: int) -> float: ... + def getLineY1(self, int: int, int2: int) -> float: ... + def getLineY2(self, int: int, int2: int) -> float: ... + def getListAnnotationAnnotationCount(self, int: int) -> int: ... + def getListAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getListAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getListAnnotationCount(self) -> int: ... + def getListAnnotationDescription(self, int: int) -> java.lang.String: ... + def getListAnnotationID(self, int: int) -> java.lang.String: ... + def getListAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getLongAnnotationAnnotationCount(self, int: int) -> int: ... + def getLongAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getLongAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getLongAnnotationCount(self) -> int: ... + def getLongAnnotationDescription(self, int: int) -> java.lang.String: ... + def getLongAnnotationID(self, int: int) -> java.lang.String: ... + def getLongAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getLongAnnotationValue(self, int: int) -> int: ... + def getMapAnnotationAnnotationCount(self, int: int) -> int: ... + def getMapAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMapAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getMapAnnotationCount(self) -> int: ... + def getMapAnnotationDescription(self, int: int) -> java.lang.String: ... + def getMapAnnotationID(self, int: int) -> java.lang.String: ... + def getMapAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getMapAnnotationValue( + self, int: int + ) -> java.util.List[ome.xml.model.MapPair]: ... + def getMaskAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMaskBinData(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getMaskBinDataBigEndian(self, int: int, int2: int) -> bool: ... + def getMaskBinDataCompression( + self, int: int, int2: int + ) -> ome.xml.model.enums.Compression: ... + def getMaskBinDataLength( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getMaskFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getMaskFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getMaskFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getMaskFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getMaskFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getMaskHeight(self, int: int, int2: int) -> float: ... + def getMaskID(self, int: int, int2: int) -> java.lang.String: ... + def getMaskLocked(self, int: int, int2: int) -> bool: ... + def getMaskStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getMaskStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getMaskStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getMaskText(self, int: int, int2: int) -> java.lang.String: ... + def getMaskTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getMaskTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getMaskWidth(self, int: int, int2: int) -> float: ... + def getMaskX(self, int: int, int2: int) -> float: ... + def getMaskY(self, int: int, int2: int) -> float: ... + def getMicrobeamManipulationCount(self, int: int) -> int: ... + def getMicrobeamManipulationDescription( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMicrobeamManipulationExperimenterRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getMicrobeamManipulationID(self, int: int, int2: int) -> java.lang.String: ... + def getMicrobeamManipulationLightSourceSettingsAttenuation( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getMicrobeamManipulationLightSourceSettingsCount( + self, int: int, int2: int + ) -> int: ... + def getMicrobeamManipulationLightSourceSettingsID( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMicrobeamManipulationLightSourceSettingsWavelength( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getMicrobeamManipulationROIRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getMicrobeamManipulationROIRefCount(self, int: int, int2: int) -> int: ... + def getMicrobeamManipulationRefCount(self, int: int) -> int: ... + def getMicrobeamManipulationType( + self, int: int, int2: int + ) -> ome.xml.model.enums.MicrobeamManipulationType: ... + def getMicroscopeLotNumber(self, int: int) -> java.lang.String: ... + def getMicroscopeManufacturer(self, int: int) -> java.lang.String: ... + def getMicroscopeModel(self, int: int) -> java.lang.String: ... + def getMicroscopeSerialNumber(self, int: int) -> java.lang.String: ... + def getMicroscopeType(self, int: int) -> ome.xml.model.enums.MicroscopeType: ... + def getObjectiveAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getObjectiveAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getObjectiveCalibratedMagnification(self, int: int, int2: int) -> float: ... + def getObjectiveCorrection( + self, int: int, int2: int + ) -> ome.xml.model.enums.Correction: ... + def getObjectiveCount(self, int: int) -> int: ... + def getObjectiveID(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveImmersion( + self, int: int, int2: int + ) -> ome.xml.model.enums.Immersion: ... + def getObjectiveIris(self, int: int, int2: int) -> bool: ... + def getObjectiveLensNA(self, int: int, int2: int) -> float: ... + def getObjectiveLotNumber(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveManufacturer(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveModel(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveNominalMagnification(self, int: int, int2: int) -> float: ... + def getObjectiveSerialNumber(self, int: int, int2: int) -> java.lang.String: ... + def getObjectiveSettingsCorrectionCollar(self, int: int) -> float: ... + def getObjectiveSettingsID(self, int: int) -> java.lang.String: ... + def getObjectiveSettingsMedium(self, int: int) -> ome.xml.model.enums.Medium: ... + def getObjectiveSettingsRefractiveIndex(self, int: int) -> float: ... + def getObjectiveWorkingDistance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPixelsBigEndian(self, int: int) -> bool: ... + def getPixelsBinData(self, int: int, int2: int) -> typing.MutableSequence[int]: ... + def getPixelsBinDataBigEndian(self, int: int, int2: int) -> bool: ... + def getPixelsBinDataCompression( + self, int: int, int2: int + ) -> ome.xml.model.enums.Compression: ... + def getPixelsBinDataCount(self, int: int) -> int: ... + def getPixelsBinDataLength( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeLong: ... + def getPixelsDimensionOrder( + self, int: int + ) -> ome.xml.model.enums.DimensionOrder: ... + def getPixelsID(self, int: int) -> java.lang.String: ... + def getPixelsInterleaved(self, int: int) -> bool: ... + def getPixelsPhysicalSizeX(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsPhysicalSizeY(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsPhysicalSizeZ(self, int: int) -> ome.units.quantity.Length: ... + def getPixelsSignificantBits( + self, int: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeC(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeT(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeX(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeY(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsSizeZ(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPixelsTimeIncrement(self, int: int) -> ome.units.quantity.Time: ... + def getPixelsType(self, int: int) -> ome.xml.model.enums.PixelType: ... + def getPlaneAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlaneAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getPlaneCount(self, int: int) -> int: ... + def getPlaneDeltaT(self, int: int, int2: int) -> ome.units.quantity.Time: ... + def getPlaneExposureTime(self, int: int, int2: int) -> ome.units.quantity.Time: ... + def getPlaneHashSHA1(self, int: int, int2: int) -> java.lang.String: ... + def getPlanePositionX(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlanePositionY(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlanePositionZ(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPlaneTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlaneTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlaneTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlateAcquisitionAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlateAcquisitionAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getPlateAcquisitionCount(self, int: int) -> int: ... + def getPlateAcquisitionDescription( + self, int: int, int2: int + ) -> java.lang.String: ... + def getPlateAcquisitionEndTime( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getPlateAcquisitionID(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAcquisitionMaximumFieldCount( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateAcquisitionName(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAcquisitionStartTime( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getPlateAcquisitionWellSampleRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPlateAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getPlateAnnotationRefCount(self, int: int) -> int: ... + def getPlateColumnNamingConvention( + self, int: int + ) -> ome.xml.model.enums.NamingConvention: ... + def getPlateColumns(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateCount(self) -> int: ... + def getPlateDescription(self, int: int) -> java.lang.String: ... + def getPlateExternalIdentifier(self, int: int) -> java.lang.String: ... + def getPlateFieldIndex( + self, int: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPlateID(self, int: int) -> java.lang.String: ... + def getPlateName(self, int: int) -> java.lang.String: ... + def getPlateRefCount(self, int: int) -> int: ... + def getPlateRowNamingConvention( + self, int: int + ) -> ome.xml.model.enums.NamingConvention: ... + def getPlateRows(self, int: int) -> ome.xml.model.primitives.PositiveInteger: ... + def getPlateStatus(self, int: int) -> java.lang.String: ... + def getPlateWellOriginX(self, int: int) -> ome.units.quantity.Length: ... + def getPlateWellOriginY(self, int: int) -> ome.units.quantity.Length: ... + def getPointAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPointFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPointFillRule(self, int: int, int2: int) -> ome.xml.model.enums.FillRule: ... + def getPointFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPointFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPointFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPointID(self, int: int, int2: int) -> java.lang.String: ... + def getPointLocked(self, int: int, int2: int) -> bool: ... + def getPointStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPointStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPointStrokeWidth(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPointText(self, int: int, int2: int) -> java.lang.String: ... + def getPointTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPointTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getPointX(self, int: int, int2: int) -> float: ... + def getPointY(self, int: int, int2: int) -> float: ... + def getPolygonAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPolygonFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolygonFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getPolygonFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPolygonFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPolygonFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPolygonID(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonLocked(self, int: int, int2: int) -> bool: ... + def getPolygonPoints(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolygonStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPolygonText(self, int: int, int2: int) -> java.lang.String: ... + def getPolygonTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolygonTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getPolylineAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getPolylineFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolylineFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getPolylineFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getPolylineFontSize(self, int: int, int2: int) -> ome.units.quantity.Length: ... + def getPolylineFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getPolylineID(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineLocked(self, int: int, int2: int) -> bool: ... + def getPolylineMarkerEnd( + self, int: int, int2: int + ) -> ome.xml.model.enums.Marker: ... + def getPolylineMarkerStart( + self, int: int, int2: int + ) -> ome.xml.model.enums.Marker: ... + def getPolylinePoints(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getPolylineStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getPolylineText(self, int: int, int2: int) -> java.lang.String: ... + def getPolylineTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPolylineTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getProjectAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getProjectAnnotationRefCount(self, int: int) -> int: ... + def getProjectCount(self) -> int: ... + def getProjectDatasetRef(self, int: int, int2: int) -> java.lang.String: ... + def getProjectDescription(self, int: int) -> java.lang.String: ... + def getProjectExperimenterGroupRef(self, int: int) -> java.lang.String: ... + def getProjectExperimenterRef(self, int: int) -> java.lang.String: ... + def getProjectID(self, int: int) -> java.lang.String: ... + def getProjectName(self, int: int) -> java.lang.String: ... + def getROIAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getROIAnnotationRefCount(self, int: int) -> int: ... + def getROICount(self) -> int: ... + def getROIDescription(self, int: int) -> java.lang.String: ... + def getROIID(self, int: int) -> java.lang.String: ... + def getROIName(self, int: int) -> java.lang.String: ... + def getReagentAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getReagentAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getReagentCount(self, int: int) -> int: ... + def getReagentDescription(self, int: int, int2: int) -> java.lang.String: ... + def getReagentID(self, int: int, int2: int) -> java.lang.String: ... + def getReagentName(self, int: int, int2: int) -> java.lang.String: ... + def getReagentReagentIdentifier(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getRectangleFillColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getRectangleFillRule( + self, int: int, int2: int + ) -> ome.xml.model.enums.FillRule: ... + def getRectangleFontFamily( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontFamily: ... + def getRectangleFontSize( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getRectangleFontStyle( + self, int: int, int2: int + ) -> ome.xml.model.enums.FontStyle: ... + def getRectangleHeight(self, int: int, int2: int) -> float: ... + def getRectangleID(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleLocked(self, int: int, int2: int) -> bool: ... + def getRectangleStrokeColor( + self, int: int, int2: int + ) -> ome.xml.model.primitives.Color: ... + def getRectangleStrokeDashArray(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleStrokeWidth( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getRectangleText(self, int: int, int2: int) -> java.lang.String: ... + def getRectangleTheC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTheT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTheZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getRectangleTransform( + self, int: int, int2: int + ) -> ome.xml.model.AffineTransform: ... + def getRectangleWidth(self, int: int, int2: int) -> float: ... + def getRectangleX(self, int: int, int2: int) -> float: ... + def getRectangleY(self, int: int, int2: int) -> float: ... + def getRightsRightsHeld(self) -> java.lang.String: ... + def getRightsRightsHolder(self) -> java.lang.String: ... + def getRoot(self) -> MetadataRoot: ... + def getScreenAnnotationRef(self, int: int, int2: int) -> java.lang.String: ... + def getScreenAnnotationRefCount(self, int: int) -> int: ... + def getScreenCount(self) -> int: ... + def getScreenDescription(self, int: int) -> java.lang.String: ... + def getScreenID(self, int: int) -> java.lang.String: ... + def getScreenName(self, int: int) -> java.lang.String: ... + def getScreenPlateRef(self, int: int, int2: int) -> java.lang.String: ... + def getScreenProtocolDescription(self, int: int) -> java.lang.String: ... + def getScreenProtocolIdentifier(self, int: int) -> java.lang.String: ... + def getScreenReagentSetDescription(self, int: int) -> java.lang.String: ... + def getScreenReagentSetIdentifier(self, int: int) -> java.lang.String: ... + def getScreenType(self, int: int) -> java.lang.String: ... + def getShapeAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getShapeCount(self, int: int) -> int: ... + def getShapeType(self, int: int, int2: int) -> java.lang.String: ... + def getStageLabelName(self, int: int) -> java.lang.String: ... + def getStageLabelX(self, int: int) -> ome.units.quantity.Length: ... + def getStageLabelY(self, int: int) -> ome.units.quantity.Length: ... + def getStageLabelZ(self, int: int) -> ome.units.quantity.Length: ... + def getTagAnnotationAnnotationCount(self, int: int) -> int: ... + def getTagAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTagAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTagAnnotationCount(self) -> int: ... + def getTagAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTagAnnotationID(self, int: int) -> java.lang.String: ... + def getTagAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTagAnnotationValue(self, int: int) -> java.lang.String: ... + def getTermAnnotationAnnotationCount(self, int: int) -> int: ... + def getTermAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTermAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTermAnnotationCount(self) -> int: ... + def getTermAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTermAnnotationID(self, int: int) -> java.lang.String: ... + def getTermAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTermAnnotationValue(self, int: int) -> java.lang.String: ... + def getTiffDataCount(self, int: int) -> int: ... + def getTiffDataFirstC( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataFirstT( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataFirstZ( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataIFD( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTiffDataPlaneCount( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTimestampAnnotationAnnotationCount(self, int: int) -> int: ... + def getTimestampAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getTimestampAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationCount(self) -> int: ... + def getTimestampAnnotationDescription(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationID(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getTimestampAnnotationValue( + self, int: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getTransmittanceRangeCutIn( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutInTolerance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutOut( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeCutOutTolerance( + self, int: int, int2: int + ) -> ome.units.quantity.Length: ... + def getTransmittanceRangeTransmittance( + self, int: int, int2: int + ) -> ome.xml.model.primitives.PercentFraction: ... + def getUUID(self) -> java.lang.String: ... + def getUUIDFileName(self, int: int, int2: int) -> java.lang.String: ... + def getUUIDValue(self, int: int, int2: int) -> java.lang.String: ... + def getWellAnnotationRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getWellAnnotationRefCount(self, int: int, int2: int) -> int: ... + def getWellColor(self, int: int, int2: int) -> ome.xml.model.primitives.Color: ... + def getWellColumn( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellCount(self, int: int) -> int: ... + def getWellExternalDescription(self, int: int, int2: int) -> java.lang.String: ... + def getWellExternalIdentifier(self, int: int, int2: int) -> java.lang.String: ... + def getWellID(self, int: int, int2: int) -> java.lang.String: ... + def getWellReagentRef(self, int: int, int2: int) -> java.lang.String: ... + def getWellRow( + self, int: int, int2: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellSampleCount(self, int: int, int2: int) -> int: ... + def getWellSampleID(self, int: int, int2: int, int3: int) -> java.lang.String: ... + def getWellSampleImageRef( + self, int: int, int2: int, int3: int + ) -> java.lang.String: ... + def getWellSampleIndex( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getWellSamplePositionX( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getWellSamplePositionY( + self, int: int, int2: int, int3: int + ) -> ome.units.quantity.Length: ... + def getWellSampleRefCount(self, int: int, int2: int) -> int: ... + def getWellSampleTimepoint( + self, int: int, int2: int, int3: int + ) -> ome.xml.model.primitives.Timestamp: ... + def getWellType(self, int: int, int2: int) -> java.lang.String: ... + def getXMLAnnotationAnnotationCount(self, int: int) -> int: ... + def getXMLAnnotationAnnotationRef( + self, int: int, int2: int + ) -> java.lang.String: ... + def getXMLAnnotationAnnotator(self, int: int) -> java.lang.String: ... + def getXMLAnnotationCount(self) -> int: ... + def getXMLAnnotationDescription(self, int: int) -> java.lang.String: ... + def getXMLAnnotationID(self, int: int) -> java.lang.String: ... + def getXMLAnnotationNamespace(self, int: int) -> java.lang.String: ... + def getXMLAnnotationValue(self, int: int) -> java.lang.String: ... + def resolveReferences(self) -> int: ... + def setArcAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setArcID(self, string: java.lang.String | str, int: int, int2: int) -> None: ... + def setArcLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setArcSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setArcType( + self, arcType: ome.xml.model.enums.ArcType, int: int, int2: int + ) -> None: ... + def setBinaryFileBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int + ) -> None: ... + def setBinaryFileBinDataBigEndian(self, boolean: bool, int: int) -> None: ... + def setBinaryFileBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int + ) -> None: ... + def setBinaryFileBinDataLength( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, int: int + ) -> None: ... + def setBinaryFileFileName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBinaryFileMIMEType( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBinaryFileSize( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, int: int + ) -> None: ... + def setBinaryOnlyMetadataFile(self, string: java.lang.String | str) -> None: ... + def setBinaryOnlyUUID(self, string: java.lang.String | str) -> None: ... + def setBooleanAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setBooleanAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setBooleanAnnotationValue(self, boolean: bool, int: int) -> None: ... + def setChannelAcquisitionMode( + self, acquisitionMode: ome.xml.model.enums.AcquisitionMode, int: int, int2: int + ) -> None: ... + def setChannelAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setChannelColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setChannelContrastMethod( + self, contrastMethod: ome.xml.model.enums.ContrastMethod, int: int, int2: int + ) -> None: ... + def setChannelEmissionWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelExcitationWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelFilterSetRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelFluor( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelIlluminationType( + self, + illuminationType: ome.xml.model.enums.IlluminationType, + int: int, + int2: int, + ) -> None: ... + def setChannelLightSourceSettingsAttenuation( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + ) -> None: ... + def setChannelLightSourceSettingsID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelLightSourceSettingsWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelNDFilter(self, double: float, int: int, int2: int) -> None: ... + def setChannelName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setChannelPinholeSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setChannelPockelCellSetting( + self, integer: int, int2: int, int3: int + ) -> None: ... + def setChannelSamplesPerPixel( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setCommentAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setCommentAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCommentAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setCreator(self, string: java.lang.String | str) -> None: ... + def setDatasetAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDatasetDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDatasetID(self, string: java.lang.String | str, int: int) -> None: ... + def setDatasetImageRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDatasetName(self, string: java.lang.String | str, int: int) -> None: ... + def setDetectorAmplificationGain( + self, double: float, int: int, int2: int + ) -> None: ... + def setDetectorAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setDetectorGain(self, double: float, int: int, int2: int) -> None: ... + def setDetectorID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorOffset(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorSettingsBinning( + self, binning: ome.xml.model.enums.Binning, int: int, int2: int + ) -> None: ... + def setDetectorSettingsGain(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSettingsID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDetectorSettingsIntegration( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setDetectorSettingsOffset(self, double: float, int: int, int2: int) -> None: ... + def setDetectorSettingsReadOutRate( + self, frequency: ome.units.quantity.Frequency, int: int, int2: int + ) -> None: ... + def setDetectorSettingsVoltage( + self, + electricPotential: ome.units.quantity.ElectricPotential, + int: int, + int2: int, + ) -> None: ... + def setDetectorSettingsZoom(self, double: float, int: int, int2: int) -> None: ... + def setDetectorType( + self, detectorType: ome.xml.model.enums.DetectorType, int: int, int2: int + ) -> None: ... + def setDetectorVoltage( + self, + electricPotential: ome.units.quantity.ElectricPotential, + int: int, + int2: int, + ) -> None: ... + def setDetectorZoom(self, double: float, int: int, int2: int) -> None: ... + def setDichroicAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setDichroicID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDichroicSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDoubleAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setDoubleAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setDoubleAnnotationValue(self, double: float, int: int) -> None: ... + def setEllipseAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setEllipseFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setEllipseFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setEllipseFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setEllipseFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setEllipseFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setEllipseID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setEllipseRadiusX(self, double: float, int: int, int2: int) -> None: ... + def setEllipseRadiusY(self, double: float, int: int, int2: int) -> None: ... + def setEllipseStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setEllipseStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setEllipseText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setEllipseTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setEllipseTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setEllipseX(self, double: float, int: int, int2: int) -> None: ... + def setEllipseY(self, double: float, int: int, int2: int) -> None: ... + def setExperimentDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimentExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimentID(self, string: java.lang.String | str, int: int) -> None: ... + def setExperimentType( + self, experimentType: ome.xml.model.enums.ExperimentType, int: int + ) -> None: ... + def setExperimenterAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterEmail( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterFirstName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupExperimenterRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterGroupLeader( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setExperimenterGroupName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterID(self, string: java.lang.String | str, int: int) -> None: ... + def setExperimenterInstitution( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterLastName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterMiddleName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setExperimenterUserName( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFilamentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilamentID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setFilamentSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilamentType( + self, filamentType: ome.xml.model.enums.FilamentType, int: int, int2: int + ) -> None: ... + def setFileAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFileAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFileAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFileAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setFileAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFilterAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterFilterWheel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetDichroicRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetEmissionFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterSetExcitationFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setFilterSetID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterSetSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFilterType( + self, filterType: ome.xml.model.enums.FilterType, int: int, int2: int + ) -> None: ... + def setFolderAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setFolderFolderRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderID(self, string: java.lang.String | str, int: int) -> None: ... + def setFolderImageRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setFolderName(self, string: java.lang.String | str, int: int) -> None: ... + def setFolderROIRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setGenericExcitationSourceID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceMap( + self, list: java.util.List[ome.xml.model.MapPair], int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourcePower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setGenericExcitationSourceSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageAcquisitionDate( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int + ) -> None: ... + def setImageAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setImageExperimentRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageID(self, string: java.lang.String | str, int: int) -> None: ... + def setImageInstrumentRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setImageMicrobeamManipulationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImageName(self, string: java.lang.String | str, int: int) -> None: ... + def setImageROIRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setImagingEnvironmentAirPressure( + self, pressure: ome.units.quantity.Pressure, int: int + ) -> None: ... + def setImagingEnvironmentCO2Percent( + self, percentFraction: ome.xml.model.primitives.PercentFraction, int: int + ) -> None: ... + def setImagingEnvironmentHumidity( + self, percentFraction: ome.xml.model.primitives.PercentFraction, int: int + ) -> None: ... + def setImagingEnvironmentMap( + self, list: java.util.List[ome.xml.model.MapPair], int: int + ) -> None: ... + def setImagingEnvironmentTemperature( + self, temperature: ome.units.quantity.Temperature, int: int + ) -> None: ... + def setInstrumentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setInstrumentID(self, string: java.lang.String | str, int: int) -> None: ... + def setLabelAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLabelFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLabelFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setLabelFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setLabelFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLabelFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setLabelID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setLabelStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLabelStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLabelText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLabelTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLabelTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setLabelX(self, double: float, int: int, int2: int) -> None: ... + def setLabelY(self, double: float, int: int, int2: int) -> None: ... + def setLaserAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLaserFrequencyMultiplication( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setLaserID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserLaserMedium( + self, laserMedium: ome.xml.model.enums.LaserMedium, int: int, int2: int + ) -> None: ... + def setLaserLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserPockelCell(self, boolean: bool, int: int, int2: int) -> None: ... + def setLaserPower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setLaserPulse( + self, pulse: ome.xml.model.enums.Pulse, int: int, int2: int + ) -> None: ... + def setLaserPump( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserRepetitionRate( + self, frequency: ome.units.quantity.Frequency, int: int, int2: int + ) -> None: ... + def setLaserSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLaserTuneable(self, boolean: bool, int: int, int2: int) -> None: ... + def setLaserType( + self, laserType: ome.xml.model.enums.LaserType, int: int, int2: int + ) -> None: ... + def setLaserWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightEmittingDiodeID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodePower( + self, power: ome.units.quantity.Power, int: int, int2: int + ) -> None: ... + def setLightEmittingDiodeSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightPathAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightPathDichroicRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLightPathEmissionFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLightPathExcitationFilterRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLineAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setLineFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLineFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setLineFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setLineFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLineFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setLineID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setLineMarkerEnd( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setLineMarkerStart( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setLineStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setLineStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setLineText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLineTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setLineTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setLineX1(self, double: float, int: int, int2: int) -> None: ... + def setLineX2(self, double: float, int: int, int2: int) -> None: ... + def setLineY1(self, double: float, int: int, int2: int) -> None: ... + def setLineY2(self, double: float, int: int, int2: int) -> None: ... + def setListAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setListAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setListAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setListAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setListAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setLongAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setLongAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setLongAnnotationValue(self, long: int, int: int) -> None: ... + def setMapAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMapAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setMapAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMapAnnotationValue( + self, list: java.util.List[ome.xml.model.MapPair], int: int + ) -> None: ... + def setMaskAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMaskBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def setMaskBinDataBigEndian(self, boolean: bool, int: int, int2: int) -> None: ... + def setMaskBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int, int2: int + ) -> None: ... + def setMaskBinDataLength( + self, + nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, + int: int, + int2: int, + ) -> None: ... + def setMaskFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setMaskFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setMaskFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setMaskFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setMaskFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setMaskHeight(self, double: float, int: int, int2: int) -> None: ... + def setMaskID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setMaskStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setMaskStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setMaskText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMaskTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setMaskTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setMaskWidth(self, double: float, int: int, int2: int) -> None: ... + def setMaskX(self, double: float, int: int, int2: int) -> None: ... + def setMaskY(self, double: float, int: int, int2: int) -> None: ... + def setMicrobeamManipulationDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationExperimenterRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsAttenuation( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsID( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationLightSourceSettingsWavelength( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationROIRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setMicrobeamManipulationType( + self, + microbeamManipulationType: ome.xml.model.enums.MicrobeamManipulationType, + int: int, + int2: int, + ) -> None: ... + def setMicroscopeLotNumber( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeManufacturer( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeModel(self, string: java.lang.String | str, int: int) -> None: ... + def setMicroscopeSerialNumber( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setMicroscopeType( + self, microscopeType: ome.xml.model.enums.MicroscopeType, int: int + ) -> None: ... + def setObjectiveAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setObjectiveCalibratedMagnification( + self, double: float, int: int, int2: int + ) -> None: ... + def setObjectiveCorrection( + self, correction: ome.xml.model.enums.Correction, int: int, int2: int + ) -> None: ... + def setObjectiveID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveImmersion( + self, immersion: ome.xml.model.enums.Immersion, int: int, int2: int + ) -> None: ... + def setObjectiveIris(self, boolean: bool, int: int, int2: int) -> None: ... + def setObjectiveLensNA(self, double: float, int: int, int2: int) -> None: ... + def setObjectiveLotNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveManufacturer( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveModel( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveNominalMagnification( + self, double: float, int: int, int2: int + ) -> None: ... + def setObjectiveSerialNumber( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setObjectiveSettingsCorrectionCollar(self, double: float, int: int) -> None: ... + def setObjectiveSettingsID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setObjectiveSettingsMedium( + self, medium: ome.xml.model.enums.Medium, int: int + ) -> None: ... + def setObjectiveSettingsRefractiveIndex(self, double: float, int: int) -> None: ... + def setObjectiveWorkingDistance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPixelsBigEndian(self, boolean: bool, int: int) -> None: ... + def setPixelsBinData( + self, byteArray: list[int] | jpype.JArray | bytes, int: int, int2: int + ) -> None: ... + def setPixelsBinDataBigEndian(self, boolean: bool, int: int, int2: int) -> None: ... + def setPixelsBinDataCompression( + self, compression: ome.xml.model.enums.Compression, int: int, int2: int + ) -> None: ... + def setPixelsBinDataLength( + self, + nonNegativeLong: ome.xml.model.primitives.NonNegativeLong, + int: int, + int2: int, + ) -> None: ... + def setPixelsDimensionOrder( + self, dimensionOrder: ome.xml.model.enums.DimensionOrder, int: int + ) -> None: ... + def setPixelsID(self, string: java.lang.String | str, int: int) -> None: ... + def setPixelsInterleaved(self, boolean: bool, int: int) -> None: ... + def setPixelsPhysicalSizeX( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsPhysicalSizeY( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsPhysicalSizeZ( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPixelsSignificantBits( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeC( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeT( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeX( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeY( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsSizeZ( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPixelsTimeIncrement( + self, time: ome.units.quantity.Time, int: int + ) -> None: ... + def setPixelsType( + self, pixelType: ome.xml.model.enums.PixelType, int: int + ) -> None: ... + def setPlaneAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlaneDeltaT( + self, time: ome.units.quantity.Time, int: int, int2: int + ) -> None: ... + def setPlaneExposureTime( + self, time: ome.units.quantity.Time, int: int, int2: int + ) -> None: ... + def setPlaneHashSHA1( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlanePositionX( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlanePositionY( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlanePositionZ( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPlaneTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlaneTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlaneTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPlateAcquisitionAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlateAcquisitionDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionEndTime( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionMaximumFieldCount( + self, + positiveInteger: ome.xml.model.primitives.PositiveInteger, + int: int, + int2: int, + ) -> None: ... + def setPlateAcquisitionName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionStartTime( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int, int2: int + ) -> None: ... + def setPlateAcquisitionWellSampleRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPlateAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPlateColumnNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention, int: int + ) -> None: ... + def setPlateColumns( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPlateDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateExternalIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setPlateFieldIndex( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, int: int + ) -> None: ... + def setPlateID(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateName(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateRowNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention, int: int + ) -> None: ... + def setPlateRows( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger, int: int + ) -> None: ... + def setPlateStatus(self, string: java.lang.String | str, int: int) -> None: ... + def setPlateWellOriginX( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPlateWellOriginY( + self, length: ome.units.quantity.Length, int: int + ) -> None: ... + def setPointAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPointFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPointFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPointFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPointFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPointFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPointID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPointStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPointStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPointText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPointTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPointTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setPointX(self, double: float, int: int, int2: int) -> None: ... + def setPointY(self, double: float, int: int, int2: int) -> None: ... + def setPolygonAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPolygonFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolygonFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPolygonFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPolygonFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolygonFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPolygonID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPolygonPoints( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolygonStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolygonText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolygonTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolygonTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setPolylineAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setPolylineFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolylineFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setPolylineFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setPolylineFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolylineFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setPolylineID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setPolylineMarkerEnd( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setPolylineMarkerStart( + self, marker: ome.xml.model.enums.Marker, int: int, int2: int + ) -> None: ... + def setPolylinePoints( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setPolylineStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setPolylineText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setPolylineTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setPolylineTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setProjectAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setProjectDatasetRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setProjectDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectExperimenterGroupRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectExperimenterRef( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setProjectID(self, string: java.lang.String | str, int: int) -> None: ... + def setProjectName(self, string: java.lang.String | str, int: int) -> None: ... + def setROIAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setROIDescription(self, string: java.lang.String | str, int: int) -> None: ... + def setROIID(self, string: java.lang.String | str, int: int) -> None: ... + def setROIName(self, string: java.lang.String | str, int: int) -> None: ... + def setReagentAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setReagentDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setReagentReagentIdentifier( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setRectangleFillColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setRectangleFillRule( + self, fillRule: ome.xml.model.enums.FillRule, int: int, int2: int + ) -> None: ... + def setRectangleFontFamily( + self, fontFamily: ome.xml.model.enums.FontFamily, int: int, int2: int + ) -> None: ... + def setRectangleFontSize( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setRectangleFontStyle( + self, fontStyle: ome.xml.model.enums.FontStyle, int: int, int2: int + ) -> None: ... + def setRectangleHeight(self, double: float, int: int, int2: int) -> None: ... + def setRectangleID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleLocked(self, boolean: bool, int: int, int2: int) -> None: ... + def setRectangleStrokeColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setRectangleStrokeDashArray( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleStrokeWidth( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setRectangleText( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setRectangleTheC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTheT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTheZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setRectangleTransform( + self, affineTransform: ome.xml.model.AffineTransform, int: int, int2: int + ) -> None: ... + def setRectangleWidth(self, double: float, int: int, int2: int) -> None: ... + def setRectangleX(self, double: float, int: int, int2: int) -> None: ... + def setRectangleY(self, double: float, int: int, int2: int) -> None: ... + def setRightsRightsHeld(self, string: java.lang.String | str) -> None: ... + def setRightsRightsHolder(self, string: java.lang.String | str) -> None: ... + def setRoot(self, metadataRoot: MetadataRoot) -> None: ... + def setScreenAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setScreenDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenID(self, string: java.lang.String | str, int: int) -> None: ... + def setScreenName(self, string: java.lang.String | str, int: int) -> None: ... + def setScreenPlateRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setScreenProtocolDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenProtocolIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenReagentSetDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenReagentSetIdentifier( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setScreenType(self, string: java.lang.String | str, int: int) -> None: ... + def setStageLabelName(self, string: java.lang.String | str, int: int) -> None: ... + def setStageLabelX(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setStageLabelY(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setStageLabelZ(self, length: ome.units.quantity.Length, int: int) -> None: ... + def setTagAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTagAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setTagAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTagAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTermAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setTermAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTermAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTiffDataFirstC( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataFirstT( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataFirstZ( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataIFD( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTiffDataPlaneCount( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setTimestampAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setTimestampAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationID( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setTimestampAnnotationValue( + self, timestamp: ome.xml.model.primitives.Timestamp, int: int + ) -> None: ... + def setTransmittanceRangeCutIn( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutInTolerance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutOut( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeCutOutTolerance( + self, length: ome.units.quantity.Length, int: int, int2: int + ) -> None: ... + def setTransmittanceRangeTransmittance( + self, + percentFraction: ome.xml.model.primitives.PercentFraction, + int: int, + int2: int, + ) -> None: ... + def setUUID(self, string: java.lang.String | str) -> None: ... + def setUUIDFileName( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setUUIDValue( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellColor( + self, color: ome.xml.model.primitives.Color, int: int, int2: int + ) -> None: ... + def setWellColumn( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setWellExternalDescription( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellExternalIdentifier( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellID( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellReagentRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setWellRow( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + ) -> None: ... + def setWellSampleID( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleImageRef( + self, string: java.lang.String | str, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleIndex( + self, + nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setWellSamplePositionX( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setWellSamplePositionY( + self, length: ome.units.quantity.Length, int: int, int2: int, int3: int + ) -> None: ... + def setWellSampleTimepoint( + self, + timestamp: ome.xml.model.primitives.Timestamp, + int: int, + int2: int, + int3: int, + ) -> None: ... + def setWellType( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setXMLAnnotationAnnotationRef( + self, string: java.lang.String | str, int: int, int2: int + ) -> None: ... + def setXMLAnnotationAnnotator( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationDescription( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationID(self, string: java.lang.String | str, int: int) -> None: ... + def setXMLAnnotationNamespace( + self, string: java.lang.String | str, int: int + ) -> None: ... + def setXMLAnnotationValue( + self, string: java.lang.String | str, int: int + ) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.xml.meta")``. + + AbstractOMEXMLMetadata: type[AbstractOMEXMLMetadata] + AggregateMetadata: type[AggregateMetadata] + BaseMetadata: type[BaseMetadata] + DummyMetadata: type[DummyMetadata] + IMetadata: type[IMetadata] + MetadataRetrieve: type[MetadataRetrieve] + MetadataRoot: type[MetadataRoot] + MetadataStore: type[MetadataStore] + OMEXMLMetadata: type[OMEXMLMetadata] + OMEXMLMetadataImpl: type[OMEXMLMetadataImpl] + OMEXMLMetadataRoot: type[OMEXMLMetadataRoot] diff --git a/typings/ome/xml/model/__init__.pyi b/typings/ome/xml/model/__init__.pyi new file mode 100644 index 0000000..e1f644e --- /dev/null +++ b/typings/ome/xml/model/__init__.pyi @@ -0,0 +1,3765 @@ +import builtins +import typing +from typing import Protocol + +import java.lang +import java.util +import jpype +import ome.units.quantity +import ome.xml.model.enums +import ome.xml.model.primitives +import org.w3c.dom + +class MapPair: + @typing.overload + def __init__( + self, string: java.lang.String | str, string2: java.lang.String | str + ): ... + @typing.overload + def __init__(self, mapPair: MapPair): ... + def equals(self, object: typing.Any) -> bool: ... + def getName(self) -> java.lang.String: ... + def getValue(self) -> java.lang.String: ... + def hashCode(self) -> int: ... + def toString(self) -> java.lang.String: ... + +class OMEModel: + def addModelObject( + self, string: java.lang.String | str, oMEModelObject: OMEModelObject + ) -> OMEModelObject: ... + def addReference( + self, oMEModelObject: OMEModelObject, reference: Reference + ) -> bool: ... + def getModelObject(self, string: java.lang.String | str) -> OMEModelObject: ... + def getModelObjects(self) -> java.util.Map[java.lang.String, OMEModelObject]: ... + def getReferences( + self, + ) -> java.util.Map[OMEModelObject, java.util.List[Reference]]: ... + def removeModelObject(self, string: java.lang.String | str) -> OMEModelObject: ... + def resolveReferences(self) -> int: ... + +class OMEModelObject: + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +_ReferenceList__T = typing.TypeVar("_ReferenceList__T") # + +class ReferenceList( + java.util.ArrayList[_ReferenceList__T], typing.Generic[_ReferenceList__T] +): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__( + self, + collection: java.util.Collection[_ReferenceList__T] + | typing.Sequence[_ReferenceList__T] + | builtins.set[_ReferenceList__T], + ): ... + @typing.overload + def add(self, t: _ReferenceList__T) -> bool: ... + @typing.overload + def add(self, int: int, t: _ReferenceList__T) -> None: ... + @typing.overload + def addAll( + self, + int: int, + collection: java.util.Collection[_ReferenceList__T] + | typing.Sequence[_ReferenceList__T] + | builtins.set[_ReferenceList__T], + ) -> bool: ... + @typing.overload + def addAll( + self, + collection: java.util.Collection[_ReferenceList__T] + | typing.Sequence[_ReferenceList__T] + | builtins.set[_ReferenceList__T], + ) -> bool: ... + def clear(self) -> None: ... + def contains(self, object: typing.Any) -> bool: ... + def containsAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def isEmpty(self) -> bool: ... + def removeAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def retainAll( + self, + collection: java.util.Collection[typing.Any] + | typing.Sequence[typing.Any] + | builtins.set[typing.Any], + ) -> bool: ... + def set(self, int: int, t: _ReferenceList__T) -> _ReferenceList__T: ... + +class AbstractOMEModelObject(OMEModelObject): + def __init__(self): ... + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @staticmethod + def getChildrenByTagName( + element: org.w3c.dom.Element, string: java.lang.String | str + ) -> java.util.List[org.w3c.dom.Element]: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + @staticmethod + def stripNamespacePrefix(string: java.lang.String | str) -> java.lang.String: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class OMEModelImpl(OMEModel): + def __init__(self): ... + def addModelObject( + self, string: java.lang.String | str, oMEModelObject: OMEModelObject + ) -> OMEModelObject: ... + def addReference( + self, oMEModelObject: OMEModelObject, reference: Reference + ) -> bool: ... + def getModelObject(self, string: java.lang.String | str) -> OMEModelObject: ... + def getModelObjects(self) -> java.util.Map[java.lang.String, OMEModelObject]: ... + def getReferences( + self, + ) -> java.util.Map[OMEModelObject, java.util.List[Reference]]: ... + def removeModelObject(self, string: java.lang.String | str) -> OMEModelObject: ... + def resolveReferences(self) -> int: ... + +class AffineTransform(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, affineTransform: AffineTransform): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + @staticmethod + def createRotationTransform(double: float) -> AffineTransform: ... + def getA00(self) -> float: ... + def getA01(self) -> float: ... + def getA02(self) -> float: ... + def getA10(self) -> float: ... + def getA11(self) -> float: ... + def getA12(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setA00(self, double: float) -> None: ... + def setA01(self, double: float) -> None: ... + def setA02(self, double: float) -> None: ... + def setA10(self, double: float) -> None: ... + def setA11(self, double: float) -> None: ... + def setA12(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Annotation(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, annotation: Annotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedChannelList(self) -> java.util.List[Channel]: ... + def copyLinkedDatasetList(self) -> java.util.List[Dataset]: ... + def copyLinkedDetectorList(self) -> java.util.List[Detector]: ... + def copyLinkedDichroicList(self) -> java.util.List[Dichroic]: ... + def copyLinkedExperimenterGroupList(self) -> java.util.List[ExperimenterGroup]: ... + def copyLinkedExperimenterList(self) -> java.util.List[Experimenter]: ... + def copyLinkedFilterList(self) -> java.util.List[Filter]: ... + def copyLinkedFolderList(self) -> java.util.List[Folder]: ... + def copyLinkedImageList(self) -> java.util.List[Image]: ... + def copyLinkedInstrumentList(self) -> java.util.List[Instrument]: ... + def copyLinkedLightPathList(self) -> java.util.List[LightPath]: ... + def copyLinkedLightSourceList(self) -> java.util.List[LightSource]: ... + def copyLinkedObjectiveList(self) -> java.util.List[Objective]: ... + def copyLinkedPlaneList(self) -> java.util.List[Plane]: ... + def copyLinkedPlateAcquisitionList(self) -> java.util.List[PlateAcquisition]: ... + def copyLinkedPlateList(self) -> java.util.List[Plate]: ... + def copyLinkedProjectList(self) -> java.util.List[Project]: ... + def copyLinkedROIList(self) -> java.util.List[ROI]: ... + def copyLinkedReagentList(self) -> java.util.List[Reagent]: ... + def copyLinkedScreenList(self) -> java.util.List[Screen]: ... + def copyLinkedShapeList(self) -> java.util.List[Shape]: ... + def copyLinkedWellList(self) -> java.util.List[Well]: ... + def getAnnotator(self) -> java.lang.String: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedChannel(self, int: int) -> Channel: ... + def getLinkedDataset(self, int: int) -> Dataset: ... + def getLinkedDetector(self, int: int) -> Detector: ... + def getLinkedDichroic(self, int: int) -> Dichroic: ... + def getLinkedExperimenter(self, int: int) -> Experimenter: ... + def getLinkedExperimenterGroup(self, int: int) -> ExperimenterGroup: ... + def getLinkedFilter(self, int: int) -> Filter: ... + def getLinkedFolder(self, int: int) -> Folder: ... + def getLinkedImage(self, int: int) -> Image: ... + def getLinkedInstrument(self, int: int) -> Instrument: ... + def getLinkedLightPath(self, int: int) -> LightPath: ... + def getLinkedLightSource(self, int: int) -> LightSource: ... + def getLinkedObjective(self, int: int) -> Objective: ... + def getLinkedPlane(self, int: int) -> Plane: ... + def getLinkedPlate(self, int: int) -> Plate: ... + def getLinkedPlateAcquisition(self, int: int) -> PlateAcquisition: ... + def getLinkedProject(self, int: int) -> Project: ... + def getLinkedROI(self, int: int) -> ROI: ... + def getLinkedReagent(self, int: int) -> Reagent: ... + def getLinkedScreen(self, int: int) -> Screen: ... + def getLinkedShape(self, int: int) -> Shape: ... + def getLinkedWell(self, int: int) -> Well: ... + def getNamespace(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkChannel(self, channel: Channel) -> bool: ... + def linkDataset(self, dataset: Dataset) -> bool: ... + def linkDetector(self, detector: Detector) -> bool: ... + def linkDichroic(self, dichroic: Dichroic) -> bool: ... + def linkExperimenter(self, experimenter: Experimenter) -> bool: ... + def linkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> bool: ... + def linkFilter(self, filter: Filter) -> bool: ... + def linkFolder(self, folder: Folder) -> bool: ... + def linkImage(self, image: Image) -> bool: ... + def linkInstrument(self, instrument: Instrument) -> bool: ... + def linkLightPath(self, lightPath: LightPath) -> bool: ... + def linkLightSource(self, lightSource: LightSource) -> bool: ... + def linkObjective(self, objective: Objective) -> bool: ... + def linkPlane(self, plane: Plane) -> bool: ... + def linkPlate(self, plate: Plate) -> bool: ... + def linkPlateAcquisition(self, plateAcquisition: PlateAcquisition) -> bool: ... + def linkProject(self, project: Project) -> bool: ... + def linkROI(self, rOI: ROI) -> bool: ... + def linkReagent(self, reagent: Reagent) -> bool: ... + def linkScreen(self, screen: Screen) -> bool: ... + def linkShape(self, shape: Shape) -> bool: ... + def linkWell(self, well: Well) -> bool: ... + def setAnnotator(self, string: java.lang.String | str) -> None: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedChannel(self, int: int, channel: Channel) -> Channel: ... + def setLinkedDataset(self, int: int, dataset: Dataset) -> Dataset: ... + def setLinkedDetector(self, int: int, detector: Detector) -> Detector: ... + def setLinkedDichroic(self, int: int, dichroic: Dichroic) -> Dichroic: ... + def setLinkedExperimenter( + self, int: int, experimenter: Experimenter + ) -> Experimenter: ... + def setLinkedExperimenterGroup( + self, int: int, experimenterGroup: ExperimenterGroup + ) -> ExperimenterGroup: ... + def setLinkedFilter(self, int: int, filter: Filter) -> Filter: ... + def setLinkedFolder(self, int: int, folder: Folder) -> Folder: ... + def setLinkedImage(self, int: int, image: Image) -> Image: ... + def setLinkedInstrument(self, int: int, instrument: Instrument) -> Instrument: ... + def setLinkedLightPath(self, int: int, lightPath: LightPath) -> LightPath: ... + def setLinkedLightSource( + self, int: int, lightSource: LightSource + ) -> LightSource: ... + def setLinkedObjective(self, int: int, objective: Objective) -> Objective: ... + def setLinkedPlane(self, int: int, plane: Plane) -> Plane: ... + def setLinkedPlate(self, int: int, plate: Plate) -> Plate: ... + def setLinkedPlateAcquisition( + self, int: int, plateAcquisition: PlateAcquisition + ) -> PlateAcquisition: ... + def setLinkedProject(self, int: int, project: Project) -> Project: ... + def setLinkedROI(self, int: int, rOI: ROI) -> ROI: ... + def setLinkedReagent(self, int: int, reagent: Reagent) -> Reagent: ... + def setLinkedScreen(self, int: int, screen: Screen) -> Screen: ... + def setLinkedShape(self, int: int, shape: Shape) -> Shape: ... + def setLinkedWell(self, int: int, well: Well) -> Well: ... + def setNamespace(self, string: java.lang.String | str) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedChannelList(self) -> int: ... + def sizeOfLinkedDatasetList(self) -> int: ... + def sizeOfLinkedDetectorList(self) -> int: ... + def sizeOfLinkedDichroicList(self) -> int: ... + def sizeOfLinkedExperimenterGroupList(self) -> int: ... + def sizeOfLinkedExperimenterList(self) -> int: ... + def sizeOfLinkedFilterList(self) -> int: ... + def sizeOfLinkedFolderList(self) -> int: ... + def sizeOfLinkedImageList(self) -> int: ... + def sizeOfLinkedInstrumentList(self) -> int: ... + def sizeOfLinkedLightPathList(self) -> int: ... + def sizeOfLinkedLightSourceList(self) -> int: ... + def sizeOfLinkedObjectiveList(self) -> int: ... + def sizeOfLinkedPlaneList(self) -> int: ... + def sizeOfLinkedPlateAcquisitionList(self) -> int: ... + def sizeOfLinkedPlateList(self) -> int: ... + def sizeOfLinkedProjectList(self) -> int: ... + def sizeOfLinkedROIList(self) -> int: ... + def sizeOfLinkedReagentList(self) -> int: ... + def sizeOfLinkedScreenList(self) -> int: ... + def sizeOfLinkedShapeList(self) -> int: ... + def sizeOfLinkedWellList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkChannel(self, channel: Channel) -> bool: ... + def unlinkDataset(self, dataset: Dataset) -> bool: ... + def unlinkDetector(self, detector: Detector) -> bool: ... + def unlinkDichroic(self, dichroic: Dichroic) -> bool: ... + def unlinkExperimenter(self, experimenter: Experimenter) -> bool: ... + def unlinkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> bool: ... + def unlinkFilter(self, filter: Filter) -> bool: ... + def unlinkFolder(self, folder: Folder) -> bool: ... + def unlinkImage(self, image: Image) -> bool: ... + def unlinkInstrument(self, instrument: Instrument) -> bool: ... + def unlinkLightPath(self, lightPath: LightPath) -> bool: ... + def unlinkLightSource(self, lightSource: LightSource) -> bool: ... + def unlinkObjective(self, objective: Objective) -> bool: ... + def unlinkPlane(self, plane: Plane) -> bool: ... + def unlinkPlate(self, plate: Plate) -> bool: ... + def unlinkPlateAcquisition(self, plateAcquisition: PlateAcquisition) -> bool: ... + def unlinkProject(self, project: Project) -> bool: ... + def unlinkROI(self, rOI: ROI) -> bool: ... + def unlinkReagent(self, reagent: Reagent) -> bool: ... + def unlinkScreen(self, screen: Screen) -> bool: ... + def unlinkShape(self, shape: Shape) -> bool: ... + def unlinkWell(self, well: Well) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class BinData(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, binData: BinData): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getBase64Binary(self) -> typing.MutableSequence[int]: ... + def getBigEndian(self) -> bool: ... + def getCompression(self) -> ome.xml.model.enums.Compression: ... + def getLength(self) -> ome.xml.model.primitives.NonNegativeLong: ... + def getPixels(self) -> Pixels: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setBase64Binary(self, byteArray: list[int] | jpype.JArray | bytes) -> None: ... + def setBigEndian(self, boolean: bool) -> None: ... + def setCompression(self, compression: ome.xml.model.enums.Compression) -> None: ... + def setLength( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong + ) -> None: ... + def setPixels(self, pixels: Pixels) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class BinaryFile(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, binaryFile: BinaryFile): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getBinData(self) -> BinData: ... + def getExternal(self) -> External: ... + def getFileName(self) -> java.lang.String: ... + def getMIMEType(self) -> java.lang.String: ... + def getSize(self) -> ome.xml.model.primitives.NonNegativeLong: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setBinData(self, binData: BinData) -> None: ... + def setExternal(self, external: External) -> None: ... + def setFileName(self, string: java.lang.String | str) -> None: ... + def setMIMEType(self, string: java.lang.String | str) -> None: ... + def setSize( + self, nonNegativeLong: ome.xml.model.primitives.NonNegativeLong + ) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class BinaryOnly(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, binaryOnly: BinaryOnly): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getMetadataFile(self) -> java.lang.String: ... + def getUUID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setMetadataFile(self, string: java.lang.String | str) -> None: ... + def setUUID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Channel(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, channel: Channel): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def getAcquisitionMode(self) -> ome.xml.model.enums.AcquisitionMode: ... + def getColor(self) -> ome.xml.model.primitives.Color: ... + def getContrastMethod(self) -> ome.xml.model.enums.ContrastMethod: ... + def getDetectorSettings(self) -> DetectorSettings: ... + def getEmissionWavelength(self) -> ome.units.quantity.Length: ... + @staticmethod + def getEmissionWavelengthUnitXsdDefault() -> java.lang.String: ... + def getExcitationWavelength(self) -> ome.units.quantity.Length: ... + @staticmethod + def getExcitationWavelengthUnitXsdDefault() -> java.lang.String: ... + def getFluor(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getIlluminationType(self) -> ome.xml.model.enums.IlluminationType: ... + def getLightPath(self) -> LightPath: ... + def getLightSourceSettings(self) -> LightSourceSettings: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedFilterSet(self) -> FilterSet: ... + def getNDFilter(self) -> float: ... + def getName(self) -> java.lang.String: ... + def getPinholeSize(self) -> ome.units.quantity.Length: ... + @staticmethod + def getPinholeSizeUnitXsdDefault() -> java.lang.String: ... + def getPixels(self) -> Pixels: ... + def getPockelCellSetting(self) -> int: ... + def getSamplesPerPixel(self) -> ome.xml.model.primitives.PositiveInteger: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkFilterSet(self, filterSet: FilterSet) -> None: ... + def setAcquisitionMode( + self, acquisitionMode: ome.xml.model.enums.AcquisitionMode + ) -> None: ... + def setColor(self, color: ome.xml.model.primitives.Color) -> None: ... + def setContrastMethod( + self, contrastMethod: ome.xml.model.enums.ContrastMethod + ) -> None: ... + def setDetectorSettings(self, detectorSettings: DetectorSettings) -> None: ... + def setEmissionWavelength(self, length: ome.units.quantity.Length) -> None: ... + def setExcitationWavelength(self, length: ome.units.quantity.Length) -> None: ... + def setFluor(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setIlluminationType( + self, illuminationType: ome.xml.model.enums.IlluminationType + ) -> None: ... + def setLightPath(self, lightPath: LightPath) -> None: ... + def setLightSourceSettings( + self, lightSourceSettings: LightSourceSettings + ) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setNDFilter(self, double: float) -> None: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setPinholeSize(self, length: ome.units.quantity.Length) -> None: ... + def setPixels(self, pixels: Pixels) -> None: ... + def setPockelCellSetting(self, integer: int) -> None: ... + def setSamplesPerPixel( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkFilterSet(self, filterSet: FilterSet) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Dataset(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, dataset: Dataset): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedImageList(self) -> java.util.List[Image]: ... + def copyLinkedProjectList(self) -> java.util.List[Project]: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedExperimenter(self) -> Experimenter: ... + def getLinkedExperimenterGroup(self) -> ExperimenterGroup: ... + def getLinkedImage(self, int: int) -> Image: ... + def getLinkedProject(self, int: int) -> Project: ... + def getName(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkExperimenter(self, experimenter: Experimenter) -> None: ... + def linkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> None: ... + def linkImage(self, image: Image) -> bool: ... + def linkProject(self, project: Project) -> bool: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedImage(self, int: int, image: Image) -> Image: ... + def setLinkedProject(self, int: int, project: Project) -> Project: ... + def setName(self, string: java.lang.String | str) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedImageList(self) -> int: ... + def sizeOfLinkedProjectList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkExperimenter(self, experimenter: Experimenter) -> None: ... + def unlinkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> None: ... + def unlinkImage(self, image: Image) -> bool: ... + def unlinkProject(self, project: Project) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Experiment(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, experiment: Experiment): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addMicrobeamManipulation( + self, microbeamManipulation: MicrobeamManipulation + ) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearMicrobeamManipulationList(self) -> None: ... + def copyLinkedImageList(self) -> java.util.List[Image]: ... + def copyMicrobeamManipulationList( + self, + ) -> java.util.List[MicrobeamManipulation]: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedExperimenter(self) -> Experimenter: ... + def getLinkedImage(self, int: int) -> Image: ... + def getMicrobeamManipulation(self, int: int) -> MicrobeamManipulation: ... + def getType(self) -> ome.xml.model.enums.ExperimentType: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkExperimenter(self, experimenter: Experimenter) -> None: ... + def linkImage(self, image: Image) -> bool: ... + def removeMicrobeamManipulation( + self, microbeamManipulation: MicrobeamManipulation + ) -> None: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedImage(self, int: int, image: Image) -> Image: ... + def setMicrobeamManipulation( + self, int: int, microbeamManipulation: MicrobeamManipulation + ) -> MicrobeamManipulation: ... + def setType(self, experimentType: ome.xml.model.enums.ExperimentType) -> None: ... + def sizeOfLinkedImageList(self) -> int: ... + def sizeOfMicrobeamManipulationList(self) -> int: ... + def unlinkExperimenter(self, experimenter: Experimenter) -> None: ... + def unlinkImage(self, image: Image) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Experimenter(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, experimenter: Experimenter): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedDatasetList(self) -> java.util.List[Dataset]: ... + def copyLinkedExperimentList(self) -> java.util.List[Experiment]: ... + def copyLinkedExperimenterGroupList(self) -> java.util.List[ExperimenterGroup]: ... + def copyLinkedImageList(self) -> java.util.List[Image]: ... + def copyLinkedMicrobeamManipulationList( + self, + ) -> java.util.List[MicrobeamManipulation]: ... + def copyLinkedProjectList(self) -> java.util.List[Project]: ... + def getEmail(self) -> java.lang.String: ... + def getFirstName(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getInstitution(self) -> java.lang.String: ... + def getLastName(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedDataset(self, int: int) -> Dataset: ... + def getLinkedExperiment(self, int: int) -> Experiment: ... + def getLinkedExperimenterGroup(self, int: int) -> ExperimenterGroup: ... + def getLinkedImage(self, int: int) -> Image: ... + def getLinkedMicrobeamManipulation(self, int: int) -> MicrobeamManipulation: ... + def getLinkedProject(self, int: int) -> Project: ... + def getMiddleName(self) -> java.lang.String: ... + def getUserName(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkDataset(self, dataset: Dataset) -> bool: ... + def linkExperiment(self, experiment: Experiment) -> bool: ... + def linkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> bool: ... + def linkImage(self, image: Image) -> bool: ... + def linkMicrobeamManipulation( + self, microbeamManipulation: MicrobeamManipulation + ) -> bool: ... + def linkProject(self, project: Project) -> bool: ... + def setEmail(self, string: java.lang.String | str) -> None: ... + def setFirstName(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setInstitution(self, string: java.lang.String | str) -> None: ... + def setLastName(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedDataset(self, int: int, dataset: Dataset) -> Dataset: ... + def setLinkedExperiment(self, int: int, experiment: Experiment) -> Experiment: ... + def setLinkedExperimenterGroup( + self, int: int, experimenterGroup: ExperimenterGroup + ) -> ExperimenterGroup: ... + def setLinkedImage(self, int: int, image: Image) -> Image: ... + def setLinkedMicrobeamManipulation( + self, int: int, microbeamManipulation: MicrobeamManipulation + ) -> MicrobeamManipulation: ... + def setLinkedProject(self, int: int, project: Project) -> Project: ... + def setMiddleName(self, string: java.lang.String | str) -> None: ... + def setUserName(self, string: java.lang.String | str) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedDatasetList(self) -> int: ... + def sizeOfLinkedExperimentList(self) -> int: ... + def sizeOfLinkedExperimenterGroupList(self) -> int: ... + def sizeOfLinkedImageList(self) -> int: ... + def sizeOfLinkedMicrobeamManipulationList(self) -> int: ... + def sizeOfLinkedProjectList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkDataset(self, dataset: Dataset) -> bool: ... + def unlinkExperiment(self, experiment: Experiment) -> bool: ... + def unlinkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> bool: ... + def unlinkImage(self, image: Image) -> bool: ... + def unlinkMicrobeamManipulation( + self, microbeamManipulation: MicrobeamManipulation + ) -> bool: ... + def unlinkProject(self, project: Project) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ExperimenterGroup(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, experimenterGroup: ExperimenterGroup): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedDatasetList(self) -> java.util.List[Dataset]: ... + def copyLinkedExperimenterList(self) -> java.util.List[Experimenter]: ... + def copyLinkedImageList(self) -> java.util.List[Image]: ... + def copyLinkedLeaderList(self) -> java.util.List[Experimenter]: ... + def copyLinkedProjectList(self) -> java.util.List[Project]: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedDataset(self, int: int) -> Dataset: ... + def getLinkedExperimenter(self, int: int) -> Experimenter: ... + def getLinkedImage(self, int: int) -> Image: ... + def getLinkedLeader(self, int: int) -> Experimenter: ... + def getLinkedProject(self, int: int) -> Project: ... + def getName(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkDataset(self, dataset: Dataset) -> bool: ... + def linkExperimenter(self, experimenter: Experimenter) -> bool: ... + def linkImage(self, image: Image) -> bool: ... + def linkLeader(self, experimenter: Experimenter) -> bool: ... + def linkProject(self, project: Project) -> bool: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedDataset(self, int: int, dataset: Dataset) -> Dataset: ... + def setLinkedExperimenter( + self, int: int, experimenter: Experimenter + ) -> Experimenter: ... + def setLinkedImage(self, int: int, image: Image) -> Image: ... + def setLinkedLeader(self, int: int, experimenter: Experimenter) -> Experimenter: ... + def setLinkedProject(self, int: int, project: Project) -> Project: ... + def setName(self, string: java.lang.String | str) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedDatasetList(self) -> int: ... + def sizeOfLinkedExperimenterList(self) -> int: ... + def sizeOfLinkedImageList(self) -> int: ... + def sizeOfLinkedLeaderList(self) -> int: ... + def sizeOfLinkedProjectList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkDataset(self, dataset: Dataset) -> bool: ... + def unlinkExperimenter(self, experimenter: Experimenter) -> bool: ... + def unlinkImage(self, image: Image) -> bool: ... + def unlinkLeader(self, experimenter: Experimenter) -> bool: ... + def unlinkProject(self, project: Project) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class External(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, external: External): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getCompression(self) -> ome.xml.model.enums.Compression: ... + def getSHA1(self) -> java.lang.String: ... + def gethref(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setCompression(self, compression: ome.xml.model.enums.Compression) -> None: ... + def setSHA1(self, string: java.lang.String | str) -> None: ... + def sethref(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Folder(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, folder: Folder): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedChildFolderList(self) -> java.util.List[Folder]: ... + def copyLinkedFolderList(self) -> java.util.List[Folder]: ... + def copyLinkedImageList(self) -> java.util.List[Image]: ... + def copyLinkedROIList(self) -> java.util.List[ROI]: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedChildFolder(self, int: int) -> Folder: ... + def getLinkedFolder(self, int: int) -> Folder: ... + def getLinkedImage(self, int: int) -> Image: ... + def getLinkedROI(self, int: int) -> ROI: ... + def getName(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkChildFolder(self, folder: Folder) -> bool: ... + def linkFolder(self, folder: Folder) -> bool: ... + def linkImage(self, image: Image) -> bool: ... + def linkROI(self, rOI: ROI) -> bool: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedChildFolder(self, int: int, folder: Folder) -> Folder: ... + def setLinkedFolder(self, int: int, folder: Folder) -> Folder: ... + def setLinkedImage(self, int: int, image: Image) -> Image: ... + def setLinkedROI(self, int: int, rOI: ROI) -> ROI: ... + def setName(self, string: java.lang.String | str) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedChildFolderList(self) -> int: ... + def sizeOfLinkedFolderList(self) -> int: ... + def sizeOfLinkedImageList(self) -> int: ... + def sizeOfLinkedROIList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkChildFolder(self, folder: Folder) -> bool: ... + def unlinkFolder(self, folder: Folder) -> bool: ... + def unlinkImage(self, image: Image) -> bool: ... + def unlinkROI(self, rOI: ROI) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Image(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, image: Image): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedDatasetList(self) -> java.util.List[Dataset]: ... + def copyLinkedFolderList(self) -> java.util.List[Folder]: ... + def copyLinkedMicrobeamManipulationList( + self, + ) -> java.util.List[MicrobeamManipulation]: ... + def copyLinkedROIList(self) -> java.util.List[ROI]: ... + def copyLinkedWellSampleList(self) -> java.util.List[WellSample]: ... + def getAcquisitionDate(self) -> ome.xml.model.primitives.Timestamp: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getImagingEnvironment(self) -> ImagingEnvironment: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedDataset(self, int: int) -> Dataset: ... + def getLinkedExperiment(self) -> Experiment: ... + def getLinkedExperimenter(self) -> Experimenter: ... + def getLinkedExperimenterGroup(self) -> ExperimenterGroup: ... + def getLinkedFolder(self, int: int) -> Folder: ... + def getLinkedInstrument(self) -> Instrument: ... + def getLinkedMicrobeamManipulation(self, int: int) -> MicrobeamManipulation: ... + def getLinkedROI(self, int: int) -> ROI: ... + def getLinkedWellSample(self, int: int) -> WellSample: ... + def getName(self) -> java.lang.String: ... + def getObjectiveSettings(self) -> ObjectiveSettings: ... + def getPixels(self) -> Pixels: ... + def getStageLabel(self) -> StageLabel: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkDataset(self, dataset: Dataset) -> bool: ... + def linkExperiment(self, experiment: Experiment) -> None: ... + def linkExperimenter(self, experimenter: Experimenter) -> None: ... + def linkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> None: ... + def linkFolder(self, folder: Folder) -> bool: ... + def linkInstrument(self, instrument: Instrument) -> None: ... + def linkMicrobeamManipulation( + self, microbeamManipulation: MicrobeamManipulation + ) -> bool: ... + def linkROI(self, rOI: ROI) -> bool: ... + def linkWellSample(self, wellSample: WellSample) -> bool: ... + def setAcquisitionDate( + self, timestamp: ome.xml.model.primitives.Timestamp + ) -> None: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setImagingEnvironment(self, imagingEnvironment: ImagingEnvironment) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedDataset(self, int: int, dataset: Dataset) -> Dataset: ... + def setLinkedFolder(self, int: int, folder: Folder) -> Folder: ... + def setLinkedMicrobeamManipulation( + self, int: int, microbeamManipulation: MicrobeamManipulation + ) -> MicrobeamManipulation: ... + def setLinkedROI(self, int: int, rOI: ROI) -> ROI: ... + def setLinkedWellSample(self, int: int, wellSample: WellSample) -> WellSample: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setObjectiveSettings(self, objectiveSettings: ObjectiveSettings) -> None: ... + def setPixels(self, pixels: Pixels) -> None: ... + def setStageLabel(self, stageLabel: StageLabel) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedDatasetList(self) -> int: ... + def sizeOfLinkedFolderList(self) -> int: ... + def sizeOfLinkedMicrobeamManipulationList(self) -> int: ... + def sizeOfLinkedROIList(self) -> int: ... + def sizeOfLinkedWellSampleList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkDataset(self, dataset: Dataset) -> bool: ... + def unlinkExperiment(self, experiment: Experiment) -> None: ... + def unlinkExperimenter(self, experimenter: Experimenter) -> None: ... + def unlinkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> None: ... + def unlinkFolder(self, folder: Folder) -> bool: ... + def unlinkInstrument(self, instrument: Instrument) -> None: ... + def unlinkMicrobeamManipulation( + self, microbeamManipulation: MicrobeamManipulation + ) -> bool: ... + def unlinkROI(self, rOI: ROI) -> bool: ... + def unlinkWellSample(self, wellSample: WellSample) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ImagingEnvironment(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, imagingEnvironment: ImagingEnvironment): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getAirPressure(self) -> ome.units.quantity.Pressure: ... + @staticmethod + def getAirPressureUnitXsdDefault() -> java.lang.String: ... + def getCO2Percent(self) -> ome.xml.model.primitives.PercentFraction: ... + def getHumidity(self) -> ome.xml.model.primitives.PercentFraction: ... + def getMap(self) -> java.util.List[MapPair]: ... + def getTemperature(self) -> ome.units.quantity.Temperature: ... + @staticmethod + def getTemperatureUnitXsdDefault() -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setAirPressure(self, pressure: ome.units.quantity.Pressure) -> None: ... + def setCO2Percent( + self, percentFraction: ome.xml.model.primitives.PercentFraction + ) -> None: ... + def setHumidity( + self, percentFraction: ome.xml.model.primitives.PercentFraction + ) -> None: ... + def setMap(self, list: java.util.List[MapPair]) -> None: ... + def setTemperature(self, temperature: ome.units.quantity.Temperature) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Instrument(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, instrument: Instrument): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addDetector(self, detector: Detector) -> None: ... + def addDichroic(self, dichroic: Dichroic) -> None: ... + def addFilter(self, filter: Filter) -> None: ... + def addFilterSet(self, filterSet: FilterSet) -> None: ... + def addLightSource(self, lightSource: LightSource) -> None: ... + def addObjective(self, objective: Objective) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearDetectorList(self) -> None: ... + def clearDichroicList(self) -> None: ... + def clearFilterList(self) -> None: ... + def clearFilterSetList(self) -> None: ... + def clearLightSourceList(self) -> None: ... + def clearObjectiveList(self) -> None: ... + def copyDetectorList(self) -> java.util.List[Detector]: ... + def copyDichroicList(self) -> java.util.List[Dichroic]: ... + def copyFilterList(self) -> java.util.List[Filter]: ... + def copyFilterSetList(self) -> java.util.List[FilterSet]: ... + def copyLightSourceList(self) -> java.util.List[LightSource]: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedImageList(self) -> java.util.List[Image]: ... + def copyObjectiveList(self) -> java.util.List[Objective]: ... + def getDetector(self, int: int) -> Detector: ... + def getDichroic(self, int: int) -> Dichroic: ... + def getFilter(self, int: int) -> Filter: ... + def getFilterSet(self, int: int) -> FilterSet: ... + def getID(self) -> java.lang.String: ... + def getLightSource(self, int: int) -> LightSource: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedImage(self, int: int) -> Image: ... + def getMicroscope(self) -> Microscope: ... + def getObjective(self, int: int) -> Objective: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkImage(self, image: Image) -> bool: ... + def removeDetector(self, detector: Detector) -> None: ... + def removeDichroic(self, dichroic: Dichroic) -> None: ... + def removeFilter(self, filter: Filter) -> None: ... + def removeFilterSet(self, filterSet: FilterSet) -> None: ... + def removeLightSource(self, lightSource: LightSource) -> None: ... + def removeObjective(self, objective: Objective) -> None: ... + def setDetector(self, int: int, detector: Detector) -> Detector: ... + def setDichroic(self, int: int, dichroic: Dichroic) -> Dichroic: ... + def setFilter(self, int: int, filter: Filter) -> Filter: ... + def setFilterSet(self, int: int, filterSet: FilterSet) -> FilterSet: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLightSource(self, int: int, lightSource: LightSource) -> LightSource: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedImage(self, int: int, image: Image) -> Image: ... + def setMicroscope(self, microscope: Microscope) -> None: ... + def setObjective(self, int: int, objective: Objective) -> Objective: ... + def sizeOfDetectorList(self) -> int: ... + def sizeOfDichroicList(self) -> int: ... + def sizeOfFilterList(self) -> int: ... + def sizeOfFilterSetList(self) -> int: ... + def sizeOfLightSourceList(self) -> int: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedImageList(self) -> int: ... + def sizeOfObjectiveList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkImage(self, image: Image) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class LightPath(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, lightPath: LightPath): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedEmissionFilterList(self) -> java.util.List[Filter]: ... + def copyLinkedExcitationFilterList(self) -> java.util.List[Filter]: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedDichroic(self) -> Dichroic: ... + def getLinkedEmissionFilter(self, int: int) -> Filter: ... + def getLinkedExcitationFilter(self, int: int) -> Filter: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkDichroic(self, dichroic: Dichroic) -> None: ... + def linkEmissionFilter(self, filter: Filter) -> bool: ... + def linkExcitationFilter(self, filter: Filter) -> bool: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedEmissionFilter(self, int: int, filter: Filter) -> Filter: ... + def setLinkedExcitationFilter(self, int: int, filter: Filter) -> Filter: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedEmissionFilterList(self) -> int: ... + def sizeOfLinkedExcitationFilterList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkDichroic(self, dichroic: Dichroic) -> None: ... + def unlinkEmissionFilter(self, filter: Filter) -> bool: ... + def unlinkExcitationFilter(self, filter: Filter) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ManufacturerSpec(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, manufacturerSpec: ManufacturerSpec): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getLotNumber(self) -> java.lang.String: ... + def getManufacturer(self) -> java.lang.String: ... + def getModel(self) -> java.lang.String: ... + def getSerialNumber(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setLotNumber(self, string: java.lang.String | str) -> None: ... + def setManufacturer(self, string: java.lang.String | str) -> None: ... + def setModel(self, string: java.lang.String | str) -> None: ... + def setSerialNumber(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class MetadataOnly(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, metadataOnly: MetadataOnly): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class MicrobeamManipulation(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, microbeamManipulation: MicrobeamManipulation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addLightSourceSettings( + self, lightSourceSettings: LightSourceSettings + ) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearLightSourceSettingsList(self) -> None: ... + def copyLightSourceSettingsList(self) -> java.util.List[LightSourceSettings]: ... + def copyLinkedImageList(self) -> java.util.List[Image]: ... + def copyLinkedROIList(self) -> java.util.List[ROI]: ... + def getDescription(self) -> java.lang.String: ... + def getExperiment(self) -> Experiment: ... + def getID(self) -> java.lang.String: ... + def getLightSourceSettings(self, int: int) -> LightSourceSettings: ... + def getLinkedExperimenter(self) -> Experimenter: ... + def getLinkedImage(self, int: int) -> Image: ... + def getLinkedROI(self, int: int) -> ROI: ... + def getType(self) -> ome.xml.model.enums.MicrobeamManipulationType: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkExperimenter(self, experimenter: Experimenter) -> None: ... + def linkImage(self, image: Image) -> bool: ... + def linkROI(self, rOI: ROI) -> bool: ... + def removeLightSourceSettings( + self, lightSourceSettings: LightSourceSettings + ) -> None: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setExperiment(self, experiment: Experiment) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLightSourceSettings( + self, int: int, lightSourceSettings: LightSourceSettings + ) -> LightSourceSettings: ... + def setLinkedImage(self, int: int, image: Image) -> Image: ... + def setLinkedROI(self, int: int, rOI: ROI) -> ROI: ... + def setType( + self, microbeamManipulationType: ome.xml.model.enums.MicrobeamManipulationType + ) -> None: ... + def sizeOfLightSourceSettingsList(self) -> int: ... + def sizeOfLinkedImageList(self) -> int: ... + def sizeOfLinkedROIList(self) -> int: ... + def unlinkExperimenter(self, experimenter: Experimenter) -> None: ... + def unlinkImage(self, image: Image) -> bool: ... + def unlinkROI(self, rOI: ROI) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class OME(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, oME: OME): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addDataset(self, dataset: Dataset) -> None: ... + def addExperiment(self, experiment: Experiment) -> None: ... + def addExperimenter(self, experimenter: Experimenter) -> None: ... + def addExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> None: ... + def addFolder(self, folder: Folder) -> None: ... + def addImage(self, image: Image) -> None: ... + def addInstrument(self, instrument: Instrument) -> None: ... + def addPlate(self, plate: Plate) -> None: ... + def addProject(self, project: Project) -> None: ... + def addROI(self, rOI: ROI) -> None: ... + def addScreen(self, screen: Screen) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearDatasetList(self) -> None: ... + def clearExperimentList(self) -> None: ... + def clearExperimenterGroupList(self) -> None: ... + def clearExperimenterList(self) -> None: ... + def clearFolderList(self) -> None: ... + def clearImageList(self) -> None: ... + def clearInstrumentList(self) -> None: ... + def clearPlateList(self) -> None: ... + def clearProjectList(self) -> None: ... + def clearROIList(self) -> None: ... + def clearScreenList(self) -> None: ... + def copyDatasetList(self) -> java.util.List[Dataset]: ... + def copyExperimentList(self) -> java.util.List[Experiment]: ... + def copyExperimenterGroupList(self) -> java.util.List[ExperimenterGroup]: ... + def copyExperimenterList(self) -> java.util.List[Experimenter]: ... + def copyFolderList(self) -> java.util.List[Folder]: ... + def copyImageList(self) -> java.util.List[Image]: ... + def copyInstrumentList(self) -> java.util.List[Instrument]: ... + def copyPlateList(self) -> java.util.List[Plate]: ... + def copyProjectList(self) -> java.util.List[Project]: ... + def copyROIList(self) -> java.util.List[ROI]: ... + def copyScreenList(self) -> java.util.List[Screen]: ... + def getBinaryOnly(self) -> BinaryOnly: ... + def getCreator(self) -> java.lang.String: ... + def getDataset(self, int: int) -> Dataset: ... + def getExperiment(self, int: int) -> Experiment: ... + def getExperimenter(self, int: int) -> Experimenter: ... + def getExperimenterGroup(self, int: int) -> ExperimenterGroup: ... + def getFolder(self, int: int) -> Folder: ... + def getImage(self, int: int) -> Image: ... + def getInstrument(self, int: int) -> Instrument: ... + def getPlate(self, int: int) -> Plate: ... + def getProject(self, int: int) -> Project: ... + def getROI(self, int: int) -> ROI: ... + def getRights(self) -> Rights: ... + def getScreen(self, int: int) -> Screen: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getUUID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def removeDataset(self, dataset: Dataset) -> None: ... + def removeExperiment(self, experiment: Experiment) -> None: ... + def removeExperimenter(self, experimenter: Experimenter) -> None: ... + def removeExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> None: ... + def removeFolder(self, folder: Folder) -> None: ... + def removeImage(self, image: Image) -> None: ... + def removeInstrument(self, instrument: Instrument) -> None: ... + def removePlate(self, plate: Plate) -> None: ... + def removeProject(self, project: Project) -> None: ... + def removeROI(self, rOI: ROI) -> None: ... + def removeScreen(self, screen: Screen) -> None: ... + def setBinaryOnly(self, binaryOnly: BinaryOnly) -> None: ... + def setCreator(self, string: java.lang.String | str) -> None: ... + def setDataset(self, int: int, dataset: Dataset) -> Dataset: ... + def setExperiment(self, int: int, experiment: Experiment) -> Experiment: ... + def setExperimenter(self, int: int, experimenter: Experimenter) -> Experimenter: ... + def setExperimenterGroup( + self, int: int, experimenterGroup: ExperimenterGroup + ) -> ExperimenterGroup: ... + def setFolder(self, int: int, folder: Folder) -> Folder: ... + def setImage(self, int: int, image: Image) -> Image: ... + def setInstrument(self, int: int, instrument: Instrument) -> Instrument: ... + def setPlate(self, int: int, plate: Plate) -> Plate: ... + def setProject(self, int: int, project: Project) -> Project: ... + def setROI(self, int: int, rOI: ROI) -> ROI: ... + def setRights(self, rights: Rights) -> None: ... + def setScreen(self, int: int, screen: Screen) -> Screen: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setUUID(self, string: java.lang.String | str) -> None: ... + def sizeOfDatasetList(self) -> int: ... + def sizeOfExperimentList(self) -> int: ... + def sizeOfExperimenterGroupList(self) -> int: ... + def sizeOfExperimenterList(self) -> int: ... + def sizeOfFolderList(self) -> int: ... + def sizeOfImageList(self) -> int: ... + def sizeOfInstrumentList(self) -> int: ... + def sizeOfPlateList(self) -> int: ... + def sizeOfProjectList(self) -> int: ... + def sizeOfROIList(self) -> int: ... + def sizeOfScreenList(self) -> int: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Pixels(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, pixels: Pixels): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addBinData(self, binData: BinData) -> None: ... + def addChannel(self, channel: Channel) -> None: ... + def addPlane(self, plane: Plane) -> None: ... + def addTiffData(self, tiffData: TiffData) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearBinDataList(self) -> None: ... + def clearChannelList(self) -> None: ... + def clearPlaneList(self) -> None: ... + def clearTiffDataList(self) -> None: ... + def copyBinDataList(self) -> java.util.List[BinData]: ... + def copyChannelList(self) -> java.util.List[Channel]: ... + def copyPlaneList(self) -> java.util.List[Plane]: ... + def copyTiffDataList(self) -> java.util.List[TiffData]: ... + def getBigEndian(self) -> bool: ... + def getBinData(self, int: int) -> BinData: ... + def getChannel(self, int: int) -> Channel: ... + def getDimensionOrder(self) -> ome.xml.model.enums.DimensionOrder: ... + def getID(self) -> java.lang.String: ... + def getInterleaved(self) -> bool: ... + def getMetadataOnly(self) -> MetadataOnly: ... + def getPhysicalSizeX(self) -> ome.units.quantity.Length: ... + @staticmethod + def getPhysicalSizeXUnitXsdDefault() -> java.lang.String: ... + def getPhysicalSizeY(self) -> ome.units.quantity.Length: ... + @staticmethod + def getPhysicalSizeYUnitXsdDefault() -> java.lang.String: ... + def getPhysicalSizeZ(self) -> ome.units.quantity.Length: ... + @staticmethod + def getPhysicalSizeZUnitXsdDefault() -> java.lang.String: ... + def getPlane(self, int: int) -> Plane: ... + def getSignificantBits(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getSizeC(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getSizeT(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getSizeX(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getSizeY(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getSizeZ(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getTiffData(self, int: int) -> TiffData: ... + def getTimeIncrement(self) -> ome.units.quantity.Time: ... + @staticmethod + def getTimeIncrementUnitXsdDefault() -> java.lang.String: ... + def getType(self) -> ome.xml.model.enums.PixelType: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def removeBinData(self, binData: BinData) -> None: ... + def removeChannel(self, channel: Channel) -> None: ... + def removePlane(self, plane: Plane) -> None: ... + def removeTiffData(self, tiffData: TiffData) -> None: ... + def setBigEndian(self, boolean: bool) -> None: ... + def setBinData(self, int: int, binData: BinData) -> BinData: ... + def setChannel(self, int: int, channel: Channel) -> Channel: ... + def setDimensionOrder( + self, dimensionOrder: ome.xml.model.enums.DimensionOrder + ) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setInterleaved(self, boolean: bool) -> None: ... + def setMetadataOnly(self, metadataOnly: MetadataOnly) -> None: ... + def setPhysicalSizeX(self, length: ome.units.quantity.Length) -> None: ... + def setPhysicalSizeY(self, length: ome.units.quantity.Length) -> None: ... + def setPhysicalSizeZ(self, length: ome.units.quantity.Length) -> None: ... + def setPlane(self, int: int, plane: Plane) -> Plane: ... + def setSignificantBits( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setSizeC( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setSizeT( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setSizeX( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setSizeY( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setSizeZ( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setTiffData(self, int: int, tiffData: TiffData) -> TiffData: ... + def setTimeIncrement(self, time: ome.units.quantity.Time) -> None: ... + def setType(self, pixelType: ome.xml.model.enums.PixelType) -> None: ... + def sizeOfBinDataList(self) -> int: ... + def sizeOfChannelList(self) -> int: ... + def sizeOfPlaneList(self) -> int: ... + def sizeOfTiffDataList(self) -> int: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Plane(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, plane: Plane): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def getDeltaT(self) -> ome.units.quantity.Time: ... + @staticmethod + def getDeltaTUnitXsdDefault() -> java.lang.String: ... + def getExposureTime(self) -> ome.units.quantity.Time: ... + @staticmethod + def getExposureTimeUnitXsdDefault() -> java.lang.String: ... + def getHashSHA1(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getPixels(self) -> Pixels: ... + def getPositionX(self) -> ome.units.quantity.Length: ... + @staticmethod + def getPositionXUnitXsdDefault() -> java.lang.String: ... + def getPositionY(self) -> ome.units.quantity.Length: ... + @staticmethod + def getPositionYUnitXsdDefault() -> java.lang.String: ... + def getPositionZ(self) -> ome.units.quantity.Length: ... + @staticmethod + def getPositionZUnitXsdDefault() -> java.lang.String: ... + def getTheC(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTheT(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTheZ(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def setDeltaT(self, time: ome.units.quantity.Time) -> None: ... + def setExposureTime(self, time: ome.units.quantity.Time) -> None: ... + def setHashSHA1(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setPixels(self, pixels: Pixels) -> None: ... + def setPositionX(self, length: ome.units.quantity.Length) -> None: ... + def setPositionY(self, length: ome.units.quantity.Length) -> None: ... + def setPositionZ(self, length: ome.units.quantity.Length) -> None: ... + def setTheC( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setTheT( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setTheZ( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Plate(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, plate: Plate): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addPlateAcquisition(self, plateAcquisition: PlateAcquisition) -> None: ... + def addWell(self, well: Well) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearPlateAcquisitionList(self) -> None: ... + def clearWellList(self) -> None: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedScreenList(self) -> java.util.List[Screen]: ... + def copyPlateAcquisitionList(self) -> java.util.List[PlateAcquisition]: ... + def copyWellList(self) -> java.util.List[Well]: ... + def getColumnNamingConvention(self) -> ome.xml.model.enums.NamingConvention: ... + def getColumns(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getDescription(self) -> java.lang.String: ... + def getExternalIdentifier(self) -> java.lang.String: ... + def getFieldIndex(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedScreen(self, int: int) -> Screen: ... + def getName(self) -> java.lang.String: ... + def getPlateAcquisition(self, int: int) -> PlateAcquisition: ... + def getRowNamingConvention(self) -> ome.xml.model.enums.NamingConvention: ... + def getRows(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getStatus(self) -> java.lang.String: ... + def getWell(self, int: int) -> Well: ... + def getWellOriginX(self) -> ome.units.quantity.Length: ... + @staticmethod + def getWellOriginXUnitXsdDefault() -> java.lang.String: ... + def getWellOriginY(self) -> ome.units.quantity.Length: ... + @staticmethod + def getWellOriginYUnitXsdDefault() -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkScreen(self, screen: Screen) -> bool: ... + def removePlateAcquisition(self, plateAcquisition: PlateAcquisition) -> None: ... + def removeWell(self, well: Well) -> None: ... + def setColumnNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention + ) -> None: ... + def setColumns( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setExternalIdentifier(self, string: java.lang.String | str) -> None: ... + def setFieldIndex( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedScreen(self, int: int, screen: Screen) -> Screen: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setPlateAcquisition( + self, int: int, plateAcquisition: PlateAcquisition + ) -> PlateAcquisition: ... + def setRowNamingConvention( + self, namingConvention: ome.xml.model.enums.NamingConvention + ) -> None: ... + def setRows( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setStatus(self, string: java.lang.String | str) -> None: ... + def setWell(self, int: int, well: Well) -> Well: ... + def setWellOriginX(self, length: ome.units.quantity.Length) -> None: ... + def setWellOriginY(self, length: ome.units.quantity.Length) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedScreenList(self) -> int: ... + def sizeOfPlateAcquisitionList(self) -> int: ... + def sizeOfWellList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkScreen(self, screen: Screen) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class PlateAcquisition(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, plateAcquisition: PlateAcquisition): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedWellSampleList(self) -> java.util.List[WellSample]: ... + def getDescription(self) -> java.lang.String: ... + def getEndTime(self) -> ome.xml.model.primitives.Timestamp: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedWellSample(self, int: int) -> WellSample: ... + def getMaximumFieldCount(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getName(self) -> java.lang.String: ... + def getPlate(self) -> Plate: ... + def getStartTime(self) -> ome.xml.model.primitives.Timestamp: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkWellSample(self, wellSample: WellSample) -> bool: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setEndTime(self, timestamp: ome.xml.model.primitives.Timestamp) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedWellSample(self, int: int, wellSample: WellSample) -> WellSample: ... + def setMaximumFieldCount( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setPlate(self, plate: Plate) -> None: ... + def setStartTime(self, timestamp: ome.xml.model.primitives.Timestamp) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedWellSampleList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkWellSample(self, wellSample: WellSample) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Project(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, project: Project): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedDatasetList(self) -> java.util.List[Dataset]: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedDataset(self, int: int) -> Dataset: ... + def getLinkedExperimenter(self) -> Experimenter: ... + def getLinkedExperimenterGroup(self) -> ExperimenterGroup: ... + def getName(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkDataset(self, dataset: Dataset) -> bool: ... + def linkExperimenter(self, experimenter: Experimenter) -> None: ... + def linkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> None: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedDataset(self, int: int, dataset: Dataset) -> Dataset: ... + def setName(self, string: java.lang.String | str) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedDatasetList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkDataset(self, dataset: Dataset) -> bool: ... + def unlinkExperimenter(self, experimenter: Experimenter) -> None: ... + def unlinkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ROI(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, rOI: ROI): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedFolderList(self) -> java.util.List[Folder]: ... + def copyLinkedImageList(self) -> java.util.List[Image]: ... + def copyLinkedMicrobeamManipulationList( + self, + ) -> java.util.List[MicrobeamManipulation]: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedFolder(self, int: int) -> Folder: ... + def getLinkedImage(self, int: int) -> Image: ... + def getLinkedMicrobeamManipulation(self, int: int) -> MicrobeamManipulation: ... + def getName(self) -> java.lang.String: ... + def getUnion(self) -> Union: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkFolder(self, folder: Folder) -> bool: ... + def linkImage(self, image: Image) -> bool: ... + def linkMicrobeamManipulation( + self, microbeamManipulation: MicrobeamManipulation + ) -> bool: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedFolder(self, int: int, folder: Folder) -> Folder: ... + def setLinkedImage(self, int: int, image: Image) -> Image: ... + def setLinkedMicrobeamManipulation( + self, int: int, microbeamManipulation: MicrobeamManipulation + ) -> MicrobeamManipulation: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setUnion(self, union: Union) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedFolderList(self) -> int: ... + def sizeOfLinkedImageList(self) -> int: ... + def sizeOfLinkedMicrobeamManipulationList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkFolder(self, folder: Folder) -> bool: ... + def unlinkImage(self, image: Image) -> bool: ... + def unlinkMicrobeamManipulation( + self, microbeamManipulation: MicrobeamManipulation + ) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Reagent(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, reagent: Reagent): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedWellList(self) -> java.util.List[Well]: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedWell(self, int: int) -> Well: ... + def getName(self) -> java.lang.String: ... + def getReagentIdentifier(self) -> java.lang.String: ... + def getScreen(self) -> Screen: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkWell(self, well: Well) -> bool: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedWell(self, int: int, well: Well) -> Well: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setReagentIdentifier(self, string: java.lang.String | str) -> None: ... + def setScreen(self, screen: Screen) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedWellList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkWell(self, well: Well) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Reference(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, reference: Reference): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Rights(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, rights: Rights): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getRightsHeld(self) -> java.lang.String: ... + def getRightsHolder(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setRightsHeld(self, string: java.lang.String | str) -> None: ... + def setRightsHolder(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Screen(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, screen: Screen): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addReagent(self, reagent: Reagent) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearReagentList(self) -> None: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedPlateList(self) -> java.util.List[Plate]: ... + def copyReagentList(self) -> java.util.List[Reagent]: ... + def getDescription(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedPlate(self, int: int) -> Plate: ... + def getName(self) -> java.lang.String: ... + def getProtocolDescription(self) -> java.lang.String: ... + def getProtocolIdentifier(self) -> java.lang.String: ... + def getReagent(self, int: int) -> Reagent: ... + def getReagentSetDescription(self) -> java.lang.String: ... + def getReagentSetIdentifier(self) -> java.lang.String: ... + def getType(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkPlate(self, plate: Plate) -> bool: ... + def removeReagent(self, reagent: Reagent) -> None: ... + def setDescription(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedPlate(self, int: int, plate: Plate) -> Plate: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setProtocolDescription(self, string: java.lang.String | str) -> None: ... + def setProtocolIdentifier(self, string: java.lang.String | str) -> None: ... + def setReagent(self, int: int, reagent: Reagent) -> Reagent: ... + def setReagentSetDescription(self, string: java.lang.String | str) -> None: ... + def setReagentSetIdentifier(self, string: java.lang.String | str) -> None: ... + def setType(self, string: java.lang.String | str) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedPlateList(self) -> int: ... + def sizeOfReagentList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkPlate(self, plate: Plate) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Shape(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, shape: Shape): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def getFillColor(self) -> ome.xml.model.primitives.Color: ... + def getFillRule(self) -> ome.xml.model.enums.FillRule: ... + def getFontFamily(self) -> ome.xml.model.enums.FontFamily: ... + def getFontSize(self) -> ome.units.quantity.Length: ... + @staticmethod + def getFontSizeUnitXsdDefault() -> java.lang.String: ... + def getFontStyle(self) -> ome.xml.model.enums.FontStyle: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLocked(self) -> bool: ... + def getStrokeColor(self) -> ome.xml.model.primitives.Color: ... + def getStrokeDashArray(self) -> java.lang.String: ... + def getStrokeWidth(self) -> ome.units.quantity.Length: ... + @staticmethod + def getStrokeWidthUnitXsdDefault() -> java.lang.String: ... + def getText(self) -> java.lang.String: ... + def getTheC(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTheT(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTheZ(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getTransform(self) -> AffineTransform: ... + def getUnion(self) -> Union: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def setFillColor(self, color: ome.xml.model.primitives.Color) -> None: ... + def setFillRule(self, fillRule: ome.xml.model.enums.FillRule) -> None: ... + def setFontFamily(self, fontFamily: ome.xml.model.enums.FontFamily) -> None: ... + def setFontSize(self, length: ome.units.quantity.Length) -> None: ... + def setFontStyle(self, fontStyle: ome.xml.model.enums.FontStyle) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLocked(self, boolean: bool) -> None: ... + def setStrokeColor(self, color: ome.xml.model.primitives.Color) -> None: ... + def setStrokeDashArray(self, string: java.lang.String | str) -> None: ... + def setStrokeWidth(self, length: ome.units.quantity.Length) -> None: ... + def setText(self, string: java.lang.String | str) -> None: ... + def setTheC( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setTheT( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setTheZ( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setTransform(self, affineTransform: AffineTransform) -> None: ... + def setUnion(self, union: Union) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class StageLabel(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, stageLabel: StageLabel): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getName(self) -> java.lang.String: ... + def getX(self) -> ome.units.quantity.Length: ... + @staticmethod + def getXUnitXsdDefault() -> java.lang.String: ... + def getY(self) -> ome.units.quantity.Length: ... + @staticmethod + def getYUnitXsdDefault() -> java.lang.String: ... + def getZ(self) -> ome.units.quantity.Length: ... + @staticmethod + def getZUnitXsdDefault() -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setName(self, string: java.lang.String | str) -> None: ... + def setX(self, length: ome.units.quantity.Length) -> None: ... + def setY(self, length: ome.units.quantity.Length) -> None: ... + def setZ(self, length: ome.units.quantity.Length) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class StructuredAnnotations(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, structuredAnnotations: StructuredAnnotations): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addBooleanAnnotation(self, booleanAnnotation: BooleanAnnotation) -> None: ... + def addCommentAnnotation(self, commentAnnotation: CommentAnnotation) -> None: ... + def addDoubleAnnotation(self, doubleAnnotation: DoubleAnnotation) -> None: ... + def addFileAnnotation(self, fileAnnotation: FileAnnotation) -> None: ... + def addListAnnotation(self, listAnnotation: ListAnnotation) -> None: ... + def addLongAnnotation(self, longAnnotation: LongAnnotation) -> None: ... + def addMapAnnotation(self, mapAnnotation: MapAnnotation) -> None: ... + def addTagAnnotation(self, tagAnnotation: TagAnnotation) -> None: ... + def addTermAnnotation(self, termAnnotation: TermAnnotation) -> None: ... + def addTimestampAnnotation( + self, timestampAnnotation: TimestampAnnotation + ) -> None: ... + def addXMLAnnotation(self, xMLAnnotation: XMLAnnotation) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearBooleanAnnotationList(self) -> None: ... + def clearCommentAnnotationList(self) -> None: ... + def clearDoubleAnnotationList(self) -> None: ... + def clearFileAnnotationList(self) -> None: ... + def clearListAnnotationList(self) -> None: ... + def clearLongAnnotationList(self) -> None: ... + def clearMapAnnotationList(self) -> None: ... + def clearTagAnnotationList(self) -> None: ... + def clearTermAnnotationList(self) -> None: ... + def clearTimestampAnnotationList(self) -> None: ... + def clearXMLAnnotationList(self) -> None: ... + def copyBooleanAnnotationList(self) -> java.util.List[BooleanAnnotation]: ... + def copyCommentAnnotationList(self) -> java.util.List[CommentAnnotation]: ... + def copyDoubleAnnotationList(self) -> java.util.List[DoubleAnnotation]: ... + def copyFileAnnotationList(self) -> java.util.List[FileAnnotation]: ... + def copyListAnnotationList(self) -> java.util.List[ListAnnotation]: ... + def copyLongAnnotationList(self) -> java.util.List[LongAnnotation]: ... + def copyMapAnnotationList(self) -> java.util.List[MapAnnotation]: ... + def copyTagAnnotationList(self) -> java.util.List[TagAnnotation]: ... + def copyTermAnnotationList(self) -> java.util.List[TermAnnotation]: ... + def copyTimestampAnnotationList(self) -> java.util.List[TimestampAnnotation]: ... + def copyXMLAnnotationList(self) -> java.util.List[XMLAnnotation]: ... + def getBooleanAnnotation(self, int: int) -> BooleanAnnotation: ... + def getCommentAnnotation(self, int: int) -> CommentAnnotation: ... + def getDoubleAnnotation(self, int: int) -> DoubleAnnotation: ... + def getFileAnnotation(self, int: int) -> FileAnnotation: ... + def getListAnnotation(self, int: int) -> ListAnnotation: ... + def getLongAnnotation(self, int: int) -> LongAnnotation: ... + def getMapAnnotation(self, int: int) -> MapAnnotation: ... + def getTagAnnotation(self, int: int) -> TagAnnotation: ... + def getTermAnnotation(self, int: int) -> TermAnnotation: ... + def getTimestampAnnotation(self, int: int) -> TimestampAnnotation: ... + def getXMLAnnotation(self, int: int) -> XMLAnnotation: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def removeBooleanAnnotation(self, booleanAnnotation: BooleanAnnotation) -> None: ... + def removeCommentAnnotation(self, commentAnnotation: CommentAnnotation) -> None: ... + def removeDoubleAnnotation(self, doubleAnnotation: DoubleAnnotation) -> None: ... + def removeFileAnnotation(self, fileAnnotation: FileAnnotation) -> None: ... + def removeListAnnotation(self, listAnnotation: ListAnnotation) -> None: ... + def removeLongAnnotation(self, longAnnotation: LongAnnotation) -> None: ... + def removeMapAnnotation(self, mapAnnotation: MapAnnotation) -> None: ... + def removeTagAnnotation(self, tagAnnotation: TagAnnotation) -> None: ... + def removeTermAnnotation(self, termAnnotation: TermAnnotation) -> None: ... + def removeTimestampAnnotation( + self, timestampAnnotation: TimestampAnnotation + ) -> None: ... + def removeXMLAnnotation(self, xMLAnnotation: XMLAnnotation) -> None: ... + def setBooleanAnnotation( + self, int: int, booleanAnnotation: BooleanAnnotation + ) -> BooleanAnnotation: ... + def setCommentAnnotation( + self, int: int, commentAnnotation: CommentAnnotation + ) -> CommentAnnotation: ... + def setDoubleAnnotation( + self, int: int, doubleAnnotation: DoubleAnnotation + ) -> DoubleAnnotation: ... + def setFileAnnotation( + self, int: int, fileAnnotation: FileAnnotation + ) -> FileAnnotation: ... + def setListAnnotation( + self, int: int, listAnnotation: ListAnnotation + ) -> ListAnnotation: ... + def setLongAnnotation( + self, int: int, longAnnotation: LongAnnotation + ) -> LongAnnotation: ... + def setMapAnnotation( + self, int: int, mapAnnotation: MapAnnotation + ) -> MapAnnotation: ... + def setTagAnnotation( + self, int: int, tagAnnotation: TagAnnotation + ) -> TagAnnotation: ... + def setTermAnnotation( + self, int: int, termAnnotation: TermAnnotation + ) -> TermAnnotation: ... + def setTimestampAnnotation( + self, int: int, timestampAnnotation: TimestampAnnotation + ) -> TimestampAnnotation: ... + def setXMLAnnotation( + self, int: int, xMLAnnotation: XMLAnnotation + ) -> XMLAnnotation: ... + def sizeOfBooleanAnnotationList(self) -> int: ... + def sizeOfCommentAnnotationList(self) -> int: ... + def sizeOfDoubleAnnotationList(self) -> int: ... + def sizeOfFileAnnotationList(self) -> int: ... + def sizeOfListAnnotationList(self) -> int: ... + def sizeOfLongAnnotationList(self) -> int: ... + def sizeOfMapAnnotationList(self) -> int: ... + def sizeOfTagAnnotationList(self) -> int: ... + def sizeOfTermAnnotationList(self) -> int: ... + def sizeOfTimestampAnnotationList(self) -> int: ... + def sizeOfXMLAnnotationList(self) -> int: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class TiffData(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, tiffData: TiffData): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getFirstC(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getFirstT(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getFirstZ(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getIFD(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getPixels(self) -> Pixels: ... + def getPlaneCount(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getUUID(self) -> UUID: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setFirstC( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setFirstT( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setFirstZ( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setIFD( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setPixels(self, pixels: Pixels) -> None: ... + def setPlaneCount( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setUUID(self, uUID: UUID) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class TransmittanceRange(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, transmittanceRange: TransmittanceRange): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getCutIn(self) -> ome.units.quantity.Length: ... + def getCutInTolerance(self) -> ome.units.quantity.Length: ... + @staticmethod + def getCutInToleranceUnitXsdDefault() -> java.lang.String: ... + @staticmethod + def getCutInUnitXsdDefault() -> java.lang.String: ... + def getCutOut(self) -> ome.units.quantity.Length: ... + def getCutOutTolerance(self) -> ome.units.quantity.Length: ... + @staticmethod + def getCutOutToleranceUnitXsdDefault() -> java.lang.String: ... + @staticmethod + def getCutOutUnitXsdDefault() -> java.lang.String: ... + def getTransmittance(self) -> ome.xml.model.primitives.PercentFraction: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setCutIn(self, length: ome.units.quantity.Length) -> None: ... + def setCutInTolerance(self, length: ome.units.quantity.Length) -> None: ... + def setCutOut(self, length: ome.units.quantity.Length) -> None: ... + def setCutOutTolerance(self, length: ome.units.quantity.Length) -> None: ... + def setTransmittance( + self, percentFraction: ome.xml.model.primitives.PercentFraction + ) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class UUID(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, uUID: UUID): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getFileName(self) -> java.lang.String: ... + def getValue(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setFileName(self, string: java.lang.String | str) -> None: ... + def setValue(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Union(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, union: Union): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addShape(self, shape: Shape) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearShapeList(self) -> None: ... + def copyShapeList(self) -> java.util.List[Shape]: ... + def getShape(self, int: int) -> Shape: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def removeShape(self, shape: Shape) -> None: ... + def setShape(self, int: int, shape: Shape) -> Shape: ... + def sizeOfShapeList(self) -> int: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Well(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, well: Well): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + def addWellSample(self, wellSample: WellSample) -> None: ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def clearWellSampleList(self) -> None: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyWellSampleList(self) -> java.util.List[WellSample]: ... + def getColor(self) -> ome.xml.model.primitives.Color: ... + def getColumn(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getExternalDescription(self) -> java.lang.String: ... + def getExternalIdentifier(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedReagent(self) -> Reagent: ... + def getPlate(self) -> Plate: ... + def getRow(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getType(self) -> java.lang.String: ... + def getWellSample(self, int: int) -> WellSample: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkReagent(self, reagent: Reagent) -> None: ... + def removeWellSample(self, wellSample: WellSample) -> None: ... + def setColor(self, color: ome.xml.model.primitives.Color) -> None: ... + def setColumn( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setExternalDescription(self, string: java.lang.String | str) -> None: ... + def setExternalIdentifier(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setPlate(self, plate: Plate) -> None: ... + def setRow( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setType(self, string: java.lang.String | str) -> None: ... + def setWellSample(self, int: int, wellSample: WellSample) -> WellSample: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfWellSampleList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkReagent(self, reagent: Reagent) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class WellSample(AbstractOMEModelObject): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, wellSample: WellSample): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedPlateAcquisitionList(self) -> java.util.List[PlateAcquisition]: ... + def getID(self) -> java.lang.String: ... + def getIndex(self) -> ome.xml.model.primitives.NonNegativeInteger: ... + def getLinkedImage(self) -> Image: ... + def getLinkedPlateAcquisition(self, int: int) -> PlateAcquisition: ... + def getPositionX(self) -> ome.units.quantity.Length: ... + @staticmethod + def getPositionXUnitXsdDefault() -> java.lang.String: ... + def getPositionY(self) -> ome.units.quantity.Length: ... + @staticmethod + def getPositionYUnitXsdDefault() -> java.lang.String: ... + def getTimepoint(self) -> ome.xml.model.primitives.Timestamp: ... + def getWell(self) -> Well: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkImage(self, image: Image) -> None: ... + def linkPlateAcquisition(self, plateAcquisition: PlateAcquisition) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setIndex( + self, nonNegativeInteger: ome.xml.model.primitives.NonNegativeInteger + ) -> None: ... + def setLinkedPlateAcquisition( + self, int: int, plateAcquisition: PlateAcquisition + ) -> PlateAcquisition: ... + def setPositionX(self, length: ome.units.quantity.Length) -> None: ... + def setPositionY(self, length: ome.units.quantity.Length) -> None: ... + def setTimepoint(self, timestamp: ome.xml.model.primitives.Timestamp) -> None: ... + def setWell(self, well: Well) -> None: ... + def sizeOfLinkedPlateAcquisitionList(self) -> int: ... + def unlinkImage(self, image: Image) -> None: ... + def unlinkPlateAcquisition(self, plateAcquisition: PlateAcquisition) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class AnnotationRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, annotationRef: AnnotationRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class BasicAnnotation(Annotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, basicAnnotation: BasicAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ChannelRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, channelRef: ChannelRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class DatasetRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, datasetRef: DatasetRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Detector(ManufacturerSpec): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, detector: Detector): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def getAmplificationGain(self) -> float: ... + def getGain(self) -> float: ... + def getID(self) -> java.lang.String: ... + def getInstrument(self) -> Instrument: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getOffset(self) -> float: ... + def getType(self) -> ome.xml.model.enums.DetectorType: ... + def getVoltage(self) -> ome.units.quantity.ElectricPotential: ... + @staticmethod + def getVoltageUnitXsdDefault() -> java.lang.String: ... + def getZoom(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def setAmplificationGain(self, double: float) -> None: ... + def setGain(self, double: float) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setInstrument(self, instrument: Instrument) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setOffset(self, double: float) -> None: ... + def setType(self, detectorType: ome.xml.model.enums.DetectorType) -> None: ... + def setVoltage( + self, electricPotential: ome.units.quantity.ElectricPotential + ) -> None: ... + def setZoom(self, double: float) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Dichroic(ManufacturerSpec): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, dichroic: Dichroic): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedFilterSetList(self) -> java.util.List[FilterSet]: ... + def copyLinkedLightPathList(self) -> java.util.List[LightPath]: ... + def getID(self) -> java.lang.String: ... + def getInstrument(self) -> Instrument: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedFilterSet(self, int: int) -> FilterSet: ... + def getLinkedLightPath(self, int: int) -> LightPath: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkFilterSet(self, filterSet: FilterSet) -> bool: ... + def linkLightPath(self, lightPath: LightPath) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setInstrument(self, instrument: Instrument) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedFilterSet(self, int: int, filterSet: FilterSet) -> FilterSet: ... + def setLinkedLightPath(self, int: int, lightPath: LightPath) -> LightPath: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedFilterSetList(self) -> int: ... + def sizeOfLinkedLightPathList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkFilterSet(self, filterSet: FilterSet) -> bool: ... + def unlinkLightPath(self, lightPath: LightPath) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class DichroicRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, dichroicRef: DichroicRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Ellipse(Shape): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, ellipse: Ellipse): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getRadiusX(self) -> float: ... + def getRadiusY(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setRadiusX(self, double: float) -> None: ... + def setRadiusY(self, double: float) -> None: ... + def setX(self, double: float) -> None: ... + def setY(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ExperimentRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, experimentRef: ExperimentRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ExperimenterGroupRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, experimenterGroupRef: ExperimenterGroupRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ExperimenterRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, experimenterRef: ExperimenterRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Filter(ManufacturerSpec): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, filter: Filter): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def copyLinkedFilterSetEmissionFilterList(self) -> java.util.List[FilterSet]: ... + def copyLinkedFilterSetExcitationFilterList(self) -> java.util.List[FilterSet]: ... + def copyLinkedLightPathEmissionFilterList(self) -> java.util.List[LightPath]: ... + def copyLinkedLightPathExcitationFilterList(self) -> java.util.List[LightPath]: ... + def getFilterWheel(self) -> java.lang.String: ... + def getID(self) -> java.lang.String: ... + def getInstrument(self) -> Instrument: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getLinkedFilterSetEmissionFilter(self, int: int) -> FilterSet: ... + def getLinkedFilterSetExcitationFilter(self, int: int) -> FilterSet: ... + def getLinkedLightPathEmissionFilter(self, int: int) -> LightPath: ... + def getLinkedLightPathExcitationFilter(self, int: int) -> LightPath: ... + def getTransmittanceRange(self) -> TransmittanceRange: ... + def getType(self) -> ome.xml.model.enums.FilterType: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def linkFilterSetEmissionFilter(self, filterSet: FilterSet) -> bool: ... + def linkFilterSetExcitationFilter(self, filterSet: FilterSet) -> bool: ... + def linkLightPathEmissionFilter(self, lightPath: LightPath) -> bool: ... + def linkLightPathExcitationFilter(self, lightPath: LightPath) -> bool: ... + def setFilterWheel(self, string: java.lang.String | str) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setInstrument(self, instrument: Instrument) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setLinkedFilterSetEmissionFilter( + self, int: int, filterSet: FilterSet + ) -> FilterSet: ... + def setLinkedFilterSetExcitationFilter( + self, int: int, filterSet: FilterSet + ) -> FilterSet: ... + def setLinkedLightPathEmissionFilter( + self, int: int, lightPath: LightPath + ) -> LightPath: ... + def setLinkedLightPathExcitationFilter( + self, int: int, lightPath: LightPath + ) -> LightPath: ... + def setTransmittanceRange(self, transmittanceRange: TransmittanceRange) -> None: ... + def setType(self, filterType: ome.xml.model.enums.FilterType) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def sizeOfLinkedFilterSetEmissionFilterList(self) -> int: ... + def sizeOfLinkedFilterSetExcitationFilterList(self) -> int: ... + def sizeOfLinkedLightPathEmissionFilterList(self) -> int: ... + def sizeOfLinkedLightPathExcitationFilterList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def unlinkFilterSetEmissionFilter(self, filterSet: FilterSet) -> bool: ... + def unlinkFilterSetExcitationFilter(self, filterSet: FilterSet) -> bool: ... + def unlinkLightPathEmissionFilter(self, lightPath: LightPath) -> bool: ... + def unlinkLightPathExcitationFilter(self, lightPath: LightPath) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class FilterRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, filterRef: FilterRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class FilterSet(ManufacturerSpec): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, filterSet: FilterSet): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedChannelList(self) -> java.util.List[Channel]: ... + def copyLinkedEmissionFilterList(self) -> java.util.List[Filter]: ... + def copyLinkedExcitationFilterList(self) -> java.util.List[Filter]: ... + def getID(self) -> java.lang.String: ... + def getInstrument(self) -> Instrument: ... + def getLinkedChannel(self, int: int) -> Channel: ... + def getLinkedDichroic(self) -> Dichroic: ... + def getLinkedEmissionFilter(self, int: int) -> Filter: ... + def getLinkedExcitationFilter(self, int: int) -> Filter: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkChannel(self, channel: Channel) -> bool: ... + def linkDichroic(self, dichroic: Dichroic) -> None: ... + def linkEmissionFilter(self, filter: Filter) -> bool: ... + def linkExcitationFilter(self, filter: Filter) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setInstrument(self, instrument: Instrument) -> None: ... + def setLinkedChannel(self, int: int, channel: Channel) -> Channel: ... + def setLinkedEmissionFilter(self, int: int, filter: Filter) -> Filter: ... + def setLinkedExcitationFilter(self, int: int, filter: Filter) -> Filter: ... + def sizeOfLinkedChannelList(self) -> int: ... + def sizeOfLinkedEmissionFilterList(self) -> int: ... + def sizeOfLinkedExcitationFilterList(self) -> int: ... + def unlinkChannel(self, channel: Channel) -> bool: ... + def unlinkDichroic(self, dichroic: Dichroic) -> None: ... + def unlinkEmissionFilter(self, filter: Filter) -> bool: ... + def unlinkExcitationFilter(self, filter: Filter) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class FilterSetRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, filterSetRef: FilterSetRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class FolderRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, folderRef: FolderRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ImageRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, imageRef: ImageRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class InstrumentRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, instrumentRef: InstrumentRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Label(Shape): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, label: Label): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setX(self, double: float) -> None: ... + def setY(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Leader(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, leader: Leader): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedExperimenterGroupList(self) -> java.util.List[ExperimenterGroup]: ... + def getID(self) -> java.lang.String: ... + def getLinkedExperimenterGroup(self, int: int) -> ExperimenterGroup: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedExperimenterGroup( + self, int: int, experimenterGroup: ExperimenterGroup + ) -> ExperimenterGroup: ... + def sizeOfLinkedExperimenterGroupList(self) -> int: ... + def unlinkExperimenterGroup(self, experimenterGroup: ExperimenterGroup) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class LightSource(ManufacturerSpec): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, lightSource: LightSource): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def getID(self) -> java.lang.String: ... + def getInstrument(self) -> Instrument: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getPower(self) -> ome.units.quantity.Power: ... + @staticmethod + def getPowerUnitXsdDefault() -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setInstrument(self, instrument: Instrument) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setPower(self, power: ome.units.quantity.Power) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Line(Shape): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, line: Line): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getMarkerEnd(self) -> ome.xml.model.enums.Marker: ... + def getMarkerStart(self) -> ome.xml.model.enums.Marker: ... + def getX1(self) -> float: ... + def getX2(self) -> float: ... + def getY1(self) -> float: ... + def getY2(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setMarkerEnd(self, marker: ome.xml.model.enums.Marker) -> None: ... + def setMarkerStart(self, marker: ome.xml.model.enums.Marker) -> None: ... + def setX1(self, double: float) -> None: ... + def setX2(self, double: float) -> None: ... + def setY1(self, double: float) -> None: ... + def setY2(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ListAnnotation(Annotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, listAnnotation: ListAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class MapAnnotation(Annotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, mapAnnotation: MapAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getValue(self) -> java.util.List[MapPair]: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setValue(self, list: java.util.List[MapPair]) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Mask(Shape): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, mask: Mask): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getBinData(self) -> BinData: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setBinData(self, binData: BinData) -> None: ... + def setHeight(self, double: float) -> None: ... + def setWidth(self, double: float) -> None: ... + def setX(self, double: float) -> None: ... + def setY(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class MicrobeamManipulationRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, microbeamManipulationRef: MicrobeamManipulationRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Microscope(ManufacturerSpec): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, microscope: Microscope): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getType(self) -> ome.xml.model.enums.MicroscopeType: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setType(self, microscopeType: ome.xml.model.enums.MicroscopeType) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Objective(ManufacturerSpec): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, objective: Objective): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedAnnotationList(self) -> java.util.List[Annotation]: ... + def getCalibratedMagnification(self) -> float: ... + def getCorrection(self) -> ome.xml.model.enums.Correction: ... + def getID(self) -> java.lang.String: ... + def getImmersion(self) -> ome.xml.model.enums.Immersion: ... + def getInstrument(self) -> Instrument: ... + def getIris(self) -> bool: ... + def getLensNA(self) -> float: ... + def getLinkedAnnotation(self, int: int) -> Annotation: ... + def getNominalMagnification(self) -> float: ... + def getWorkingDistance(self) -> ome.units.quantity.Length: ... + @staticmethod + def getWorkingDistanceUnitXsdDefault() -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkAnnotation(self, annotation: Annotation) -> bool: ... + def setCalibratedMagnification(self, double: float) -> None: ... + def setCorrection(self, correction: ome.xml.model.enums.Correction) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setImmersion(self, immersion: ome.xml.model.enums.Immersion) -> None: ... + def setInstrument(self, instrument: Instrument) -> None: ... + def setIris(self, boolean: bool) -> None: ... + def setLensNA(self, double: float) -> None: ... + def setLinkedAnnotation(self, int: int, annotation: Annotation) -> Annotation: ... + def setNominalMagnification(self, double: float) -> None: ... + def setWorkingDistance(self, length: ome.units.quantity.Length) -> None: ... + def sizeOfLinkedAnnotationList(self) -> int: ... + def unlinkAnnotation(self, annotation: Annotation) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class PlateRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, plateRef: PlateRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Point(Shape): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, point: Point): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setX(self, double: float) -> None: ... + def setY(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Polygon(Shape): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, polygon: Polygon): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getPoints(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setPoints(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Polyline(Shape): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, polyline: Polyline): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getMarkerEnd(self) -> ome.xml.model.enums.Marker: ... + def getMarkerStart(self) -> ome.xml.model.enums.Marker: ... + def getPoints(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setMarkerEnd(self, marker: ome.xml.model.enums.Marker) -> None: ... + def setMarkerStart(self, marker: ome.xml.model.enums.Marker) -> None: ... + def setPoints(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ProjectRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, projectRef: ProjectRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Pump(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, pump: Pump): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def copyLinkedLaserList(self) -> java.util.List[Laser]: ... + def getID(self) -> java.lang.String: ... + def getLinkedLaser(self, int: int) -> Laser: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkLaser(self, laser: Laser) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLinkedLaser(self, int: int, laser: Laser) -> Laser: ... + def sizeOfLinkedLaserList(self) -> int: ... + def unlinkLaser(self, laser: Laser) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ROIRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, rOIRef: ROIRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ReagentRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, reagentRef: ReagentRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Rectangle(Shape): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, rectangle: Rectangle): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getHeight(self) -> float: ... + def getWidth(self) -> float: ... + def getX(self) -> float: ... + def getY(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setHeight(self, double: float) -> None: ... + def setWidth(self, double: float) -> None: ... + def setX(self, double: float) -> None: ... + def setY(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Settings(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, settings: Settings): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class TextAnnotation(Annotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, textAnnotation: TextAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class TypeAnnotation(Annotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, typeAnnotation: TypeAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class WellSampleRef(Reference): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, wellSampleRef: WellSampleRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getID(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setID(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Arc(LightSource): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, arc: Arc): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getType(self) -> ome.xml.model.enums.ArcType: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setType(self, arcType: ome.xml.model.enums.ArcType) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class BooleanAnnotation(BasicAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, booleanAnnotation: BooleanAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getValue(self) -> bool: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setValue(self, boolean: bool) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class CommentAnnotation(TextAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, commentAnnotation: CommentAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getValue(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setValue(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class DetectorSettings(Settings): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, detectorSettings: DetectorSettings): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getBinning(self) -> ome.xml.model.enums.Binning: ... + def getDetector(self) -> Detector: ... + def getGain(self) -> float: ... + def getID(self) -> java.lang.String: ... + def getIntegration(self) -> ome.xml.model.primitives.PositiveInteger: ... + def getOffset(self) -> float: ... + def getReadOutRate(self) -> ome.units.quantity.Frequency: ... + @staticmethod + def getReadOutRateUnitXsdDefault() -> java.lang.String: ... + def getVoltage(self) -> ome.units.quantity.ElectricPotential: ... + @staticmethod + def getVoltageUnitXsdDefault() -> java.lang.String: ... + def getZoom(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setBinning(self, binning: ome.xml.model.enums.Binning) -> None: ... + def setDetector(self, detector: Detector) -> None: ... + def setGain(self, double: float) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setIntegration( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setOffset(self, double: float) -> None: ... + def setReadOutRate(self, frequency: ome.units.quantity.Frequency) -> None: ... + def setVoltage( + self, electricPotential: ome.units.quantity.ElectricPotential + ) -> None: ... + def setZoom(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class EmissionFilterRef(FilterRef): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, emissionFilterRef: EmissionFilterRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ExcitationFilterRef(FilterRef): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, excitationFilterRef: ExcitationFilterRef): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Filament(LightSource): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, filament: Filament): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getType(self) -> ome.xml.model.enums.FilamentType: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setType(self, filamentType: ome.xml.model.enums.FilamentType) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class FileAnnotation(TypeAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, fileAnnotation: FileAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getBinaryFile(self) -> BinaryFile: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setBinaryFile(self, binaryFile: BinaryFile) -> None: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class GenericExcitationSource(LightSource): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, genericExcitationSource: GenericExcitationSource): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getMap(self) -> java.util.List[MapPair]: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setMap(self, list: java.util.List[MapPair]) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class Laser(LightSource): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, laser: Laser): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getFrequencyMultiplication( + self, + ) -> ome.xml.model.primitives.PositiveInteger: ... + def getLaserMedium(self) -> ome.xml.model.enums.LaserMedium: ... + def getLinkedPump(self) -> LightSource: ... + def getPockelCell(self) -> bool: ... + def getPulse(self) -> ome.xml.model.enums.Pulse: ... + def getRepetitionRate(self) -> ome.units.quantity.Frequency: ... + @staticmethod + def getRepetitionRateUnitXsdDefault() -> java.lang.String: ... + def getTuneable(self) -> bool: ... + def getType(self) -> ome.xml.model.enums.LaserType: ... + def getWavelength(self) -> ome.units.quantity.Length: ... + @staticmethod + def getWavelengthUnitXsdDefault() -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def linkPump(self, lightSource: LightSource) -> None: ... + def setFrequencyMultiplication( + self, positiveInteger: ome.xml.model.primitives.PositiveInteger + ) -> None: ... + def setLaserMedium(self, laserMedium: ome.xml.model.enums.LaserMedium) -> None: ... + def setPockelCell(self, boolean: bool) -> None: ... + def setPulse(self, pulse: ome.xml.model.enums.Pulse) -> None: ... + def setRepetitionRate(self, frequency: ome.units.quantity.Frequency) -> None: ... + def setTuneable(self, boolean: bool) -> None: ... + def setType(self, laserType: ome.xml.model.enums.LaserType) -> None: ... + def setWavelength(self, length: ome.units.quantity.Length) -> None: ... + def unlinkPump(self, lightSource: LightSource) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class LightEmittingDiode(LightSource): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, lightEmittingDiode: LightEmittingDiode): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class LightSourceSettings(Settings): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, lightSourceSettings: LightSourceSettings): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getAttenuation(self) -> ome.xml.model.primitives.PercentFraction: ... + def getID(self) -> java.lang.String: ... + def getLightSource(self) -> LightSource: ... + def getMicrobeamManipulation(self) -> MicrobeamManipulation: ... + def getWavelength(self) -> ome.units.quantity.Length: ... + @staticmethod + def getWavelengthUnitXsdDefault() -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setAttenuation( + self, percentFraction: ome.xml.model.primitives.PercentFraction + ) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setLightSource(self, lightSource: LightSource) -> None: ... + def setMicrobeamManipulation( + self, microbeamManipulation: MicrobeamManipulation + ) -> None: ... + def setWavelength(self, length: ome.units.quantity.Length) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class NumericAnnotation(BasicAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, numericAnnotation: NumericAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class ObjectiveSettings(Settings): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, objectiveSettings: ObjectiveSettings): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getCorrectionCollar(self) -> float: ... + def getID(self) -> java.lang.String: ... + def getMedium(self) -> ome.xml.model.enums.Medium: ... + def getObjective(self) -> Objective: ... + def getRefractiveIndex(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setCorrectionCollar(self, double: float) -> None: ... + def setID(self, string: java.lang.String | str) -> None: ... + def setMedium(self, medium: ome.xml.model.enums.Medium) -> None: ... + def setObjective(self, objective: Objective) -> None: ... + def setRefractiveIndex(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class TagAnnotation(TextAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, tagAnnotation: TagAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getValue(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setValue(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class TermAnnotation(BasicAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, termAnnotation: TermAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getValue(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setValue(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class TimestampAnnotation(BasicAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, timestampAnnotation: TimestampAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getValue(self) -> ome.xml.model.primitives.Timestamp: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setValue(self, timestamp: ome.xml.model.primitives.Timestamp) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class XMLAnnotation(TextAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, xMLAnnotation: XMLAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getValue(self) -> java.lang.String: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setValue(self, string: java.lang.String | str) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class DoubleAnnotation(NumericAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, doubleAnnotation: DoubleAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getValue(self) -> float: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setValue(self, double: float) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class LongAnnotation(NumericAnnotation): + NAMESPACE: typing.ClassVar[java.lang.String] = ... + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, longAnnotation: LongAnnotation): ... + @typing.overload + def __init__(self, element: org.w3c.dom.Element, oMEModel: OMEModel): ... + @typing.overload + def asXMLElement(self, document: org.w3c.dom.Document) -> org.w3c.dom.Element: ... + @typing.overload + def asXMLElement( + self, document: org.w3c.dom.Document, element: org.w3c.dom.Element + ) -> org.w3c.dom.Element: ... + def getStructuredAnnotations(self) -> StructuredAnnotations: ... + def getValue(self) -> int: ... + def link(self, reference: Reference, oMEModelObject: OMEModelObject) -> bool: ... + def setStructuredAnnotations( + self, structuredAnnotations: StructuredAnnotations + ) -> None: ... + def setValue(self, long: int) -> None: ... + def update(self, element: org.w3c.dom.Element, oMEModel: OMEModel) -> None: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.xml.model")``. + + AbstractOMEModelObject: type[AbstractOMEModelObject] + AffineTransform: type[AffineTransform] + Annotation: type[Annotation] + AnnotationRef: type[AnnotationRef] + Arc: type[Arc] + BasicAnnotation: type[BasicAnnotation] + BinData: type[BinData] + BinaryFile: type[BinaryFile] + BinaryOnly: type[BinaryOnly] + BooleanAnnotation: type[BooleanAnnotation] + Channel: type[Channel] + ChannelRef: type[ChannelRef] + CommentAnnotation: type[CommentAnnotation] + Dataset: type[Dataset] + DatasetRef: type[DatasetRef] + Detector: type[Detector] + DetectorSettings: type[DetectorSettings] + Dichroic: type[Dichroic] + DichroicRef: type[DichroicRef] + DoubleAnnotation: type[DoubleAnnotation] + Ellipse: type[Ellipse] + EmissionFilterRef: type[EmissionFilterRef] + ExcitationFilterRef: type[ExcitationFilterRef] + Experiment: type[Experiment] + ExperimentRef: type[ExperimentRef] + Experimenter: type[Experimenter] + ExperimenterGroup: type[ExperimenterGroup] + ExperimenterGroupRef: type[ExperimenterGroupRef] + ExperimenterRef: type[ExperimenterRef] + External: type[External] + Filament: type[Filament] + FileAnnotation: type[FileAnnotation] + Filter: type[Filter] + FilterRef: type[FilterRef] + FilterSet: type[FilterSet] + FilterSetRef: type[FilterSetRef] + Folder: type[Folder] + FolderRef: type[FolderRef] + GenericExcitationSource: type[GenericExcitationSource] + Image: type[Image] + ImageRef: type[ImageRef] + ImagingEnvironment: type[ImagingEnvironment] + Instrument: type[Instrument] + InstrumentRef: type[InstrumentRef] + Label: type[Label] + Laser: type[Laser] + Leader: type[Leader] + LightEmittingDiode: type[LightEmittingDiode] + LightPath: type[LightPath] + LightSource: type[LightSource] + LightSourceSettings: type[LightSourceSettings] + Line: type[Line] + ListAnnotation: type[ListAnnotation] + LongAnnotation: type[LongAnnotation] + ManufacturerSpec: type[ManufacturerSpec] + MapAnnotation: type[MapAnnotation] + MapPair: type[MapPair] + Mask: type[Mask] + MetadataOnly: type[MetadataOnly] + MicrobeamManipulation: type[MicrobeamManipulation] + MicrobeamManipulationRef: type[MicrobeamManipulationRef] + Microscope: type[Microscope] + NumericAnnotation: type[NumericAnnotation] + OME: type[OME] + OMEModel: type[OMEModel] + OMEModelImpl: type[OMEModelImpl] + OMEModelObject: type[OMEModelObject] + Objective: type[Objective] + ObjectiveSettings: type[ObjectiveSettings] + Pixels: type[Pixels] + Plane: type[Plane] + Plate: type[Plate] + PlateAcquisition: type[PlateAcquisition] + PlateRef: type[PlateRef] + Point: type[Point] + Polygon: type[Polygon] + Polyline: type[Polyline] + Project: type[Project] + ProjectRef: type[ProjectRef] + Pump: type[Pump] + ROI: type[ROI] + ROIRef: type[ROIRef] + Reagent: type[Reagent] + ReagentRef: type[ReagentRef] + Rectangle: type[Rectangle] + Reference: type[Reference] + ReferenceList: type[ReferenceList] + Rights: type[Rights] + Screen: type[Screen] + Settings: type[Settings] + Shape: type[Shape] + StageLabel: type[StageLabel] + StructuredAnnotations: type[StructuredAnnotations] + TagAnnotation: type[TagAnnotation] + TermAnnotation: type[TermAnnotation] + TextAnnotation: type[TextAnnotation] + TiffData: type[TiffData] + TimestampAnnotation: type[TimestampAnnotation] + TransmittanceRange: type[TransmittanceRange] + TypeAnnotation: type[TypeAnnotation] + UUID: type[UUID] + Union: type[Union] + Well: type[Well] + WellSample: type[WellSample] + WellSampleRef: type[WellSampleRef] + XMLAnnotation: type[XMLAnnotation] + enums: ome.xml.model.enums.__module_protocol__ + primitives: ome.xml.model.primitives.__module_protocol__ diff --git a/typings/ome/xml/model/enums/__init__.pyi b/typings/ome/xml/model/enums/__init__.pyi new file mode 100644 index 0000000..c63600c --- /dev/null +++ b/typings/ome/xml/model/enums/__init__.pyi @@ -0,0 +1,1064 @@ +import typing +from typing import Protocol + +import java.lang +import ome.units.quantity +import ome.xml.model.enums.handlers +import ome.xml.model.primitives + +class Enumeration: ... + +class EnumerationException(java.lang.Exception): + @typing.overload + def __init__(self): ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__( + self, string: java.lang.String | str, throwable: java.lang.Throwable + ): ... + @typing.overload + def __init__(self, throwable: java.lang.Throwable): ... + +class AcquisitionMode(java.lang.Enum["AcquisitionMode"], Enumeration): + WIDEFIELD: typing.ClassVar[AcquisitionMode] = ... + LASERSCANNINGCONFOCALMICROSCOPY: typing.ClassVar[AcquisitionMode] = ... + SPINNINGDISKCONFOCAL: typing.ClassVar[AcquisitionMode] = ... + SLITSCANCONFOCAL: typing.ClassVar[AcquisitionMode] = ... + MULTIPHOTONMICROSCOPY: typing.ClassVar[AcquisitionMode] = ... + STRUCTUREDILLUMINATION: typing.ClassVar[AcquisitionMode] = ... + SINGLEMOLECULEIMAGING: typing.ClassVar[AcquisitionMode] = ... + TOTALINTERNALREFLECTION: typing.ClassVar[AcquisitionMode] = ... + FLUORESCENCELIFETIME: typing.ClassVar[AcquisitionMode] = ... + SPECTRALIMAGING: typing.ClassVar[AcquisitionMode] = ... + FLUORESCENCECORRELATIONSPECTROSCOPY: typing.ClassVar[AcquisitionMode] = ... + NEARFIELDSCANNINGOPTICALMICROSCOPY: typing.ClassVar[AcquisitionMode] = ... + SECONDHARMONICGENERATIONIMAGING: typing.ClassVar[AcquisitionMode] = ... + PALM: typing.ClassVar[AcquisitionMode] = ... + STORM: typing.ClassVar[AcquisitionMode] = ... + STED: typing.ClassVar[AcquisitionMode] = ... + TIRF: typing.ClassVar[AcquisitionMode] = ... + FSM: typing.ClassVar[AcquisitionMode] = ... + LCM: typing.ClassVar[AcquisitionMode] = ... + OTHER: typing.ClassVar[AcquisitionMode] = ... + BRIGHTFIELD: typing.ClassVar[AcquisitionMode] = ... + SWEPTFIELDCONFOCAL: typing.ClassVar[AcquisitionMode] = ... + SPIM: typing.ClassVar[AcquisitionMode] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> AcquisitionMode: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> AcquisitionMode: ... + @staticmethod + def values() -> typing.MutableSequence[AcquisitionMode]: ... + +class ArcType(java.lang.Enum["ArcType"], Enumeration): + HG: typing.ClassVar[ArcType] = ... + XE: typing.ClassVar[ArcType] = ... + HGXE: typing.ClassVar[ArcType] = ... + OTHER: typing.ClassVar[ArcType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> ArcType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ArcType: ... + @staticmethod + def values() -> typing.MutableSequence[ArcType]: ... + +class Binning(java.lang.Enum["Binning"], Enumeration): + ONEBYONE: typing.ClassVar[Binning] = ... + TWOBYTWO: typing.ClassVar[Binning] = ... + FOURBYFOUR: typing.ClassVar[Binning] = ... + EIGHTBYEIGHT: typing.ClassVar[Binning] = ... + OTHER: typing.ClassVar[Binning] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> Binning: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Binning: ... + @staticmethod + def values() -> typing.MutableSequence[Binning]: ... + +class Compression(java.lang.Enum["Compression"], Enumeration): + ZLIB: typing.ClassVar[Compression] = ... + BZIP2: typing.ClassVar[Compression] = ... + NONE: typing.ClassVar[Compression] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> Compression: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Compression: ... + @staticmethod + def values() -> typing.MutableSequence[Compression]: ... + +class ContrastMethod(java.lang.Enum["ContrastMethod"], Enumeration): + BRIGHTFIELD: typing.ClassVar[ContrastMethod] = ... + PHASE: typing.ClassVar[ContrastMethod] = ... + DIC: typing.ClassVar[ContrastMethod] = ... + HOFFMANMODULATION: typing.ClassVar[ContrastMethod] = ... + OBLIQUEILLUMINATION: typing.ClassVar[ContrastMethod] = ... + POLARIZEDLIGHT: typing.ClassVar[ContrastMethod] = ... + DARKFIELD: typing.ClassVar[ContrastMethod] = ... + FLUORESCENCE: typing.ClassVar[ContrastMethod] = ... + OTHER: typing.ClassVar[ContrastMethod] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> ContrastMethod: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ContrastMethod: ... + @staticmethod + def values() -> typing.MutableSequence[ContrastMethod]: ... + +class Correction(java.lang.Enum["Correction"], Enumeration): + UV: typing.ClassVar[Correction] = ... + PLANAPO: typing.ClassVar[Correction] = ... + PLANFLUOR: typing.ClassVar[Correction] = ... + SUPERFLUOR: typing.ClassVar[Correction] = ... + VIOLETCORRECTED: typing.ClassVar[Correction] = ... + ACHRO: typing.ClassVar[Correction] = ... + ACHROMAT: typing.ClassVar[Correction] = ... + FLUOR: typing.ClassVar[Correction] = ... + FL: typing.ClassVar[Correction] = ... + FLUAR: typing.ClassVar[Correction] = ... + NEOFLUAR: typing.ClassVar[Correction] = ... + FLUOTAR: typing.ClassVar[Correction] = ... + APO: typing.ClassVar[Correction] = ... + PLANNEOFLUAR: typing.ClassVar[Correction] = ... + OTHER: typing.ClassVar[Correction] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> Correction: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Correction: ... + @staticmethod + def values() -> typing.MutableSequence[Correction]: ... + +class DetectorType(java.lang.Enum["DetectorType"], Enumeration): + CCD: typing.ClassVar[DetectorType] = ... + INTENSIFIEDCCD: typing.ClassVar[DetectorType] = ... + ANALOGVIDEO: typing.ClassVar[DetectorType] = ... + PMT: typing.ClassVar[DetectorType] = ... + PHOTODIODE: typing.ClassVar[DetectorType] = ... + SPECTROSCOPY: typing.ClassVar[DetectorType] = ... + LIFETIMEIMAGING: typing.ClassVar[DetectorType] = ... + CORRELATIONSPECTROSCOPY: typing.ClassVar[DetectorType] = ... + FTIR: typing.ClassVar[DetectorType] = ... + EMCCD: typing.ClassVar[DetectorType] = ... + APD: typing.ClassVar[DetectorType] = ... + CMOS: typing.ClassVar[DetectorType] = ... + EBCCD: typing.ClassVar[DetectorType] = ... + OTHER: typing.ClassVar[DetectorType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> DetectorType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> DetectorType: ... + @staticmethod + def values() -> typing.MutableSequence[DetectorType]: ... + +class DimensionOrder(java.lang.Enum["DimensionOrder"], Enumeration): + XYZCT: typing.ClassVar[DimensionOrder] = ... + XYZTC: typing.ClassVar[DimensionOrder] = ... + XYCTZ: typing.ClassVar[DimensionOrder] = ... + XYCZT: typing.ClassVar[DimensionOrder] = ... + XYTCZ: typing.ClassVar[DimensionOrder] = ... + XYTZC: typing.ClassVar[DimensionOrder] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> DimensionOrder: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> DimensionOrder: ... + @staticmethod + def values() -> typing.MutableSequence[DimensionOrder]: ... + +class ExperimentType(java.lang.Enum["ExperimentType"], Enumeration): + FP: typing.ClassVar[ExperimentType] = ... + FRET: typing.ClassVar[ExperimentType] = ... + TIMELAPSE: typing.ClassVar[ExperimentType] = ... + FOURDPLUS: typing.ClassVar[ExperimentType] = ... + SCREEN: typing.ClassVar[ExperimentType] = ... + IMMUNOCYTOCHEMISTRY: typing.ClassVar[ExperimentType] = ... + IMMUNOFLUORESCENCE: typing.ClassVar[ExperimentType] = ... + FISH: typing.ClassVar[ExperimentType] = ... + ELECTROPHYSIOLOGY: typing.ClassVar[ExperimentType] = ... + IONIMAGING: typing.ClassVar[ExperimentType] = ... + COLOCALIZATION: typing.ClassVar[ExperimentType] = ... + PGIDOCUMENTATION: typing.ClassVar[ExperimentType] = ... + FLUORESCENCELIFETIME: typing.ClassVar[ExperimentType] = ... + SPECTRALIMAGING: typing.ClassVar[ExperimentType] = ... + PHOTOBLEACHING: typing.ClassVar[ExperimentType] = ... + SPIM: typing.ClassVar[ExperimentType] = ... + OTHER: typing.ClassVar[ExperimentType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> ExperimentType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> ExperimentType: ... + @staticmethod + def values() -> typing.MutableSequence[ExperimentType]: ... + +class FilamentType(java.lang.Enum["FilamentType"], Enumeration): + INCANDESCENT: typing.ClassVar[FilamentType] = ... + HALOGEN: typing.ClassVar[FilamentType] = ... + OTHER: typing.ClassVar[FilamentType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> FilamentType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> FilamentType: ... + @staticmethod + def values() -> typing.MutableSequence[FilamentType]: ... + +class FillRule(java.lang.Enum["FillRule"], Enumeration): + EVENODD: typing.ClassVar[FillRule] = ... + NONZERO: typing.ClassVar[FillRule] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> FillRule: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> FillRule: ... + @staticmethod + def values() -> typing.MutableSequence[FillRule]: ... + +class FilterType(java.lang.Enum["FilterType"], Enumeration): + DICHROIC: typing.ClassVar[FilterType] = ... + LONGPASS: typing.ClassVar[FilterType] = ... + SHORTPASS: typing.ClassVar[FilterType] = ... + BANDPASS: typing.ClassVar[FilterType] = ... + MULTIPASS: typing.ClassVar[FilterType] = ... + NEUTRALDENSITY: typing.ClassVar[FilterType] = ... + TUNEABLE: typing.ClassVar[FilterType] = ... + OTHER: typing.ClassVar[FilterType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> FilterType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> FilterType: ... + @staticmethod + def values() -> typing.MutableSequence[FilterType]: ... + +class FontFamily(java.lang.Enum["FontFamily"], Enumeration): + SERIF: typing.ClassVar[FontFamily] = ... + SANSSERIF: typing.ClassVar[FontFamily] = ... + CURSIVE: typing.ClassVar[FontFamily] = ... + FANTASY: typing.ClassVar[FontFamily] = ... + MONOSPACE: typing.ClassVar[FontFamily] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> FontFamily: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> FontFamily: ... + @staticmethod + def values() -> typing.MutableSequence[FontFamily]: ... + +class FontStyle(java.lang.Enum["FontStyle"], Enumeration): + BOLD: typing.ClassVar[FontStyle] = ... + BOLDITALIC: typing.ClassVar[FontStyle] = ... + ITALIC: typing.ClassVar[FontStyle] = ... + NORMAL: typing.ClassVar[FontStyle] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> FontStyle: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> FontStyle: ... + @staticmethod + def values() -> typing.MutableSequence[FontStyle]: ... + +class IlluminationType(java.lang.Enum["IlluminationType"], Enumeration): + TRANSMITTED: typing.ClassVar[IlluminationType] = ... + EPIFLUORESCENCE: typing.ClassVar[IlluminationType] = ... + OBLIQUE: typing.ClassVar[IlluminationType] = ... + NONLINEAR: typing.ClassVar[IlluminationType] = ... + OTHER: typing.ClassVar[IlluminationType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> IlluminationType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> IlluminationType: ... + @staticmethod + def values() -> typing.MutableSequence[IlluminationType]: ... + +class Immersion(java.lang.Enum["Immersion"], Enumeration): + OIL: typing.ClassVar[Immersion] = ... + WATER: typing.ClassVar[Immersion] = ... + WATERDIPPING: typing.ClassVar[Immersion] = ... + AIR: typing.ClassVar[Immersion] = ... + MULTI: typing.ClassVar[Immersion] = ... + GLYCEROL: typing.ClassVar[Immersion] = ... + OTHER: typing.ClassVar[Immersion] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> Immersion: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Immersion: ... + @staticmethod + def values() -> typing.MutableSequence[Immersion]: ... + +class LaserMedium(java.lang.Enum["LaserMedium"], Enumeration): + CU: typing.ClassVar[LaserMedium] = ... + AG: typing.ClassVar[LaserMedium] = ... + ARFL: typing.ClassVar[LaserMedium] = ... + ARCL: typing.ClassVar[LaserMedium] = ... + KRFL: typing.ClassVar[LaserMedium] = ... + KRCL: typing.ClassVar[LaserMedium] = ... + XEFL: typing.ClassVar[LaserMedium] = ... + XECL: typing.ClassVar[LaserMedium] = ... + XEBR: typing.ClassVar[LaserMedium] = ... + N: typing.ClassVar[LaserMedium] = ... + AR: typing.ClassVar[LaserMedium] = ... + KR: typing.ClassVar[LaserMedium] = ... + XE: typing.ClassVar[LaserMedium] = ... + HENE: typing.ClassVar[LaserMedium] = ... + HECD: typing.ClassVar[LaserMedium] = ... + CO: typing.ClassVar[LaserMedium] = ... + CO2: typing.ClassVar[LaserMedium] = ... + H2O: typing.ClassVar[LaserMedium] = ... + HFL: typing.ClassVar[LaserMedium] = ... + NDGLASS: typing.ClassVar[LaserMedium] = ... + NDYAG: typing.ClassVar[LaserMedium] = ... + ERGLASS: typing.ClassVar[LaserMedium] = ... + ERYAG: typing.ClassVar[LaserMedium] = ... + HOYLF: typing.ClassVar[LaserMedium] = ... + HOYAG: typing.ClassVar[LaserMedium] = ... + RUBY: typing.ClassVar[LaserMedium] = ... + TISAPPHIRE: typing.ClassVar[LaserMedium] = ... + ALEXANDRITE: typing.ClassVar[LaserMedium] = ... + RHODAMINE6G: typing.ClassVar[LaserMedium] = ... + COUMARINC30: typing.ClassVar[LaserMedium] = ... + GAAS: typing.ClassVar[LaserMedium] = ... + GAALAS: typing.ClassVar[LaserMedium] = ... + EMINUS: typing.ClassVar[LaserMedium] = ... + OTHER: typing.ClassVar[LaserMedium] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> LaserMedium: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> LaserMedium: ... + @staticmethod + def values() -> typing.MutableSequence[LaserMedium]: ... + +class LaserType(java.lang.Enum["LaserType"], Enumeration): + EXCIMER: typing.ClassVar[LaserType] = ... + GAS: typing.ClassVar[LaserType] = ... + METALVAPOR: typing.ClassVar[LaserType] = ... + SOLIDSTATE: typing.ClassVar[LaserType] = ... + DYE: typing.ClassVar[LaserType] = ... + SEMICONDUCTOR: typing.ClassVar[LaserType] = ... + FREEELECTRON: typing.ClassVar[LaserType] = ... + OTHER: typing.ClassVar[LaserType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> LaserType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> LaserType: ... + @staticmethod + def values() -> typing.MutableSequence[LaserType]: ... + +class Marker(java.lang.Enum["Marker"], Enumeration): + ARROW: typing.ClassVar[Marker] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> Marker: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Marker: ... + @staticmethod + def values() -> typing.MutableSequence[Marker]: ... + +class Medium(java.lang.Enum["Medium"], Enumeration): + AIR: typing.ClassVar[Medium] = ... + OIL: typing.ClassVar[Medium] = ... + WATER: typing.ClassVar[Medium] = ... + GLYCEROL: typing.ClassVar[Medium] = ... + OTHER: typing.ClassVar[Medium] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> Medium: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Medium: ... + @staticmethod + def values() -> typing.MutableSequence[Medium]: ... + +class MicrobeamManipulationType( + java.lang.Enum["MicrobeamManipulationType"], Enumeration +): + FRAP: typing.ClassVar[MicrobeamManipulationType] = ... + FLIP: typing.ClassVar[MicrobeamManipulationType] = ... + INVERSEFRAP: typing.ClassVar[MicrobeamManipulationType] = ... + PHOTOABLATION: typing.ClassVar[MicrobeamManipulationType] = ... + PHOTOACTIVATION: typing.ClassVar[MicrobeamManipulationType] = ... + UNCAGING: typing.ClassVar[MicrobeamManipulationType] = ... + OPTICALTRAPPING: typing.ClassVar[MicrobeamManipulationType] = ... + OTHER: typing.ClassVar[MicrobeamManipulationType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> MicrobeamManipulationType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> MicrobeamManipulationType: ... + @staticmethod + def values() -> typing.MutableSequence[MicrobeamManipulationType]: ... + +class MicroscopeType(java.lang.Enum["MicroscopeType"], Enumeration): + UPRIGHT: typing.ClassVar[MicroscopeType] = ... + INVERTED: typing.ClassVar[MicroscopeType] = ... + DISSECTION: typing.ClassVar[MicroscopeType] = ... + ELECTROPHYSIOLOGY: typing.ClassVar[MicroscopeType] = ... + OTHER: typing.ClassVar[MicroscopeType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> MicroscopeType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> MicroscopeType: ... + @staticmethod + def values() -> typing.MutableSequence[MicroscopeType]: ... + +class NamingConvention(java.lang.Enum["NamingConvention"], Enumeration): + LETTER: typing.ClassVar[NamingConvention] = ... + NUMBER: typing.ClassVar[NamingConvention] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> NamingConvention: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> NamingConvention: ... + @staticmethod + def values() -> typing.MutableSequence[NamingConvention]: ... + +class PixelType(java.lang.Enum["PixelType"], Enumeration): + INT8: typing.ClassVar[PixelType] = ... + INT16: typing.ClassVar[PixelType] = ... + INT32: typing.ClassVar[PixelType] = ... + UINT8: typing.ClassVar[PixelType] = ... + UINT16: typing.ClassVar[PixelType] = ... + UINT32: typing.ClassVar[PixelType] = ... + FLOAT: typing.ClassVar[PixelType] = ... + DOUBLE: typing.ClassVar[PixelType] = ... + COMPLEXFLOAT: typing.ClassVar[PixelType] = ... + COMPLEXDOUBLE: typing.ClassVar[PixelType] = ... + BIT: typing.ClassVar[PixelType] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> PixelType: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> PixelType: ... + @staticmethod + def values() -> typing.MutableSequence[PixelType]: ... + +class Pulse(java.lang.Enum["Pulse"], Enumeration): + CW: typing.ClassVar[Pulse] = ... + SINGLE: typing.ClassVar[Pulse] = ... + QSWITCHED: typing.ClassVar[Pulse] = ... + REPETITIVE: typing.ClassVar[Pulse] = ... + MODELOCKED: typing.ClassVar[Pulse] = ... + OTHER: typing.ClassVar[Pulse] = ... + @staticmethod + def fromString(string: java.lang.String | str) -> Pulse: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> Pulse: ... + @staticmethod + def values() -> typing.MutableSequence[Pulse]: ... + +class UnitsElectricPotential(java.lang.Enum["UnitsElectricPotential"], Enumeration): + YOTTAVOLT: typing.ClassVar[UnitsElectricPotential] = ... + ZETTAVOLT: typing.ClassVar[UnitsElectricPotential] = ... + EXAVOLT: typing.ClassVar[UnitsElectricPotential] = ... + PETAVOLT: typing.ClassVar[UnitsElectricPotential] = ... + TERAVOLT: typing.ClassVar[UnitsElectricPotential] = ... + GIGAVOLT: typing.ClassVar[UnitsElectricPotential] = ... + MEGAVOLT: typing.ClassVar[UnitsElectricPotential] = ... + KILOVOLT: typing.ClassVar[UnitsElectricPotential] = ... + HECTOVOLT: typing.ClassVar[UnitsElectricPotential] = ... + DECAVOLT: typing.ClassVar[UnitsElectricPotential] = ... + VOLT: typing.ClassVar[UnitsElectricPotential] = ... + DECIVOLT: typing.ClassVar[UnitsElectricPotential] = ... + CENTIVOLT: typing.ClassVar[UnitsElectricPotential] = ... + MILLIVOLT: typing.ClassVar[UnitsElectricPotential] = ... + MICROVOLT: typing.ClassVar[UnitsElectricPotential] = ... + NANOVOLT: typing.ClassVar[UnitsElectricPotential] = ... + PICOVOLT: typing.ClassVar[UnitsElectricPotential] = ... + FEMTOVOLT: typing.ClassVar[UnitsElectricPotential] = ... + ATTOVOLT: typing.ClassVar[UnitsElectricPotential] = ... + ZEPTOVOLT: typing.ClassVar[UnitsElectricPotential] = ... + YOCTOVOLT: typing.ClassVar[UnitsElectricPotential] = ... + _create_0__T = typing.TypeVar("_create_0__T", bound=java.lang.Number) # + _create_1__T = typing.TypeVar( + "_create_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def create( + t: _create_0__T, unitsElectricPotential: UnitsElectricPotential + ) -> ome.units.quantity.ElectricPotential: ... + @typing.overload + @staticmethod + def create( + t: _create_1__T, unitsElectricPotential: UnitsElectricPotential + ) -> ome.units.quantity.ElectricPotential: ... + @staticmethod + def fromString(string: java.lang.String | str) -> UnitsElectricPotential: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> UnitsElectricPotential: ... + @staticmethod + def values() -> typing.MutableSequence[UnitsElectricPotential]: ... + +class UnitsFrequency(java.lang.Enum["UnitsFrequency"], Enumeration): + YOTTAHERTZ: typing.ClassVar[UnitsFrequency] = ... + ZETTAHERTZ: typing.ClassVar[UnitsFrequency] = ... + EXAHERTZ: typing.ClassVar[UnitsFrequency] = ... + PETAHERTZ: typing.ClassVar[UnitsFrequency] = ... + TERAHERTZ: typing.ClassVar[UnitsFrequency] = ... + GIGAHERTZ: typing.ClassVar[UnitsFrequency] = ... + MEGAHERTZ: typing.ClassVar[UnitsFrequency] = ... + KILOHERTZ: typing.ClassVar[UnitsFrequency] = ... + HECTOHERTZ: typing.ClassVar[UnitsFrequency] = ... + DECAHERTZ: typing.ClassVar[UnitsFrequency] = ... + HERTZ: typing.ClassVar[UnitsFrequency] = ... + DECIHERTZ: typing.ClassVar[UnitsFrequency] = ... + CENTIHERTZ: typing.ClassVar[UnitsFrequency] = ... + MILLIHERTZ: typing.ClassVar[UnitsFrequency] = ... + MICROHERTZ: typing.ClassVar[UnitsFrequency] = ... + NANOHERTZ: typing.ClassVar[UnitsFrequency] = ... + PICOHERTZ: typing.ClassVar[UnitsFrequency] = ... + FEMTOHERTZ: typing.ClassVar[UnitsFrequency] = ... + ATTOHERTZ: typing.ClassVar[UnitsFrequency] = ... + ZEPTOHERTZ: typing.ClassVar[UnitsFrequency] = ... + YOCTOHERTZ: typing.ClassVar[UnitsFrequency] = ... + _create_0__T = typing.TypeVar("_create_0__T", bound=java.lang.Number) # + _create_1__T = typing.TypeVar( + "_create_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def create( + t: _create_0__T, unitsFrequency: UnitsFrequency + ) -> ome.units.quantity.Frequency: ... + @typing.overload + @staticmethod + def create( + t: _create_1__T, unitsFrequency: UnitsFrequency + ) -> ome.units.quantity.Frequency: ... + @staticmethod + def fromString(string: java.lang.String | str) -> UnitsFrequency: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> UnitsFrequency: ... + @staticmethod + def values() -> typing.MutableSequence[UnitsFrequency]: ... + +class UnitsLength(java.lang.Enum["UnitsLength"], Enumeration): + YOTTAMETER: typing.ClassVar[UnitsLength] = ... + ZETTAMETER: typing.ClassVar[UnitsLength] = ... + EXAMETER: typing.ClassVar[UnitsLength] = ... + PETAMETER: typing.ClassVar[UnitsLength] = ... + TERAMETER: typing.ClassVar[UnitsLength] = ... + GIGAMETER: typing.ClassVar[UnitsLength] = ... + MEGAMETER: typing.ClassVar[UnitsLength] = ... + KILOMETER: typing.ClassVar[UnitsLength] = ... + HECTOMETER: typing.ClassVar[UnitsLength] = ... + DECAMETER: typing.ClassVar[UnitsLength] = ... + METER: typing.ClassVar[UnitsLength] = ... + DECIMETER: typing.ClassVar[UnitsLength] = ... + CENTIMETER: typing.ClassVar[UnitsLength] = ... + MILLIMETER: typing.ClassVar[UnitsLength] = ... + MICROMETER: typing.ClassVar[UnitsLength] = ... + NANOMETER: typing.ClassVar[UnitsLength] = ... + PICOMETER: typing.ClassVar[UnitsLength] = ... + FEMTOMETER: typing.ClassVar[UnitsLength] = ... + ATTOMETER: typing.ClassVar[UnitsLength] = ... + ZEPTOMETER: typing.ClassVar[UnitsLength] = ... + YOCTOMETER: typing.ClassVar[UnitsLength] = ... + ANGSTROM: typing.ClassVar[UnitsLength] = ... + THOU: typing.ClassVar[UnitsLength] = ... + LINE: typing.ClassVar[UnitsLength] = ... + INCH: typing.ClassVar[UnitsLength] = ... + FOOT: typing.ClassVar[UnitsLength] = ... + YARD: typing.ClassVar[UnitsLength] = ... + MILE: typing.ClassVar[UnitsLength] = ... + ASTRONOMICALUNIT: typing.ClassVar[UnitsLength] = ... + LIGHTYEAR: typing.ClassVar[UnitsLength] = ... + PARSEC: typing.ClassVar[UnitsLength] = ... + POINT: typing.ClassVar[UnitsLength] = ... + PIXEL: typing.ClassVar[UnitsLength] = ... + REFERENCEFRAME: typing.ClassVar[UnitsLength] = ... + _create_0__T = typing.TypeVar("_create_0__T", bound=java.lang.Number) # + _create_1__T = typing.TypeVar( + "_create_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def create( + t: _create_0__T, unitsLength: UnitsLength + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def create( + t: _create_1__T, unitsLength: UnitsLength + ) -> ome.units.quantity.Length: ... + @staticmethod + def fromString(string: java.lang.String | str) -> UnitsLength: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> UnitsLength: ... + @staticmethod + def values() -> typing.MutableSequence[UnitsLength]: ... + +class UnitsPower(java.lang.Enum["UnitsPower"], Enumeration): + YOTTAWATT: typing.ClassVar[UnitsPower] = ... + ZETTAWATT: typing.ClassVar[UnitsPower] = ... + EXAWATT: typing.ClassVar[UnitsPower] = ... + PETAWATT: typing.ClassVar[UnitsPower] = ... + TERAWATT: typing.ClassVar[UnitsPower] = ... + GIGAWATT: typing.ClassVar[UnitsPower] = ... + MEGAWATT: typing.ClassVar[UnitsPower] = ... + KILOWATT: typing.ClassVar[UnitsPower] = ... + HECTOWATT: typing.ClassVar[UnitsPower] = ... + DECAWATT: typing.ClassVar[UnitsPower] = ... + WATT: typing.ClassVar[UnitsPower] = ... + DECIWATT: typing.ClassVar[UnitsPower] = ... + CENTIWATT: typing.ClassVar[UnitsPower] = ... + MILLIWATT: typing.ClassVar[UnitsPower] = ... + MICROWATT: typing.ClassVar[UnitsPower] = ... + NANOWATT: typing.ClassVar[UnitsPower] = ... + PICOWATT: typing.ClassVar[UnitsPower] = ... + FEMTOWATT: typing.ClassVar[UnitsPower] = ... + ATTOWATT: typing.ClassVar[UnitsPower] = ... + ZEPTOWATT: typing.ClassVar[UnitsPower] = ... + YOCTOWATT: typing.ClassVar[UnitsPower] = ... + _create_0__T = typing.TypeVar("_create_0__T", bound=java.lang.Number) # + _create_1__T = typing.TypeVar( + "_create_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def create(t: _create_0__T, unitsPower: UnitsPower) -> ome.units.quantity.Power: ... + @typing.overload + @staticmethod + def create(t: _create_1__T, unitsPower: UnitsPower) -> ome.units.quantity.Power: ... + @staticmethod + def fromString(string: java.lang.String | str) -> UnitsPower: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> UnitsPower: ... + @staticmethod + def values() -> typing.MutableSequence[UnitsPower]: ... + +class UnitsPressure(java.lang.Enum["UnitsPressure"], Enumeration): + YOTTAPASCAL: typing.ClassVar[UnitsPressure] = ... + ZETTAPASCAL: typing.ClassVar[UnitsPressure] = ... + EXAPASCAL: typing.ClassVar[UnitsPressure] = ... + PETAPASCAL: typing.ClassVar[UnitsPressure] = ... + TERAPASCAL: typing.ClassVar[UnitsPressure] = ... + GIGAPASCAL: typing.ClassVar[UnitsPressure] = ... + MEGAPASCAL: typing.ClassVar[UnitsPressure] = ... + KILOPASCAL: typing.ClassVar[UnitsPressure] = ... + HECTOPASCAL: typing.ClassVar[UnitsPressure] = ... + DECAPASCAL: typing.ClassVar[UnitsPressure] = ... + PASCAL: typing.ClassVar[UnitsPressure] = ... + DECIPASCAL: typing.ClassVar[UnitsPressure] = ... + CENTIPASCAL: typing.ClassVar[UnitsPressure] = ... + MILLIPASCAL: typing.ClassVar[UnitsPressure] = ... + MICROPASCAL: typing.ClassVar[UnitsPressure] = ... + NANOPASCAL: typing.ClassVar[UnitsPressure] = ... + PICOPASCAL: typing.ClassVar[UnitsPressure] = ... + FEMTOPASCAL: typing.ClassVar[UnitsPressure] = ... + ATTOPASCAL: typing.ClassVar[UnitsPressure] = ... + ZEPTOPASCAL: typing.ClassVar[UnitsPressure] = ... + YOCTOPASCAL: typing.ClassVar[UnitsPressure] = ... + BAR: typing.ClassVar[UnitsPressure] = ... + MEGABAR: typing.ClassVar[UnitsPressure] = ... + KILOBAR: typing.ClassVar[UnitsPressure] = ... + DECIBAR: typing.ClassVar[UnitsPressure] = ... + CENTIBAR: typing.ClassVar[UnitsPressure] = ... + MILLIBAR: typing.ClassVar[UnitsPressure] = ... + ATMOSPHERE: typing.ClassVar[UnitsPressure] = ... + PSI: typing.ClassVar[UnitsPressure] = ... + TORR: typing.ClassVar[UnitsPressure] = ... + MILLITORR: typing.ClassVar[UnitsPressure] = ... + MMHG: typing.ClassVar[UnitsPressure] = ... + Pascal: typing.ClassVar[UnitsPressure] = ... + _create_0__T = typing.TypeVar("_create_0__T", bound=java.lang.Number) # + _create_1__T = typing.TypeVar( + "_create_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def create( + t: _create_0__T, unitsPressure: UnitsPressure + ) -> ome.units.quantity.Pressure: ... + @typing.overload + @staticmethod + def create( + t: _create_1__T, unitsPressure: UnitsPressure + ) -> ome.units.quantity.Pressure: ... + @staticmethod + def fromString(string: java.lang.String | str) -> UnitsPressure: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> UnitsPressure: ... + @staticmethod + def values() -> typing.MutableSequence[UnitsPressure]: ... + +class UnitsTemperature(java.lang.Enum["UnitsTemperature"], Enumeration): + CELSIUS: typing.ClassVar[UnitsTemperature] = ... + FAHRENHEIT: typing.ClassVar[UnitsTemperature] = ... + KELVIN: typing.ClassVar[UnitsTemperature] = ... + RANKINE: typing.ClassVar[UnitsTemperature] = ... + _create_0__T = typing.TypeVar("_create_0__T", bound=java.lang.Number) # + _create_1__T = typing.TypeVar( + "_create_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def create( + t: _create_0__T, unitsTemperature: UnitsTemperature + ) -> ome.units.quantity.Temperature: ... + @typing.overload + @staticmethod + def create( + t: _create_1__T, unitsTemperature: UnitsTemperature + ) -> ome.units.quantity.Temperature: ... + @staticmethod + def fromString(string: java.lang.String | str) -> UnitsTemperature: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> UnitsTemperature: ... + @staticmethod + def values() -> typing.MutableSequence[UnitsTemperature]: ... + +class UnitsTime(java.lang.Enum["UnitsTime"], Enumeration): + YOTTASECOND: typing.ClassVar[UnitsTime] = ... + ZETTASECOND: typing.ClassVar[UnitsTime] = ... + EXASECOND: typing.ClassVar[UnitsTime] = ... + PETASECOND: typing.ClassVar[UnitsTime] = ... + TERASECOND: typing.ClassVar[UnitsTime] = ... + GIGASECOND: typing.ClassVar[UnitsTime] = ... + MEGASECOND: typing.ClassVar[UnitsTime] = ... + KILOSECOND: typing.ClassVar[UnitsTime] = ... + HECTOSECOND: typing.ClassVar[UnitsTime] = ... + DECASECOND: typing.ClassVar[UnitsTime] = ... + SECOND: typing.ClassVar[UnitsTime] = ... + DECISECOND: typing.ClassVar[UnitsTime] = ... + CENTISECOND: typing.ClassVar[UnitsTime] = ... + MILLISECOND: typing.ClassVar[UnitsTime] = ... + MICROSECOND: typing.ClassVar[UnitsTime] = ... + NANOSECOND: typing.ClassVar[UnitsTime] = ... + PICOSECOND: typing.ClassVar[UnitsTime] = ... + FEMTOSECOND: typing.ClassVar[UnitsTime] = ... + ATTOSECOND: typing.ClassVar[UnitsTime] = ... + ZEPTOSECOND: typing.ClassVar[UnitsTime] = ... + YOCTOSECOND: typing.ClassVar[UnitsTime] = ... + MINUTE: typing.ClassVar[UnitsTime] = ... + HOUR: typing.ClassVar[UnitsTime] = ... + DAY: typing.ClassVar[UnitsTime] = ... + _create_0__T = typing.TypeVar("_create_0__T", bound=java.lang.Number) # + _create_1__T = typing.TypeVar( + "_create_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def create(t: _create_0__T, unitsTime: UnitsTime) -> ome.units.quantity.Time: ... + @typing.overload + @staticmethod + def create(t: _create_1__T, unitsTime: UnitsTime) -> ome.units.quantity.Time: ... + @staticmethod + def fromString(string: java.lang.String | str) -> UnitsTime: ... + def getValue(self) -> java.lang.String: ... + def toString(self) -> java.lang.String: ... + _valueOf_0__T = typing.TypeVar("_valueOf_0__T", bound=java.lang.Enum) # + @typing.overload + @staticmethod + def valueOf( + class_: type[_valueOf_0__T], string: java.lang.String | str + ) -> _valueOf_0__T: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> UnitsTime: ... + @staticmethod + def values() -> typing.MutableSequence[UnitsTime]: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.xml.model.enums")``. + + AcquisitionMode: type[AcquisitionMode] + ArcType: type[ArcType] + Binning: type[Binning] + Compression: type[Compression] + ContrastMethod: type[ContrastMethod] + Correction: type[Correction] + DetectorType: type[DetectorType] + DimensionOrder: type[DimensionOrder] + Enumeration: type[Enumeration] + EnumerationException: type[EnumerationException] + ExperimentType: type[ExperimentType] + FilamentType: type[FilamentType] + FillRule: type[FillRule] + FilterType: type[FilterType] + FontFamily: type[FontFamily] + FontStyle: type[FontStyle] + IlluminationType: type[IlluminationType] + Immersion: type[Immersion] + LaserMedium: type[LaserMedium] + LaserType: type[LaserType] + Marker: type[Marker] + Medium: type[Medium] + MicrobeamManipulationType: type[MicrobeamManipulationType] + MicroscopeType: type[MicroscopeType] + NamingConvention: type[NamingConvention] + PixelType: type[PixelType] + Pulse: type[Pulse] + UnitsElectricPotential: type[UnitsElectricPotential] + UnitsFrequency: type[UnitsFrequency] + UnitsLength: type[UnitsLength] + UnitsPower: type[UnitsPower] + UnitsPressure: type[UnitsPressure] + UnitsTemperature: type[UnitsTemperature] + UnitsTime: type[UnitsTime] + handlers: ome.xml.model.enums.handlers.__module_protocol__ diff --git a/typings/ome/xml/model/enums/handlers/__init__.pyi b/typings/ome/xml/model/enums/handlers/__init__.pyi new file mode 100644 index 0000000..33db88e --- /dev/null +++ b/typings/ome/xml/model/enums/handlers/__init__.pyi @@ -0,0 +1,452 @@ +import typing +from typing import Protocol + +import java.lang +import ome.units.quantity +import ome.units.unit +import ome.xml.model.enums +import ome.xml.model.primitives + +class IEnumerationHandler: + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class AcquisitionModeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class ArcTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class BinningEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class CompressionEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class ContrastMethodEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class CorrectionEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class DetectorTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class DimensionOrderEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class ExperimentTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class FilamentTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class FillRuleEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class FilterTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class FontFamilyEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class FontStyleEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class IlluminationTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class ImmersionEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class LaserMediumEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class LaserTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class MarkerEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class MediumEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class MicrobeamManipulationTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class MicroscopeTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class NamingConventionEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class PixelTypeEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class PulseEnumHandler(IEnumerationHandler): + def __init__(self): ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + +class UnitsElectricPotentialEnumHandler(IEnumerationHandler): + def __init__(self): ... + @staticmethod + def getBaseUnit( + unitsElectricPotential: ome.xml.model.enums.UnitsElectricPotential, + ) -> ome.units.unit.Unit[ome.units.quantity.ElectricPotential]: ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + @typing.overload + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + @typing.overload + def getEnumeration( + self, electricPotential: ome.units.quantity.ElectricPotential + ) -> ome.xml.model.enums.Enumeration: ... + _getQuantity_0__T = typing.TypeVar( + "_getQuantity_0__T", bound=java.lang.Number + ) # + _getQuantity_1__T = typing.TypeVar( + "_getQuantity_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_0__T, + unitsElectricPotential: ome.xml.model.enums.UnitsElectricPotential, + ) -> ome.units.quantity.ElectricPotential: ... + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_1__T, + unitsElectricPotential: ome.xml.model.enums.UnitsElectricPotential, + ) -> ome.units.quantity.ElectricPotential: ... + +class UnitsFrequencyEnumHandler(IEnumerationHandler): + def __init__(self): ... + @staticmethod + def getBaseUnit( + unitsFrequency: ome.xml.model.enums.UnitsFrequency, + ) -> ome.units.unit.Unit[ome.units.quantity.Frequency]: ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + @typing.overload + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + @typing.overload + def getEnumeration( + self, frequency: ome.units.quantity.Frequency + ) -> ome.xml.model.enums.Enumeration: ... + _getQuantity_0__T = typing.TypeVar( + "_getQuantity_0__T", bound=java.lang.Number + ) # + _getQuantity_1__T = typing.TypeVar( + "_getQuantity_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_0__T, unitsFrequency: ome.xml.model.enums.UnitsFrequency + ) -> ome.units.quantity.Frequency: ... + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_1__T, unitsFrequency: ome.xml.model.enums.UnitsFrequency + ) -> ome.units.quantity.Frequency: ... + +class UnitsLengthEnumHandler(IEnumerationHandler): + def __init__(self): ... + @staticmethod + def getBaseUnit( + unitsLength: ome.xml.model.enums.UnitsLength, + ) -> ome.units.unit.Unit[ome.units.quantity.Length]: ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + @typing.overload + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + @typing.overload + def getEnumeration( + self, length: ome.units.quantity.Length + ) -> ome.xml.model.enums.Enumeration: ... + _getQuantity_0__T = typing.TypeVar( + "_getQuantity_0__T", bound=java.lang.Number + ) # + _getQuantity_1__T = typing.TypeVar( + "_getQuantity_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_0__T, unitsLength: ome.xml.model.enums.UnitsLength + ) -> ome.units.quantity.Length: ... + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_1__T, unitsLength: ome.xml.model.enums.UnitsLength + ) -> ome.units.quantity.Length: ... + +class UnitsPowerEnumHandler(IEnumerationHandler): + def __init__(self): ... + @staticmethod + def getBaseUnit( + unitsPower: ome.xml.model.enums.UnitsPower, + ) -> ome.units.unit.Unit[ome.units.quantity.Power]: ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + @typing.overload + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + @typing.overload + def getEnumeration( + self, power: ome.units.quantity.Power + ) -> ome.xml.model.enums.Enumeration: ... + _getQuantity_0__T = typing.TypeVar( + "_getQuantity_0__T", bound=java.lang.Number + ) # + _getQuantity_1__T = typing.TypeVar( + "_getQuantity_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_0__T, unitsPower: ome.xml.model.enums.UnitsPower + ) -> ome.units.quantity.Power: ... + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_1__T, unitsPower: ome.xml.model.enums.UnitsPower + ) -> ome.units.quantity.Power: ... + +class UnitsPressureEnumHandler(IEnumerationHandler): + def __init__(self): ... + @staticmethod + def getBaseUnit( + unitsPressure: ome.xml.model.enums.UnitsPressure, + ) -> ome.units.unit.Unit[ome.units.quantity.Pressure]: ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + @typing.overload + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + @typing.overload + def getEnumeration( + self, pressure: ome.units.quantity.Pressure + ) -> ome.xml.model.enums.Enumeration: ... + _getQuantity_0__T = typing.TypeVar( + "_getQuantity_0__T", bound=java.lang.Number + ) # + _getQuantity_1__T = typing.TypeVar( + "_getQuantity_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_0__T, unitsPressure: ome.xml.model.enums.UnitsPressure + ) -> ome.units.quantity.Pressure: ... + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_1__T, unitsPressure: ome.xml.model.enums.UnitsPressure + ) -> ome.units.quantity.Pressure: ... + +class UnitsTemperatureEnumHandler(IEnumerationHandler): + def __init__(self): ... + @staticmethod + def getBaseUnit( + unitsTemperature: ome.xml.model.enums.UnitsTemperature, + ) -> ome.units.unit.Unit[ome.units.quantity.Temperature]: ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + @typing.overload + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + @typing.overload + def getEnumeration( + self, temperature: ome.units.quantity.Temperature + ) -> ome.xml.model.enums.Enumeration: ... + _getQuantity_0__T = typing.TypeVar( + "_getQuantity_0__T", bound=java.lang.Number + ) # + _getQuantity_1__T = typing.TypeVar( + "_getQuantity_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_0__T, unitsTemperature: ome.xml.model.enums.UnitsTemperature + ) -> ome.units.quantity.Temperature: ... + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_1__T, unitsTemperature: ome.xml.model.enums.UnitsTemperature + ) -> ome.units.quantity.Temperature: ... + +class UnitsTimeEnumHandler(IEnumerationHandler): + def __init__(self): ... + @staticmethod + def getBaseUnit( + unitsTime: ome.xml.model.enums.UnitsTime, + ) -> ome.units.unit.Unit[ome.units.quantity.Time]: ... + def getEntity(self) -> type[ome.xml.model.enums.Enumeration]: ... + @typing.overload + def getEnumeration( + self, string: java.lang.String | str + ) -> ome.xml.model.enums.Enumeration: ... + @typing.overload + def getEnumeration( + self, time: ome.units.quantity.Time + ) -> ome.xml.model.enums.Enumeration: ... + _getQuantity_0__T = typing.TypeVar( + "_getQuantity_0__T", bound=java.lang.Number + ) # + _getQuantity_1__T = typing.TypeVar( + "_getQuantity_1__T", bound=ome.xml.model.primitives.PrimitiveNumber + ) # + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_0__T, unitsTime: ome.xml.model.enums.UnitsTime + ) -> ome.units.quantity.Time: ... + @typing.overload + @staticmethod + def getQuantity( + t: _getQuantity_1__T, unitsTime: ome.xml.model.enums.UnitsTime + ) -> ome.units.quantity.Time: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.xml.model.enums.handlers")``. + + AcquisitionModeEnumHandler: type[AcquisitionModeEnumHandler] + ArcTypeEnumHandler: type[ArcTypeEnumHandler] + BinningEnumHandler: type[BinningEnumHandler] + CompressionEnumHandler: type[CompressionEnumHandler] + ContrastMethodEnumHandler: type[ContrastMethodEnumHandler] + CorrectionEnumHandler: type[CorrectionEnumHandler] + DetectorTypeEnumHandler: type[DetectorTypeEnumHandler] + DimensionOrderEnumHandler: type[DimensionOrderEnumHandler] + ExperimentTypeEnumHandler: type[ExperimentTypeEnumHandler] + FilamentTypeEnumHandler: type[FilamentTypeEnumHandler] + FillRuleEnumHandler: type[FillRuleEnumHandler] + FilterTypeEnumHandler: type[FilterTypeEnumHandler] + FontFamilyEnumHandler: type[FontFamilyEnumHandler] + FontStyleEnumHandler: type[FontStyleEnumHandler] + IEnumerationHandler: type[IEnumerationHandler] + IlluminationTypeEnumHandler: type[IlluminationTypeEnumHandler] + ImmersionEnumHandler: type[ImmersionEnumHandler] + LaserMediumEnumHandler: type[LaserMediumEnumHandler] + LaserTypeEnumHandler: type[LaserTypeEnumHandler] + MarkerEnumHandler: type[MarkerEnumHandler] + MediumEnumHandler: type[MediumEnumHandler] + MicrobeamManipulationTypeEnumHandler: type[MicrobeamManipulationTypeEnumHandler] + MicroscopeTypeEnumHandler: type[MicroscopeTypeEnumHandler] + NamingConventionEnumHandler: type[NamingConventionEnumHandler] + PixelTypeEnumHandler: type[PixelTypeEnumHandler] + PulseEnumHandler: type[PulseEnumHandler] + UnitsElectricPotentialEnumHandler: type[UnitsElectricPotentialEnumHandler] + UnitsFrequencyEnumHandler: type[UnitsFrequencyEnumHandler] + UnitsLengthEnumHandler: type[UnitsLengthEnumHandler] + UnitsPowerEnumHandler: type[UnitsPowerEnumHandler] + UnitsPressureEnumHandler: type[UnitsPressureEnumHandler] + UnitsTemperatureEnumHandler: type[UnitsTemperatureEnumHandler] + UnitsTimeEnumHandler: type[UnitsTimeEnumHandler] diff --git a/typings/ome/xml/model/primitives/__init__.pyi b/typings/ome/xml/model/primitives/__init__.pyi new file mode 100644 index 0000000..7b62d67 --- /dev/null +++ b/typings/ome/xml/model/primitives/__init__.pyi @@ -0,0 +1,117 @@ +import typing +from typing import Protocol + +import java.lang +import org.joda.time +import org.joda.time.format + +class PrimitiveNumber: + def getNumberValue(self) -> java.lang.Number: ... + +_PrimitiveType__T = typing.TypeVar("_PrimitiveType__T") # + +class PrimitiveType(typing.Generic[_PrimitiveType__T]): + def equals(self, object: typing.Any) -> bool: ... + def getValue(self) -> _PrimitiveType__T: ... + def toString(self) -> java.lang.String: ... + +class Color(PrimitiveType[int]): + @typing.overload + def __init__(self, int: int, int2: int, int3: int, int4: int): ... + @typing.overload + def __init__(self, integer: int): ... + def getAlpha(self) -> int: ... + def getBlue(self) -> int: ... + def getGreen(self) -> int: ... + def getRed(self) -> int: ... + @staticmethod + def valueOf(string: java.lang.String | str) -> Color: ... + +class NonNegativeFloat(PrimitiveType[float], PrimitiveNumber): + def __init__(self, double: float): ... + def getNumberValue(self) -> java.lang.Number: ... + @staticmethod + def valueOf(string: java.lang.String | str) -> NonNegativeFloat: ... + +class NonNegativeInteger(PrimitiveType[int], PrimitiveNumber): + def __init__(self, integer: int): ... + def getNumberValue(self) -> java.lang.Number: ... + @staticmethod + def valueOf(string: java.lang.String | str) -> NonNegativeInteger: ... + +class NonNegativeLong(PrimitiveType[int], PrimitiveNumber): + def __init__(self, long: int): ... + def getNumberValue(self) -> java.lang.Number: ... + @staticmethod + def valueOf(string: java.lang.String | str) -> NonNegativeLong: ... + +class PercentFraction(PrimitiveType[float], PrimitiveNumber): + def __init__(self, float: float): ... + def getNumberValue(self) -> java.lang.Number: ... + @staticmethod + def valueOf(string: java.lang.String | str) -> PercentFraction: ... + +class Timestamp(PrimitiveType[java.lang.String]): + ISO8601_FORMAT_MS: typing.ClassVar[java.lang.String] = ... + ISO8601_FORMAT_S: typing.ClassVar[java.lang.String] = ... + ISO8601_PARSER: typing.ClassVar[org.joda.time.format.DateTimeFormatter] = ... + ISO8601_FORMATTER_MS: typing.ClassVar[org.joda.time.format.DateTimeFormatter] = ... + ISO8601_FORMATTER_S: typing.ClassVar[org.joda.time.format.DateTimeFormatter] = ... + @typing.overload + def __init__(self, string: java.lang.String | str): ... + @typing.overload + def __init__(self, dateTime: org.joda.time.DateTime): ... + @typing.overload + def __init__(self, instant: org.joda.time.Instant): ... + def asDateTime( + self, dateTimeZone: org.joda.time.DateTimeZone + ) -> org.joda.time.DateTime: ... + def asInstant(self) -> org.joda.time.Instant: ... + def toString(self) -> java.lang.String: ... + @staticmethod + def valueOf(string: java.lang.String | str) -> Timestamp: ... + +class PositiveFloat(NonNegativeFloat): + def __init__(self, double: float): ... + def getNumberValue(self) -> java.lang.Number: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> NonNegativeFloat: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> PositiveFloat: ... + +class PositiveInteger(NonNegativeInteger): + def __init__(self, integer: int): ... + def getNumberValue(self) -> java.lang.Number: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> NonNegativeInteger: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> PositiveInteger: ... + +class PositiveLong(NonNegativeLong): + def __init__(self, long: int): ... + def getNumberValue(self) -> java.lang.Number: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> NonNegativeLong: ... + @typing.overload + @staticmethod + def valueOf(string: java.lang.String | str) -> PositiveLong: ... + +class __module_protocol__(Protocol): + # A module protocol which reflects the result of ``jp.JPackage("ome.xml.model.primitives")``. + + Color: type[Color] + NonNegativeFloat: type[NonNegativeFloat] + NonNegativeInteger: type[NonNegativeInteger] + NonNegativeLong: type[NonNegativeLong] + PercentFraction: type[PercentFraction] + PositiveFloat: type[PositiveFloat] + PositiveInteger: type[PositiveInteger] + PositiveLong: type[PositiveLong] + PrimitiveNumber: type[PrimitiveNumber] + PrimitiveType: type[PrimitiveType] + Timestamp: type[Timestamp] diff --git a/uv.lock b/uv.lock deleted file mode 100644 index 01dd872..0000000 --- a/uv.lock +++ /dev/null @@ -1,1446 +0,0 @@ -version = 1 -revision = 1 -requires-python = ">=3.9" -resolution-markers = [ - "python_full_version >= '3.11'", - "python_full_version == '3.10.*'", - "python_full_version < '3.10'", -] - -[[package]] -name = "annotated-types" -version = "0.7.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643 }, -] - -[[package]] -name = "asttokens" -version = "3.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 }, -] - -[[package]] -name = "bffile" -source = { editable = "." } -dependencies = [ - { name = "dask", version = "2024.8.0", source = { registry = "https://pypi.org/simple" }, extra = ["array"], marker = "python_full_version < '3.10'" }, - { name = "dask", version = "2025.3.0", source = { registry = "https://pypi.org/simple" }, extra = ["array"], marker = "python_full_version >= '3.10'" }, - { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "numpy", version = "2.2.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, - { name = "ome-types" }, - { name = "resource-backed-dask-array" }, - { name = "scyjava" }, -] - -[package.dev-dependencies] -dev = [ - { name = "ipython", version = "8.18.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, - { name = "ipython", version = "8.35.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" }, - { name = "ipython", version = "9.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, - { name = "mypy" }, - { name = "pdbpp", marker = "sys_platform != 'win32'" }, - { name = "pre-commit" }, - { name = "pyright" }, - { name = "pytest" }, - { name = "pytest-cov" }, - { name = "requests" }, - { name = "rich" }, - { name = "ruff" }, -] -test = [ - { name = "pytest" }, - { name = "pytest-cov" }, - { name = "requests" }, -] - -[package.metadata] -requires-dist = [ - { name = "dask", extras = ["array"], specifier = ">=2024.8.0" }, - { name = "numpy", specifier = ">=2.0.2" }, - { name = "ome-types", specifier = ">=0.6.1" }, - { name = "resource-backed-dask-array", specifier = ">=0.1.0" }, - { name = "scyjava", specifier = ">=1.10.2" }, -] - -[package.metadata.requires-dev] -dev = [ - { name = "ipython", specifier = ">=8.18.1" }, - { name = "mypy", specifier = ">=1.15.0" }, - { name = "pdbpp", marker = "sys_platform != 'win32'", specifier = ">=0.11.6" }, - { name = "pre-commit", specifier = ">=4.2.0" }, - { name = "pyright", specifier = ">=1.1.399" }, - { name = "pytest", specifier = ">=8.3.5" }, - { name = "pytest-cov", specifier = ">=6.1.1" }, - { name = "requests", specifier = ">=2.32.3" }, - { name = "rich", specifier = ">=14.0.0" }, - { name = "ruff", specifier = ">=0.11.6" }, -] -test = [ - { name = "pytest", specifier = ">=8.3.5" }, - { name = "pytest-cov", specifier = ">=6.1.1" }, - { name = "requests", specifier = ">=2.32.3" }, -] - -[[package]] -name = "certifi" -version = "2025.1.31" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1c/ab/c9f1e32b7b1bf505bf26f0ef697775960db7932abeb7b516de930ba2705f/certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651", size = 167577 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/38/fc/bce832fd4fd99766c04d1ee0eead6b0ec6486fb100ae5e74c1d91292b982/certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe", size = 166393 }, -] - -[[package]] -name = "cfgv" -version = "3.4.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/11/74/539e56497d9bd1d484fd863dd69cbbfa653cd2aa27abfe35653494d85e94/cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560", size = 7114 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c5/55/51844dd50c4fc7a33b653bfaba4c2456f06955289ca770a5dbd5fd267374/cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9", size = 7249 }, -] - -[[package]] -name = "charset-normalizer" -version = "3.4.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/16/b0/572805e227f01586461c80e0fd25d65a2115599cc9dad142fee4b747c357/charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3", size = 123188 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/58/5580c1716040bc89206c77d8f74418caf82ce519aae06450393ca73475d1/charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de", size = 198013 }, - { url = "https://files.pythonhosted.org/packages/d0/11/00341177ae71c6f5159a08168bcb98c6e6d196d372c94511f9f6c9afe0c6/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176", size = 141285 }, - { url = "https://files.pythonhosted.org/packages/01/09/11d684ea5819e5a8f5100fb0b38cf8d02b514746607934134d31233e02c8/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037", size = 151449 }, - { url = "https://files.pythonhosted.org/packages/08/06/9f5a12939db324d905dc1f70591ae7d7898d030d7662f0d426e2286f68c9/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f", size = 143892 }, - { url = "https://files.pythonhosted.org/packages/93/62/5e89cdfe04584cb7f4d36003ffa2936681b03ecc0754f8e969c2becb7e24/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a", size = 146123 }, - { url = "https://files.pythonhosted.org/packages/a9/ac/ab729a15c516da2ab70a05f8722ecfccc3f04ed7a18e45c75bbbaa347d61/charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a", size = 147943 }, - { url = "https://files.pythonhosted.org/packages/03/d2/3f392f23f042615689456e9a274640c1d2e5dd1d52de36ab8f7955f8f050/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247", size = 142063 }, - { url = "https://files.pythonhosted.org/packages/f2/e3/e20aae5e1039a2cd9b08d9205f52142329f887f8cf70da3650326670bddf/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408", size = 150578 }, - { url = "https://files.pythonhosted.org/packages/8d/af/779ad72a4da0aed925e1139d458adc486e61076d7ecdcc09e610ea8678db/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb", size = 153629 }, - { url = "https://files.pythonhosted.org/packages/c2/b6/7aa450b278e7aa92cf7732140bfd8be21f5f29d5bf334ae987c945276639/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d", size = 150778 }, - { url = "https://files.pythonhosted.org/packages/39/f4/d9f4f712d0951dcbfd42920d3db81b00dd23b6ab520419626f4023334056/charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807", size = 146453 }, - { url = "https://files.pythonhosted.org/packages/49/2b/999d0314e4ee0cff3cb83e6bc9aeddd397eeed693edb4facb901eb8fbb69/charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f", size = 95479 }, - { url = "https://files.pythonhosted.org/packages/2d/ce/3cbed41cff67e455a386fb5e5dd8906cdda2ed92fbc6297921f2e4419309/charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f", size = 102790 }, - { url = "https://files.pythonhosted.org/packages/72/80/41ef5d5a7935d2d3a773e3eaebf0a9350542f2cab4eac59a7a4741fbbbbe/charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125", size = 194995 }, - { url = "https://files.pythonhosted.org/packages/7a/28/0b9fefa7b8b080ec492110af6d88aa3dea91c464b17d53474b6e9ba5d2c5/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1", size = 139471 }, - { url = "https://files.pythonhosted.org/packages/71/64/d24ab1a997efb06402e3fc07317e94da358e2585165930d9d59ad45fcae2/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3", size = 149831 }, - { url = "https://files.pythonhosted.org/packages/37/ed/be39e5258e198655240db5e19e0b11379163ad7070962d6b0c87ed2c4d39/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd", size = 142335 }, - { url = "https://files.pythonhosted.org/packages/88/83/489e9504711fa05d8dde1574996408026bdbdbd938f23be67deebb5eca92/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00", size = 143862 }, - { url = "https://files.pythonhosted.org/packages/c6/c7/32da20821cf387b759ad24627a9aca289d2822de929b8a41b6241767b461/charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12", size = 145673 }, - { url = "https://files.pythonhosted.org/packages/68/85/f4288e96039abdd5aeb5c546fa20a37b50da71b5cf01e75e87f16cd43304/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77", size = 140211 }, - { url = "https://files.pythonhosted.org/packages/28/a3/a42e70d03cbdabc18997baf4f0227c73591a08041c149e710045c281f97b/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146", size = 148039 }, - { url = "https://files.pythonhosted.org/packages/85/e4/65699e8ab3014ecbe6f5c71d1a55d810fb716bbfd74f6283d5c2aa87febf/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd", size = 151939 }, - { url = "https://files.pythonhosted.org/packages/b1/82/8e9fe624cc5374193de6860aba3ea8070f584c8565ee77c168ec13274bd2/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6", size = 149075 }, - { url = "https://files.pythonhosted.org/packages/3d/7b/82865ba54c765560c8433f65e8acb9217cb839a9e32b42af4aa8e945870f/charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8", size = 144340 }, - { url = "https://files.pythonhosted.org/packages/b5/b6/9674a4b7d4d99a0d2df9b215da766ee682718f88055751e1e5e753c82db0/charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b", size = 95205 }, - { url = "https://files.pythonhosted.org/packages/1e/ab/45b180e175de4402dcf7547e4fb617283bae54ce35c27930a6f35b6bef15/charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76", size = 102441 }, - { url = "https://files.pythonhosted.org/packages/0a/9a/dd1e1cdceb841925b7798369a09279bd1cf183cef0f9ddf15a3a6502ee45/charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545", size = 196105 }, - { url = "https://files.pythonhosted.org/packages/d3/8c/90bfabf8c4809ecb648f39794cf2a84ff2e7d2a6cf159fe68d9a26160467/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7", size = 140404 }, - { url = "https://files.pythonhosted.org/packages/ad/8f/e410d57c721945ea3b4f1a04b74f70ce8fa800d393d72899f0a40526401f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757", size = 150423 }, - { url = "https://files.pythonhosted.org/packages/f0/b8/e6825e25deb691ff98cf5c9072ee0605dc2acfca98af70c2d1b1bc75190d/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa", size = 143184 }, - { url = "https://files.pythonhosted.org/packages/3e/a2/513f6cbe752421f16d969e32f3583762bfd583848b763913ddab8d9bfd4f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d", size = 145268 }, - { url = "https://files.pythonhosted.org/packages/74/94/8a5277664f27c3c438546f3eb53b33f5b19568eb7424736bdc440a88a31f/charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616", size = 147601 }, - { url = "https://files.pythonhosted.org/packages/7c/5f/6d352c51ee763623a98e31194823518e09bfa48be2a7e8383cf691bbb3d0/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b", size = 141098 }, - { url = "https://files.pythonhosted.org/packages/78/d4/f5704cb629ba5ab16d1d3d741396aec6dc3ca2b67757c45b0599bb010478/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d", size = 149520 }, - { url = "https://files.pythonhosted.org/packages/c5/96/64120b1d02b81785f222b976c0fb79a35875457fa9bb40827678e54d1bc8/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a", size = 152852 }, - { url = "https://files.pythonhosted.org/packages/84/c9/98e3732278a99f47d487fd3468bc60b882920cef29d1fa6ca460a1fdf4e6/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9", size = 150488 }, - { url = "https://files.pythonhosted.org/packages/13/0e/9c8d4cb99c98c1007cc11eda969ebfe837bbbd0acdb4736d228ccaabcd22/charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1", size = 146192 }, - { url = "https://files.pythonhosted.org/packages/b2/21/2b6b5b860781a0b49427309cb8670785aa543fb2178de875b87b9cc97746/charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35", size = 95550 }, - { url = "https://files.pythonhosted.org/packages/21/5b/1b390b03b1d16c7e382b561c5329f83cc06623916aab983e8ab9239c7d5c/charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f", size = 102785 }, - { url = "https://files.pythonhosted.org/packages/38/94/ce8e6f63d18049672c76d07d119304e1e2d7c6098f0841b51c666e9f44a0/charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda", size = 195698 }, - { url = "https://files.pythonhosted.org/packages/24/2e/dfdd9770664aae179a96561cc6952ff08f9a8cd09a908f259a9dfa063568/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313", size = 140162 }, - { url = "https://files.pythonhosted.org/packages/24/4e/f646b9093cff8fc86f2d60af2de4dc17c759de9d554f130b140ea4738ca6/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9", size = 150263 }, - { url = "https://files.pythonhosted.org/packages/5e/67/2937f8d548c3ef6e2f9aab0f6e21001056f692d43282b165e7c56023e6dd/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b", size = 142966 }, - { url = "https://files.pythonhosted.org/packages/52/ed/b7f4f07de100bdb95c1756d3a4d17b90c1a3c53715c1a476f8738058e0fa/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11", size = 144992 }, - { url = "https://files.pythonhosted.org/packages/96/2c/d49710a6dbcd3776265f4c923bb73ebe83933dfbaa841c5da850fe0fd20b/charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f", size = 147162 }, - { url = "https://files.pythonhosted.org/packages/b4/41/35ff1f9a6bd380303dea55e44c4933b4cc3c4850988927d4082ada230273/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd", size = 140972 }, - { url = "https://files.pythonhosted.org/packages/fb/43/c6a0b685fe6910d08ba971f62cd9c3e862a85770395ba5d9cad4fede33ab/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2", size = 149095 }, - { url = "https://files.pythonhosted.org/packages/4c/ff/a9a504662452e2d2878512115638966e75633519ec11f25fca3d2049a94a/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886", size = 152668 }, - { url = "https://files.pythonhosted.org/packages/6c/71/189996b6d9a4b932564701628af5cee6716733e9165af1d5e1b285c530ed/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601", size = 150073 }, - { url = "https://files.pythonhosted.org/packages/e4/93/946a86ce20790e11312c87c75ba68d5f6ad2208cfb52b2d6a2c32840d922/charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd", size = 145732 }, - { url = "https://files.pythonhosted.org/packages/cd/e5/131d2fb1b0dddafc37be4f3a2fa79aa4c037368be9423061dccadfd90091/charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407", size = 95391 }, - { url = "https://files.pythonhosted.org/packages/27/f2/4f9a69cc7712b9b5ad8fdb87039fd89abba997ad5cbe690d1835d40405b0/charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971", size = 102702 }, - { url = "https://files.pythonhosted.org/packages/7f/c0/b913f8f02836ed9ab32ea643c6fe4d3325c3d8627cf6e78098671cafff86/charset_normalizer-3.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b97e690a2118911e39b4042088092771b4ae3fc3aa86518f84b8cf6888dbdb41", size = 197867 }, - { url = "https://files.pythonhosted.org/packages/0f/6c/2bee440303d705b6fb1e2ec789543edec83d32d258299b16eed28aad48e0/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78baa6d91634dfb69ec52a463534bc0df05dbd546209b79a3880a34487f4b84f", size = 141385 }, - { url = "https://files.pythonhosted.org/packages/3d/04/cb42585f07f6f9fd3219ffb6f37d5a39b4fd2db2355b23683060029c35f7/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a2bc9f351a75ef49d664206d51f8e5ede9da246602dc2d2726837620ea034b2", size = 151367 }, - { url = "https://files.pythonhosted.org/packages/54/54/2412a5b093acb17f0222de007cc129ec0e0df198b5ad2ce5699355269dfe/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75832c08354f595c760a804588b9357d34ec00ba1c940c15e31e96d902093770", size = 143928 }, - { url = "https://files.pythonhosted.org/packages/5a/6d/e2773862b043dcf8a221342954f375392bb2ce6487bcd9f2c1b34e1d6781/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0af291f4fe114be0280cdd29d533696a77b5b49cfde5467176ecab32353395c4", size = 146203 }, - { url = "https://files.pythonhosted.org/packages/b9/f8/ca440ef60d8f8916022859885f231abb07ada3c347c03d63f283bec32ef5/charset_normalizer-3.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0167ddc8ab6508fe81860a57dd472b2ef4060e8d378f0cc555707126830f2537", size = 148082 }, - { url = "https://files.pythonhosted.org/packages/04/d2/42fd330901aaa4b805a1097856c2edf5095e260a597f65def493f4b8c833/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2a75d49014d118e4198bcee5ee0a6f25856b29b12dbf7cd012791f8a6cc5c496", size = 142053 }, - { url = "https://files.pythonhosted.org/packages/9e/af/3a97a4fa3c53586f1910dadfc916e9c4f35eeada36de4108f5096cb7215f/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:363e2f92b0f0174b2f8238240a1a30142e3db7b957a5dd5689b0e75fb717cc78", size = 150625 }, - { url = "https://files.pythonhosted.org/packages/26/ae/23d6041322a3556e4da139663d02fb1b3c59a23ab2e2b56432bd2ad63ded/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ab36c8eb7e454e34e60eb55ca5d241a5d18b2c6244f6827a30e451c42410b5f7", size = 153549 }, - { url = "https://files.pythonhosted.org/packages/94/22/b8f2081c6a77cb20d97e57e0b385b481887aa08019d2459dc2858ed64871/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:4c0907b1928a36d5a998d72d64d8eaa7244989f7aaaf947500d3a800c83a3fd6", size = 150945 }, - { url = "https://files.pythonhosted.org/packages/c7/0b/c5ec5092747f801b8b093cdf5610e732b809d6cb11f4c51e35fc28d1d389/charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:04432ad9479fa40ec0f387795ddad4437a2b50417c69fa275e212933519ff294", size = 146595 }, - { url = "https://files.pythonhosted.org/packages/0c/5a/0b59704c38470df6768aa154cc87b1ac7c9bb687990a1559dc8765e8627e/charset_normalizer-3.4.1-cp39-cp39-win32.whl", hash = "sha256:3bed14e9c89dcb10e8f3a29f9ccac4955aebe93c71ae803af79265c9ca5644c5", size = 95453 }, - { url = "https://files.pythonhosted.org/packages/85/2d/a9790237cb4d01a6d57afadc8573c8b73c609ade20b80f4cda30802009ee/charset_normalizer-3.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:49402233c892a461407c512a19435d1ce275543138294f7ef013f0b63d5d3765", size = 102811 }, - { url = "https://files.pythonhosted.org/packages/0e/f6/65ecc6878a89bb1c23a086ea335ad4bf21a588990c3f535a227b9eea9108/charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85", size = 49767 }, -] - -[[package]] -name = "click" -version = "8.1.8" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 }, -] - -[[package]] -name = "cloudpickle" -version = "3.1.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/52/39/069100b84d7418bc358d81669d5748efb14b9cceacd2f9c75f550424132f/cloudpickle-3.1.1.tar.gz", hash = "sha256:b216fa8ae4019d5482a8ac3c95d8f6346115d8835911fd4aefd1a445e4242c64", size = 22113 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7e/e8/64c37fadfc2816a7701fa8a6ed8d87327c7d54eacfbfb6edab14a2f2be75/cloudpickle-3.1.1-py3-none-any.whl", hash = "sha256:c8c5a44295039331ee9dad40ba100a9c7297b6f988e50e87ccdf3765a668350e", size = 20992 }, -] - -[[package]] -name = "colorama" -version = "0.4.6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, -] - -[[package]] -name = "coverage" -version = "7.8.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/19/4f/2251e65033ed2ce1e68f00f91a0294e0f80c80ae8c3ebbe2f12828c4cd53/coverage-7.8.0.tar.gz", hash = "sha256:7a3d62b3b03b4b6fd41a085f3574874cf946cb4604d2b4d3e8dca8cd570ca501", size = 811872 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/78/01/1c5e6ee4ebaaa5e079db933a9a45f61172048c7efa06648445821a201084/coverage-7.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2931f66991175369859b5fd58529cd4b73582461877ecfd859b6549869287ffe", size = 211379 }, - { url = "https://files.pythonhosted.org/packages/e9/16/a463389f5ff916963471f7c13585e5f38c6814607306b3cb4d6b4cf13384/coverage-7.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:52a523153c568d2c0ef8826f6cc23031dc86cffb8c6aeab92c4ff776e7951b28", size = 211814 }, - { url = "https://files.pythonhosted.org/packages/b8/b1/77062b0393f54d79064dfb72d2da402657d7c569cfbc724d56ac0f9c67ed/coverage-7.8.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c8a5c139aae4c35cbd7cadca1df02ea8cf28a911534fc1b0456acb0b14234f3", size = 240937 }, - { url = "https://files.pythonhosted.org/packages/d7/54/c7b00a23150083c124e908c352db03bcd33375494a4beb0c6d79b35448b9/coverage-7.8.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5a26c0c795c3e0b63ec7da6efded5f0bc856d7c0b24b2ac84b4d1d7bc578d676", size = 238849 }, - { url = "https://files.pythonhosted.org/packages/f7/ec/a6b7cfebd34e7b49f844788fda94713035372b5200c23088e3bbafb30970/coverage-7.8.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:821f7bcbaa84318287115d54becb1915eece6918136c6f91045bb84e2f88739d", size = 239986 }, - { url = "https://files.pythonhosted.org/packages/21/8c/c965ecef8af54e6d9b11bfbba85d4f6a319399f5f724798498387f3209eb/coverage-7.8.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a321c61477ff8ee705b8a5fed370b5710c56b3a52d17b983d9215861e37b642a", size = 239896 }, - { url = "https://files.pythonhosted.org/packages/40/83/070550273fb4c480efa8381735969cb403fa8fd1626d74865bfaf9e4d903/coverage-7.8.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:ed2144b8a78f9d94d9515963ed273d620e07846acd5d4b0a642d4849e8d91a0c", size = 238613 }, - { url = "https://files.pythonhosted.org/packages/07/76/fbb2540495b01d996d38e9f8897b861afed356be01160ab4e25471f4fed1/coverage-7.8.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:042e7841a26498fff7a37d6fda770d17519982f5b7d8bf5278d140b67b61095f", size = 238909 }, - { url = "https://files.pythonhosted.org/packages/a3/7e/76d604db640b7d4a86e5dd730b73e96e12a8185f22b5d0799025121f4dcb/coverage-7.8.0-cp310-cp310-win32.whl", hash = "sha256:f9983d01d7705b2d1f7a95e10bbe4091fabc03a46881a256c2787637b087003f", size = 213948 }, - { url = "https://files.pythonhosted.org/packages/5c/a7/f8ce4aafb4a12ab475b56c76a71a40f427740cf496c14e943ade72e25023/coverage-7.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:5a570cd9bd20b85d1a0d7b009aaf6c110b52b5755c17be6962f8ccd65d1dbd23", size = 214844 }, - { url = "https://files.pythonhosted.org/packages/2b/77/074d201adb8383addae5784cb8e2dac60bb62bfdf28b2b10f3a3af2fda47/coverage-7.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e7ac22a0bb2c7c49f441f7a6d46c9c80d96e56f5a8bc6972529ed43c8b694e27", size = 211493 }, - { url = "https://files.pythonhosted.org/packages/a9/89/7a8efe585750fe59b48d09f871f0e0c028a7b10722b2172dfe021fa2fdd4/coverage-7.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bf13d564d310c156d1c8e53877baf2993fb3073b2fc9f69790ca6a732eb4bfea", size = 211921 }, - { url = "https://files.pythonhosted.org/packages/e9/ef/96a90c31d08a3f40c49dbe897df4f1fd51fb6583821a1a1c5ee30cc8f680/coverage-7.8.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5761c70c017c1b0d21b0815a920ffb94a670c8d5d409d9b38857874c21f70d7", size = 244556 }, - { url = "https://files.pythonhosted.org/packages/89/97/dcd5c2ce72cee9d7b0ee8c89162c24972fb987a111b92d1a3d1d19100c61/coverage-7.8.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5ff52d790c7e1628241ffbcaeb33e07d14b007b6eb00a19320c7b8a7024c040", size = 242245 }, - { url = "https://files.pythonhosted.org/packages/b2/7b/b63cbb44096141ed435843bbb251558c8e05cc835c8da31ca6ffb26d44c0/coverage-7.8.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d39fc4817fd67b3915256af5dda75fd4ee10621a3d484524487e33416c6f3543", size = 244032 }, - { url = "https://files.pythonhosted.org/packages/97/e3/7fa8c2c00a1ef530c2a42fa5df25a6971391f92739d83d67a4ee6dcf7a02/coverage-7.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b44674870709017e4b4036e3d0d6c17f06a0e6d4436422e0ad29b882c40697d2", size = 243679 }, - { url = "https://files.pythonhosted.org/packages/4f/b3/e0a59d8df9150c8a0c0841d55d6568f0a9195692136c44f3d21f1842c8f6/coverage-7.8.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8f99eb72bf27cbb167b636eb1726f590c00e1ad375002230607a844d9e9a2318", size = 241852 }, - { url = "https://files.pythonhosted.org/packages/9b/82/db347ccd57bcef150c173df2ade97976a8367a3be7160e303e43dd0c795f/coverage-7.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b571bf5341ba8c6bc02e0baeaf3b061ab993bf372d982ae509807e7f112554e9", size = 242389 }, - { url = "https://files.pythonhosted.org/packages/21/f6/3f7d7879ceb03923195d9ff294456241ed05815281f5254bc16ef71d6a20/coverage-7.8.0-cp311-cp311-win32.whl", hash = "sha256:e75a2ad7b647fd8046d58c3132d7eaf31b12d8a53c0e4b21fa9c4d23d6ee6d3c", size = 213997 }, - { url = "https://files.pythonhosted.org/packages/28/87/021189643e18ecf045dbe1e2071b2747901f229df302de01c998eeadf146/coverage-7.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:3043ba1c88b2139126fc72cb48574b90e2e0546d4c78b5299317f61b7f718b78", size = 214911 }, - { url = "https://files.pythonhosted.org/packages/aa/12/4792669473297f7973518bec373a955e267deb4339286f882439b8535b39/coverage-7.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bbb5cc845a0292e0c520656d19d7ce40e18d0e19b22cb3e0409135a575bf79fc", size = 211684 }, - { url = "https://files.pythonhosted.org/packages/be/e1/2a4ec273894000ebedd789e8f2fc3813fcaf486074f87fd1c5b2cb1c0a2b/coverage-7.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4dfd9a93db9e78666d178d4f08a5408aa3f2474ad4d0e0378ed5f2ef71640cb6", size = 211935 }, - { url = "https://files.pythonhosted.org/packages/f8/3a/7b14f6e4372786709a361729164125f6b7caf4024ce02e596c4a69bccb89/coverage-7.8.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f017a61399f13aa6d1039f75cd467be388d157cd81f1a119b9d9a68ba6f2830d", size = 245994 }, - { url = "https://files.pythonhosted.org/packages/54/80/039cc7f1f81dcbd01ea796d36d3797e60c106077e31fd1f526b85337d6a1/coverage-7.8.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0915742f4c82208ebf47a2b154a5334155ed9ef9fe6190674b8a46c2fb89cb05", size = 242885 }, - { url = "https://files.pythonhosted.org/packages/10/e0/dc8355f992b6cc2f9dcd5ef6242b62a3f73264893bc09fbb08bfcab18eb4/coverage-7.8.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a40fcf208e021eb14b0fac6bdb045c0e0cab53105f93ba0d03fd934c956143a", size = 245142 }, - { url = "https://files.pythonhosted.org/packages/43/1b/33e313b22cf50f652becb94c6e7dae25d8f02e52e44db37a82de9ac357e8/coverage-7.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a1f406a8e0995d654b2ad87c62caf6befa767885301f3b8f6f73e6f3c31ec3a6", size = 244906 }, - { url = "https://files.pythonhosted.org/packages/05/08/c0a8048e942e7f918764ccc99503e2bccffba1c42568693ce6955860365e/coverage-7.8.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:77af0f6447a582fdc7de5e06fa3757a3ef87769fbb0fdbdeba78c23049140a47", size = 243124 }, - { url = "https://files.pythonhosted.org/packages/5b/62/ea625b30623083c2aad645c9a6288ad9fc83d570f9adb913a2abdba562dd/coverage-7.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f2d32f95922927186c6dbc8bc60df0d186b6edb828d299ab10898ef3f40052fe", size = 244317 }, - { url = "https://files.pythonhosted.org/packages/62/cb/3871f13ee1130a6c8f020e2f71d9ed269e1e2124aa3374d2180ee451cee9/coverage-7.8.0-cp312-cp312-win32.whl", hash = "sha256:769773614e676f9d8e8a0980dd7740f09a6ea386d0f383db6821df07d0f08545", size = 214170 }, - { url = "https://files.pythonhosted.org/packages/88/26/69fe1193ab0bfa1eb7a7c0149a066123611baba029ebb448500abd8143f9/coverage-7.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:e5d2b9be5b0693cf21eb4ce0ec8d211efb43966f6657807f6859aab3814f946b", size = 214969 }, - { url = "https://files.pythonhosted.org/packages/f3/21/87e9b97b568e223f3438d93072479c2f36cc9b3f6b9f7094b9d50232acc0/coverage-7.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5ac46d0c2dd5820ce93943a501ac5f6548ea81594777ca585bf002aa8854cacd", size = 211708 }, - { url = "https://files.pythonhosted.org/packages/75/be/882d08b28a0d19c9c4c2e8a1c6ebe1f79c9c839eb46d4fca3bd3b34562b9/coverage-7.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:771eb7587a0563ca5bb6f622b9ed7f9d07bd08900f7589b4febff05f469bea00", size = 211981 }, - { url = "https://files.pythonhosted.org/packages/7a/1d/ce99612ebd58082fbe3f8c66f6d8d5694976c76a0d474503fa70633ec77f/coverage-7.8.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42421e04069fb2cbcbca5a696c4050b84a43b05392679d4068acbe65449b5c64", size = 245495 }, - { url = "https://files.pythonhosted.org/packages/dc/8d/6115abe97df98db6b2bd76aae395fcc941d039a7acd25f741312ced9a78f/coverage-7.8.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:554fec1199d93ab30adaa751db68acec2b41c5602ac944bb19187cb9a41a8067", size = 242538 }, - { url = "https://files.pythonhosted.org/packages/cb/74/2f8cc196643b15bc096d60e073691dadb3dca48418f08bc78dd6e899383e/coverage-7.8.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5aaeb00761f985007b38cf463b1d160a14a22c34eb3f6a39d9ad6fc27cb73008", size = 244561 }, - { url = "https://files.pythonhosted.org/packages/22/70/c10c77cd77970ac965734fe3419f2c98665f6e982744a9bfb0e749d298f4/coverage-7.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:581a40c7b94921fffd6457ffe532259813fc68eb2bdda60fa8cc343414ce3733", size = 244633 }, - { url = "https://files.pythonhosted.org/packages/38/5a/4f7569d946a07c952688debee18c2bb9ab24f88027e3d71fd25dbc2f9dca/coverage-7.8.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:f319bae0321bc838e205bf9e5bc28f0a3165f30c203b610f17ab5552cff90323", size = 242712 }, - { url = "https://files.pythonhosted.org/packages/bb/a1/03a43b33f50475a632a91ea8c127f7e35e53786dbe6781c25f19fd5a65f8/coverage-7.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:04bfec25a8ef1c5f41f5e7e5c842f6b615599ca8ba8391ec33a9290d9d2db3a3", size = 244000 }, - { url = "https://files.pythonhosted.org/packages/6a/89/ab6c43b1788a3128e4d1b7b54214548dcad75a621f9d277b14d16a80d8a1/coverage-7.8.0-cp313-cp313-win32.whl", hash = "sha256:dd19608788b50eed889e13a5d71d832edc34fc9dfce606f66e8f9f917eef910d", size = 214195 }, - { url = "https://files.pythonhosted.org/packages/12/12/6bf5f9a8b063d116bac536a7fb594fc35cb04981654cccb4bbfea5dcdfa0/coverage-7.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:a9abbccd778d98e9c7e85038e35e91e67f5b520776781d9a1e2ee9d400869487", size = 214998 }, - { url = "https://files.pythonhosted.org/packages/2a/e6/1e9df74ef7a1c983a9c7443dac8aac37a46f1939ae3499424622e72a6f78/coverage-7.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:18c5ae6d061ad5b3e7eef4363fb27a0576012a7447af48be6c75b88494c6cf25", size = 212541 }, - { url = "https://files.pythonhosted.org/packages/04/51/c32174edb7ee49744e2e81c4b1414ac9df3dacfcb5b5f273b7f285ad43f6/coverage-7.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:95aa6ae391a22bbbce1b77ddac846c98c5473de0372ba5c463480043a07bff42", size = 212767 }, - { url = "https://files.pythonhosted.org/packages/e9/8f/f454cbdb5212f13f29d4a7983db69169f1937e869a5142bce983ded52162/coverage-7.8.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e013b07ba1c748dacc2a80e69a46286ff145935f260eb8c72df7185bf048f502", size = 256997 }, - { url = "https://files.pythonhosted.org/packages/e6/74/2bf9e78b321216d6ee90a81e5c22f912fc428442c830c4077b4a071db66f/coverage-7.8.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d766a4f0e5aa1ba056ec3496243150698dc0481902e2b8559314368717be82b1", size = 252708 }, - { url = "https://files.pythonhosted.org/packages/92/4d/50d7eb1e9a6062bee6e2f92e78b0998848a972e9afad349b6cdde6fa9e32/coverage-7.8.0-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad80e6b4a0c3cb6f10f29ae4c60e991f424e6b14219d46f1e7d442b938ee68a4", size = 255046 }, - { url = "https://files.pythonhosted.org/packages/40/9e/71fb4e7402a07c4198ab44fc564d09d7d0ffca46a9fb7b0a7b929e7641bd/coverage-7.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b87eb6fc9e1bb8f98892a2458781348fa37e6925f35bb6ceb9d4afd54ba36c73", size = 256139 }, - { url = "https://files.pythonhosted.org/packages/49/1a/78d37f7a42b5beff027e807c2843185961fdae7fe23aad5a4837c93f9d25/coverage-7.8.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:d1ba00ae33be84066cfbe7361d4e04dec78445b2b88bdb734d0d1cbab916025a", size = 254307 }, - { url = "https://files.pythonhosted.org/packages/58/e9/8fb8e0ff6bef5e170ee19d59ca694f9001b2ec085dc99b4f65c128bb3f9a/coverage-7.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f3c38e4e5ccbdc9198aecc766cedbb134b2d89bf64533973678dfcf07effd883", size = 255116 }, - { url = "https://files.pythonhosted.org/packages/56/b0/d968ecdbe6fe0a863de7169bbe9e8a476868959f3af24981f6a10d2b6924/coverage-7.8.0-cp313-cp313t-win32.whl", hash = "sha256:379fe315e206b14e21db5240f89dc0774bdd3e25c3c58c2c733c99eca96f1ada", size = 214909 }, - { url = "https://files.pythonhosted.org/packages/87/e9/d6b7ef9fecf42dfb418d93544af47c940aa83056c49e6021a564aafbc91f/coverage-7.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:2e4b6b87bb0c846a9315e3ab4be2d52fac905100565f4b92f02c445c8799e257", size = 216068 }, - { url = "https://files.pythonhosted.org/packages/60/0c/5da94be095239814bf2730a28cffbc48d6df4304e044f80d39e1ae581997/coverage-7.8.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:fa260de59dfb143af06dcf30c2be0b200bed2a73737a8a59248fcb9fa601ef0f", size = 211377 }, - { url = "https://files.pythonhosted.org/packages/d5/cb/b9e93ebf193a0bb89dbcd4f73d7b0e6ecb7c1b6c016671950e25f041835e/coverage-7.8.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:96121edfa4c2dfdda409877ea8608dd01de816a4dc4a0523356067b305e4e17a", size = 211803 }, - { url = "https://files.pythonhosted.org/packages/78/1a/cdbfe9e1bb14d3afcaf6bb6e1b9ba76c72666e329cd06865bbd241efd652/coverage-7.8.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b8af63b9afa1031c0ef05b217faa598f3069148eeee6bb24b79da9012423b82", size = 240561 }, - { url = "https://files.pythonhosted.org/packages/59/04/57f1223f26ac018d7ce791bfa65b0c29282de3e041c1cd3ed430cfeac5a5/coverage-7.8.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:89b1f4af0d4afe495cd4787a68e00f30f1d15939f550e869de90a86efa7e0814", size = 238488 }, - { url = "https://files.pythonhosted.org/packages/b7/b1/0f25516ae2a35e265868670384feebe64e7857d9cffeeb3887b0197e2ba2/coverage-7.8.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:94ec0be97723ae72d63d3aa41961a0b9a6f5a53ff599813c324548d18e3b9e8c", size = 239589 }, - { url = "https://files.pythonhosted.org/packages/e0/a4/99d88baac0d1d5a46ceef2dd687aac08fffa8795e4c3e71b6f6c78e14482/coverage-7.8.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8a1d96e780bdb2d0cbb297325711701f7c0b6f89199a57f2049e90064c29f6bd", size = 239366 }, - { url = "https://files.pythonhosted.org/packages/ea/9e/1db89e135feb827a868ed15f8fc857160757f9cab140ffee21342c783ceb/coverage-7.8.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:f1d8a2a57b47142b10374902777e798784abf400a004b14f1b0b9eaf1e528ba4", size = 237591 }, - { url = "https://files.pythonhosted.org/packages/1b/6d/ac4d6fdfd0e201bc82d1b08adfacb1e34b40d21a22cdd62cfaf3c1828566/coverage-7.8.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:cf60dd2696b457b710dd40bf17ad269d5f5457b96442f7f85722bdb16fa6c899", size = 238572 }, - { url = "https://files.pythonhosted.org/packages/25/5e/917cbe617c230f7f1745b6a13e780a3a1cd1cf328dbcd0fd8d7ec52858cd/coverage-7.8.0-cp39-cp39-win32.whl", hash = "sha256:be945402e03de47ba1872cd5236395e0f4ad635526185a930735f66710e1bd3f", size = 213966 }, - { url = "https://files.pythonhosted.org/packages/bd/93/72b434fe550135869f9ea88dd36068af19afce666db576e059e75177e813/coverage-7.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:90e7fbc6216ecaffa5a880cdc9c77b7418c1dcb166166b78dbc630d07f278cc3", size = 214852 }, - { url = "https://files.pythonhosted.org/packages/c4/f1/1da77bb4c920aa30e82fa9b6ea065da3467977c2e5e032e38e66f1c57ffd/coverage-7.8.0-pp39.pp310.pp311-none-any.whl", hash = "sha256:b8194fb8e50d556d5849753de991d390c5a1edeeba50f68e3a9253fbd8bf8ccd", size = 203443 }, - { url = "https://files.pythonhosted.org/packages/59/f1/4da7717f0063a222db253e7121bd6a56f6fb1ba439dcc36659088793347c/coverage-7.8.0-py3-none-any.whl", hash = "sha256:dbf364b4c5e7bae9250528167dfe40219b62e2d573c854d74be213e1e52069f7", size = 203435 }, -] - -[package.optional-dependencies] -toml = [ - { name = "tomli", marker = "python_full_version <= '3.11'" }, -] - -[[package]] -name = "dask" -version = "2024.8.0" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.10'", -] -dependencies = [ - { name = "click", marker = "python_full_version < '3.10'" }, - { name = "cloudpickle", marker = "python_full_version < '3.10'" }, - { name = "fsspec", marker = "python_full_version < '3.10'" }, - { name = "importlib-metadata", marker = "python_full_version < '3.10'" }, - { name = "packaging", marker = "python_full_version < '3.10'" }, - { name = "partd", marker = "python_full_version < '3.10'" }, - { name = "pyyaml", marker = "python_full_version < '3.10'" }, - { name = "toolz", marker = "python_full_version < '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1f/2e/568a422d907745a3a897a732c83d05a3923d8cfa2511a6abea2a0e19994e/dask-2024.8.0.tar.gz", hash = "sha256:f1fec39373d2f101bc045529ad4e9b30e34e6eb33b7aa0fa7073aec7b1bf9eee", size = 9895684 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/db/47/136a5dd68a33089f96f8aa1178ccd545d325ec9ab2bb42a3038711a935c0/dask-2024.8.0-py3-none-any.whl", hash = "sha256:250ea3df30d4a25958290eec4f252850091c6cfaed82d098179c3b25bba18309", size = 1233681 }, -] - -[package.optional-dependencies] -array = [ - { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" }, -] - -[[package]] -name = "dask" -version = "2025.3.0" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.11'", - "python_full_version == '3.10.*'", -] -dependencies = [ - { name = "click", marker = "python_full_version >= '3.10'" }, - { name = "cloudpickle", marker = "python_full_version >= '3.10'" }, - { name = "fsspec", marker = "python_full_version >= '3.10'" }, - { name = "importlib-metadata", marker = "python_full_version >= '3.10' and python_full_version < '3.12'" }, - { name = "packaging", marker = "python_full_version >= '3.10'" }, - { name = "partd", marker = "python_full_version >= '3.10'" }, - { name = "pyyaml", marker = "python_full_version >= '3.10'" }, - { name = "toolz", marker = "python_full_version >= '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/c3/f1/b4d8ccb5010ecba58a1799cb3c6b7ef5ed0d7d2add53adc1fc0d0ace56fe/dask-2025.3.0.tar.gz", hash = "sha256:322834f44ebc24abeb564c56ccb817c97d6e7af6be71ad0ad96b78b51f2e0e85", size = 10928728 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/bd/8a/3609033a4bfd7c9b3e8a4e8a5d6e318dfc06ab2e2d3b5cb0e01a60458858/dask-2025.3.0-py3-none-any.whl", hash = "sha256:b5d72bb33788904a218fd7da1850238517592358ecc79c30bb5c188a71df506d", size = 1437133 }, -] - -[package.optional-dependencies] -array = [ - { name = "numpy", version = "2.2.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" }, -] - -[[package]] -name = "decorator" -version = "5.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190 }, -] - -[[package]] -name = "distlib" -version = "0.3.9" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0d/dd/1bec4c5ddb504ca60fc29472f3d27e8d4da1257a854e1d96742f15c1d02d/distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403", size = 613923 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/91/a1/cf2472db20f7ce4a6be1253a81cfdf85ad9c7885ffbed7047fb72c24cf87/distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87", size = 468973 }, -] - -[[package]] -name = "exceptiongroup" -version = "1.2.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 }, -] - -[[package]] -name = "executing" -version = "2.2.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702 }, -] - -[[package]] -name = "fancycompleter" -version = "0.11.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pyrepl", marker = "python_full_version < '3.13'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/f3/03/eb007f5e90c13016debb6ecd717f0595ce758bf30906f2cb273673e8427d/fancycompleter-0.11.0.tar.gz", hash = "sha256:632b265b29dd0315b96d33d13d83132a541d6312262214f50211b3981bb4fa00", size = 341517 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/07/52/d3e234bf32ee97e71b45886a52871dc681345d64b449a930bab38c73cbcb/fancycompleter-0.11.0-py3-none-any.whl", hash = "sha256:a4712fdda8d7f3df08511ab2755ea0f1e669e2c65701a28c0c0aa2ff528521ed", size = 11166 }, -] - -[[package]] -name = "filelock" -version = "3.18.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/0a/10/c23352565a6544bdc5353e0b15fc1c563352101f30e24bf500207a54df9a/filelock-3.18.0.tar.gz", hash = "sha256:adbc88eabb99d2fec8c9c1b229b171f18afa655400173ddc653d5d01501fb9f2", size = 18075 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4d/36/2a115987e2d8c300a974597416d9de88f2444426de9571f4b59b2cca3acc/filelock-3.18.0-py3-none-any.whl", hash = "sha256:c401f4f8377c4464e6db25fff06205fd89bdd83b65eb0488ed1b160f780e21de", size = 16215 }, -] - -[[package]] -name = "fsspec" -version = "2025.3.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/45/d8/8425e6ba5fcec61a1d16e41b1b71d2bf9344f1fe48012c2b48b9620feae5/fsspec-2025.3.2.tar.gz", hash = "sha256:e52c77ef398680bbd6a98c0e628fbc469491282981209907bbc8aea76a04fdc6", size = 299281 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/44/4b/e0cfc1a6f17e990f3e64b7d941ddc4acdc7b19d6edd51abf495f32b1a9e4/fsspec-2025.3.2-py3-none-any.whl", hash = "sha256:2daf8dc3d1dfa65b6aa37748d112773a7a08416f6c70d96b264c96476ecaf711", size = 194435 }, -] - -[[package]] -name = "identify" -version = "2.6.9" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/9b/98/a71ab060daec766acc30fb47dfca219d03de34a70d616a79a38c6066c5bf/identify-2.6.9.tar.gz", hash = "sha256:d40dfe3142a1421d8518e3d3985ef5ac42890683e32306ad614a29490abeb6bf", size = 99249 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/07/ce/0845144ed1f0e25db5e7a79c2354c1da4b5ce392b8966449d5db8dca18f1/identify-2.6.9-py2.py3-none-any.whl", hash = "sha256:c98b4322da415a8e5a70ff6e51fbc2d2932c015532d77e9f8537b4ba7813b150", size = 99101 }, -] - -[[package]] -name = "idna" -version = "3.10" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442 }, -] - -[[package]] -name = "importlib-metadata" -version = "8.6.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "zipp" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/33/08/c1395a292bb23fd03bdf572a1357c5a733d3eecbab877641ceacab23db6e/importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580", size = 55767 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/79/9d/0fb148dc4d6fa4a7dd1d8378168d9b4cd8d4560a6fbf6f0121c5fc34eb68/importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e", size = 26971 }, -] - -[[package]] -name = "iniconfig" -version = "2.1.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050 }, -] - -[[package]] -name = "ipython" -version = "8.18.1" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.10'", -] -dependencies = [ - { name = "colorama", marker = "python_full_version < '3.10' and sys_platform == 'win32'" }, - { name = "decorator", marker = "python_full_version < '3.10'" }, - { name = "exceptiongroup", marker = "python_full_version < '3.10'" }, - { name = "jedi", marker = "python_full_version < '3.10'" }, - { name = "matplotlib-inline", marker = "python_full_version < '3.10'" }, - { name = "pexpect", marker = "python_full_version < '3.10' and sys_platform != 'win32'" }, - { name = "prompt-toolkit", marker = "python_full_version < '3.10'" }, - { name = "pygments", marker = "python_full_version < '3.10'" }, - { name = "stack-data", marker = "python_full_version < '3.10'" }, - { name = "traitlets", marker = "python_full_version < '3.10'" }, - { name = "typing-extensions", marker = "python_full_version < '3.10'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b1/b9/3ba6c45a6df813c09a48bac313c22ff83efa26cbb55011218d925a46e2ad/ipython-8.18.1.tar.gz", hash = "sha256:ca6f079bb33457c66e233e4580ebfc4128855b4cf6370dddd73842a9563e8a27", size = 5486330 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/47/6b/d9fdcdef2eb6a23f391251fde8781c38d42acd82abe84d054cb74f7863b0/ipython-8.18.1-py3-none-any.whl", hash = "sha256:e8267419d72d81955ec1177f8a29aaa90ac80ad647499201119e2f05e99aa397", size = 808161 }, -] - -[[package]] -name = "ipython" -version = "8.35.0" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version == '3.10.*'", -] -dependencies = [ - { name = "colorama", marker = "python_full_version == '3.10.*' and sys_platform == 'win32'" }, - { name = "decorator", marker = "python_full_version == '3.10.*'" }, - { name = "exceptiongroup", marker = "python_full_version == '3.10.*'" }, - { name = "jedi", marker = "python_full_version == '3.10.*'" }, - { name = "matplotlib-inline", marker = "python_full_version == '3.10.*'" }, - { name = "pexpect", marker = "python_full_version == '3.10.*' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, - { name = "prompt-toolkit", marker = "python_full_version == '3.10.*'" }, - { name = "pygments", marker = "python_full_version == '3.10.*'" }, - { name = "stack-data", marker = "python_full_version == '3.10.*'" }, - { name = "traitlets", marker = "python_full_version == '3.10.*'" }, - { name = "typing-extensions", marker = "python_full_version == '3.10.*'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/0c/77/7d1501e8b539b179936e0d5969b578ed23887be0ab8c63e0120b825bda3e/ipython-8.35.0.tar.gz", hash = "sha256:d200b7d93c3f5883fc36ab9ce28a18249c7706e51347681f80a0aef9895f2520", size = 5605027 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/91/bf/17ffca8c8b011d0bac90adb5d4e720cb3ae1fe5ccfdfc14ca31f827ee320/ipython-8.35.0-py3-none-any.whl", hash = "sha256:e6b7470468ba6f1f0a7b116bb688a3ece2f13e2f94138e508201fad677a788ba", size = 830880 }, -] - -[[package]] -name = "ipython" -version = "9.1.0" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.11'", -] -dependencies = [ - { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, - { name = "decorator", marker = "python_full_version >= '3.11'" }, - { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11'" }, - { name = "jedi", marker = "python_full_version >= '3.11'" }, - { name = "matplotlib-inline", marker = "python_full_version >= '3.11'" }, - { name = "pexpect", marker = "python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, - { name = "prompt-toolkit", marker = "python_full_version >= '3.11'" }, - { name = "pygments", marker = "python_full_version >= '3.11'" }, - { name = "stack-data", marker = "python_full_version >= '3.11'" }, - { name = "traitlets", marker = "python_full_version >= '3.11'" }, - { name = "typing-extensions", marker = "python_full_version == '3.11.*'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/70/9a/6b8984bedc990f3a4aa40ba8436dea27e23d26a64527de7c2e5e12e76841/ipython-9.1.0.tar.gz", hash = "sha256:a47e13a5e05e02f3b8e1e7a0f9db372199fe8c3763532fe7a1e0379e4e135f16", size = 4373688 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b2/9d/4ff2adf55d1b6e3777b0303fdbe5b723f76e46cba4a53a32fe82260d2077/ipython-9.1.0-py3-none-any.whl", hash = "sha256:2df07257ec2f84a6b346b8d83100bcf8fa501c6e01ab75cd3799b0bb253b3d2a", size = 604053 }, -] - -[[package]] -name = "ipython-pygments-lexers" -version = "1.1.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pygments", marker = "python_full_version >= '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074 }, -] - -[[package]] -name = "jedi" -version = "0.19.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "parso" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278 }, -] - -[[package]] -name = "jgo" -version = "1.0.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "psutil" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/89/4f/2a9485b9e3d68b343c5b590b19d503f6cc4bebb2fcd827e3467c9d3ab92a/jgo-1.0.6.tar.gz", hash = "sha256:31824d329dc5824954cc150a9d934c543a227818dc1c0ea6ea20741c2e462b24", size = 23284 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6c/0c/c29fcd6a59f50d953fd296d10fa5d455a239c84fa74ed8db4913f30d13cc/jgo-1.0.6-py3-none-any.whl", hash = "sha256:b59b8da5ab13f84cae2eae295bafa54592204433cef1e3fdede9dae946c0b61d", size = 15355 }, -] - -[[package]] -name = "jpype1" -version = "1.5.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "packaging" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/bd/68/47fa634cbd0418cbca86355e9421425f5892ee994f7338106327e49f9117/jpype1-1.5.2.tar.gz", hash = "sha256:74a42eccf21d30394c1832aec3985a14965fa5320da087b65029d172c0cec43b", size = 1011421 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c7/f2/b2efcad1ea5a541f125218e4eb1529ebb8ca18941264c879f3e89a36dc35/jpype1-1.5.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7b2da98c142812ca40a18a735b33e47c6511b03debf1e979630f4cf473b68a87", size = 584511 }, - { url = "https://files.pythonhosted.org/packages/c0/c6/63538d160c17e837f62d29ba4163bc444cef08c29cd3f3b8090691c1869c/jpype1-1.5.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fcfc5c1d45d6b108800d172ea817bda585db7f1646d6a98d14da9aca66e0eb44", size = 467488 }, - { url = "https://files.pythonhosted.org/packages/91/69/655d73a64ae6731706eab73d3f63fd2d48e36704da09710fbc0155c14402/jpype1-1.5.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:156f469a976cc61f695a2455db6de7334774388e7d53c3da8a0a23d9c062d1b2", size = 510064 }, - { url = "https://files.pythonhosted.org/packages/97/0a/cbe03759331c640aa5862f974028122a862b08935a0b11b8fa6f6e46c26b/jpype1-1.5.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdca93cc74f8db1f604d2ea6adb764dec4dec68528f1ee68308fa3d524095739", size = 494097 }, - { url = "https://files.pythonhosted.org/packages/22/18/0a51845ca890ffdc72f4d71a0c2be334b887c5bb6812207efe5ad45afcb3/jpype1-1.5.2-cp310-cp310-win_amd64.whl", hash = "sha256:924b0a0cf93d3dddb3f79286fbe40f8c901c78ed61216edbe108666234df43e0", size = 356655 }, - { url = "https://files.pythonhosted.org/packages/35/a0/638186a75026a02286041e4a0449b1dff799a3914dc1c0716ef9b9367b73/jpype1-1.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c9f6ab8dd284c16e2617a697d54c3d0304b08020a37386ed96103a129391a2d9", size = 584474 }, - { url = "https://files.pythonhosted.org/packages/0e/78/95db2eb3c8a7311ee08a2c237cea24828859db6a6cb5e901971d3f5e49da/jpype1-1.5.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a54a771ee56260f98e5b9a77455084e4a48061967de13dabf628bdba9c8122e0", size = 467508 }, - { url = "https://files.pythonhosted.org/packages/84/07/f4ed08bf1f65526d59a07efa86a79a2cc37263fea9a91efeb7dfd2b81bcb/jpype1-1.5.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05dc6d2759111483a9c808a50e67f556efe494e999585c7d7e7d6d8a8ee58525", size = 510256 }, - { url = "https://files.pythonhosted.org/packages/0b/7d/9fdbbc1a574be43f9820735ca8df0caf8b159856201d9b21fd73932342bc/jpype1-1.5.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b900e154826a076118d074166596f1d817e113e07084bf0c9c43d8064a86ab77", size = 494076 }, - { url = "https://files.pythonhosted.org/packages/0e/b9/4dfb38a7f4efb21f71df7344944a8d9a23e30d0503574e455af6ce4f1a56/jpype1-1.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:0a0d18d4384b3df2e55282545737dfcf18c604504f1382ad14f880bef960f265", size = 356587 }, - { url = "https://files.pythonhosted.org/packages/8d/e4/0c27352e8222dcc0e3ce44b298015072d2057d08dd353541c980a31d26c9/jpype1-1.5.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:1e1db9ac909ad2ae0e40b04c2aa88cb14250d5245d69715561507681f2b08b2f", size = 583445 }, - { url = "https://files.pythonhosted.org/packages/fa/4c/e0200a6e3fed5cda79e926c2a8a610676f04948f89d7e38d93c7d4b21be9/jpype1-1.5.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:994fb7b319b453f77ad4b6aff01e0dd4180ea74a6fe5a031e4e9db92dbe95376", size = 466485 }, - { url = "https://files.pythonhosted.org/packages/c3/ad/d85926b2f0104ded953fa53ff95fe71c96935cd742fdadb888f1145ffe79/jpype1-1.5.2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bec2f1009d7221fb3443decfb8f326039febc93578aadedfb3e052dab0afbf5a", size = 509372 }, - { url = "https://files.pythonhosted.org/packages/74/f3/1cd4332076ed0421e703412f47f15f43af170809435c57ba3162edc80d4b/jpype1-1.5.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b5b1fb2b430a50f081ea0ee24d19232ae0d03dbfe3dd076ec5f8ae42b30a656f", size = 493520 }, - { url = "https://files.pythonhosted.org/packages/74/dd/7408d4beae755de6fcd07c76b2f0bacabc0461b43fba83811c1f7c22440e/jpype1-1.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:c7b1c2d76d211cab60be16505d32a6b3c9fffc51ce79c68e81a3d48e5effff2d", size = 356149 }, - { url = "https://files.pythonhosted.org/packages/76/be/b37005bec457b94eaaf637a663073b7c5df70113fd4ae4865f6e386c612f/jpype1-1.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:4acb098cb1698b14b6e5c79e275f4c70dcc01b0fb93425f206d0a5e380e43c66", size = 583600 }, - { url = "https://files.pythonhosted.org/packages/20/a3/00a265d424f7d47e0dc547df2320225ce0143fec671faf710def41404b8c/jpype1-1.5.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c08480c7d18125664a12bf0a244b96b49c05105306b65937dbefeb05ab4b2847", size = 466426 }, - { url = "https://files.pythonhosted.org/packages/0e/cd/890d9ed43d7e1366e151c0ed7046e59f6c1cb7ecfc8ecfefe9e5e79f8420/jpype1-1.5.2-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6819f231c651ef876ffb23158083ea498ff80b57c46da537148412aa22235a13", size = 509513 }, - { url = "https://files.pythonhosted.org/packages/6d/d0/191db2e9ab6ae7029368a488c9d88235966843b185aba7925e54aa0c0013/jpype1-1.5.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42fe8db66ad4e5c66f637f5c4de82fca880ba696104e1f4a7e575885923dead8", size = 493474 }, - { url = "https://files.pythonhosted.org/packages/e3/b7/e1787633b41d609320b41d0dd87fe3118598210609e4e3f6cef93cfcef40/jpype1-1.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:2b96365f1302df2fb3c6ad73117d6fe450a55b7550fd7fecadac3cec5bc7117c", size = 356150 }, - { url = "https://files.pythonhosted.org/packages/a8/c8/76541ffefa6fc4ee7a3a8c7e6d9e376f5ac8980a47ff31a8c330ffbb5dcf/jpype1-1.5.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ea5001f6a7a42be6f5f500dcb20dad5738fef6a7d19c86dbcf482b803f01cab", size = 468412 }, - { url = "https://files.pythonhosted.org/packages/be/6f/827ca43aaa5ea6b773aa90b405acec22bd152d1284aa40f7c0c02bc1657b/jpype1-1.5.2-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:220d33305998ff7a7cbc9c0b5eea54f2691fdc21e60d52ad56276ea13fd5bd4c", size = 511322 }, - { url = "https://files.pythonhosted.org/packages/76/37/f1396d7b66f9b6867a279db510e625ba51c8a4b4397f59a6c2b20fb55548/jpype1-1.5.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f1ed152fdd5200067dc0cdcd4683530b87a6be3987b98596cdf5a7d3ac4c679", size = 494714 }, - { url = "https://files.pythonhosted.org/packages/05/71/590b2a91b43763aa27eac2c63803542a2878a4d8c600b81aa694d3fde919/jpype1-1.5.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8b75d33e93a3bc6543ddf97c24ee0adb5a86a69fb67f0e4f4fa1c8c3970bbf98", size = 385026 }, - { url = "https://files.pythonhosted.org/packages/77/6b/130fb6d0c43976b4e129c6bc19daf0e25c42fc38c5096ed92c4105bfd2c4/jpype1-1.5.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea21bca4cece752cd3ee88fcd62ce8f444feac8dc7244475fdb9c0e8712e07ea", size = 467423 }, - { url = "https://files.pythonhosted.org/packages/d4/a9/ec047a94e85c7cadf07f33f871e72d20faa6935c911dc5884388ca08a8bf/jpype1-1.5.2-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:670daf6b13f32653438ebde81aa30f6f48149b95dad4d80a40b3ebea47622164", size = 510117 }, - { url = "https://files.pythonhosted.org/packages/77/91/f08a719461a390b48d9096b50f1f4a49ee281007ec192e51073090d3d8b7/jpype1-1.5.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:54744265ef36665d110d139a4b81d10532694c6077b23ef60f3609feadc22d30", size = 494053 }, - { url = "https://files.pythonhosted.org/packages/e5/cf/344e1f81f1e8c651ec23dfa9fe4b91f6e1d699b36f610a547ba85ee7fb16/jpype1-1.5.2-cp39-cp39-win_amd64.whl", hash = "sha256:68e1d118200fc46f4ea4bf20900081587ec04de484037c997b0a3b7c5eb71fe3", size = 356716 }, -] - -[[package]] -name = "locket" -version = "1.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2f/83/97b29fe05cb6ae28d2dbd30b81e2e402a3eed5f460c26e9eaa5895ceacf5/locket-1.0.0.tar.gz", hash = "sha256:5c0d4c052a8bbbf750e056a8e65ccd309086f4f0f18a2eac306a8dfa4112a632", size = 4350 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/db/bc/83e112abc66cd466c6b83f99118035867cecd41802f8d044638aa78a106e/locket-1.0.0-py2.py3-none-any.whl", hash = "sha256:b6c819a722f7b6bd955b80781788e4a66a55628b858d347536b7e81325a3a5e3", size = 4398 }, -] - -[[package]] -name = "markdown-it-py" -version = "3.0.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "mdurl" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 }, -] - -[[package]] -name = "matplotlib-inline" -version = "0.1.7" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "traitlets" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899 }, -] - -[[package]] -name = "mdurl" -version = "0.1.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 }, -] - -[[package]] -name = "mypy" -version = "1.15.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "mypy-extensions" }, - { name = "tomli", marker = "python_full_version < '3.11'" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ce/43/d5e49a86afa64bd3839ea0d5b9c7103487007d728e1293f52525d6d5486a/mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43", size = 3239717 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/68/f8/65a7ce8d0e09b6329ad0c8d40330d100ea343bd4dd04c4f8ae26462d0a17/mypy-1.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:979e4e1a006511dacf628e36fadfecbcc0160a8af6ca7dad2f5025529e082c13", size = 10738433 }, - { url = "https://files.pythonhosted.org/packages/b4/95/9c0ecb8eacfe048583706249439ff52105b3f552ea9c4024166c03224270/mypy-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c4bb0e1bd29f7d34efcccd71cf733580191e9a264a2202b0239da95984c5b559", size = 9861472 }, - { url = "https://files.pythonhosted.org/packages/84/09/9ec95e982e282e20c0d5407bc65031dfd0f0f8ecc66b69538296e06fcbee/mypy-1.15.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be68172e9fd9ad8fb876c6389f16d1c1b5f100ffa779f77b1fb2176fcc9ab95b", size = 11611424 }, - { url = "https://files.pythonhosted.org/packages/78/13/f7d14e55865036a1e6a0a69580c240f43bc1f37407fe9235c0d4ef25ffb0/mypy-1.15.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7be1e46525adfa0d97681432ee9fcd61a3964c2446795714699a998d193f1a3", size = 12365450 }, - { url = "https://files.pythonhosted.org/packages/48/e1/301a73852d40c241e915ac6d7bcd7fedd47d519246db2d7b86b9d7e7a0cb/mypy-1.15.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2e2c2e6d3593f6451b18588848e66260ff62ccca522dd231cd4dd59b0160668b", size = 12551765 }, - { url = "https://files.pythonhosted.org/packages/77/ba/c37bc323ae5fe7f3f15a28e06ab012cd0b7552886118943e90b15af31195/mypy-1.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:6983aae8b2f653e098edb77f893f7b6aca69f6cffb19b2cc7443f23cce5f4828", size = 9274701 }, - { url = "https://files.pythonhosted.org/packages/03/bc/f6339726c627bd7ca1ce0fa56c9ae2d0144604a319e0e339bdadafbbb599/mypy-1.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2922d42e16d6de288022e5ca321cd0618b238cfc5570e0263e5ba0a77dbef56f", size = 10662338 }, - { url = "https://files.pythonhosted.org/packages/e2/90/8dcf506ca1a09b0d17555cc00cd69aee402c203911410136cd716559efe7/mypy-1.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2ee2d57e01a7c35de00f4634ba1bbf015185b219e4dc5909e281016df43f5ee5", size = 9787540 }, - { url = "https://files.pythonhosted.org/packages/05/05/a10f9479681e5da09ef2f9426f650d7b550d4bafbef683b69aad1ba87457/mypy-1.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:973500e0774b85d9689715feeffcc980193086551110fd678ebe1f4342fb7c5e", size = 11538051 }, - { url = "https://files.pythonhosted.org/packages/e9/9a/1f7d18b30edd57441a6411fcbc0c6869448d1a4bacbaee60656ac0fc29c8/mypy-1.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a95fb17c13e29d2d5195869262f8125dfdb5c134dc8d9a9d0aecf7525b10c2c", size = 12286751 }, - { url = "https://files.pythonhosted.org/packages/72/af/19ff499b6f1dafcaf56f9881f7a965ac2f474f69f6f618b5175b044299f5/mypy-1.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1905f494bfd7d85a23a88c5d97840888a7bd516545fc5aaedff0267e0bb54e2f", size = 12421783 }, - { url = "https://files.pythonhosted.org/packages/96/39/11b57431a1f686c1aed54bf794870efe0f6aeca11aca281a0bd87a5ad42c/mypy-1.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:c9817fa23833ff189db061e6d2eff49b2f3b6ed9856b4a0a73046e41932d744f", size = 9265618 }, - { url = "https://files.pythonhosted.org/packages/98/3a/03c74331c5eb8bd025734e04c9840532226775c47a2c39b56a0c8d4f128d/mypy-1.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:aea39e0583d05124836ea645f412e88a5c7d0fd77a6d694b60d9b6b2d9f184fd", size = 10793981 }, - { url = "https://files.pythonhosted.org/packages/f0/1a/41759b18f2cfd568848a37c89030aeb03534411eef981df621d8fad08a1d/mypy-1.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f2147ab812b75e5b5499b01ade1f4a81489a147c01585cda36019102538615f", size = 9749175 }, - { url = "https://files.pythonhosted.org/packages/12/7e/873481abf1ef112c582db832740f4c11b2bfa510e829d6da29b0ab8c3f9c/mypy-1.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce436f4c6d218a070048ed6a44c0bbb10cd2cc5e272b29e7845f6a2f57ee4464", size = 11455675 }, - { url = "https://files.pythonhosted.org/packages/b3/d0/92ae4cde706923a2d3f2d6c39629134063ff64b9dedca9c1388363da072d/mypy-1.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8023ff13985661b50a5928fc7a5ca15f3d1affb41e5f0a9952cb68ef090b31ee", size = 12410020 }, - { url = "https://files.pythonhosted.org/packages/46/8b/df49974b337cce35f828ba6fda228152d6db45fed4c86ba56ffe442434fd/mypy-1.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1124a18bc11a6a62887e3e137f37f53fbae476dc36c185d549d4f837a2a6a14e", size = 12498582 }, - { url = "https://files.pythonhosted.org/packages/13/50/da5203fcf6c53044a0b699939f31075c45ae8a4cadf538a9069b165c1050/mypy-1.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:171a9ca9a40cd1843abeca0e405bc1940cd9b305eaeea2dda769ba096932bb22", size = 9366614 }, - { url = "https://files.pythonhosted.org/packages/6a/9b/fd2e05d6ffff24d912f150b87db9e364fa8282045c875654ce7e32fffa66/mypy-1.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93faf3fdb04768d44bf28693293f3904bbb555d076b781ad2530214ee53e3445", size = 10788592 }, - { url = "https://files.pythonhosted.org/packages/74/37/b246d711c28a03ead1fd906bbc7106659aed7c089d55fe40dd58db812628/mypy-1.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:811aeccadfb730024c5d3e326b2fbe9249bb7413553f15499a4050f7c30e801d", size = 9753611 }, - { url = "https://files.pythonhosted.org/packages/a6/ac/395808a92e10cfdac8003c3de9a2ab6dc7cde6c0d2a4df3df1b815ffd067/mypy-1.15.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:98b7b9b9aedb65fe628c62a6dc57f6d5088ef2dfca37903a7d9ee374d03acca5", size = 11438443 }, - { url = "https://files.pythonhosted.org/packages/d2/8b/801aa06445d2de3895f59e476f38f3f8d610ef5d6908245f07d002676cbf/mypy-1.15.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43a7682e24b4f576d93072216bf56eeff70d9140241f9edec0c104d0c515036", size = 12402541 }, - { url = "https://files.pythonhosted.org/packages/c7/67/5a4268782eb77344cc613a4cf23540928e41f018a9a1ec4c6882baf20ab8/mypy-1.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:baefc32840a9f00babd83251560e0ae1573e2f9d1b067719479bfb0e987c6357", size = 12494348 }, - { url = "https://files.pythonhosted.org/packages/83/3e/57bb447f7bbbfaabf1712d96f9df142624a386d98fb026a761532526057e/mypy-1.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:b9378e2c00146c44793c98b8d5a61039a048e31f429fb0eb546d93f4b000bedf", size = 9373648 }, - { url = "https://files.pythonhosted.org/packages/5a/fa/79cf41a55b682794abe71372151dbbf856e3008f6767057229e6649d294a/mypy-1.15.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e601a7fa172c2131bff456bb3ee08a88360760d0d2f8cbd7a75a65497e2df078", size = 10737129 }, - { url = "https://files.pythonhosted.org/packages/d3/33/dd8feb2597d648de29e3da0a8bf4e1afbda472964d2a4a0052203a6f3594/mypy-1.15.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:712e962a6357634fef20412699a3655c610110e01cdaa6180acec7fc9f8513ba", size = 9856335 }, - { url = "https://files.pythonhosted.org/packages/e4/b5/74508959c1b06b96674b364ffeb7ae5802646b32929b7701fc6b18447592/mypy-1.15.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95579473af29ab73a10bada2f9722856792a36ec5af5399b653aa28360290a5", size = 11611935 }, - { url = "https://files.pythonhosted.org/packages/6c/53/da61b9d9973efcd6507183fdad96606996191657fe79701b2c818714d573/mypy-1.15.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8f8722560a14cde92fdb1e31597760dc35f9f5524cce17836c0d22841830fd5b", size = 12365827 }, - { url = "https://files.pythonhosted.org/packages/c1/72/965bd9ee89540c79a25778cc080c7e6ef40aa1eeac4d52cec7eae6eb5228/mypy-1.15.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:1fbb8da62dc352133d7d7ca90ed2fb0e9d42bb1a32724c287d3c76c58cbaa9c2", size = 12541924 }, - { url = "https://files.pythonhosted.org/packages/46/d0/f41645c2eb263e6c77ada7d76f894c580c9ddb20d77f0c24d34273a4dab2/mypy-1.15.0-cp39-cp39-win_amd64.whl", hash = "sha256:d10d994b41fb3497719bbf866f227b3489048ea4bbbb5015357db306249f7980", size = 9271176 }, - { url = "https://files.pythonhosted.org/packages/09/4e/a7d65c7322c510de2c409ff3828b03354a7c43f5a8ed458a7a131b41c7b9/mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e", size = 2221777 }, -] - -[[package]] -name = "mypy-extensions" -version = "1.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 }, -] - -[[package]] -name = "nodeenv" -version = "1.9.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 }, -] - -[[package]] -name = "numpy" -version = "2.0.2" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version < '3.10'", -] -sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245 }, - { url = "https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04", size = 13738540 }, - { url = "https://files.pythonhosted.org/packages/ec/31/cc46e13bf07644efc7a4bf68df2df5fb2a1a88d0cd0da9ddc84dc0033e51/numpy-2.0.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66", size = 5300623 }, - { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774 }, - { url = "https://files.pythonhosted.org/packages/f9/a3/561c531c0e8bf082c5bef509d00d56f82e0ea7e1e3e3a7fc8fa78742a6e5/numpy-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd", size = 13907081 }, - { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451 }, - { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572 }, - { url = "https://files.pythonhosted.org/packages/3e/df/2619393b1e1b565cd2d4c4403bdd979621e2c4dea1f8532754b2598ed63b/numpy-2.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326", size = 14400722 }, - { url = "https://files.pythonhosted.org/packages/22/ad/77e921b9f256d5da36424ffb711ae79ca3f451ff8489eeca544d0701d74a/numpy-2.0.2-cp310-cp310-win32.whl", hash = "sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97", size = 6472170 }, - { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558 }, - { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137 }, - { url = "https://files.pythonhosted.org/packages/4a/d9/32de45561811a4b87fbdee23b5797394e3d1504b4a7cf40c10199848893e/numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195", size = 13703552 }, - { url = "https://files.pythonhosted.org/packages/c1/ca/2f384720020c7b244d22508cb7ab23d95f179fcfff33c31a6eeba8d6c512/numpy-2.0.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57", size = 5298957 }, - { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573 }, - { url = "https://files.pythonhosted.org/packages/a0/72/cfc3a1beb2caf4efc9d0b38a15fe34025230da27e1c08cc2eb9bfb1c7231/numpy-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669", size = 13914330 }, - { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895 }, - { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253 }, - { url = "https://files.pythonhosted.org/packages/df/87/f76450e6e1c14e5bb1eae6836478b1028e096fd02e85c1c37674606ab752/numpy-2.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15", size = 14414074 }, - { url = "https://files.pythonhosted.org/packages/5c/ca/0f0f328e1e59f73754f06e1adfb909de43726d4f24c6a3f8805f34f2b0fa/numpy-2.0.2-cp311-cp311-win32.whl", hash = "sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4", size = 6470640 }, - { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230 }, - { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803 }, - { url = "https://files.pythonhosted.org/packages/46/92/1b8b8dee833f53cef3e0a3f69b2374467789e0bb7399689582314df02651/numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e", size = 13471835 }, - { url = "https://files.pythonhosted.org/packages/7f/19/e2793bde475f1edaea6945be141aef6c8b4c669b90c90a300a8954d08f0a/numpy-2.0.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c", size = 5038499 }, - { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497 }, - { url = "https://files.pythonhosted.org/packages/72/21/67f36eac8e2d2cd652a2e69595a54128297cdcb1ff3931cfc87838874bd4/numpy-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692", size = 13621158 }, - { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173 }, - { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174 }, - { url = "https://files.pythonhosted.org/packages/71/af/a469674070c8d8408384e3012e064299f7a2de540738a8e414dcfd639996/numpy-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded", size = 14099701 }, - { url = "https://files.pythonhosted.org/packages/d0/3d/08ea9f239d0e0e939b6ca52ad403c84a2bce1bde301a8eb4888c1c1543f1/numpy-2.0.2-cp312-cp312-win32.whl", hash = "sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5", size = 6174313 }, - { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179 }, - { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942 }, - { url = "https://files.pythonhosted.org/packages/39/bc/fd298f308dcd232b56a4031fd6ddf11c43f9917fbc937e53762f7b5a3bb1/numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd", size = 13711512 }, - { url = "https://files.pythonhosted.org/packages/96/ff/06d1aa3eeb1c614eda245c1ba4fb88c483bee6520d361641331872ac4b82/numpy-2.0.2-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b", size = 5306976 }, - { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494 }, - { url = "https://files.pythonhosted.org/packages/15/31/9dffc70da6b9bbf7968f6551967fc21156207366272c2a40b4ed6008dc9b/numpy-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1", size = 13912596 }, - { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099 }, - { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823 }, - { url = "https://files.pythonhosted.org/packages/f1/46/ea25b98b13dccaebddf1a803f8c748680d972e00507cd9bc6dcdb5aa2ac1/numpy-2.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d", size = 14404424 }, - { url = "https://files.pythonhosted.org/packages/c8/a6/177dd88d95ecf07e722d21008b1b40e681a929eb9e329684d449c36586b2/numpy-2.0.2-cp39-cp39-win32.whl", hash = "sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa", size = 6476809 }, - { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314 }, - { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288 }, - { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793 }, - { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885 }, - { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784 }, -] - -[[package]] -name = "numpy" -version = "2.2.4" -source = { registry = "https://pypi.org/simple" } -resolution-markers = [ - "python_full_version >= '3.11'", - "python_full_version == '3.10.*'", -] -sdist = { url = "https://files.pythonhosted.org/packages/e1/78/31103410a57bc2c2b93a3597340a8119588571f6a4539067546cb9a0bfac/numpy-2.2.4.tar.gz", hash = "sha256:9ba03692a45d3eef66559efe1d1096c4b9b75c0986b5dff5530c378fb8331d4f", size = 20270701 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/04/89/a79e86e5c1433926ed7d60cb267fb64aa578b6101ab645800fd43b4801de/numpy-2.2.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8146f3550d627252269ac42ae660281d673eb6f8b32f113538e0cc2a9aed42b9", size = 21250661 }, - { url = "https://files.pythonhosted.org/packages/79/c2/f50921beb8afd60ed9589ad880332cfefdb805422210d327fb48f12b7a81/numpy-2.2.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e642d86b8f956098b564a45e6f6ce68a22c2c97a04f5acd3f221f57b8cb850ae", size = 14389926 }, - { url = "https://files.pythonhosted.org/packages/c7/b9/2c4e96130b0b0f97b0ef4a06d6dae3b39d058b21a5e2fa2decd7fd6b1c8f/numpy-2.2.4-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:a84eda42bd12edc36eb5b53bbcc9b406820d3353f1994b6cfe453a33ff101775", size = 5428329 }, - { url = "https://files.pythonhosted.org/packages/7f/a5/3d7094aa898f4fc5c84cdfb26beeae780352d43f5d8bdec966c4393d644c/numpy-2.2.4-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:4ba5054787e89c59c593a4169830ab362ac2bee8a969249dc56e5d7d20ff8df9", size = 6963559 }, - { url = "https://files.pythonhosted.org/packages/4c/22/fb1be710a14434c09080dd4a0acc08939f612ec02efcb04b9e210474782d/numpy-2.2.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7716e4a9b7af82c06a2543c53ca476fa0b57e4d760481273e09da04b74ee6ee2", size = 14368066 }, - { url = "https://files.pythonhosted.org/packages/c2/07/2e5cc71193e3ef3a219ffcf6ca4858e46ea2be09c026ddd480d596b32867/numpy-2.2.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:adf8c1d66f432ce577d0197dceaac2ac00c0759f573f28516246351c58a85020", size = 16417040 }, - { url = "https://files.pythonhosted.org/packages/1a/97/3b1537776ad9a6d1a41813818343745e8dd928a2916d4c9edcd9a8af1dac/numpy-2.2.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:218f061d2faa73621fa23d6359442b0fc658d5b9a70801373625d958259eaca3", size = 15879862 }, - { url = "https://files.pythonhosted.org/packages/b0/b7/4472f603dd45ef36ff3d8e84e84fe02d9467c78f92cc121633dce6da307b/numpy-2.2.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:df2f57871a96bbc1b69733cd4c51dc33bea66146b8c63cacbfed73eec0883017", size = 18206032 }, - { url = "https://files.pythonhosted.org/packages/0d/bd/6a092963fb82e6c5aa0d0440635827bbb2910da229545473bbb58c537ed3/numpy-2.2.4-cp310-cp310-win32.whl", hash = "sha256:a0258ad1f44f138b791327961caedffbf9612bfa504ab9597157806faa95194a", size = 6608517 }, - { url = "https://files.pythonhosted.org/packages/01/e3/cb04627bc2a1638948bc13e818df26495aa18e20d5be1ed95ab2b10b6847/numpy-2.2.4-cp310-cp310-win_amd64.whl", hash = "sha256:0d54974f9cf14acf49c60f0f7f4084b6579d24d439453d5fc5805d46a165b542", size = 12943498 }, - { url = "https://files.pythonhosted.org/packages/16/fb/09e778ee3a8ea0d4dc8329cca0a9c9e65fed847d08e37eba74cb7ed4b252/numpy-2.2.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e9e0a277bb2eb5d8a7407e14688b85fd8ad628ee4e0c7930415687b6564207a4", size = 21254989 }, - { url = "https://files.pythonhosted.org/packages/a2/0a/1212befdbecab5d80eca3cde47d304cad986ad4eec7d85a42e0b6d2cc2ef/numpy-2.2.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9eeea959168ea555e556b8188da5fa7831e21d91ce031e95ce23747b7609f8a4", size = 14425910 }, - { url = "https://files.pythonhosted.org/packages/2b/3e/e7247c1d4f15086bb106c8d43c925b0b2ea20270224f5186fa48d4fb5cbd/numpy-2.2.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:bd3ad3b0a40e713fc68f99ecfd07124195333f1e689387c180813f0e94309d6f", size = 5426490 }, - { url = "https://files.pythonhosted.org/packages/5d/fa/aa7cd6be51419b894c5787a8a93c3302a1ed4f82d35beb0613ec15bdd0e2/numpy-2.2.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:cf28633d64294969c019c6df4ff37f5698e8326db68cc2b66576a51fad634880", size = 6967754 }, - { url = "https://files.pythonhosted.org/packages/d5/ee/96457c943265de9fadeb3d2ffdbab003f7fba13d971084a9876affcda095/numpy-2.2.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2fa8fa7697ad1646b5c93de1719965844e004fcad23c91228aca1cf0800044a1", size = 14373079 }, - { url = "https://files.pythonhosted.org/packages/c5/5c/ceefca458559f0ccc7a982319f37ed07b0d7b526964ae6cc61f8ad1b6119/numpy-2.2.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f4162988a360a29af158aeb4a2f4f09ffed6a969c9776f8f3bdee9b06a8ab7e5", size = 16428819 }, - { url = "https://files.pythonhosted.org/packages/22/31/9b2ac8eee99e001eb6add9fa27514ef5e9faf176169057a12860af52704c/numpy-2.2.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:892c10d6a73e0f14935c31229e03325a7b3093fafd6ce0af704be7f894d95687", size = 15881470 }, - { url = "https://files.pythonhosted.org/packages/f0/dc/8569b5f25ff30484b555ad8a3f537e0225d091abec386c9420cf5f7a2976/numpy-2.2.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db1f1c22173ac1c58db249ae48aa7ead29f534b9a948bc56828337aa84a32ed6", size = 18218144 }, - { url = "https://files.pythonhosted.org/packages/5e/05/463c023a39bdeb9bb43a99e7dee2c664cb68d5bb87d14f92482b9f6011cc/numpy-2.2.4-cp311-cp311-win32.whl", hash = "sha256:ea2bb7e2ae9e37d96835b3576a4fa4b3a97592fbea8ef7c3587078b0068b8f09", size = 6606368 }, - { url = "https://files.pythonhosted.org/packages/8b/72/10c1d2d82101c468a28adc35de6c77b308f288cfd0b88e1070f15b98e00c/numpy-2.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:f7de08cbe5551911886d1ab60de58448c6df0f67d9feb7d1fb21e9875ef95e91", size = 12947526 }, - { url = "https://files.pythonhosted.org/packages/a2/30/182db21d4f2a95904cec1a6f779479ea1ac07c0647f064dea454ec650c42/numpy-2.2.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a7b9084668aa0f64e64bd00d27ba5146ef1c3a8835f3bd912e7a9e01326804c4", size = 20947156 }, - { url = "https://files.pythonhosted.org/packages/24/6d/9483566acfbda6c62c6bc74b6e981c777229d2af93c8eb2469b26ac1b7bc/numpy-2.2.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:dbe512c511956b893d2dacd007d955a3f03d555ae05cfa3ff1c1ff6df8851854", size = 14133092 }, - { url = "https://files.pythonhosted.org/packages/27/f6/dba8a258acbf9d2bed2525cdcbb9493ef9bae5199d7a9cb92ee7e9b2aea6/numpy-2.2.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:bb649f8b207ab07caebba230d851b579a3c8711a851d29efe15008e31bb4de24", size = 5163515 }, - { url = "https://files.pythonhosted.org/packages/62/30/82116199d1c249446723c68f2c9da40d7f062551036f50b8c4caa42ae252/numpy-2.2.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:f34dc300df798742b3d06515aa2a0aee20941c13579d7a2f2e10af01ae4901ee", size = 6696558 }, - { url = "https://files.pythonhosted.org/packages/0e/b2/54122b3c6df5df3e87582b2e9430f1bdb63af4023c739ba300164c9ae503/numpy-2.2.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3f7ac96b16955634e223b579a3e5798df59007ca43e8d451a0e6a50f6bfdfba", size = 14084742 }, - { url = "https://files.pythonhosted.org/packages/02/e2/e2cbb8d634151aab9528ef7b8bab52ee4ab10e076509285602c2a3a686e0/numpy-2.2.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f92084defa704deadd4e0a5ab1dc52d8ac9e8a8ef617f3fbb853e79b0ea3592", size = 16134051 }, - { url = "https://files.pythonhosted.org/packages/8e/21/efd47800e4affc993e8be50c1b768de038363dd88865920439ef7b422c60/numpy-2.2.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7a4e84a6283b36632e2a5b56e121961f6542ab886bc9e12f8f9818b3c266bfbb", size = 15578972 }, - { url = "https://files.pythonhosted.org/packages/04/1e/f8bb88f6157045dd5d9b27ccf433d016981032690969aa5c19e332b138c0/numpy-2.2.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:11c43995255eb4127115956495f43e9343736edb7fcdb0d973defd9de14cd84f", size = 17898106 }, - { url = "https://files.pythonhosted.org/packages/2b/93/df59a5a3897c1f036ae8ff845e45f4081bb06943039ae28a3c1c7c780f22/numpy-2.2.4-cp312-cp312-win32.whl", hash = "sha256:65ef3468b53269eb5fdb3a5c09508c032b793da03251d5f8722b1194f1790c00", size = 6311190 }, - { url = "https://files.pythonhosted.org/packages/46/69/8c4f928741c2a8efa255fdc7e9097527c6dc4e4df147e3cadc5d9357ce85/numpy-2.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:2aad3c17ed2ff455b8eaafe06bcdae0062a1db77cb99f4b9cbb5f4ecb13c5146", size = 12644305 }, - { url = "https://files.pythonhosted.org/packages/2a/d0/bd5ad792e78017f5decfb2ecc947422a3669a34f775679a76317af671ffc/numpy-2.2.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cf4e5c6a278d620dee9ddeb487dc6a860f9b199eadeecc567f777daace1e9e7", size = 20933623 }, - { url = "https://files.pythonhosted.org/packages/c3/bc/2b3545766337b95409868f8e62053135bdc7fa2ce630aba983a2aa60b559/numpy-2.2.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1974afec0b479e50438fc3648974268f972e2d908ddb6d7fb634598cdb8260a0", size = 14148681 }, - { url = "https://files.pythonhosted.org/packages/6a/70/67b24d68a56551d43a6ec9fe8c5f91b526d4c1a46a6387b956bf2d64744e/numpy-2.2.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:79bd5f0a02aa16808fcbc79a9a376a147cc1045f7dfe44c6e7d53fa8b8a79392", size = 5148759 }, - { url = "https://files.pythonhosted.org/packages/1c/8b/e2fc8a75fcb7be12d90b31477c9356c0cbb44abce7ffb36be39a0017afad/numpy-2.2.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:3387dd7232804b341165cedcb90694565a6015433ee076c6754775e85d86f1fc", size = 6683092 }, - { url = "https://files.pythonhosted.org/packages/13/73/41b7b27f169ecf368b52533edb72e56a133f9e86256e809e169362553b49/numpy-2.2.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f527d8fdb0286fd2fd97a2a96c6be17ba4232da346931d967a0630050dfd298", size = 14081422 }, - { url = "https://files.pythonhosted.org/packages/4b/04/e208ff3ae3ddfbafc05910f89546382f15a3f10186b1f56bd99f159689c2/numpy-2.2.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bce43e386c16898b91e162e5baaad90c4b06f9dcbe36282490032cec98dc8ae7", size = 16132202 }, - { url = "https://files.pythonhosted.org/packages/fe/bc/2218160574d862d5e55f803d88ddcad88beff94791f9c5f86d67bd8fbf1c/numpy-2.2.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:31504f970f563d99f71a3512d0c01a645b692b12a63630d6aafa0939e52361e6", size = 15573131 }, - { url = "https://files.pythonhosted.org/packages/a5/78/97c775bc4f05abc8a8426436b7cb1be806a02a2994b195945600855e3a25/numpy-2.2.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:81413336ef121a6ba746892fad881a83351ee3e1e4011f52e97fba79233611fd", size = 17894270 }, - { url = "https://files.pythonhosted.org/packages/b9/eb/38c06217a5f6de27dcb41524ca95a44e395e6a1decdc0c99fec0832ce6ae/numpy-2.2.4-cp313-cp313-win32.whl", hash = "sha256:f486038e44caa08dbd97275a9a35a283a8f1d2f0ee60ac260a1790e76660833c", size = 6308141 }, - { url = "https://files.pythonhosted.org/packages/52/17/d0dd10ab6d125c6d11ffb6dfa3423c3571befab8358d4f85cd4471964fcd/numpy-2.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:207a2b8441cc8b6a2a78c9ddc64d00d20c303d79fba08c577752f080c4007ee3", size = 12636885 }, - { url = "https://files.pythonhosted.org/packages/fa/e2/793288ede17a0fdc921172916efb40f3cbc2aa97e76c5c84aba6dc7e8747/numpy-2.2.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8120575cb4882318c791f839a4fd66161a6fa46f3f0a5e613071aae35b5dd8f8", size = 20961829 }, - { url = "https://files.pythonhosted.org/packages/3a/75/bb4573f6c462afd1ea5cbedcc362fe3e9bdbcc57aefd37c681be1155fbaa/numpy-2.2.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a761ba0fa886a7bb33c6c8f6f20213735cb19642c580a931c625ee377ee8bd39", size = 14161419 }, - { url = "https://files.pythonhosted.org/packages/03/68/07b4cd01090ca46c7a336958b413cdbe75002286295f2addea767b7f16c9/numpy-2.2.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:ac0280f1ba4a4bfff363a99a6aceed4f8e123f8a9b234c89140f5e894e452ecd", size = 5196414 }, - { url = "https://files.pythonhosted.org/packages/a5/fd/d4a29478d622fedff5c4b4b4cedfc37a00691079623c0575978d2446db9e/numpy-2.2.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:879cf3a9a2b53a4672a168c21375166171bc3932b7e21f622201811c43cdd3b0", size = 6709379 }, - { url = "https://files.pythonhosted.org/packages/41/78/96dddb75bb9be730b87c72f30ffdd62611aba234e4e460576a068c98eff6/numpy-2.2.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f05d4198c1bacc9124018109c5fba2f3201dbe7ab6e92ff100494f236209c960", size = 14051725 }, - { url = "https://files.pythonhosted.org/packages/00/06/5306b8199bffac2a29d9119c11f457f6c7d41115a335b78d3f86fad4dbe8/numpy-2.2.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2f085ce2e813a50dfd0e01fbfc0c12bbe5d2063d99f8b29da30e544fb6483b8", size = 16101638 }, - { url = "https://files.pythonhosted.org/packages/fa/03/74c5b631ee1ded596945c12027649e6344614144369fd3ec1aaced782882/numpy-2.2.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:92bda934a791c01d6d9d8e038363c50918ef7c40601552a58ac84c9613a665bc", size = 15571717 }, - { url = "https://files.pythonhosted.org/packages/cb/dc/4fc7c0283abe0981e3b89f9b332a134e237dd476b0c018e1e21083310c31/numpy-2.2.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ee4d528022f4c5ff67332469e10efe06a267e32f4067dc76bb7e2cddf3cd25ff", size = 17879998 }, - { url = "https://files.pythonhosted.org/packages/e5/2b/878576190c5cfa29ed896b518cc516aecc7c98a919e20706c12480465f43/numpy-2.2.4-cp313-cp313t-win32.whl", hash = "sha256:05c076d531e9998e7e694c36e8b349969c56eadd2cdcd07242958489d79a7286", size = 6366896 }, - { url = "https://files.pythonhosted.org/packages/3e/05/eb7eec66b95cf697f08c754ef26c3549d03ebd682819f794cb039574a0a6/numpy-2.2.4-cp313-cp313t-win_amd64.whl", hash = "sha256:188dcbca89834cc2e14eb2f106c96d6d46f200fe0200310fc29089657379c58d", size = 12739119 }, - { url = "https://files.pythonhosted.org/packages/b2/5c/f09c33a511aff41a098e6ef3498465d95f6360621034a3d95f47edbc9119/numpy-2.2.4-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7051ee569db5fbac144335e0f3b9c2337e0c8d5c9fee015f259a5bd70772b7e8", size = 21081956 }, - { url = "https://files.pythonhosted.org/packages/ba/30/74c48b3b6494c4b820b7fa1781d441e94d87a08daa5b35d222f06ba41a6f/numpy-2.2.4-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:ab2939cd5bec30a7430cbdb2287b63151b77cf9624de0532d629c9a1c59b1d5c", size = 6827143 }, - { url = "https://files.pythonhosted.org/packages/54/f5/ab0d2f48b490535c7a80e05da4a98902b632369efc04f0e47bb31ca97d8f/numpy-2.2.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d0f35b19894a9e08639fd60a1ec1978cb7f5f7f1eace62f38dd36be8aecdef4d", size = 16233350 }, - { url = "https://files.pythonhosted.org/packages/3b/3a/2f6d8c1f8e45d496bca6baaec93208035faeb40d5735c25afac092ec9a12/numpy-2.2.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:b4adfbbc64014976d2f91084915ca4e626fbf2057fb81af209c1a6d776d23e3d", size = 12857565 }, -] - -[[package]] -name = "ome-types" -version = "0.6.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pydantic" }, - { name = "pydantic-extra-types" }, - { name = "xsdata" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/cb/49/f9d313e03eefb4a7f81d1edba8493a4a40ef622bb48bab2f03600ee1ad86/ome_types-0.6.1.tar.gz", hash = "sha256:49e7a79ac90f8e4c33392f285491cb2577d41f2583bb879307c4f5ba9436e721", size = 121623 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/93/c7/5d63372b13bfe9eaff26d540e7a1d2da5f0b4d82a5cbe634b638f1df61a3/ome_types-0.6.1-py3-none-any.whl", hash = "sha256:128f9bd5f52212cf37dad087ee4a7df939ccbf40a328d986e0bf9ac564abd4e9", size = 245142 }, -] - -[[package]] -name = "packaging" -version = "24.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, -] - -[[package]] -name = "parso" -version = "0.8.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650 }, -] - -[[package]] -name = "partd" -version = "1.4.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "locket" }, - { name = "toolz" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b2/3a/3f06f34820a31257ddcabdfafc2672c5816be79c7e353b02c1f318daa7d4/partd-1.4.2.tar.gz", hash = "sha256:d022c33afbdc8405c226621b015e8067888173d85f7f5ecebb3cafed9a20f02c", size = 21029 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/71/e7/40fb618334dcdf7c5a316c0e7343c5cd82d3d866edc100d98e29bc945ecd/partd-1.4.2-py3-none-any.whl", hash = "sha256:978e4ac767ec4ba5b86c6eaa52e5a2a3bc748a2ca839e8cc798f1cc6ce6efb0f", size = 18905 }, -] - -[[package]] -name = "pdbpp" -version = "0.11.6" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "fancycompleter" }, - { name = "pygments" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/27/ef/e6ae1a1e1d2cbe0fbf04f22b21d7d58e8e13d24dfcc3b6a4dea18a3ed1e0/pdbpp-0.11.6.tar.gz", hash = "sha256:36a73c5bcf0c3c35034be4cf99e6106e3ee0c8f5e0faafc2cf9be5f1481eb4b7", size = 78178 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/c5/e1/77fa5c45fcd95a80b0d793b604c19b71c9fa8d5b27d403eced79f3842828/pdbpp-0.11.6-py3-none-any.whl", hash = "sha256:8e024d36bd2f35a3b19d8732524c696b8b4aef633250d28547198e746cd81ccb", size = 33334 }, -] - -[[package]] -name = "pexpect" -version = "4.9.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "ptyprocess" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772 }, -] - -[[package]] -name = "platformdirs" -version = "4.3.7" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/b6/2d/7d512a3913d60623e7eb945c6d1b4f0bddf1d0b7ada5225274c87e5b53d1/platformdirs-4.3.7.tar.gz", hash = "sha256:eb437d586b6a0986388f0d6f74aa0cde27b48d0e3d66843640bfb6bdcdb6e351", size = 21291 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6d/45/59578566b3275b8fd9157885918fcd0c4d74162928a5310926887b856a51/platformdirs-4.3.7-py3-none-any.whl", hash = "sha256:a03875334331946f13c549dbd8f4bac7a13a50a895a0eb1e8c6a8ace80d40a94", size = 18499 }, -] - -[[package]] -name = "pluggy" -version = "1.5.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, -] - -[[package]] -name = "pre-commit" -version = "4.2.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "cfgv" }, - { name = "identify" }, - { name = "nodeenv" }, - { name = "pyyaml" }, - { name = "virtualenv" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/08/39/679ca9b26c7bb2999ff122d50faa301e49af82ca9c066ec061cfbc0c6784/pre_commit-4.2.0.tar.gz", hash = "sha256:601283b9757afd87d40c4c4a9b2b5de9637a8ea02eaff7adc2d0fb4e04841146", size = 193424 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/88/74/a88bf1b1efeae488a0c0b7bdf71429c313722d1fc0f377537fbe554e6180/pre_commit-4.2.0-py2.py3-none-any.whl", hash = "sha256:a009ca7205f1eb497d10b845e52c838a98b6cdd2102a6c8e4540e94ee75c58bd", size = 220707 }, -] - -[[package]] -name = "prompt-toolkit" -version = "3.0.51" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "wcwidth" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/bb/6e/9d084c929dfe9e3bfe0c6a47e31f78a25c54627d64a66e884a8bf5474f1c/prompt_toolkit-3.0.51.tar.gz", hash = "sha256:931a162e3b27fc90c86f1b48bb1fb2c528c2761475e57c9c06de13311c7b54ed", size = 428940 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl", hash = "sha256:52742911fde84e2d423e2f9a4cf1de7d7ac4e51958f648d9540e0fb8db077b07", size = 387810 }, -] - -[[package]] -name = "psutil" -version = "7.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051 }, - { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535 }, - { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004 }, - { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986 }, - { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544 }, - { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053 }, - { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885 }, -] - -[[package]] -name = "ptyprocess" -version = "0.7.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993 }, -] - -[[package]] -name = "pure-eval" -version = "0.2.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842 }, -] - -[[package]] -name = "pydantic" -version = "2.11.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "annotated-types" }, - { name = "pydantic-core" }, - { name = "typing-extensions" }, - { name = "typing-inspection" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/10/2e/ca897f093ee6c5f3b0bee123ee4465c50e75431c3d5b6a3b44a47134e891/pydantic-2.11.3.tar.gz", hash = "sha256:7471657138c16adad9322fe3070c0116dd6c3ad8d649300e3cbdfe91f4db4ec3", size = 785513 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b0/1d/407b29780a289868ed696d1616f4aad49d6388e5a77f567dcd2629dcd7b8/pydantic-2.11.3-py3-none-any.whl", hash = "sha256:a082753436a07f9ba1289c6ffa01cd93db3548776088aa917cc43b63f68fa60f", size = 443591 }, -] - -[[package]] -name = "pydantic-core" -version = "2.33.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/17/19/ed6a078a5287aea7922de6841ef4c06157931622c89c2a47940837b5eecd/pydantic_core-2.33.1.tar.gz", hash = "sha256:bcc9c6fdb0ced789245b02b7d6603e17d1563064ddcfc36f046b61c0c05dd9df", size = 434395 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/38/ea/5f572806ab4d4223d11551af814d243b0e3e02cc6913def4d1fe4a5ca41c/pydantic_core-2.33.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:3077cfdb6125cc8dab61b155fdd714663e401f0e6883f9632118ec12cf42df26", size = 2044021 }, - { url = "https://files.pythonhosted.org/packages/8c/d1/f86cc96d2aa80e3881140d16d12ef2b491223f90b28b9a911346c04ac359/pydantic_core-2.33.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8ffab8b2908d152e74862d276cf5017c81a2f3719f14e8e3e8d6b83fda863927", size = 1861742 }, - { url = "https://files.pythonhosted.org/packages/37/08/fbd2cd1e9fc735a0df0142fac41c114ad9602d1c004aea340169ae90973b/pydantic_core-2.33.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5183e4f6a2d468787243ebcd70cf4098c247e60d73fb7d68d5bc1e1beaa0c4db", size = 1910414 }, - { url = "https://files.pythonhosted.org/packages/7f/73/3ac217751decbf8d6cb9443cec9b9eb0130eeada6ae56403e11b486e277e/pydantic_core-2.33.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:398a38d323f37714023be1e0285765f0a27243a8b1506b7b7de87b647b517e48", size = 1996848 }, - { url = "https://files.pythonhosted.org/packages/9a/f5/5c26b265cdcff2661e2520d2d1e9db72d117ea00eb41e00a76efe68cb009/pydantic_core-2.33.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:87d3776f0001b43acebfa86f8c64019c043b55cc5a6a2e313d728b5c95b46969", size = 2141055 }, - { url = "https://files.pythonhosted.org/packages/5d/14/a9c3cee817ef2f8347c5ce0713e91867a0dceceefcb2973942855c917379/pydantic_core-2.33.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c566dd9c5f63d22226409553531f89de0cac55397f2ab8d97d6f06cfce6d947e", size = 2753806 }, - { url = "https://files.pythonhosted.org/packages/f2/68/866ce83a51dd37e7c604ce0050ff6ad26de65a7799df89f4db87dd93d1d6/pydantic_core-2.33.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0d5f3acc81452c56895e90643a625302bd6be351e7010664151cc55b7b97f89", size = 2007777 }, - { url = "https://files.pythonhosted.org/packages/b6/a8/36771f4404bb3e49bd6d4344da4dede0bf89cc1e01f3b723c47248a3761c/pydantic_core-2.33.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d3a07fadec2a13274a8d861d3d37c61e97a816beae717efccaa4b36dfcaadcde", size = 2122803 }, - { url = "https://files.pythonhosted.org/packages/18/9c/730a09b2694aa89360d20756369822d98dc2f31b717c21df33b64ffd1f50/pydantic_core-2.33.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:f99aeda58dce827f76963ee87a0ebe75e648c72ff9ba1174a253f6744f518f65", size = 2086755 }, - { url = "https://files.pythonhosted.org/packages/54/8e/2dccd89602b5ec31d1c58138d02340ecb2ebb8c2cac3cc66b65ce3edb6ce/pydantic_core-2.33.1-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:902dbc832141aa0ec374f4310f1e4e7febeebc3256f00dc359a9ac3f264a45dc", size = 2257358 }, - { url = "https://files.pythonhosted.org/packages/d1/9c/126e4ac1bfad8a95a9837acdd0963695d69264179ba4ede8b8c40d741702/pydantic_core-2.33.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fe44d56aa0b00d66640aa84a3cbe80b7a3ccdc6f0b1ca71090696a6d4777c091", size = 2257916 }, - { url = "https://files.pythonhosted.org/packages/7d/ba/91eea2047e681a6853c81c20aeca9dcdaa5402ccb7404a2097c2adf9d038/pydantic_core-2.33.1-cp310-cp310-win32.whl", hash = "sha256:ed3eb16d51257c763539bde21e011092f127a2202692afaeaccb50db55a31383", size = 1923823 }, - { url = "https://files.pythonhosted.org/packages/94/c0/fcdf739bf60d836a38811476f6ecd50374880b01e3014318b6e809ddfd52/pydantic_core-2.33.1-cp310-cp310-win_amd64.whl", hash = "sha256:694ad99a7f6718c1a498dc170ca430687a39894a60327f548e02a9c7ee4b6504", size = 1952494 }, - { url = "https://files.pythonhosted.org/packages/d6/7f/c6298830cb780c46b4f46bb24298d01019ffa4d21769f39b908cd14bbd50/pydantic_core-2.33.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6e966fc3caaf9f1d96b349b0341c70c8d6573bf1bac7261f7b0ba88f96c56c24", size = 2044224 }, - { url = "https://files.pythonhosted.org/packages/a8/65/6ab3a536776cad5343f625245bd38165d6663256ad43f3a200e5936afd6c/pydantic_core-2.33.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bfd0adeee563d59c598ceabddf2c92eec77abcb3f4a391b19aa7366170bd9e30", size = 1858845 }, - { url = "https://files.pythonhosted.org/packages/e9/15/9a22fd26ba5ee8c669d4b8c9c244238e940cd5d818649603ca81d1c69861/pydantic_core-2.33.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:91815221101ad3c6b507804178a7bb5cb7b2ead9ecd600041669c8d805ebd595", size = 1910029 }, - { url = "https://files.pythonhosted.org/packages/d5/33/8cb1a62818974045086f55f604044bf35b9342900318f9a2a029a1bec460/pydantic_core-2.33.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9fea9c1869bb4742d174a57b4700c6dadea951df8b06de40c2fedb4f02931c2e", size = 1997784 }, - { url = "https://files.pythonhosted.org/packages/c0/ca/49958e4df7715c71773e1ea5be1c74544923d10319173264e6db122543f9/pydantic_core-2.33.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d20eb4861329bb2484c021b9d9a977566ab16d84000a57e28061151c62b349a", size = 2141075 }, - { url = "https://files.pythonhosted.org/packages/7b/a6/0b3a167a9773c79ba834b959b4e18c3ae9216b8319bd8422792abc8a41b1/pydantic_core-2.33.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb935c5591573ae3201640579f30128ccc10739b45663f93c06796854405505", size = 2745849 }, - { url = "https://files.pythonhosted.org/packages/0b/60/516484135173aa9e5861d7a0663dce82e4746d2e7f803627d8c25dfa5578/pydantic_core-2.33.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c964fd24e6166420d18fb53996d8c9fd6eac9bf5ae3ec3d03015be4414ce497f", size = 2005794 }, - { url = "https://files.pythonhosted.org/packages/86/70/05b1eb77459ad47de00cf78ee003016da0cedf8b9170260488d7c21e9181/pydantic_core-2.33.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:681d65e9011f7392db5aa002b7423cc442d6a673c635668c227c6c8d0e5a4f77", size = 2123237 }, - { url = "https://files.pythonhosted.org/packages/c7/57/12667a1409c04ae7dc95d3b43158948eb0368e9c790be8b095cb60611459/pydantic_core-2.33.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e100c52f7355a48413e2999bfb4e139d2977a904495441b374f3d4fb4a170961", size = 2086351 }, - { url = "https://files.pythonhosted.org/packages/57/61/cc6d1d1c1664b58fdd6ecc64c84366c34ec9b606aeb66cafab6f4088974c/pydantic_core-2.33.1-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:048831bd363490be79acdd3232f74a0e9951b11b2b4cc058aeb72b22fdc3abe1", size = 2258914 }, - { url = "https://files.pythonhosted.org/packages/d1/0a/edb137176a1f5419b2ddee8bde6a0a548cfa3c74f657f63e56232df8de88/pydantic_core-2.33.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:bdc84017d28459c00db6f918a7272a5190bec3090058334e43a76afb279eac7c", size = 2257385 }, - { url = "https://files.pythonhosted.org/packages/26/3c/48ca982d50e4b0e1d9954919c887bdc1c2b462801bf408613ccc641b3daa/pydantic_core-2.33.1-cp311-cp311-win32.whl", hash = "sha256:32cd11c5914d1179df70406427097c7dcde19fddf1418c787540f4b730289896", size = 1923765 }, - { url = "https://files.pythonhosted.org/packages/33/cd/7ab70b99e5e21559f5de38a0928ea84e6f23fdef2b0d16a6feaf942b003c/pydantic_core-2.33.1-cp311-cp311-win_amd64.whl", hash = "sha256:2ea62419ba8c397e7da28a9170a16219d310d2cf4970dbc65c32faf20d828c83", size = 1950688 }, - { url = "https://files.pythonhosted.org/packages/4b/ae/db1fc237b82e2cacd379f63e3335748ab88b5adde98bf7544a1b1bd10a84/pydantic_core-2.33.1-cp311-cp311-win_arm64.whl", hash = "sha256:fc903512177361e868bc1f5b80ac8c8a6e05fcdd574a5fb5ffeac5a9982b9e89", size = 1908185 }, - { url = "https://files.pythonhosted.org/packages/c8/ce/3cb22b07c29938f97ff5f5bb27521f95e2ebec399b882392deb68d6c440e/pydantic_core-2.33.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:1293d7febb995e9d3ec3ea09caf1a26214eec45b0f29f6074abb004723fc1de8", size = 2026640 }, - { url = "https://files.pythonhosted.org/packages/19/78/f381d643b12378fee782a72126ec5d793081ef03791c28a0fd542a5bee64/pydantic_core-2.33.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:99b56acd433386c8f20be5c4000786d1e7ca0523c8eefc995d14d79c7a081498", size = 1852649 }, - { url = "https://files.pythonhosted.org/packages/9d/2b/98a37b80b15aac9eb2c6cfc6dbd35e5058a352891c5cce3a8472d77665a6/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35a5ec3fa8c2fe6c53e1b2ccc2454398f95d5393ab398478f53e1afbbeb4d939", size = 1892472 }, - { url = "https://files.pythonhosted.org/packages/4e/d4/3c59514e0f55a161004792b9ff3039da52448f43f5834f905abef9db6e4a/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b172f7b9d2f3abc0efd12e3386f7e48b576ef309544ac3a63e5e9cdd2e24585d", size = 1977509 }, - { url = "https://files.pythonhosted.org/packages/a9/b6/c2c7946ef70576f79a25db59a576bce088bdc5952d1b93c9789b091df716/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9097b9f17f91eea659b9ec58148c0747ec354a42f7389b9d50701610d86f812e", size = 2128702 }, - { url = "https://files.pythonhosted.org/packages/88/fe/65a880f81e3f2a974312b61f82a03d85528f89a010ce21ad92f109d94deb/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cc77ec5b7e2118b152b0d886c7514a4653bcb58c6b1d760134a9fab915f777b3", size = 2679428 }, - { url = "https://files.pythonhosted.org/packages/6f/ff/4459e4146afd0462fb483bb98aa2436d69c484737feaceba1341615fb0ac/pydantic_core-2.33.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5e3d15245b08fa4a84cefc6c9222e6f37c98111c8679fbd94aa145f9a0ae23d", size = 2008753 }, - { url = "https://files.pythonhosted.org/packages/7c/76/1c42e384e8d78452ededac8b583fe2550c84abfef83a0552e0e7478ccbc3/pydantic_core-2.33.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ef99779001d7ac2e2461d8ab55d3373fe7315caefdbecd8ced75304ae5a6fc6b", size = 2114849 }, - { url = "https://files.pythonhosted.org/packages/00/72/7d0cf05095c15f7ffe0eb78914b166d591c0eed72f294da68378da205101/pydantic_core-2.33.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:fc6bf8869e193855e8d91d91f6bf59699a5cdfaa47a404e278e776dd7f168b39", size = 2069541 }, - { url = "https://files.pythonhosted.org/packages/b3/69/94a514066bb7d8be499aa764926937409d2389c09be0b5107a970286ef81/pydantic_core-2.33.1-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:b1caa0bc2741b043db7823843e1bde8aaa58a55a58fda06083b0569f8b45693a", size = 2239225 }, - { url = "https://files.pythonhosted.org/packages/84/b0/e390071eadb44b41f4f54c3cef64d8bf5f9612c92686c9299eaa09e267e2/pydantic_core-2.33.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ec259f62538e8bf364903a7d0d0239447059f9434b284f5536e8402b7dd198db", size = 2248373 }, - { url = "https://files.pythonhosted.org/packages/d6/b2/288b3579ffc07e92af66e2f1a11be3b056fe1214aab314748461f21a31c3/pydantic_core-2.33.1-cp312-cp312-win32.whl", hash = "sha256:e14f369c98a7c15772b9da98987f58e2b509a93235582838bd0d1d8c08b68fda", size = 1907034 }, - { url = "https://files.pythonhosted.org/packages/02/28/58442ad1c22b5b6742b992ba9518420235adced665513868f99a1c2638a5/pydantic_core-2.33.1-cp312-cp312-win_amd64.whl", hash = "sha256:1c607801d85e2e123357b3893f82c97a42856192997b95b4d8325deb1cd0c5f4", size = 1956848 }, - { url = "https://files.pythonhosted.org/packages/a1/eb/f54809b51c7e2a1d9f439f158b8dd94359321abcc98767e16fc48ae5a77e/pydantic_core-2.33.1-cp312-cp312-win_arm64.whl", hash = "sha256:8d13f0276806ee722e70a1c93da19748594f19ac4299c7e41237fc791d1861ea", size = 1903986 }, - { url = "https://files.pythonhosted.org/packages/7a/24/eed3466a4308d79155f1cdd5c7432c80ddcc4530ba8623b79d5ced021641/pydantic_core-2.33.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:70af6a21237b53d1fe7b9325b20e65cbf2f0a848cf77bed492b029139701e66a", size = 2033551 }, - { url = "https://files.pythonhosted.org/packages/ab/14/df54b1a0bc9b6ded9b758b73139d2c11b4e8eb43e8ab9c5847c0a2913ada/pydantic_core-2.33.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:282b3fe1bbbe5ae35224a0dbd05aed9ccabccd241e8e6b60370484234b456266", size = 1852785 }, - { url = "https://files.pythonhosted.org/packages/fa/96/e275f15ff3d34bb04b0125d9bc8848bf69f25d784d92a63676112451bfb9/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4b315e596282bbb5822d0c7ee9d255595bd7506d1cb20c2911a4da0b970187d3", size = 1897758 }, - { url = "https://files.pythonhosted.org/packages/b7/d8/96bc536e975b69e3a924b507d2a19aedbf50b24e08c80fb00e35f9baaed8/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1dfae24cf9921875ca0ca6a8ecb4bb2f13c855794ed0d468d6abbec6e6dcd44a", size = 1986109 }, - { url = "https://files.pythonhosted.org/packages/90/72/ab58e43ce7e900b88cb571ed057b2fcd0e95b708a2e0bed475b10130393e/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6dd8ecfde08d8bfadaea669e83c63939af76f4cf5538a72597016edfa3fad516", size = 2129159 }, - { url = "https://files.pythonhosted.org/packages/dc/3f/52d85781406886c6870ac995ec0ba7ccc028b530b0798c9080531b409fdb/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2f593494876eae852dc98c43c6f260f45abdbfeec9e4324e31a481d948214764", size = 2680222 }, - { url = "https://files.pythonhosted.org/packages/f4/56/6e2ef42f363a0eec0fd92f74a91e0ac48cd2e49b695aac1509ad81eee86a/pydantic_core-2.33.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:948b73114f47fd7016088e5186d13faf5e1b2fe83f5e320e371f035557fd264d", size = 2006980 }, - { url = "https://files.pythonhosted.org/packages/4c/c0/604536c4379cc78359f9ee0aa319f4aedf6b652ec2854953f5a14fc38c5a/pydantic_core-2.33.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e11f3864eb516af21b01e25fac915a82e9ddad3bb0fb9e95a246067398b435a4", size = 2120840 }, - { url = "https://files.pythonhosted.org/packages/1f/46/9eb764814f508f0edfb291a0f75d10854d78113fa13900ce13729aaec3ae/pydantic_core-2.33.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:549150be302428b56fdad0c23c2741dcdb5572413776826c965619a25d9c6bde", size = 2072518 }, - { url = "https://files.pythonhosted.org/packages/42/e3/fb6b2a732b82d1666fa6bf53e3627867ea3131c5f39f98ce92141e3e3dc1/pydantic_core-2.33.1-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:495bc156026efafd9ef2d82372bd38afce78ddd82bf28ef5276c469e57c0c83e", size = 2248025 }, - { url = "https://files.pythonhosted.org/packages/5c/9d/fbe8fe9d1aa4dac88723f10a921bc7418bd3378a567cb5e21193a3c48b43/pydantic_core-2.33.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ec79de2a8680b1a67a07490bddf9636d5c2fab609ba8c57597e855fa5fa4dacd", size = 2254991 }, - { url = "https://files.pythonhosted.org/packages/aa/99/07e2237b8a66438d9b26482332cda99a9acccb58d284af7bc7c946a42fd3/pydantic_core-2.33.1-cp313-cp313-win32.whl", hash = "sha256:ee12a7be1742f81b8a65b36c6921022301d466b82d80315d215c4c691724986f", size = 1915262 }, - { url = "https://files.pythonhosted.org/packages/8a/f4/e457a7849beeed1e5defbcf5051c6f7b3c91a0624dd31543a64fc9adcf52/pydantic_core-2.33.1-cp313-cp313-win_amd64.whl", hash = "sha256:ede9b407e39949d2afc46385ce6bd6e11588660c26f80576c11c958e6647bc40", size = 1956626 }, - { url = "https://files.pythonhosted.org/packages/20/d0/e8d567a7cff7b04e017ae164d98011f1e1894269fe8e90ea187a3cbfb562/pydantic_core-2.33.1-cp313-cp313-win_arm64.whl", hash = "sha256:aa687a23d4b7871a00e03ca96a09cad0f28f443690d300500603bd0adba4b523", size = 1909590 }, - { url = "https://files.pythonhosted.org/packages/ef/fd/24ea4302d7a527d672c5be06e17df16aabfb4e9fdc6e0b345c21580f3d2a/pydantic_core-2.33.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:401d7b76e1000d0dd5538e6381d28febdcacb097c8d340dde7d7fc6e13e9f95d", size = 1812963 }, - { url = "https://files.pythonhosted.org/packages/5f/95/4fbc2ecdeb5c1c53f1175a32d870250194eb2fdf6291b795ab08c8646d5d/pydantic_core-2.33.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7aeb055a42d734c0255c9e489ac67e75397d59c6fbe60d155851e9782f276a9c", size = 1986896 }, - { url = "https://files.pythonhosted.org/packages/71/ae/fe31e7f4a62431222d8f65a3bd02e3fa7e6026d154a00818e6d30520ea77/pydantic_core-2.33.1-cp313-cp313t-win_amd64.whl", hash = "sha256:338ea9b73e6e109f15ab439e62cb3b78aa752c7fd9536794112e14bee02c8d18", size = 1931810 }, - { url = "https://files.pythonhosted.org/packages/49/78/b86bad645cc3e8dfa6858c70ec38939bf350e54004837c48de09474b2b9e/pydantic_core-2.33.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:5ab77f45d33d264de66e1884fca158bc920cb5e27fd0764a72f72f5756ae8bdb", size = 2044282 }, - { url = "https://files.pythonhosted.org/packages/3b/00/a02531331773b2bf08743d84c6b776bd6a449d23b3ae6b0e3229d568bac4/pydantic_core-2.33.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e7aaba1b4b03aaea7bb59e1b5856d734be011d3e6d98f5bcaa98cb30f375f2ad", size = 1877598 }, - { url = "https://files.pythonhosted.org/packages/a1/fa/32cc152b84a1f420f8a7d80161373e8d87d4ffa077e67d6c8aab3ce1a6ab/pydantic_core-2.33.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7fb66263e9ba8fea2aa85e1e5578980d127fb37d7f2e292773e7bc3a38fb0c7b", size = 1911021 }, - { url = "https://files.pythonhosted.org/packages/5e/87/ea553e0d98bce6c4876f8c50f65cb45597eff6e0aaa8b15813e9972bb19d/pydantic_core-2.33.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3f2648b9262607a7fb41d782cc263b48032ff7a03a835581abbf7a3bec62bcf5", size = 1997276 }, - { url = "https://files.pythonhosted.org/packages/f7/9b/60cb9f4b52158b3adac0066492bbadd0b8473f4f8da5bcc73972655b76ef/pydantic_core-2.33.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:723c5630c4259400818b4ad096735a829074601805d07f8cafc366d95786d331", size = 2141348 }, - { url = "https://files.pythonhosted.org/packages/9b/38/374d254e270d4de0add68a8239f4ed0f444fdd7b766ea69244fb9491dccb/pydantic_core-2.33.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d100e3ae783d2167782391e0c1c7a20a31f55f8015f3293647544df3f9c67824", size = 2753708 }, - { url = "https://files.pythonhosted.org/packages/05/a8/fd79111eb5ab9bc4ef98d8fb0b3a2ffdc80107b2c59859a741ab379c96f8/pydantic_core-2.33.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:177d50460bc976a0369920b6c744d927b0ecb8606fb56858ff542560251b19e5", size = 2008699 }, - { url = "https://files.pythonhosted.org/packages/35/31/2e06619868eb4c18642c5601db420599c1cf9cf50fe868c9ac09cd298e24/pydantic_core-2.33.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a3edde68d1a1f9af1273b2fe798997b33f90308fb6d44d8550c89fc6a3647cf6", size = 2123426 }, - { url = "https://files.pythonhosted.org/packages/4a/d0/3531e8783a311802e3db7ee5a1a5ed79e5706e930b1b4e3109ce15eeb681/pydantic_core-2.33.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a62c3c3ef6a7e2c45f7853b10b5bc4ddefd6ee3cd31024754a1a5842da7d598d", size = 2087330 }, - { url = "https://files.pythonhosted.org/packages/ac/32/5ff252ed73bacd7677a706ab17723e261a76793f98b305aa20cfc10bbd56/pydantic_core-2.33.1-cp39-cp39-musllinux_1_1_armv7l.whl", hash = "sha256:c91dbb0ab683fa0cd64a6e81907c8ff41d6497c346890e26b23de7ee55353f96", size = 2258171 }, - { url = "https://files.pythonhosted.org/packages/c9/f9/e96e00f92b8f5b3e2cddc80c5ee6cf038f8a0f238c44b67b01759943a7b4/pydantic_core-2.33.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9f466e8bf0a62dc43e068c12166281c2eca72121dd2adc1040f3aa1e21ef8599", size = 2258745 }, - { url = "https://files.pythonhosted.org/packages/54/1e/51c86688e809d94797fdf0efc41514f001caec982a05f62d90c180a9639d/pydantic_core-2.33.1-cp39-cp39-win32.whl", hash = "sha256:ab0277cedb698749caada82e5d099dc9fed3f906a30d4c382d1a21725777a1e5", size = 1923626 }, - { url = "https://files.pythonhosted.org/packages/57/18/c2da959fd8d019b70cadafdda2bf845378ada47973e0bad6cc84f56dbe6e/pydantic_core-2.33.1-cp39-cp39-win_amd64.whl", hash = "sha256:5773da0ee2d17136b1f1c6fbde543398d452a6ad2a7b54ea1033e2daa739b8d2", size = 1953703 }, - { url = "https://files.pythonhosted.org/packages/9c/c7/8b311d5adb0fe00a93ee9b4e92a02b0ec08510e9838885ef781ccbb20604/pydantic_core-2.33.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5c834f54f8f4640fd7e4b193f80eb25a0602bba9e19b3cd2fc7ffe8199f5ae02", size = 2041659 }, - { url = "https://files.pythonhosted.org/packages/8a/d6/4f58d32066a9e26530daaf9adc6664b01875ae0691570094968aaa7b8fcc/pydantic_core-2.33.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:049e0de24cf23766f12cc5cc71d8abc07d4a9deb9061b334b62093dedc7cb068", size = 1873294 }, - { url = "https://files.pythonhosted.org/packages/f7/3f/53cc9c45d9229da427909c751f8ed2bf422414f7664ea4dde2d004f596ba/pydantic_core-2.33.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a28239037b3d6f16916a4c831a5a0eadf856bdd6d2e92c10a0da3a59eadcf3e", size = 1903771 }, - { url = "https://files.pythonhosted.org/packages/f0/49/bf0783279ce674eb9903fb9ae43f6c614cb2f1c4951370258823f795368b/pydantic_core-2.33.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d3da303ab5f378a268fa7d45f37d7d85c3ec19769f28d2cc0c61826a8de21fe", size = 2083558 }, - { url = "https://files.pythonhosted.org/packages/9c/5b/0d998367687f986c7d8484a2c476d30f07bf5b8b1477649a6092bd4c540e/pydantic_core-2.33.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:25626fb37b3c543818c14821afe0fd3830bc327a43953bc88db924b68c5723f1", size = 2118038 }, - { url = "https://files.pythonhosted.org/packages/b3/33/039287d410230ee125daee57373ac01940d3030d18dba1c29cd3089dc3ca/pydantic_core-2.33.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:3ab2d36e20fbfcce8f02d73c33a8a7362980cff717926bbae030b93ae46b56c7", size = 2079315 }, - { url = "https://files.pythonhosted.org/packages/1f/85/6d8b2646d99c062d7da2d0ab2faeb0d6ca9cca4c02da6076376042a20da3/pydantic_core-2.33.1-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:2f9284e11c751b003fd4215ad92d325d92c9cb19ee6729ebd87e3250072cdcde", size = 2249063 }, - { url = "https://files.pythonhosted.org/packages/17/d7/c37d208d5738f7b9ad8f22ae8a727d88ebf9c16c04ed2475122cc3f7224a/pydantic_core-2.33.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:048c01eee07d37cbd066fc512b9d8b5ea88ceeb4e629ab94b3e56965ad655add", size = 2254631 }, - { url = "https://files.pythonhosted.org/packages/13/e0/bafa46476d328e4553b85ab9b2f7409e7aaef0ce4c937c894821c542d347/pydantic_core-2.33.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5ccd429694cf26af7997595d627dd2637e7932214486f55b8a357edaac9dae8c", size = 2080877 }, - { url = "https://files.pythonhosted.org/packages/0b/76/1794e440c1801ed35415238d2c728f26cd12695df9057154ad768b7b991c/pydantic_core-2.33.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:3a371dc00282c4b84246509a5ddc808e61b9864aa1eae9ecc92bb1268b82db4a", size = 2042858 }, - { url = "https://files.pythonhosted.org/packages/73/b4/9cd7b081fb0b1b4f8150507cd59d27b275c3e22ad60b35cb19ea0977d9b9/pydantic_core-2.33.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f59295ecc75a1788af8ba92f2e8c6eeaa5a94c22fc4d151e8d9638814f85c8fc", size = 1873745 }, - { url = "https://files.pythonhosted.org/packages/e1/d7/9ddb7575d4321e40d0363903c2576c8c0c3280ebea137777e5ab58d723e3/pydantic_core-2.33.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08530b8ac922003033f399128505f513e30ca770527cc8bbacf75a84fcc2c74b", size = 1904188 }, - { url = "https://files.pythonhosted.org/packages/d1/a8/3194ccfe461bb08da19377ebec8cb4f13c9bd82e13baebc53c5c7c39a029/pydantic_core-2.33.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bae370459da6a5466978c0eacf90690cb57ec9d533f8e63e564ef3822bfa04fe", size = 2083479 }, - { url = "https://files.pythonhosted.org/packages/42/c7/84cb569555d7179ca0b3f838cef08f66f7089b54432f5b8599aac6e9533e/pydantic_core-2.33.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e3de2777e3b9f4d603112f78006f4ae0acb936e95f06da6cb1a45fbad6bdb4b5", size = 2118415 }, - { url = "https://files.pythonhosted.org/packages/3b/67/72abb8c73e0837716afbb58a59cc9e3ae43d1aa8677f3b4bc72c16142716/pydantic_core-2.33.1-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:3a64e81e8cba118e108d7126362ea30e021291b7805d47e4896e52c791be2761", size = 2079623 }, - { url = "https://files.pythonhosted.org/packages/0b/cd/c59707e35a47ba4cbbf153c3f7c56420c58653b5801b055dc52cccc8e2dc/pydantic_core-2.33.1-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:52928d8c1b6bda03cc6d811e8923dffc87a2d3c8b3bfd2ce16471c7147a24850", size = 2250175 }, - { url = "https://files.pythonhosted.org/packages/84/32/e4325a6676b0bed32d5b084566ec86ed7fd1e9bcbfc49c578b1755bde920/pydantic_core-2.33.1-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:1b30d92c9412beb5ac6b10a3eb7ef92ccb14e3f2a8d7732e2d739f58b3aa7544", size = 2254674 }, - { url = "https://files.pythonhosted.org/packages/12/6f/5596dc418f2e292ffc661d21931ab34591952e2843e7168ea5a52591f6ff/pydantic_core-2.33.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f995719707e0e29f0f41a8aa3bcea6e761a36c9136104d3189eafb83f5cec5e5", size = 2080951 }, - { url = "https://files.pythonhosted.org/packages/2d/a8/c2c8f29bd18f7ef52de32a6deb9e3ee87ba18b7b2122636aa9f4438cf627/pydantic_core-2.33.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:7edbc454a29fc6aeae1e1eecba4f07b63b8d76e76a748532233c4c167b4cb9ea", size = 2041791 }, - { url = "https://files.pythonhosted.org/packages/08/ad/328081b1c82543ae49d0650048305058583c51f1a9a56a0d6e87bb3a2443/pydantic_core-2.33.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:ad05b683963f69a1d5d2c2bdab1274a31221ca737dbbceaa32bcb67359453cdd", size = 1873579 }, - { url = "https://files.pythonhosted.org/packages/6e/8a/bc65dbf7e501e88367cdab06a2c1340457c785f0c72288cae737fd80c0fa/pydantic_core-2.33.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df6a94bf9452c6da9b5d76ed229a5683d0306ccb91cca8e1eea883189780d568", size = 1904189 }, - { url = "https://files.pythonhosted.org/packages/9a/db/30ca6aefda211fb01ef185ca73cb7a0c6e7fe952c524025c8782b5acd771/pydantic_core-2.33.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7965c13b3967909a09ecc91f21d09cfc4576bf78140b988904e94f130f188396", size = 2084446 }, - { url = "https://files.pythonhosted.org/packages/f2/89/a12b55286e30c9f476eab7c53c9249ec76faf70430596496ab0309f28629/pydantic_core-2.33.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:3f1fdb790440a34f6ecf7679e1863b825cb5ffde858a9197f851168ed08371e5", size = 2118215 }, - { url = "https://files.pythonhosted.org/packages/8e/55/12721c4a8d7951584ad3d9848b44442559cf1876e0bb424148d1060636b3/pydantic_core-2.33.1-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:5277aec8d879f8d05168fdd17ae811dd313b8ff894aeeaf7cd34ad28b4d77e33", size = 2079963 }, - { url = "https://files.pythonhosted.org/packages/bd/0c/3391bd5d6ff62ea998db94732528d9bc32c560b0ed861c39119759461946/pydantic_core-2.33.1-pp39-pypy39_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:8ab581d3530611897d863d1a649fb0644b860286b4718db919bfd51ece41f10b", size = 2249388 }, - { url = "https://files.pythonhosted.org/packages/d3/5f/3e4feb042998d7886a9b523b372d83955cbc192a07013dcd24276db078ee/pydantic_core-2.33.1-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:0483847fa9ad5e3412265c1bd72aad35235512d9ce9d27d81a56d935ef489672", size = 2255226 }, - { url = "https://files.pythonhosted.org/packages/25/f2/1647933efaaad61846109a27619f3704929e758a09e6431b8f932a053d40/pydantic_core-2.33.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:de9e06abe3cc5ec6a2d5f75bc99b0bdca4f5c719a5b34026f8c57efbdecd2ee3", size = 2081073 }, -] - -[[package]] -name = "pydantic-extra-types" -version = "2.10.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "pydantic" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/53/fa/6b268a47839f8af46ffeb5bb6aee7bded44fbad54e6bf826c11f17aef91a/pydantic_extra_types-2.10.3.tar.gz", hash = "sha256:dcc0a7b90ac9ef1b58876c9b8fdede17fbdde15420de9d571a9fccde2ae175bb", size = 95128 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/38/0a/f6f8e5f79d188e2f3fa9ecfccfa72538b685985dd5c7c2886c67af70e685/pydantic_extra_types-2.10.3-py3-none-any.whl", hash = "sha256:e8b372752b49019cd8249cc192c62a820d8019f5382a8789d0f887338a59c0f3", size = 37175 }, -] - -[[package]] -name = "pygments" -version = "2.19.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 }, -] - -[[package]] -name = "pyrepl" -version = "0.11.3.post1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/92/78/65b9a4a4b15f7f5aae84c3edb9d3adc1acb2acc38eb9d5404cd5cf980927/pyrepl-0.11.3.post1.tar.gz", hash = "sha256:0ca7568c8be919b69f99644d29d31738a5b1a87750d06dd36564bcfad278d402", size = 50954 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2d/45/02a5e2da58a32ff407b14d38690c1d2f8705bd6909320817b444070dcbb0/pyrepl-0.11.3.post1-py3-none-any.whl", hash = "sha256:59fcd67588892731dc6e7aff106c380d303d54324ff028827804a2b056223d92", size = 55613 }, -] - -[[package]] -name = "pyright" -version = "1.1.399" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "nodeenv" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/db/9d/d91d5f6d26b2db95476fefc772e2b9a16d54c6bd0ea6bb5c1b6d635ab8b4/pyright-1.1.399.tar.gz", hash = "sha256:439035d707a36c3d1b443aec980bc37053fbda88158eded24b8eedcf1c7b7a1b", size = 3856954 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/2f/b5/380380c9e7a534cb1783c70c3e8ac6d1193c599650a55838d0557586796e/pyright-1.1.399-py3-none-any.whl", hash = "sha256:55f9a875ddf23c9698f24208c764465ffdfd38be6265f7faf9a176e1dc549f3b", size = 5592584 }, -] - -[[package]] -name = "pytest" -version = "8.3.5" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, - { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, - { name = "iniconfig" }, - { name = "packaging" }, - { name = "pluggy" }, - { name = "tomli", marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ae/3c/c9d525a414d506893f0cd8a8d0de7706446213181570cdbd766691164e40/pytest-8.3.5.tar.gz", hash = "sha256:f4efe70cc14e511565ac476b57c279e12a855b11f48f212af1080ef2263d3845", size = 1450891 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/30/3d/64ad57c803f1fa1e963a7946b6e0fea4a70df53c1a7fed304586539c2bac/pytest-8.3.5-py3-none-any.whl", hash = "sha256:c69214aa47deac29fad6c2a4f590b9c4a9fdb16a403176fe154b79c0b4d4d820", size = 343634 }, -] - -[[package]] -name = "pytest-cov" -version = "6.1.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "coverage", extra = ["toml"] }, - { name = "pytest" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/25/69/5f1e57f6c5a39f81411b550027bf72842c4567ff5fd572bed1edc9e4b5d9/pytest_cov-6.1.1.tar.gz", hash = "sha256:46935f7aaefba760e716c2ebfbe1c216240b9592966e7da99ea8292d4d3e2a0a", size = 66857 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/28/d0/def53b4a790cfb21483016430ed828f64830dd981ebe1089971cd10cab25/pytest_cov-6.1.1-py3-none-any.whl", hash = "sha256:bddf29ed2d0ab6f4df17b4c55b0a657287db8684af9c42ea546b21b1041b3dde", size = 23841 }, -] - -[[package]] -name = "pyyaml" -version = "6.0.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199 }, - { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758 }, - { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463 }, - { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280 }, - { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239 }, - { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802 }, - { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527 }, - { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052 }, - { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774 }, - { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612 }, - { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040 }, - { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829 }, - { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167 }, - { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952 }, - { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301 }, - { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638 }, - { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850 }, - { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980 }, - { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873 }, - { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302 }, - { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154 }, - { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223 }, - { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542 }, - { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164 }, - { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611 }, - { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591 }, - { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338 }, - { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309 }, - { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679 }, - { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428 }, - { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361 }, - { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523 }, - { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660 }, - { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597 }, - { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527 }, - { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446 }, - { url = "https://files.pythonhosted.org/packages/65/d8/b7a1db13636d7fb7d4ff431593c510c8b8fca920ade06ca8ef20015493c5/PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d", size = 184777 }, - { url = "https://files.pythonhosted.org/packages/0a/02/6ec546cd45143fdf9840b2c6be8d875116a64076218b61d68e12548e5839/PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f", size = 172318 }, - { url = "https://files.pythonhosted.org/packages/0e/9a/8cc68be846c972bda34f6c2a93abb644fb2476f4dcc924d52175786932c9/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290", size = 720891 }, - { url = "https://files.pythonhosted.org/packages/e9/6c/6e1b7f40181bc4805e2e07f4abc10a88ce4648e7e95ff1abe4ae4014a9b2/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12", size = 722614 }, - { url = "https://files.pythonhosted.org/packages/3d/32/e7bd8535d22ea2874cef6a81021ba019474ace0d13a4819c2a4bce79bd6a/PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19", size = 737360 }, - { url = "https://files.pythonhosted.org/packages/d7/12/7322c1e30b9be969670b672573d45479edef72c9a0deac3bb2868f5d7469/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e", size = 699006 }, - { url = "https://files.pythonhosted.org/packages/82/72/04fcad41ca56491995076630c3ec1e834be241664c0c09a64c9a2589b507/PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725", size = 723577 }, - { url = "https://files.pythonhosted.org/packages/ed/5e/46168b1f2757f1fcd442bc3029cd8767d88a98c9c05770d8b420948743bb/PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631", size = 144593 }, - { url = "https://files.pythonhosted.org/packages/19/87/5124b1c1f2412bb95c59ec481eaf936cd32f0fe2a7b16b97b81c4c017a6a/PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8", size = 162312 }, -] - -[[package]] -name = "requests" -version = "2.32.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "certifi" }, - { name = "charset-normalizer" }, - { name = "idna" }, - { name = "urllib3" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928 }, -] - -[[package]] -name = "resource-backed-dask-array" -version = "0.1.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "dask", version = "2024.8.0", source = { registry = "https://pypi.org/simple" }, extra = ["array"], marker = "python_full_version < '3.10'" }, - { name = "dask", version = "2025.3.0", source = { registry = "https://pypi.org/simple" }, extra = ["array"], marker = "python_full_version >= '3.10'" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/62/80/b8952048ae1772d33b95dbf7d7107cf364c037cc229a2690fc8fa9ee8e48/resource_backed_dask_array-0.1.0.tar.gz", hash = "sha256:8fabcccf5c7e29059b5badd6786dd7675a258a203c58babf10077d9c90ada54f", size = 10300 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/b5/852f619e53fa7fb70d8915fcae66632df3958cac7e926c4ac38458958674/resource_backed_dask_array-0.1.0-py2.py3-none-any.whl", hash = "sha256:ec457fa72d81f0340a67ea6557a5a5919323a11cccc978a950df29fa69fe5679", size = 8044 }, -] - -[[package]] -name = "rich" -version = "14.0.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "markdown-it-py" }, - { name = "pygments" }, - { name = "typing-extensions", marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/a1/53/830aa4c3066a8ab0ae9a9955976fb770fe9c6102117c8ec4ab3ea62d89e8/rich-14.0.0.tar.gz", hash = "sha256:82f1bc23a6a21ebca4ae0c45af9bdbc492ed20231dcb63f297d6d1021a9d5725", size = 224078 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/0d/9b/63f4c7ebc259242c89b3acafdb37b41d1185c07ff0011164674e9076b491/rich-14.0.0-py3-none-any.whl", hash = "sha256:1c9491e1951aac09caffd42f448ee3d04e58923ffe14993f6e83068dc395d7e0", size = 243229 }, -] - -[[package]] -name = "ruff" -version = "0.11.6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d9/11/bcef6784c7e5d200b8a1f5c2ddf53e5da0efec37e6e5a44d163fb97e04ba/ruff-0.11.6.tar.gz", hash = "sha256:bec8bcc3ac228a45ccc811e45f7eb61b950dbf4cf31a67fa89352574b01c7d79", size = 4010053 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6e/1f/8848b625100ebcc8740c8bac5b5dd8ba97dd4ee210970e98832092c1635b/ruff-0.11.6-py3-none-linux_armv6l.whl", hash = "sha256:d84dcbe74cf9356d1bdb4a78cf74fd47c740bf7bdeb7529068f69b08272239a1", size = 10248105 }, - { url = "https://files.pythonhosted.org/packages/e0/47/c44036e70c6cc11e6ee24399c2a1e1f1e99be5152bd7dff0190e4b325b76/ruff-0.11.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:9bc583628e1096148011a5d51ff3c836f51899e61112e03e5f2b1573a9b726de", size = 11001494 }, - { url = "https://files.pythonhosted.org/packages/ed/5b/170444061650202d84d316e8f112de02d092bff71fafe060d3542f5bc5df/ruff-0.11.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:f2959049faeb5ba5e3b378709e9d1bf0cab06528b306b9dd6ebd2a312127964a", size = 10352151 }, - { url = "https://files.pythonhosted.org/packages/ff/91/f02839fb3787c678e112c8865f2c3e87cfe1744dcc96ff9fc56cfb97dda2/ruff-0.11.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:63c5d4e30d9d0de7fedbfb3e9e20d134b73a30c1e74b596f40f0629d5c28a193", size = 10541951 }, - { url = "https://files.pythonhosted.org/packages/9e/f3/c09933306096ff7a08abede3cc2534d6fcf5529ccd26504c16bf363989b5/ruff-0.11.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:26a4b9a4e1439f7d0a091c6763a100cef8fbdc10d68593df6f3cfa5abdd9246e", size = 10079195 }, - { url = "https://files.pythonhosted.org/packages/e0/0d/a87f8933fccbc0d8c653cfbf44bedda69c9582ba09210a309c066794e2ee/ruff-0.11.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b5edf270223dd622218256569636dc3e708c2cb989242262fe378609eccf1308", size = 11698918 }, - { url = "https://files.pythonhosted.org/packages/52/7d/8eac0bd083ea8a0b55b7e4628428203441ca68cd55e0b67c135a4bc6e309/ruff-0.11.6-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:f55844e818206a9dd31ff27f91385afb538067e2dc0beb05f82c293ab84f7d55", size = 12319426 }, - { url = "https://files.pythonhosted.org/packages/c2/dc/d0c17d875662d0c86fadcf4ca014ab2001f867621b793d5d7eef01b9dcce/ruff-0.11.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d8f782286c5ff562e4e00344f954b9320026d8e3fae2ba9e6948443fafd9ffc", size = 11791012 }, - { url = "https://files.pythonhosted.org/packages/f9/f3/81a1aea17f1065449a72509fc7ccc3659cf93148b136ff2a8291c4bc3ef1/ruff-0.11.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:01c63ba219514271cee955cd0adc26a4083df1956d57847978383b0e50ffd7d2", size = 13949947 }, - { url = "https://files.pythonhosted.org/packages/61/9f/a3e34de425a668284e7024ee6fd41f452f6fa9d817f1f3495b46e5e3a407/ruff-0.11.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15adac20ef2ca296dd3d8e2bedc6202ea6de81c091a74661c3666e5c4c223ff6", size = 11471753 }, - { url = "https://files.pythonhosted.org/packages/df/c5/4a57a86d12542c0f6e2744f262257b2aa5a3783098ec14e40f3e4b3a354a/ruff-0.11.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:4dd6b09e98144ad7aec026f5588e493c65057d1b387dd937d7787baa531d9bc2", size = 10417121 }, - { url = "https://files.pythonhosted.org/packages/58/3f/a3b4346dff07ef5b862e2ba06d98fcbf71f66f04cf01d375e871382b5e4b/ruff-0.11.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:45b2e1d6c0eed89c248d024ea95074d0e09988d8e7b1dad8d3ab9a67017a5b03", size = 10073829 }, - { url = "https://files.pythonhosted.org/packages/93/cc/7ed02e0b86a649216b845b3ac66ed55d8aa86f5898c5f1691797f408fcb9/ruff-0.11.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:bd40de4115b2ec4850302f1a1d8067f42e70b4990b68838ccb9ccd9f110c5e8b", size = 11076108 }, - { url = "https://files.pythonhosted.org/packages/39/5e/5b09840fef0eff1a6fa1dea6296c07d09c17cb6fb94ed5593aa591b50460/ruff-0.11.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:77cda2dfbac1ab73aef5e514c4cbfc4ec1fbef4b84a44c736cc26f61b3814cd9", size = 11512366 }, - { url = "https://files.pythonhosted.org/packages/6f/4c/1cd5a84a412d3626335ae69f5f9de2bb554eea0faf46deb1f0cb48534042/ruff-0.11.6-py3-none-win32.whl", hash = "sha256:5151a871554be3036cd6e51d0ec6eef56334d74dfe1702de717a995ee3d5b287", size = 10485900 }, - { url = "https://files.pythonhosted.org/packages/42/46/8997872bc44d43df986491c18d4418f1caff03bc47b7f381261d62c23442/ruff-0.11.6-py3-none-win_amd64.whl", hash = "sha256:cce85721d09c51f3b782c331b0abd07e9d7d5f775840379c640606d3159cae0e", size = 11558592 }, - { url = "https://files.pythonhosted.org/packages/d7/6a/65fecd51a9ca19e1477c3879a7fda24f8904174d1275b419422ac00f6eee/ruff-0.11.6-py3-none-win_arm64.whl", hash = "sha256:3567ba0d07fb170b1b48d944715e3294b77f5b7679e8ba258199a250383ccb79", size = 10682766 }, -] - -[[package]] -name = "scyjava" -version = "1.10.2" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "jgo" }, - { name = "jpype1" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/82/7a/8d184f699238fc61fe56e08acd48945cb50064b133a6ebfb6895af4015f0/scyjava-1.10.2.tar.gz", hash = "sha256:483eda5017127ffa3907390cea2868fe86e18d36c21b16c30e21eb1147b5bc4c", size = 49625 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/15/5000ca4cf86e9ceb69b4f8fa55a58002d622b0a39e64ecf4c49b2ccccdd6/scyjava-1.10.2-py3-none-any.whl", hash = "sha256:9ec9a206a39502edba3aa09f6684bcfbe748ead2cd9cf049d62a4e92e2863c67", size = 30990 }, -] - -[[package]] -name = "stack-data" -version = "0.6.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "asttokens" }, - { name = "executing" }, - { name = "pure-eval" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521 }, -] - -[[package]] -name = "tomli" -version = "2.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 }, - { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 }, - { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 }, - { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 }, - { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 }, - { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 }, - { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 }, - { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 }, - { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 }, - { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 }, - { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 }, - { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 }, - { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 }, - { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 }, - { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 }, - { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 }, - { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 }, - { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 }, - { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 }, - { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 }, - { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 }, - { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 }, - { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 }, - { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 }, - { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 }, - { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 }, - { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 }, - { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 }, - { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 }, - { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 }, - { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, -] - -[[package]] -name = "toolz" -version = "1.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8a/0b/d80dfa675bf592f636d1ea0b835eab4ec8df6e9415d8cfd766df54456123/toolz-1.0.0.tar.gz", hash = "sha256:2c86e3d9a04798ac556793bced838816296a2f085017664e4995cb40a1047a02", size = 66790 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/03/98/eb27cc78ad3af8e302c9d8ff4977f5026676e130d28dd7578132a457170c/toolz-1.0.0-py3-none-any.whl", hash = "sha256:292c8f1c4e7516bf9086f8850935c799a874039c8bcf959d47b600e4c44a6236", size = 56383 }, -] - -[[package]] -name = "traitlets" -version = "5.14.3" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359 }, -] - -[[package]] -name = "typing-extensions" -version = "4.13.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/f6/37/23083fcd6e35492953e8d2aaaa68b860eb422b34627b13f2ce3eb6106061/typing_extensions-4.13.2.tar.gz", hash = "sha256:e6c81219bd689f51865d9e372991c540bda33a0379d5573cddb9a3a23f7caaef", size = 106967 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/8b/54/b1ae86c0973cc6f0210b53d508ca3641fb6d0c56823f288d108bc7ab3cc8/typing_extensions-4.13.2-py3-none-any.whl", hash = "sha256:a439e7c04b49fec3e5d3e2beaa21755cadbbdc391694e28ccdd36ca4a1408f8c", size = 45806 }, -] - -[[package]] -name = "typing-inspection" -version = "0.4.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/82/5c/e6082df02e215b846b4b8c0b887a64d7d08ffaba30605502639d44c06b82/typing_inspection-0.4.0.tar.gz", hash = "sha256:9765c87de36671694a67904bf2c96e395be9c6439bb6c87b5142569dcdd65122", size = 76222 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/31/08/aa4fdfb71f7de5176385bd9e90852eaf6b5d622735020ad600f2bab54385/typing_inspection-0.4.0-py3-none-any.whl", hash = "sha256:50e72559fcd2a6367a19f7a7e610e6afcb9fac940c650290eed893d61386832f", size = 14125 }, -] - -[[package]] -name = "urllib3" -version = "2.4.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/8a/78/16493d9c386d8e60e442a35feac5e00f0913c0f4b7c217c11e8ec2ff53e0/urllib3-2.4.0.tar.gz", hash = "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466", size = 390672 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680 }, -] - -[[package]] -name = "virtualenv" -version = "20.30.0" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "distlib" }, - { name = "filelock" }, - { name = "platformdirs" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/38/e0/633e369b91bbc664df47dcb5454b6c7cf441e8f5b9d0c250ce9f0546401e/virtualenv-20.30.0.tar.gz", hash = "sha256:800863162bcaa5450a6e4d721049730e7f2dae07720e0902b0e4040bd6f9ada8", size = 4346945 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/4c/ed/3cfeb48175f0671ec430ede81f628f9fb2b1084c9064ca67ebe8c0ed6a05/virtualenv-20.30.0-py3-none-any.whl", hash = "sha256:e34302959180fca3af42d1800df014b35019490b119eba981af27f2fa486e5d6", size = 4329461 }, -] - -[[package]] -name = "wcwidth" -version = "0.2.13" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166 }, -] - -[[package]] -name = "xsdata" -version = "24.3.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/af/da/bce6f30a2b85bb258bd3c282258c3cec294ef6c3214397ca22349bcb515b/xsdata-24.3.1.tar.gz", hash = "sha256:cf6c6895616260cbe2a4eff6f8f906cd16f9c1dba8fd8561e500b91269b86616", size = 330034 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/e9/ac/27a6fcf61c64549a17b9eaa087ae7876417b5ed9efb6efdec8b52289cae4/xsdata-24.3.1-py3-none-any.whl", hash = "sha256:2f4a00ec33fb6ff41fca95f3fac826b83fc34d8644e2f3da830ad393defb5705", size = 224141 }, -] - -[[package]] -name = "zipp" -version = "3.21.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/3f/50/bad581df71744867e9468ebd0bcd6505de3b275e06f202c2cb016e3ff56f/zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4", size = 24545 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/1a/7e4798e9339adc931158c9d69ecc34f5e6791489d469f5e50ec15e35f458/zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931", size = 9630 }, -]