diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 48671110..bc170c67 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -67,3 +67,29 @@ jobs: working-directory: ${{ matrix.library.path }} run: | poetry run pytest + + validation-workflow-with-generated-code: + runs-on: ubuntu-latest + timeout-minutes: 40 + strategy: + max-parallel: 10 + matrix: + python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"] + + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + working-directory: "./tests/validation" + run: | + python -m pip install --upgrade poetry + poetry install + - name: Static type checking with Mypy + working-directory: "./tests/validation" + run: | + poetry run mypy validation + diff --git a/packages/abstractions/kiota_abstractions/request_adapter.py b/packages/abstractions/kiota_abstractions/request_adapter.py index c2a65f2c..7ef551b6 100644 --- a/packages/abstractions/kiota_abstractions/request_adapter.py +++ b/packages/abstractions/kiota_abstractions/request_adapter.py @@ -1,3 +1,4 @@ +from __future__ import annotations from abc import ABC, abstractmethod from datetime import datetime from io import BytesIO @@ -31,7 +32,7 @@ def get_serialization_writer_factory(self) -> SerializationWriterFactory: @abstractmethod async def send_async( self, request_info: RequestInformation, parsable_factory: ParsableFactory[ModelType], - error_map: Optional[Dict[str, ParsableFactory]] + error_map: Optional[Dict[str, type[ParsableFactory]]] ) -> Optional[ModelType]: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized response model. @@ -40,7 +41,7 @@ async def send_async( request_info (RequestInformation): the request info to execute. parsable_factory (ParsableFactory): the class of response model to deserialize the response into. - error_map (Optional[Dict[str, ParsableFactory]]): the error dict to use in case + error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in case of a failed request. Returns: @@ -52,8 +53,8 @@ async def send_async( async def send_collection_async( self, request_info: RequestInformation, - parsable_factory: ParsableFactory, - error_map: Optional[Dict[str, ParsableFactory]], + parsable_factory: ParsableFactory[ModelType], + error_map: Optional[Dict[str, type[ParsableFactory]]], ) -> Optional[List[ModelType]]: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized response model collection. @@ -62,7 +63,7 @@ async def send_collection_async( request_info (RequestInformation): the request info to execute. parsable_factory (ParsableFactory): the class of response model to deserialize the response into. - error_map (Optional[Dict[str, ParsableFactory]]): the error dict to use in + error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in case of a failed request. Returns: @@ -75,7 +76,7 @@ async def send_collection_of_primitive_async( self, request_info: RequestInformation, response_type: ResponseType, - error_map: Optional[Dict[str, ParsableFactory]], + error_map: Optional[Dict[str, type[ParsableFactory]]], ) -> Optional[List[ResponseType]]: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized response model collection. @@ -84,7 +85,7 @@ async def send_collection_of_primitive_async( request_info (RequestInformation): the request info to execute. response_type (ResponseType): the class of the response model to deserialize the response into. - error_map (Optional[Dict[str, ParsableFactory]]): the error dict to use in + error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in case of a failed request. Returns: @@ -95,7 +96,7 @@ async def send_collection_of_primitive_async( @abstractmethod async def send_primitive_async( self, request_info: RequestInformation, response_type: str, - error_map: Optional[Dict[str, ParsableFactory]] + error_map: Optional[Dict[str, type[ParsableFactory]]] ) -> Optional[ResponseType]: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized primitive response model. @@ -104,7 +105,7 @@ async def send_primitive_async( request_info (RequestInformation): the request info to execute. response_type (str): the class name of the response model to deserialize the response into. - error_map (Optional[Dict[str, ParsableFactory]]): the error dict to use in + error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in case of a failed request. Returns: @@ -114,14 +115,15 @@ async def send_primitive_async( @abstractmethod async def send_no_response_content_async( - self, request_info: RequestInformation, error_map: Optional[Dict[str, ParsableFactory]] + self, request_info: RequestInformation, error_map: Optional[Dict[str, + type[ParsableFactory]]] ) -> None: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized primitive response model. Args: request_info (RequestInformation):the request info to execute. - error_map (Optional[Dict[str, ParsableFactory]]): the error dict to use in + error_map (Optional[Dict[str, type[ParsableFactory]]]): the error dict to use in case of a failed request. """ pass diff --git a/packages/abstractions/kiota_abstractions/serialization/parsable_factory.py b/packages/abstractions/kiota_abstractions/serialization/parsable_factory.py index 4e340cf8..139883ed 100644 --- a/packages/abstractions/kiota_abstractions/serialization/parsable_factory.py +++ b/packages/abstractions/kiota_abstractions/serialization/parsable_factory.py @@ -1,19 +1,19 @@ from abc import abstractmethod -from typing import Generic, Optional, TypeVar +from typing import Generic, Optional, Protocol, TypeVar from .parsable import Parsable from .parse_node import ParseNode -U = TypeVar("U", bound=Parsable) +U_co = TypeVar("U_co", bound="Parsable", covariant=True) -class ParsableFactory(Generic[U]): +class ParsableFactory(Protocol, Generic[U_co]): """Defines the factory for creating parsable objects. """ @staticmethod @abstractmethod - def create_from_discriminator_value(parse_node: Optional[ParseNode]) -> U: + def create_from_discriminator_value(parse_node: ParseNode) -> U_co: """Create a new parsable object from the given serialized data. Args: diff --git a/packages/http/httpx/kiota_http/httpx_request_adapter.py b/packages/http/httpx/kiota_http/httpx_request_adapter.py index dedfd96a..a8811490 100644 --- a/packages/http/httpx/kiota_http/httpx_request_adapter.py +++ b/packages/http/httpx/kiota_http/httpx_request_adapter.py @@ -1,4 +1,5 @@ """HTTPX client request adapter.""" +from __future__ import annotations import re from datetime import datetime from typing import Any, Dict, Generic, List, Optional, TypeVar, Union @@ -152,7 +153,7 @@ async def send_async( self, request_info: RequestInformation, parsable_factory: ParsableFactory[ModelType], - error_map: Optional[Dict[str, ParsableFactory]], + error_map: Optional[Dict[str, type[ParsableFactory]]], ) -> Optional[ModelType]: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized response model. @@ -160,7 +161,7 @@ async def send_async( request_info (RequestInformation): the request info to execute. parsable_factory (ParsableFactory): the class of the response model to deserialize the response into. - error_map (Dict[str, ParsableFactory]): the error dict to use in + error_map (Dict[str, type[ParsableFactory]]): the error dict to use in case of a failed request. Returns: @@ -197,7 +198,7 @@ async def send_collection_async( self, request_info: RequestInformation, parsable_factory: ParsableFactory, - error_map: Optional[Dict[str, ParsableFactory]], + error_map: Optional[Dict[str, type[ParsableFactory]]], ) -> Optional[List[ModelType]]: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized response model collection. @@ -205,7 +206,7 @@ async def send_collection_async( request_info (RequestInformation): the request info to execute. parsable_factory (ParsableFactory): the class of the response model to deserialize the response into. - error_map (Dict[str, ParsableFactory]): the error dict to use in + error_map (Dict[str, type[ParsableFactory]]): the error dict to use in case of a failed request. Returns: @@ -244,7 +245,7 @@ async def send_collection_of_primitive_async( self, request_info: RequestInformation, response_type: ResponseType, - error_map: Optional[Dict[str, ParsableFactory]], + error_map: Optional[Dict[str, type[ParsableFactory]]], ) -> Optional[List[ResponseType]]: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized response model collection. @@ -252,7 +253,7 @@ async def send_collection_of_primitive_async( request_info (RequestInformation): the request info to execute. response_type (ResponseType): the class of the response model to deserialize the response into. - error_map (Dict[str, ParsableFactory]): the error dict to use in + error_map (Dict[str, type[ParsableFactory]]): the error dict to use in case of a failed request. Returns: @@ -291,7 +292,7 @@ async def send_primitive_async( self, request_info: RequestInformation, response_type: str, - error_map: Optional[Dict[str, ParsableFactory]], + error_map: Optional[Dict[str, type[ParsableFactory]]], ) -> Optional[ResponseType]: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized primitive response model. @@ -299,7 +300,7 @@ async def send_primitive_async( request_info (RequestInformation): the request info to execute. response_type (str): the class name of the response model to deserialize the response into. - error_map (Dict[str, ParsableFactory]): the error dict to use in case + error_map (Dict[str, type[ParsableFactory]]): the error dict to use in case of a failed request. Returns: @@ -352,13 +353,14 @@ async def send_primitive_async( parent_span.end() async def send_no_response_content_async( - self, request_info: RequestInformation, error_map: Optional[Dict[str, ParsableFactory]] + self, request_info: RequestInformation, error_map: Optional[Dict[str, + type[ParsableFactory]]] ) -> None: """Excutes the HTTP request specified by the given RequestInformation and returns the deserialized primitive response model. Args: request_info (RequestInformation):the request info to execute. - error_map (Dict[str, ParsableFactory]): the error dict to use in case + error_map (Dict[str, type[ParsableFactory]]): the error dict to use in case of a failed request. """ parent_span = self.start_tracing_span(request_info, "send_no_response_content_async") @@ -418,7 +420,7 @@ def _should_return_none(self, response: httpx.Response) -> bool: async def throw_failed_responses( self, response: httpx.Response, - error_map: Optional[Dict[str, ParsableFactory]], + error_map: Optional[Dict[str, type[ParsableFactory]]], parent_span: trace.Span, attribute_span: trace.Span, ) -> None: @@ -644,13 +646,13 @@ async def convert_to_native_async(self, request_info: RequestInformation) -> htt parent_span.end() def _error_class_not_in_error_mapping( - self, error_map: Dict[str, ParsableFactory], status_code: int + self, error_map: Dict[str, type[ParsableFactory]], status_code: int ) -> bool: """Helper function to check if the error class corresponding to a response status code is not in the error mapping. Args: - error_map (Dict[str, ParsableFactory]): The error mapping. + error_map (Dict[str, type[ParsableFactory]]): The error mapping. status_code (int): The response status code. Returns: diff --git a/packages/serialization/text/kiota_serialization_text/py.typed b/packages/serialization/text/kiota_serialization_text/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/tests/validation/.pylintrc b/tests/validation/.pylintrc new file mode 100644 index 00000000..5ead1697 --- /dev/null +++ b/tests/validation/.pylintrc @@ -0,0 +1,512 @@ +[MASTER] + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. +extension-pkg-whitelist= + +# Add files or directories to the blacklist. They should be base names, not +# paths. +ignore=CVS + +# Add files or directories matching the regex patterns to the blacklist. The +# regex matches against base names, not paths. +ignore-patterns= + +# Python code to execute, usually for sys.path manipulation such as +# pygtk.require(). +#init-hook= + +# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the +# number of processors available to use. +jobs=1 + +# Control the amount of potential inferred values when inferring a single +# object. This can help the performance when dealing with large functions or +# complex, nested conditions. +limit-inference-results=100 + +# List of plugins (as comma separated values of python module names) to load, +# usually to register additional checkers. +load-plugins= + +# Pickle collected data for later comparisons. +persistent=yes + +# Specify a configuration file. +#rcfile= + +# When enabled, pylint would attempt to guess common misconfiguration and emit +# user-friendly hints instead of false-positive error messages. +suggestion-mode=yes + +# Allow loading of arbitrary C extensions. Extensions are imported into the +# active Python interpreter and may run arbitrary code. +unsafe-load-any-extension=no + + +[MESSAGES CONTROL] + +# Only show warnings with the listed confidence levels. Leave empty to show +# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED. +confidence= + +# Disable the message, report, category or checker with the given id(s). You +# can either give multiple identifiers separated by comma (,) or put this +# option multiple times (only on the command line, not in the configuration +# file where it should appear only once). You can also use "--disable=all" to +# disable everything first and then reenable specific checks. For example, if +# you want to run only the similarities checker, you can use "--disable=all +# --enable=similarities". If you want to run only the classes checker, but have +# no Warning level messages displayed, use "--disable=all --enable=classes +# --disable=W". +disable=raw-checker-failed, + bad-inline-option, + locally-disabled, + file-ignored, + suppressed-message, + useless-suppression, + deprecated-pragma, + use-symbolic-message-instead, + too-few-public-methods, + missing-module-docstring, + missing-class-docstring, + missing-function-docstring, + C0103, + R0801, + R0904, + R0911, + + +# Enable the message, report, category or checker with the given id(s). You can +# either give multiple identifier separated by comma (,) or put this option +# multiple time (only on the command line, not in the configuration file where +# it should appear only once). See also the "--disable" option for examples. +enable=c-extension-no-member + + +[REPORTS] + +# Python expression which should return a score less than or equal to 10. You +# have access to the variables 'error', 'warning', 'refactor', and 'convention' +# which contain the number of messages in each category, as well as 'statement' +# which is the total number of statements analyzed. This score is used by the +# global evaluation report (RP0004). +evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10) + +# Template used to display messages. This is a python new-style format string +# used to format the message information. See doc for all details. +#msg-template= + +# Set the output format. Available formats are text, parseable, colorized, json +# and msvs (visual studio). You can also give a reporter class, e.g. +# mypackage.mymodule.MyReporterClass. +output-format=text + +# Tells whether to display a full report or only the messages. +reports=no + +# Activate the evaluation score. +score=yes + + +[REFACTORING] + +# Maximum number of nested blocks for function / method body +max-nested-blocks=5 + +# Complete name of functions that never returns. When checking for +# inconsistent-return-statements if a never returning function is called then +# it will be considered as an explicit return statement and no message will be +# printed. +never-returning-functions=sys.exit + + +[BASIC] + +# Naming style matching correct argument names. +argument-naming-style=snake_case + +# Regular expression matching correct argument names. Overrides argument- +# naming-style. +#argument-rgx= + +# Naming style matching correct attribute names. +attr-naming-style=snake_case + +# Regular expression matching correct attribute names. Overrides attr-naming- +# style. +#attr-rgx= + +# Bad variable names which should always be refused, separated by a comma. +bad-names=foo, + bar, + baz, + toto, + tutu, + tata + +# Naming style matching correct class attribute names. +class-attribute-naming-style=any + +# Regular expression matching correct class attribute names. Overrides class- +# attribute-naming-style. +#class-attribute-rgx= + +# Naming style matching correct class names. +class-naming-style=PascalCase + +# Regular expression matching correct class names. Overrides class-naming- +# style. +#class-rgx= + +# Naming style matching correct constant names. +const-naming-style=UPPER_CASE + +# Regular expression matching correct constant names. Overrides const-naming- +# style. +#const-rgx= + +# Minimum line length for functions/classes that require docstrings, shorter +# ones are exempt. +docstring-min-length=-1 + +# Naming style matching correct function names. +function-naming-style=snake_case + +# Regular expression matching correct function names. Overrides function- +# naming-style. +#function-rgx= + +# Good variable names which should always be accepted, separated by a comma. +good-names=i, + j, + k, + ex, + Run, + _ + +# Include a hint for the correct naming format with invalid-name. +include-naming-hint=no + +# Naming style matching correct inline iteration names. +inlinevar-naming-style=any + +# Regular expression matching correct inline iteration names. Overrides +# inlinevar-naming-style. +#inlinevar-rgx= + +# Naming style matching correct method names. +method-naming-style=snake_case + +# Regular expression matching correct method names. Overrides method-naming- +# style. +#method-rgx= + +# Naming style matching correct module names. +module-naming-style=snake_case + +# Regular expression matching correct module names. Overrides module-naming- +# style. +#module-rgx= + +# Colon-delimited sets of names that determine each other's naming style when +# the name regexes allow several styles. +name-group= + +# Regular expression which should only match function or class names that do +# not require a docstring. +no-docstring-rgx=^_ + +# List of decorators that produce properties, such as abc.abstractproperty. Add +# to this list to register other decorators that produce valid properties. +# These decorators are taken in consideration only for invalid-name. +property-classes=abc.abstractproperty + +# Naming style matching correct variable names. +variable-naming-style=snake_case + +# Regular expression matching correct variable names. Overrides variable- +# naming-style. +#variable-rgx= + + +[FORMAT] + +# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. +expected-line-ending-format= + +# Regexp for a line that is allowed to be longer than the limit. +ignore-long-lines=^\s*(# )??$ + +# Number of spaces of indent required inside a hanging or continued line. +indent-after-paren=4 + +# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 +# tab). +indent-string=' ' + +# Maximum number of characters on a single line. +max-line-length=100 + +# Maximum number of lines in a module. +max-module-lines=1000 + +# Allow the body of a class to be on the same line as the declaration if body +# contains single statement. +single-line-class-stmt=no + +# Allow the body of an if to be on the same line as the test if there is no +# else. +single-line-if-stmt=no + + +[LOGGING] + +# Format style used to check logging format string. `old` means using % +# formatting, `new` is for `{}` formatting,and `fstr` is for f-strings. +logging-format-style=old + +# Logging modules to check that the string format arguments are in logging +# function parameter format. +logging-modules=logging + + +[MISCELLANEOUS] + +# List of note tags to take in consideration, separated by a comma. +notes=FIXME, + XXX, + TODO + + +[SIMILARITIES] + +# Ignore comments when computing similarities. +ignore-comments=yes + +# Ignore docstrings when computing similarities. +ignore-docstrings=yes + +# Ignore imports when computing similarities. +ignore-imports=no + +# Minimum lines number of a similarity. +min-similarity-lines=4 + + +[SPELLING] + +# Limits count of emitted suggestions for spelling mistakes. +max-spelling-suggestions=4 + +# Spelling dictionary name. Available dictionaries: none. To make it work, +# install the python-enchant package. +spelling-dict= + +# List of comma separated words that should not be checked. +spelling-ignore-words= + +# A path to a file that contains the private dictionary; one word per line. +spelling-private-dict-file= + +# Tells whether to store unknown words to the private dictionary (see the +# --spelling-private-dict-file option) instead of raising a message. +spelling-store-unknown-words=no + + +[STRING] + +# This flag controls whether the implicit-str-concat-in-sequence should +# generate a warning on implicit string concatenation in sequences defined over +# several lines. +check-str-concat-over-line-jumps=no + + +[TYPECHECK] + +# List of decorators that produce context managers, such as +# contextlib.contextmanager. Add to this list to register other decorators that +# produce valid context managers. +contextmanager-decorators=contextlib.contextmanager + +# List of members which are set dynamically and missed by pylint inference +# system, and so shouldn't trigger E1101 when accessed. Python regular +# expressions are accepted. +generated-members= + +# Tells whether missing members accessed in mixin class should be ignored. A +# mixin class is detected if its name ends with "mixin" (case insensitive). +ignore-mixin-members=yes + +# Tells whether to warn about missing members when the owner of the attribute +# is inferred to be None. +ignore-none=yes + +# This flag controls whether pylint should warn about no-member and similar +# checks whenever an opaque object is returned when inferring. The inference +# can return multiple potential results while evaluating a Python object, but +# some branches might not be evaluated, which results in partial inference. In +# that case, it might be useful to still emit no-member and other checks for +# the rest of the inferred objects. +ignore-on-opaque-inference=yes + +# List of class names for which member attributes should not be checked (useful +# for classes with dynamically set attributes). This supports the use of +# qualified names. +ignored-classes=optparse.Values,thread._local,_thread._local + +# List of module names for which member attributes should not be checked +# (useful for modules/projects where namespaces are manipulated during runtime +# and thus existing member attributes cannot be deduced by static analysis). It +# supports qualified module names, as well as Unix pattern matching. +ignored-modules= + +# Show a hint with possible names when a member name was not found. The aspect +# of finding the hint is based on edit distance. +missing-member-hint=yes + +# The minimum edit distance a name should have in order to be considered a +# similar match for a missing member name. +missing-member-hint-distance=1 + +# The total number of similar names that should be taken in consideration when +# showing a hint for a missing member. +missing-member-max-choices=1 + +# List of decorators that change the signature of a decorated function. +signature-mutators= + + +[VARIABLES] + +# List of additional names supposed to be defined in builtins. Remember that +# you should avoid defining new builtins when possible. +additional-builtins= + +# Tells whether unused global variables should be treated as a violation. +allow-global-unused-variables=yes + +# List of strings which can identify a callback function by name. A callback +# name must start or end with one of those strings. +callbacks=cb_, + _cb + +# A regular expression matching the name of dummy variables (i.e. expected to +# not be used). +dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_ + +# Argument names that match this expression will be ignored. Default to name +# with leading underscore. +ignored-argument-names=_.*|^ignored_|^unused_ + +# Tells whether we should check for unused import in __init__ files. +init-import=no + +# List of qualified module names which can have objects that can redefine +# builtins. +redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io + + +[CLASSES] + +# List of method names used to declare (i.e. assign) instance attributes. +defining-attr-methods=__init__, + __new__, + setUp, + __post_init__ + +# List of member names, which should be excluded from the protected access +# warning. +exclude-protected=_asdict, + _fields, + _replace, + _source, + _make + +# List of valid names for the first argument in a class method. +valid-classmethod-first-arg=cls + +# List of valid names for the first argument in a metaclass class method. +valid-metaclass-classmethod-first-arg=cls + + +[DESIGN] + +# Maximum number of arguments for function / method. +max-args=7 + +# Maximum number of attributes for a class (see R0902). +max-attributes=12 + +# Maximum number of boolean expressions in an if statement (see R0916). +max-bool-expr=5 + +# Maximum number of branch for function / method body. +max-branches=12 + +# Maximum number of locals for function / method body. +max-locals=15 + +# Maximum number of parents for a class (see R0901). +max-parents=7 + +# Maximum number of public methods for a class (see R0904). +max-public-methods=20 + +# Maximum number of return / yield for function / method body. +max-returns=6 + +# Maximum number of statements in function / method body. +max-statements=50 + +# Minimum number of public methods for a class (see R0903). +min-public-methods=2 + + +[IMPORTS] + +# List of modules that can be imported at any level, not just the top level +# one. +allow-any-import-level= + +# Allow wildcard imports from modules that define __all__. +allow-wildcard-with-all=no + +# Analyse import fallback blocks. This can be used to support both Python 2 and +# 3 compatible code, which means that the block might have code that exists +# only in one or another interpreter, leading to false positives when analysed. +analyse-fallback-blocks=no + +# Deprecated modules which should not be used, separated by a comma. +deprecated-modules=optparse,tkinter.tix + +# Create a graph of external dependencies in the given file (report RP0402 must +# not be disabled). +ext-import-graph= + +# Create a graph of every (i.e. internal and external) dependencies in the +# given file (report RP0402 must not be disabled). +import-graph= + +# Create a graph of internal dependencies in the given file (report RP0402 must +# not be disabled). +int-import-graph= + +# Force import order to recognize a module as part of the standard +# compatibility libraries. +known-standard-library= + +# Force import order to recognize a module as part of a third party library. +known-third-party=enchant + +# Couples of modules and preferred modules, separated by a comma. +preferred-modules= + + +[EXCEPTIONS] + +# Exceptions that will emit a warning when being caught. Defaults to +# "BaseException, Exception". +overgeneral-exceptions=builtins.BaseException, + builtins.Exception \ No newline at end of file diff --git a/tests/validation/pyproject.toml b/tests/validation/pyproject.toml new file mode 100644 index 00000000..b01c36f6 --- /dev/null +++ b/tests/validation/pyproject.toml @@ -0,0 +1,59 @@ +[build-system] +requires = ["poetry-core>=1.0.0"] +build-backend = "poetry.core.masonry.api" + +[tool.poetry] +name = "validation-client" +version = "0.0.4" +description = "Core abstractions for kiota generated libraries in Python" +authors = ["Microsoft "] +license = "MIT" +readme = "README.md" +keywords = ["kiota", "openAPI", "Microsoft", "Graph"] +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "License :: OSI Approved :: MIT License", +] +homepage = "https://github.com/microsoft/kiota#readme" +repository = "https://github.com/microsoft/kiota-python" +documentation = "https://microsoft.github.io/kiota/" +packages = [{include = "kiota_abstractions"}] + +[tool.poetry.dependencies] +python = ">=3.8,<4.0" +microsoft-kiota-abstractions = {path="../../packages/abstractions/", develop=true} +microsoft-kiota-http = {path="../../packages/http/httpx/", develop=true} +microsoft-kiota-serialization-json = {path="../../packages/serialization/json/", develop=true} +microsoft-kiota-serialization-form = {path="../../packages/serialization/form/", develop=true} +microsoft-kiota-serialization-text = {path="../../packages/serialization/text/", develop=true} +microsoft-kiota-serialization-multipart = {path="../../packages/serialization/multipart/", develop=true} + +[tool.poetry.group.dev.dependencies] +yapf = "^0.40.2" +isort = "^5.13.2" +pylint = "^3.2.7" +mypy = "^1.11.2" +pytest = "^8.3.2" +pytest-asyncio = "^0.24.0" +poetry-plugin-mono-repo-deps = "^0.2.1" + +[mypy] +warn_unused_configs = true +files = "kiota_abstractions" + +[tool.yapf] +based_on_style = "pep8" +dedent_closing_brackets = true +each_dict_entry_on_separate_line = true +column_limit = 100 + +[tool.isort] +profile = "hug" + +[tool.poetry-monorepo.deps] +enabled = true +commands = ["build", "export", "publish"] \ No newline at end of file diff --git a/tests/validation/validation/__init__.py b/tests/validation/validation/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/tests/validation/validation/kiota-lock.json b/tests/validation/validation/kiota-lock.json new file mode 100644 index 00000000..c90fd94d --- /dev/null +++ b/tests/validation/validation/kiota-lock.json @@ -0,0 +1,34 @@ +{ + "descriptionHash": "CE55775E5E36A748E59FB2BA5E63C392C63AA9CC15CE23D56FB5C14B92BBFA708FF5D4386EC1532D7A7BB74C8D9E80AE6482AB3806FB0393E1DD8151FAE8FE50", + "descriptionLocation": "https://raw.githubusercontent.com/microsoftgraph/msgraph-sdk-powershell/dev/openApiDocs/v1.0/Mail.yml", + "lockFileVersion": "1.0.0", + "kiotaVersion": "1.19.0", + "clientClassName": "ValidationClient", + "typeAccessModifier": "Public", + "clientNamespaceName": "validation", + "language": "Python", + "usesBackingStore": false, + "excludeBackwardCompatible": false, + "includeAdditionalData": true, + "disableSSLValidation": false, + "serializers": [ + "Microsoft.Kiota.Serialization.Json.JsonSerializationWriterFactory", + "Microsoft.Kiota.Serialization.Text.TextSerializationWriterFactory", + "Microsoft.Kiota.Serialization.Form.FormSerializationWriterFactory", + "Microsoft.Kiota.Serialization.Multipart.MultipartSerializationWriterFactory" + ], + "deserializers": [ + "Microsoft.Kiota.Serialization.Json.JsonParseNodeFactory", + "Microsoft.Kiota.Serialization.Text.TextParseNodeFactory", + "Microsoft.Kiota.Serialization.Form.FormParseNodeFactory" + ], + "structuredMimeTypes": [ + "application/json", + "text/plain;q=0.9", + "application/x-www-form-urlencoded;q=0.2", + "multipart/form-data;q=0.1" + ], + "includePatterns": [], + "excludePatterns": [], + "disabledValidationRules": [] +} \ No newline at end of file diff --git a/tests/validation/validation/models/attachment.py b/tests/validation/validation/models/attachment.py new file mode 100644 index 00000000..23cd85b8 --- /dev/null +++ b/tests/validation/validation/models/attachment.py @@ -0,0 +1,71 @@ +from __future__ import annotations +import datetime +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .entity import Entity + +from .entity import Entity + +@dataclass +class Attachment(Entity): + # The MIME type. + content_type: Optional[str] = None + # true if the attachment is an inline attachment; otherwise, false. + is_inline: Optional[bool] = None + # The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z + last_modified_date_time: Optional[datetime.datetime] = None + # The attachment's file name. + name: Optional[str] = None + # The length of the attachment in bytes. + size: Optional[int] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> Attachment: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: Attachment + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return Attachment() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .entity import Entity + + from .entity import Entity + + fields: Dict[str, Callable[[Any], None]] = { + "contentType": lambda n : setattr(self, 'content_type', n.get_str_value()), + "isInline": lambda n : setattr(self, 'is_inline', n.get_bool_value()), + "lastModifiedDateTime": lambda n : setattr(self, 'last_modified_date_time', n.get_datetime_value()), + "name": lambda n : setattr(self, 'name', n.get_str_value()), + "size": lambda n : setattr(self, 'size', n.get_int_value()), + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + writer.write_str_value("contentType", self.content_type) + writer.write_bool_value("isInline", self.is_inline) + writer.write_datetime_value("lastModifiedDateTime", self.last_modified_date_time) + writer.write_str_value("name", self.name) + writer.write_int_value("size", self.size) + + diff --git a/tests/validation/validation/models/attachment_collection_response.py b/tests/validation/validation/models/attachment_collection_response.py new file mode 100644 index 00000000..d45b74fe --- /dev/null +++ b/tests/validation/validation/models/attachment_collection_response.py @@ -0,0 +1,57 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .attachment import Attachment + +@dataclass +class AttachmentCollectionResponse(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The OdataNextLink property + odata_next_link: Optional[str] = None + # The value property + value: Optional[List[Attachment]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> AttachmentCollectionResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: AttachmentCollectionResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return AttachmentCollectionResponse() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .attachment import Attachment + + from .attachment import Attachment + + fields: Dict[str, Callable[[Any], None]] = { + "@odata.nextLink": lambda n : setattr(self, 'odata_next_link', n.get_str_value()), + "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(Attachment)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("@odata.nextLink", self.odata_next_link) + writer.write_collection_of_object_values("value", self.value) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/body_type.py b/tests/validation/validation/models/body_type.py new file mode 100644 index 00000000..12970552 --- /dev/null +++ b/tests/validation/validation/models/body_type.py @@ -0,0 +1,6 @@ +from enum import Enum + +class BodyType(str, Enum): + Text = "text", + Html = "html", + diff --git a/tests/validation/validation/models/date_time_time_zone.py b/tests/validation/validation/models/date_time_time_zone.py new file mode 100644 index 00000000..6a458d38 --- /dev/null +++ b/tests/validation/validation/models/date_time_time_zone.py @@ -0,0 +1,50 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +@dataclass +class DateTimeTimeZone(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # A single point of time in a combined date and time representation ({date}T{time}; for example, 2017-08-29T04:00:00.0000000). + date_time: Optional[str] = None + # Represents a time zone, for example, 'Pacific Standard Time'. See below for more possible values. + time_zone: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> DateTimeTimeZone: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: DateTimeTimeZone + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return DateTimeTimeZone() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + fields: Dict[str, Callable[[Any], None]] = { + "dateTime": lambda n : setattr(self, 'date_time', n.get_str_value()), + "timeZone": lambda n : setattr(self, 'time_zone', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("dateTime", self.date_time) + writer.write_str_value("timeZone", self.time_zone) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/email_address.py b/tests/validation/validation/models/email_address.py new file mode 100644 index 00000000..f1a8f4d9 --- /dev/null +++ b/tests/validation/validation/models/email_address.py @@ -0,0 +1,50 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +@dataclass +class EmailAddress(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The email address of the person or entity. + address: Optional[str] = None + # The display name of the person or entity. + name: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> EmailAddress: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: EmailAddress + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return EmailAddress() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + fields: Dict[str, Callable[[Any], None]] = { + "address": lambda n : setattr(self, 'address', n.get_str_value()), + "name": lambda n : setattr(self, 'name', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("address", self.address) + writer.write_str_value("name", self.name) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/entity.py b/tests/validation/validation/models/entity.py new file mode 100644 index 00000000..786cdd0f --- /dev/null +++ b/tests/validation/validation/models/entity.py @@ -0,0 +1,46 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +@dataclass +class Entity(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The unique identifier for an entity. Read-only. + id: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> Entity: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: Entity + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return Entity() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + fields: Dict[str, Callable[[Any], None]] = { + "id": lambda n : setattr(self, 'id', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("id", self.id) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/extension.py b/tests/validation/validation/models/extension.py new file mode 100644 index 00000000..eb653569 --- /dev/null +++ b/tests/validation/validation/models/extension.py @@ -0,0 +1,50 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .entity import Entity + +from .entity import Entity + +@dataclass +class Extension(Entity): + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> Extension: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: Extension + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return Extension() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .entity import Entity + + from .entity import Entity + + fields: Dict[str, Callable[[Any], None]] = { + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + + diff --git a/tests/validation/validation/models/extension_collection_response.py b/tests/validation/validation/models/extension_collection_response.py new file mode 100644 index 00000000..f43d22d3 --- /dev/null +++ b/tests/validation/validation/models/extension_collection_response.py @@ -0,0 +1,57 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .extension import Extension + +@dataclass +class ExtensionCollectionResponse(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The OdataNextLink property + odata_next_link: Optional[str] = None + # The value property + value: Optional[List[Extension]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> ExtensionCollectionResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: ExtensionCollectionResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return ExtensionCollectionResponse() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .extension import Extension + + from .extension import Extension + + fields: Dict[str, Callable[[Any], None]] = { + "@odata.nextLink": lambda n : setattr(self, 'odata_next_link', n.get_str_value()), + "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(Extension)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("@odata.nextLink", self.odata_next_link) + writer.write_collection_of_object_values("value", self.value) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/followup_flag.py b/tests/validation/validation/models/followup_flag.py new file mode 100644 index 00000000..033f0c33 --- /dev/null +++ b/tests/validation/validation/models/followup_flag.py @@ -0,0 +1,68 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .date_time_time_zone import DateTimeTimeZone + from .followup_flag_status import FollowupFlagStatus + +@dataclass +class FollowupFlag(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The completedDateTime property + completed_date_time: Optional[DateTimeTimeZone] = None + # The dueDateTime property + due_date_time: Optional[DateTimeTimeZone] = None + # The flagStatus property + flag_status: Optional[FollowupFlagStatus] = None + # The startDateTime property + start_date_time: Optional[DateTimeTimeZone] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> FollowupFlag: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: FollowupFlag + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return FollowupFlag() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .date_time_time_zone import DateTimeTimeZone + from .followup_flag_status import FollowupFlagStatus + + from .date_time_time_zone import DateTimeTimeZone + from .followup_flag_status import FollowupFlagStatus + + fields: Dict[str, Callable[[Any], None]] = { + "completedDateTime": lambda n : setattr(self, 'completed_date_time', n.get_object_value(DateTimeTimeZone)), + "dueDateTime": lambda n : setattr(self, 'due_date_time', n.get_object_value(DateTimeTimeZone)), + "flagStatus": lambda n : setattr(self, 'flag_status', n.get_enum_value(FollowupFlagStatus)), + "startDateTime": lambda n : setattr(self, 'start_date_time', n.get_object_value(DateTimeTimeZone)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_object_value("completedDateTime", self.completed_date_time) + writer.write_object_value("dueDateTime", self.due_date_time) + writer.write_enum_value("flagStatus", self.flag_status) + writer.write_object_value("startDateTime", self.start_date_time) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/followup_flag_status.py b/tests/validation/validation/models/followup_flag_status.py new file mode 100644 index 00000000..c772ae07 --- /dev/null +++ b/tests/validation/validation/models/followup_flag_status.py @@ -0,0 +1,7 @@ +from enum import Enum + +class FollowupFlagStatus(str, Enum): + NotFlagged = "notFlagged", + Complete = "complete", + Flagged = "flagged", + diff --git a/tests/validation/validation/models/importance.py b/tests/validation/validation/models/importance.py new file mode 100644 index 00000000..878b10f7 --- /dev/null +++ b/tests/validation/validation/models/importance.py @@ -0,0 +1,7 @@ +from enum import Enum + +class Importance(str, Enum): + Low = "low", + Normal = "normal", + High = "high", + diff --git a/tests/validation/validation/models/inference_classification.py b/tests/validation/validation/models/inference_classification.py new file mode 100644 index 00000000..6eda9b59 --- /dev/null +++ b/tests/validation/validation/models/inference_classification.py @@ -0,0 +1,57 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .entity import Entity + from .inference_classification_override import InferenceClassificationOverride + +from .entity import Entity + +@dataclass +class InferenceClassification(Entity): + # A set of overrides for a user to always classify messages from specific senders in certain ways: focused, or other. Read-only. Nullable. + overrides: Optional[List[InferenceClassificationOverride]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> InferenceClassification: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: InferenceClassification + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return InferenceClassification() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .entity import Entity + from .inference_classification_override import InferenceClassificationOverride + + from .entity import Entity + from .inference_classification_override import InferenceClassificationOverride + + fields: Dict[str, Callable[[Any], None]] = { + "overrides": lambda n : setattr(self, 'overrides', n.get_collection_of_object_values(InferenceClassificationOverride)), + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + writer.write_collection_of_object_values("overrides", self.overrides) + + diff --git a/tests/validation/validation/models/inference_classification_override.py b/tests/validation/validation/models/inference_classification_override.py new file mode 100644 index 00000000..0695cc41 --- /dev/null +++ b/tests/validation/validation/models/inference_classification_override.py @@ -0,0 +1,64 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .email_address import EmailAddress + from .entity import Entity + from .inference_classification_type import InferenceClassificationType + +from .entity import Entity + +@dataclass +class InferenceClassificationOverride(Entity): + # The classifyAs property + classify_as: Optional[InferenceClassificationType] = None + # The senderEmailAddress property + sender_email_address: Optional[EmailAddress] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> InferenceClassificationOverride: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: InferenceClassificationOverride + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return InferenceClassificationOverride() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .email_address import EmailAddress + from .entity import Entity + from .inference_classification_type import InferenceClassificationType + + from .email_address import EmailAddress + from .entity import Entity + from .inference_classification_type import InferenceClassificationType + + fields: Dict[str, Callable[[Any], None]] = { + "classifyAs": lambda n : setattr(self, 'classify_as', n.get_enum_value(InferenceClassificationType)), + "senderEmailAddress": lambda n : setattr(self, 'sender_email_address', n.get_object_value(EmailAddress)), + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + writer.write_enum_value("classifyAs", self.classify_as) + writer.write_object_value("senderEmailAddress", self.sender_email_address) + + diff --git a/tests/validation/validation/models/inference_classification_override_collection_response.py b/tests/validation/validation/models/inference_classification_override_collection_response.py new file mode 100644 index 00000000..35bda2e7 --- /dev/null +++ b/tests/validation/validation/models/inference_classification_override_collection_response.py @@ -0,0 +1,57 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .inference_classification_override import InferenceClassificationOverride + +@dataclass +class InferenceClassificationOverrideCollectionResponse(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The OdataNextLink property + odata_next_link: Optional[str] = None + # The value property + value: Optional[List[InferenceClassificationOverride]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> InferenceClassificationOverrideCollectionResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: InferenceClassificationOverrideCollectionResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return InferenceClassificationOverrideCollectionResponse() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .inference_classification_override import InferenceClassificationOverride + + from .inference_classification_override import InferenceClassificationOverride + + fields: Dict[str, Callable[[Any], None]] = { + "@odata.nextLink": lambda n : setattr(self, 'odata_next_link', n.get_str_value()), + "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(InferenceClassificationOverride)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("@odata.nextLink", self.odata_next_link) + writer.write_collection_of_object_values("value", self.value) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/inference_classification_type.py b/tests/validation/validation/models/inference_classification_type.py new file mode 100644 index 00000000..abe36c27 --- /dev/null +++ b/tests/validation/validation/models/inference_classification_type.py @@ -0,0 +1,6 @@ +from enum import Enum + +class InferenceClassificationType(str, Enum): + Focused = "focused", + Other = "other", + diff --git a/tests/validation/validation/models/internet_message_header.py b/tests/validation/validation/models/internet_message_header.py new file mode 100644 index 00000000..44a43cda --- /dev/null +++ b/tests/validation/validation/models/internet_message_header.py @@ -0,0 +1,50 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +@dataclass +class InternetMessageHeader(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # Represents the key in a key-value pair. + name: Optional[str] = None + # The value in a key-value pair. + value: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> InternetMessageHeader: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: InternetMessageHeader + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return InternetMessageHeader() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + fields: Dict[str, Callable[[Any], None]] = { + "name": lambda n : setattr(self, 'name', n.get_str_value()), + "value": lambda n : setattr(self, 'value', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("name", self.name) + writer.write_str_value("value", self.value) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/item_body.py b/tests/validation/validation/models/item_body.py new file mode 100644 index 00000000..f47434d1 --- /dev/null +++ b/tests/validation/validation/models/item_body.py @@ -0,0 +1,57 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .body_type import BodyType + +@dataclass +class ItemBody(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The content of the item. + content: Optional[str] = None + # The contentType property + content_type: Optional[BodyType] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> ItemBody: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: ItemBody + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return ItemBody() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .body_type import BodyType + + from .body_type import BodyType + + fields: Dict[str, Callable[[Any], None]] = { + "content": lambda n : setattr(self, 'content', n.get_str_value()), + "contentType": lambda n : setattr(self, 'content_type', n.get_enum_value(BodyType)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("content", self.content) + writer.write_enum_value("contentType", self.content_type) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/mail_folder.py b/tests/validation/validation/models/mail_folder.py new file mode 100644 index 00000000..2de00b02 --- /dev/null +++ b/tests/validation/validation/models/mail_folder.py @@ -0,0 +1,106 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .entity import Entity + from .message import Message + from .message_rule import MessageRule + from .multi_value_legacy_extended_property import MultiValueLegacyExtendedProperty + from .single_value_legacy_extended_property import SingleValueLegacyExtendedProperty + +from .entity import Entity + +@dataclass +class MailFolder(Entity): + # The number of immediate child mailFolders in the current mailFolder. + child_folder_count: Optional[int] = None + # The collection of child folders in the mailFolder. + child_folders: Optional[List[MailFolder]] = None + # The mailFolder's display name. + display_name: Optional[str] = None + # Indicates whether the mailFolder is hidden. This property can be set only when creating the folder. Find more information in Hidden mail folders. + is_hidden: Optional[bool] = None + # The collection of rules that apply to the user's Inbox folder. + message_rules: Optional[List[MessageRule]] = None + # The collection of messages in the mailFolder. + messages: Optional[List[Message]] = None + # The collection of multi-value extended properties defined for the mailFolder. Read-only. Nullable. + multi_value_extended_properties: Optional[List[MultiValueLegacyExtendedProperty]] = None + # The unique identifier for the mailFolder's parent mailFolder. + parent_folder_id: Optional[str] = None + # The collection of single-value extended properties defined for the mailFolder. Read-only. Nullable. + single_value_extended_properties: Optional[List[SingleValueLegacyExtendedProperty]] = None + # The number of items in the mailFolder. + total_item_count: Optional[int] = None + # The number of items in the mailFolder marked as unread. + unread_item_count: Optional[int] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MailFolder: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MailFolder + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MailFolder() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .entity import Entity + from .message import Message + from .message_rule import MessageRule + from .multi_value_legacy_extended_property import MultiValueLegacyExtendedProperty + from .single_value_legacy_extended_property import SingleValueLegacyExtendedProperty + + from .entity import Entity + from .message import Message + from .message_rule import MessageRule + from .multi_value_legacy_extended_property import MultiValueLegacyExtendedProperty + from .single_value_legacy_extended_property import SingleValueLegacyExtendedProperty + + fields: Dict[str, Callable[[Any], None]] = { + "childFolderCount": lambda n : setattr(self, 'child_folder_count', n.get_int_value()), + "childFolders": lambda n : setattr(self, 'child_folders', n.get_collection_of_object_values(MailFolder)), + "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()), + "isHidden": lambda n : setattr(self, 'is_hidden', n.get_bool_value()), + "messageRules": lambda n : setattr(self, 'message_rules', n.get_collection_of_object_values(MessageRule)), + "messages": lambda n : setattr(self, 'messages', n.get_collection_of_object_values(Message)), + "multiValueExtendedProperties": lambda n : setattr(self, 'multi_value_extended_properties', n.get_collection_of_object_values(MultiValueLegacyExtendedProperty)), + "parentFolderId": lambda n : setattr(self, 'parent_folder_id', n.get_str_value()), + "singleValueExtendedProperties": lambda n : setattr(self, 'single_value_extended_properties', n.get_collection_of_object_values(SingleValueLegacyExtendedProperty)), + "totalItemCount": lambda n : setattr(self, 'total_item_count', n.get_int_value()), + "unreadItemCount": lambda n : setattr(self, 'unread_item_count', n.get_int_value()), + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + writer.write_int_value("childFolderCount", self.child_folder_count) + writer.write_collection_of_object_values("childFolders", self.child_folders) + writer.write_str_value("displayName", self.display_name) + writer.write_bool_value("isHidden", self.is_hidden) + writer.write_collection_of_object_values("messageRules", self.message_rules) + writer.write_collection_of_object_values("messages", self.messages) + writer.write_collection_of_object_values("multiValueExtendedProperties", self.multi_value_extended_properties) + writer.write_str_value("parentFolderId", self.parent_folder_id) + writer.write_collection_of_object_values("singleValueExtendedProperties", self.single_value_extended_properties) + writer.write_int_value("totalItemCount", self.total_item_count) + writer.write_int_value("unreadItemCount", self.unread_item_count) + + diff --git a/tests/validation/validation/models/mail_folder_collection_response.py b/tests/validation/validation/models/mail_folder_collection_response.py new file mode 100644 index 00000000..b0a99b50 --- /dev/null +++ b/tests/validation/validation/models/mail_folder_collection_response.py @@ -0,0 +1,57 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .mail_folder import MailFolder + +@dataclass +class MailFolderCollectionResponse(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The OdataNextLink property + odata_next_link: Optional[str] = None + # The value property + value: Optional[List[MailFolder]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MailFolderCollectionResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MailFolderCollectionResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MailFolderCollectionResponse() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .mail_folder import MailFolder + + from .mail_folder import MailFolder + + fields: Dict[str, Callable[[Any], None]] = { + "@odata.nextLink": lambda n : setattr(self, 'odata_next_link', n.get_str_value()), + "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(MailFolder)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("@odata.nextLink", self.odata_next_link) + writer.write_collection_of_object_values("value", self.value) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/message.py b/tests/validation/validation/models/message.py new file mode 100644 index 00000000..ff1f3d2e --- /dev/null +++ b/tests/validation/validation/models/message.py @@ -0,0 +1,201 @@ +from __future__ import annotations +import datetime +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .attachment import Attachment + from .extension import Extension + from .followup_flag import FollowupFlag + from .importance import Importance + from .inference_classification_type import InferenceClassificationType + from .internet_message_header import InternetMessageHeader + from .item_body import ItemBody + from .multi_value_legacy_extended_property import MultiValueLegacyExtendedProperty + from .outlook_item import OutlookItem + from .recipient import Recipient + from .single_value_legacy_extended_property import SingleValueLegacyExtendedProperty + +from .outlook_item import OutlookItem + +@dataclass +class Message(OutlookItem): + # The fileAttachment and itemAttachment attachments for the message. + attachments: Optional[List[Attachment]] = None + # The Bcc: recipients for the message. + bcc_recipients: Optional[List[Recipient]] = None + # The body property + body: Optional[ItemBody] = None + # The first 255 characters of the message body. It is in text format. + body_preview: Optional[str] = None + # The Cc: recipients for the message. + cc_recipients: Optional[List[Recipient]] = None + # The ID of the conversation the email belongs to. + conversation_id: Optional[str] = None + # Indicates the position of the message within the conversation. + conversation_index: Optional[bytes] = None + # The collection of open extensions defined for the message. Nullable. + extensions: Optional[List[Extension]] = None + # The flag property + flag: Optional[FollowupFlag] = None + # The from property + from_: Optional[Recipient] = None + # Indicates whether the message has attachments. This property doesn't include inline attachments, so if a message contains only inline attachments, this property is false. To verify the existence of inline attachments, parse the body property to look for a src attribute, such as . + has_attachments: Optional[bool] = None + # The importance property + importance: Optional[Importance] = None + # The inferenceClassification property + inference_classification: Optional[InferenceClassificationType] = None + # A collection of message headers defined by RFC5322. The set includes message headers indicating the network path taken by a message from the sender to the recipient. It can also contain custom message headers that hold app data for the message. Returned only on applying a $select query option. Read-only. + internet_message_headers: Optional[List[InternetMessageHeader]] = None + # The message ID in the format specified by RFC2822. + internet_message_id: Optional[str] = None + # Indicates whether a read receipt is requested for the message. + is_delivery_receipt_requested: Optional[bool] = None + # Indicates whether the message is a draft. A message is a draft if it hasn't been sent yet. + is_draft: Optional[bool] = None + # Indicates whether the message has been read. + is_read: Optional[bool] = None + # Indicates whether a read receipt is requested for the message. + is_read_receipt_requested: Optional[bool] = None + # The collection of multi-value extended properties defined for the message. Nullable. + multi_value_extended_properties: Optional[List[MultiValueLegacyExtendedProperty]] = None + # The unique identifier for the message's parent mailFolder. + parent_folder_id: Optional[str] = None + # The date and time the message was received. The date and time information uses ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z. + received_date_time: Optional[datetime.datetime] = None + # The email addresses to use when replying. + reply_to: Optional[List[Recipient]] = None + # The sender property + sender: Optional[Recipient] = None + # The date and time the message was sent. The date and time information uses ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z. + sent_date_time: Optional[datetime.datetime] = None + # The collection of single-value extended properties defined for the message. Nullable. + single_value_extended_properties: Optional[List[SingleValueLegacyExtendedProperty]] = None + # The subject of the message. + subject: Optional[str] = None + # The To: recipients for the message. + to_recipients: Optional[List[Recipient]] = None + # The uniqueBody property + unique_body: Optional[ItemBody] = None + # The URL to open the message in Outlook on the web.You can append an ispopout argument to the end of the URL to change how the message is displayed. If ispopout is not present or if it is set to 1, then the message is shown in a popout window. If ispopout is set to 0, the browser shows the message in the Outlook on the web review pane.The message opens in the browser if you are signed in to your mailbox via Outlook on the web. You are prompted to sign in if you are not already signed in with the browser.This URL cannot be accessed from within an iFrame. + web_link: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> Message: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: Message + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return Message() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .attachment import Attachment + from .extension import Extension + from .followup_flag import FollowupFlag + from .importance import Importance + from .inference_classification_type import InferenceClassificationType + from .internet_message_header import InternetMessageHeader + from .item_body import ItemBody + from .multi_value_legacy_extended_property import MultiValueLegacyExtendedProperty + from .outlook_item import OutlookItem + from .recipient import Recipient + from .single_value_legacy_extended_property import SingleValueLegacyExtendedProperty + + from .attachment import Attachment + from .extension import Extension + from .followup_flag import FollowupFlag + from .importance import Importance + from .inference_classification_type import InferenceClassificationType + from .internet_message_header import InternetMessageHeader + from .item_body import ItemBody + from .multi_value_legacy_extended_property import MultiValueLegacyExtendedProperty + from .outlook_item import OutlookItem + from .recipient import Recipient + from .single_value_legacy_extended_property import SingleValueLegacyExtendedProperty + + fields: Dict[str, Callable[[Any], None]] = { + "attachments": lambda n : setattr(self, 'attachments', n.get_collection_of_object_values(Attachment)), + "bccRecipients": lambda n : setattr(self, 'bcc_recipients', n.get_collection_of_object_values(Recipient)), + "body": lambda n : setattr(self, 'body', n.get_object_value(ItemBody)), + "bodyPreview": lambda n : setattr(self, 'body_preview', n.get_str_value()), + "ccRecipients": lambda n : setattr(self, 'cc_recipients', n.get_collection_of_object_values(Recipient)), + "conversationId": lambda n : setattr(self, 'conversation_id', n.get_str_value()), + "conversationIndex": lambda n : setattr(self, 'conversation_index', n.get_bytes_value()), + "extensions": lambda n : setattr(self, 'extensions', n.get_collection_of_object_values(Extension)), + "flag": lambda n : setattr(self, 'flag', n.get_object_value(FollowupFlag)), + "from": lambda n : setattr(self, 'from_', n.get_object_value(Recipient)), + "hasAttachments": lambda n : setattr(self, 'has_attachments', n.get_bool_value()), + "importance": lambda n : setattr(self, 'importance', n.get_enum_value(Importance)), + "inferenceClassification": lambda n : setattr(self, 'inference_classification', n.get_enum_value(InferenceClassificationType)), + "internetMessageHeaders": lambda n : setattr(self, 'internet_message_headers', n.get_collection_of_object_values(InternetMessageHeader)), + "internetMessageId": lambda n : setattr(self, 'internet_message_id', n.get_str_value()), + "isDeliveryReceiptRequested": lambda n : setattr(self, 'is_delivery_receipt_requested', n.get_bool_value()), + "isDraft": lambda n : setattr(self, 'is_draft', n.get_bool_value()), + "isRead": lambda n : setattr(self, 'is_read', n.get_bool_value()), + "isReadReceiptRequested": lambda n : setattr(self, 'is_read_receipt_requested', n.get_bool_value()), + "multiValueExtendedProperties": lambda n : setattr(self, 'multi_value_extended_properties', n.get_collection_of_object_values(MultiValueLegacyExtendedProperty)), + "parentFolderId": lambda n : setattr(self, 'parent_folder_id', n.get_str_value()), + "receivedDateTime": lambda n : setattr(self, 'received_date_time', n.get_datetime_value()), + "replyTo": lambda n : setattr(self, 'reply_to', n.get_collection_of_object_values(Recipient)), + "sender": lambda n : setattr(self, 'sender', n.get_object_value(Recipient)), + "sentDateTime": lambda n : setattr(self, 'sent_date_time', n.get_datetime_value()), + "singleValueExtendedProperties": lambda n : setattr(self, 'single_value_extended_properties', n.get_collection_of_object_values(SingleValueLegacyExtendedProperty)), + "subject": lambda n : setattr(self, 'subject', n.get_str_value()), + "toRecipients": lambda n : setattr(self, 'to_recipients', n.get_collection_of_object_values(Recipient)), + "uniqueBody": lambda n : setattr(self, 'unique_body', n.get_object_value(ItemBody)), + "webLink": lambda n : setattr(self, 'web_link', n.get_str_value()), + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + writer.write_collection_of_object_values("attachments", self.attachments) + writer.write_collection_of_object_values("bccRecipients", self.bcc_recipients) + writer.write_object_value("body", self.body) + writer.write_str_value("bodyPreview", self.body_preview) + writer.write_collection_of_object_values("ccRecipients", self.cc_recipients) + writer.write_str_value("conversationId", self.conversation_id) + writer.write_bytes_value("conversationIndex", self.conversation_index) + writer.write_collection_of_object_values("extensions", self.extensions) + writer.write_object_value("flag", self.flag) + writer.write_object_value("from", self.from_) + writer.write_bool_value("hasAttachments", self.has_attachments) + writer.write_enum_value("importance", self.importance) + writer.write_enum_value("inferenceClassification", self.inference_classification) + writer.write_collection_of_object_values("internetMessageHeaders", self.internet_message_headers) + writer.write_str_value("internetMessageId", self.internet_message_id) + writer.write_bool_value("isDeliveryReceiptRequested", self.is_delivery_receipt_requested) + writer.write_bool_value("isDraft", self.is_draft) + writer.write_bool_value("isRead", self.is_read) + writer.write_bool_value("isReadReceiptRequested", self.is_read_receipt_requested) + writer.write_collection_of_object_values("multiValueExtendedProperties", self.multi_value_extended_properties) + writer.write_str_value("parentFolderId", self.parent_folder_id) + writer.write_datetime_value("receivedDateTime", self.received_date_time) + writer.write_collection_of_object_values("replyTo", self.reply_to) + writer.write_object_value("sender", self.sender) + writer.write_datetime_value("sentDateTime", self.sent_date_time) + writer.write_collection_of_object_values("singleValueExtendedProperties", self.single_value_extended_properties) + writer.write_str_value("subject", self.subject) + writer.write_collection_of_object_values("toRecipients", self.to_recipients) + writer.write_object_value("uniqueBody", self.unique_body) + writer.write_str_value("webLink", self.web_link) + + diff --git a/tests/validation/validation/models/message_action_flag.py b/tests/validation/validation/models/message_action_flag.py new file mode 100644 index 00000000..08034835 --- /dev/null +++ b/tests/validation/validation/models/message_action_flag.py @@ -0,0 +1,15 @@ +from enum import Enum + +class MessageActionFlag(str, Enum): + Any = "any", + Call = "call", + DoNotForward = "doNotForward", + FollowUp = "followUp", + Fyi = "fyi", + Forward = "forward", + NoResponseNecessary = "noResponseNecessary", + Read = "read", + Reply = "reply", + ReplyToAll = "replyToAll", + Review = "review", + diff --git a/tests/validation/validation/models/message_collection_response.py b/tests/validation/validation/models/message_collection_response.py new file mode 100644 index 00000000..24e493a7 --- /dev/null +++ b/tests/validation/validation/models/message_collection_response.py @@ -0,0 +1,57 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .message import Message + +@dataclass +class MessageCollectionResponse(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The OdataNextLink property + odata_next_link: Optional[str] = None + # The value property + value: Optional[List[Message]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MessageCollectionResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MessageCollectionResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MessageCollectionResponse() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .message import Message + + from .message import Message + + fields: Dict[str, Callable[[Any], None]] = { + "@odata.nextLink": lambda n : setattr(self, 'odata_next_link', n.get_str_value()), + "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(Message)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("@odata.nextLink", self.odata_next_link) + writer.write_collection_of_object_values("value", self.value) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/message_rule.py b/tests/validation/validation/models/message_rule.py new file mode 100644 index 00000000..7c60c337 --- /dev/null +++ b/tests/validation/validation/models/message_rule.py @@ -0,0 +1,88 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .entity import Entity + from .message_rule_actions import MessageRuleActions + from .message_rule_predicates import MessageRulePredicates + +from .entity import Entity + +@dataclass +class MessageRule(Entity): + # The actions property + actions: Optional[MessageRuleActions] = None + # The conditions property + conditions: Optional[MessageRulePredicates] = None + # The display name of the rule. + display_name: Optional[str] = None + # The exceptions property + exceptions: Optional[MessageRulePredicates] = None + # Indicates whether the rule is in an error condition. Read-only. + has_error: Optional[bool] = None + # Indicates whether the rule is enabled to be applied to messages. + is_enabled: Optional[bool] = None + # Indicates if the rule is read-only and cannot be modified or deleted by the rules REST API. + is_read_only: Optional[bool] = None + # Indicates the order in which the rule is executed, among other rules. + sequence: Optional[int] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MessageRule: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MessageRule + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MessageRule() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .entity import Entity + from .message_rule_actions import MessageRuleActions + from .message_rule_predicates import MessageRulePredicates + + from .entity import Entity + from .message_rule_actions import MessageRuleActions + from .message_rule_predicates import MessageRulePredicates + + fields: Dict[str, Callable[[Any], None]] = { + "actions": lambda n : setattr(self, 'actions', n.get_object_value(MessageRuleActions)), + "conditions": lambda n : setattr(self, 'conditions', n.get_object_value(MessageRulePredicates)), + "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()), + "exceptions": lambda n : setattr(self, 'exceptions', n.get_object_value(MessageRulePredicates)), + "hasError": lambda n : setattr(self, 'has_error', n.get_bool_value()), + "isEnabled": lambda n : setattr(self, 'is_enabled', n.get_bool_value()), + "isReadOnly": lambda n : setattr(self, 'is_read_only', n.get_bool_value()), + "sequence": lambda n : setattr(self, 'sequence', n.get_int_value()), + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + writer.write_object_value("actions", self.actions) + writer.write_object_value("conditions", self.conditions) + writer.write_str_value("displayName", self.display_name) + writer.write_object_value("exceptions", self.exceptions) + writer.write_bool_value("hasError", self.has_error) + writer.write_bool_value("isEnabled", self.is_enabled) + writer.write_bool_value("isReadOnly", self.is_read_only) + writer.write_int_value("sequence", self.sequence) + + diff --git a/tests/validation/validation/models/message_rule_actions.py b/tests/validation/validation/models/message_rule_actions.py new file mode 100644 index 00000000..58b50893 --- /dev/null +++ b/tests/validation/validation/models/message_rule_actions.py @@ -0,0 +1,96 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .importance import Importance + from .recipient import Recipient + +@dataclass +class MessageRuleActions(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # A list of categories to be assigned to a message. + assign_categories: Optional[List[str]] = None + # The ID of a folder that a message is to be copied to. + copy_to_folder: Optional[str] = None + # Indicates whether a message should be moved to the Deleted Items folder. + delete: Optional[bool] = None + # The email addresses of the recipients to which a message should be forwarded as an attachment. + forward_as_attachment_to: Optional[List[Recipient]] = None + # The email addresses of the recipients to which a message should be forwarded. + forward_to: Optional[List[Recipient]] = None + # Indicates whether a message should be marked as read. + mark_as_read: Optional[bool] = None + # The markImportance property + mark_importance: Optional[Importance] = None + # The ID of the folder that a message will be moved to. + move_to_folder: Optional[str] = None + # Indicates whether a message should be permanently deleted and not saved to the Deleted Items folder. + permanent_delete: Optional[bool] = None + # The email addresses to which a message should be redirected. + redirect_to: Optional[List[Recipient]] = None + # Indicates whether subsequent rules should be evaluated. + stop_processing_rules: Optional[bool] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MessageRuleActions: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MessageRuleActions + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MessageRuleActions() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .importance import Importance + from .recipient import Recipient + + from .importance import Importance + from .recipient import Recipient + + fields: Dict[str, Callable[[Any], None]] = { + "assignCategories": lambda n : setattr(self, 'assign_categories', n.get_collection_of_primitive_values(str)), + "copyToFolder": lambda n : setattr(self, 'copy_to_folder', n.get_str_value()), + "delete": lambda n : setattr(self, 'delete', n.get_bool_value()), + "forwardAsAttachmentTo": lambda n : setattr(self, 'forward_as_attachment_to', n.get_collection_of_object_values(Recipient)), + "forwardTo": lambda n : setattr(self, 'forward_to', n.get_collection_of_object_values(Recipient)), + "markAsRead": lambda n : setattr(self, 'mark_as_read', n.get_bool_value()), + "markImportance": lambda n : setattr(self, 'mark_importance', n.get_enum_value(Importance)), + "moveToFolder": lambda n : setattr(self, 'move_to_folder', n.get_str_value()), + "permanentDelete": lambda n : setattr(self, 'permanent_delete', n.get_bool_value()), + "redirectTo": lambda n : setattr(self, 'redirect_to', n.get_collection_of_object_values(Recipient)), + "stopProcessingRules": lambda n : setattr(self, 'stop_processing_rules', n.get_bool_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_collection_of_primitive_values("assignCategories", self.assign_categories) + writer.write_str_value("copyToFolder", self.copy_to_folder) + writer.write_bool_value("delete", self.delete) + writer.write_collection_of_object_values("forwardAsAttachmentTo", self.forward_as_attachment_to) + writer.write_collection_of_object_values("forwardTo", self.forward_to) + writer.write_bool_value("markAsRead", self.mark_as_read) + writer.write_enum_value("markImportance", self.mark_importance) + writer.write_str_value("moveToFolder", self.move_to_folder) + writer.write_bool_value("permanentDelete", self.permanent_delete) + writer.write_collection_of_object_values("redirectTo", self.redirect_to) + writer.write_bool_value("stopProcessingRules", self.stop_processing_rules) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/message_rule_collection_response.py b/tests/validation/validation/models/message_rule_collection_response.py new file mode 100644 index 00000000..6f2d8ba6 --- /dev/null +++ b/tests/validation/validation/models/message_rule_collection_response.py @@ -0,0 +1,57 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .message_rule import MessageRule + +@dataclass +class MessageRuleCollectionResponse(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The OdataNextLink property + odata_next_link: Optional[str] = None + # The value property + value: Optional[List[MessageRule]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MessageRuleCollectionResponse: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MessageRuleCollectionResponse + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MessageRuleCollectionResponse() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .message_rule import MessageRule + + from .message_rule import MessageRule + + fields: Dict[str, Callable[[Any], None]] = { + "@odata.nextLink": lambda n : setattr(self, 'odata_next_link', n.get_str_value()), + "value": lambda n : setattr(self, 'value', n.get_collection_of_object_values(MessageRule)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("@odata.nextLink", self.odata_next_link) + writer.write_collection_of_object_values("value", self.value) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/message_rule_predicates.py b/tests/validation/validation/models/message_rule_predicates.py new file mode 100644 index 00000000..aefa71c8 --- /dev/null +++ b/tests/validation/validation/models/message_rule_predicates.py @@ -0,0 +1,181 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .importance import Importance + from .message_action_flag import MessageActionFlag + from .recipient import Recipient + from .sensitivity import Sensitivity + from .size_range import SizeRange + +@dataclass +class MessageRulePredicates(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # Represents the strings that should appear in the body of an incoming message in order for the condition or exception to apply. + body_contains: Optional[List[str]] = None + # Represents the strings that should appear in the body or subject of an incoming message in order for the condition or exception to apply. + body_or_subject_contains: Optional[List[str]] = None + # Represents the categories that an incoming message should be labeled with in order for the condition or exception to apply. + categories: Optional[List[str]] = None + # Represents the specific sender email addresses of an incoming message in order for the condition or exception to apply. + from_addresses: Optional[List[Recipient]] = None + # Indicates whether an incoming message must have attachments in order for the condition or exception to apply. + has_attachments: Optional[bool] = None + # Represents the strings that appear in the headers of an incoming message in order for the condition or exception to apply. + header_contains: Optional[List[str]] = None + # The importance property + importance: Optional[Importance] = None + # Indicates whether an incoming message must be an approval request in order for the condition or exception to apply. + is_approval_request: Optional[bool] = None + # Indicates whether an incoming message must be automatically forwarded in order for the condition or exception to apply. + is_automatic_forward: Optional[bool] = None + # Indicates whether an incoming message must be an auto reply in order for the condition or exception to apply. + is_automatic_reply: Optional[bool] = None + # Indicates whether an incoming message must be encrypted in order for the condition or exception to apply. + is_encrypted: Optional[bool] = None + # Indicates whether an incoming message must be a meeting request in order for the condition or exception to apply. + is_meeting_request: Optional[bool] = None + # Indicates whether an incoming message must be a meeting response in order for the condition or exception to apply. + is_meeting_response: Optional[bool] = None + # Indicates whether an incoming message must be a non-delivery report in order for the condition or exception to apply. + is_non_delivery_report: Optional[bool] = None + # Indicates whether an incoming message must be permission controlled (RMS-protected) in order for the condition or exception to apply. + is_permission_controlled: Optional[bool] = None + # Indicates whether an incoming message must be a read receipt in order for the condition or exception to apply. + is_read_receipt: Optional[bool] = None + # Indicates whether an incoming message must be S/MIME-signed in order for the condition or exception to apply. + is_signed: Optional[bool] = None + # Indicates whether an incoming message must be a voice mail in order for the condition or exception to apply. + is_voicemail: Optional[bool] = None + # The messageActionFlag property + message_action_flag: Optional[MessageActionFlag] = None + # Indicates whether the owner of the mailbox must not be a recipient of an incoming message in order for the condition or exception to apply. + not_sent_to_me: Optional[bool] = None + # Represents the strings that appear in either the toRecipients or ccRecipients properties of an incoming message in order for the condition or exception to apply. + recipient_contains: Optional[List[str]] = None + # Represents the strings that appear in the from property of an incoming message in order for the condition or exception to apply. + sender_contains: Optional[List[str]] = None + # The sensitivity property + sensitivity: Optional[Sensitivity] = None + # Indicates whether the owner of the mailbox must be in the ccRecipients property of an incoming message in order for the condition or exception to apply. + sent_cc_me: Optional[bool] = None + # Indicates whether the owner of the mailbox must be the only recipient in an incoming message in order for the condition or exception to apply. + sent_only_to_me: Optional[bool] = None + # Represents the email addresses that an incoming message must have been sent to in order for the condition or exception to apply. + sent_to_addresses: Optional[List[Recipient]] = None + # Indicates whether the owner of the mailbox must be in the toRecipients property of an incoming message in order for the condition or exception to apply. + sent_to_me: Optional[bool] = None + # Indicates whether the owner of the mailbox must be in either a toRecipients or ccRecipients property of an incoming message in order for the condition or exception to apply. + sent_to_or_cc_me: Optional[bool] = None + # Represents the strings that appear in the subject of an incoming message in order for the condition or exception to apply. + subject_contains: Optional[List[str]] = None + # The withinSizeRange property + within_size_range: Optional[SizeRange] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MessageRulePredicates: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MessageRulePredicates + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MessageRulePredicates() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .importance import Importance + from .message_action_flag import MessageActionFlag + from .recipient import Recipient + from .sensitivity import Sensitivity + from .size_range import SizeRange + + from .importance import Importance + from .message_action_flag import MessageActionFlag + from .recipient import Recipient + from .sensitivity import Sensitivity + from .size_range import SizeRange + + fields: Dict[str, Callable[[Any], None]] = { + "bodyContains": lambda n : setattr(self, 'body_contains', n.get_collection_of_primitive_values(str)), + "bodyOrSubjectContains": lambda n : setattr(self, 'body_or_subject_contains', n.get_collection_of_primitive_values(str)), + "categories": lambda n : setattr(self, 'categories', n.get_collection_of_primitive_values(str)), + "fromAddresses": lambda n : setattr(self, 'from_addresses', n.get_collection_of_object_values(Recipient)), + "hasAttachments": lambda n : setattr(self, 'has_attachments', n.get_bool_value()), + "headerContains": lambda n : setattr(self, 'header_contains', n.get_collection_of_primitive_values(str)), + "importance": lambda n : setattr(self, 'importance', n.get_enum_value(Importance)), + "isApprovalRequest": lambda n : setattr(self, 'is_approval_request', n.get_bool_value()), + "isAutomaticForward": lambda n : setattr(self, 'is_automatic_forward', n.get_bool_value()), + "isAutomaticReply": lambda n : setattr(self, 'is_automatic_reply', n.get_bool_value()), + "isEncrypted": lambda n : setattr(self, 'is_encrypted', n.get_bool_value()), + "isMeetingRequest": lambda n : setattr(self, 'is_meeting_request', n.get_bool_value()), + "isMeetingResponse": lambda n : setattr(self, 'is_meeting_response', n.get_bool_value()), + "isNonDeliveryReport": lambda n : setattr(self, 'is_non_delivery_report', n.get_bool_value()), + "isPermissionControlled": lambda n : setattr(self, 'is_permission_controlled', n.get_bool_value()), + "isReadReceipt": lambda n : setattr(self, 'is_read_receipt', n.get_bool_value()), + "isSigned": lambda n : setattr(self, 'is_signed', n.get_bool_value()), + "isVoicemail": lambda n : setattr(self, 'is_voicemail', n.get_bool_value()), + "messageActionFlag": lambda n : setattr(self, 'message_action_flag', n.get_enum_value(MessageActionFlag)), + "notSentToMe": lambda n : setattr(self, 'not_sent_to_me', n.get_bool_value()), + "recipientContains": lambda n : setattr(self, 'recipient_contains', n.get_collection_of_primitive_values(str)), + "senderContains": lambda n : setattr(self, 'sender_contains', n.get_collection_of_primitive_values(str)), + "sensitivity": lambda n : setattr(self, 'sensitivity', n.get_enum_value(Sensitivity)), + "sentCcMe": lambda n : setattr(self, 'sent_cc_me', n.get_bool_value()), + "sentOnlyToMe": lambda n : setattr(self, 'sent_only_to_me', n.get_bool_value()), + "sentToAddresses": lambda n : setattr(self, 'sent_to_addresses', n.get_collection_of_object_values(Recipient)), + "sentToMe": lambda n : setattr(self, 'sent_to_me', n.get_bool_value()), + "sentToOrCcMe": lambda n : setattr(self, 'sent_to_or_cc_me', n.get_bool_value()), + "subjectContains": lambda n : setattr(self, 'subject_contains', n.get_collection_of_primitive_values(str)), + "withinSizeRange": lambda n : setattr(self, 'within_size_range', n.get_object_value(SizeRange)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_collection_of_primitive_values("bodyContains", self.body_contains) + writer.write_collection_of_primitive_values("bodyOrSubjectContains", self.body_or_subject_contains) + writer.write_collection_of_primitive_values("categories", self.categories) + writer.write_collection_of_object_values("fromAddresses", self.from_addresses) + writer.write_bool_value("hasAttachments", self.has_attachments) + writer.write_collection_of_primitive_values("headerContains", self.header_contains) + writer.write_enum_value("importance", self.importance) + writer.write_bool_value("isApprovalRequest", self.is_approval_request) + writer.write_bool_value("isAutomaticForward", self.is_automatic_forward) + writer.write_bool_value("isAutomaticReply", self.is_automatic_reply) + writer.write_bool_value("isEncrypted", self.is_encrypted) + writer.write_bool_value("isMeetingRequest", self.is_meeting_request) + writer.write_bool_value("isMeetingResponse", self.is_meeting_response) + writer.write_bool_value("isNonDeliveryReport", self.is_non_delivery_report) + writer.write_bool_value("isPermissionControlled", self.is_permission_controlled) + writer.write_bool_value("isReadReceipt", self.is_read_receipt) + writer.write_bool_value("isSigned", self.is_signed) + writer.write_bool_value("isVoicemail", self.is_voicemail) + writer.write_enum_value("messageActionFlag", self.message_action_flag) + writer.write_bool_value("notSentToMe", self.not_sent_to_me) + writer.write_collection_of_primitive_values("recipientContains", self.recipient_contains) + writer.write_collection_of_primitive_values("senderContains", self.sender_contains) + writer.write_enum_value("sensitivity", self.sensitivity) + writer.write_bool_value("sentCcMe", self.sent_cc_me) + writer.write_bool_value("sentOnlyToMe", self.sent_only_to_me) + writer.write_collection_of_object_values("sentToAddresses", self.sent_to_addresses) + writer.write_bool_value("sentToMe", self.sent_to_me) + writer.write_bool_value("sentToOrCcMe", self.sent_to_or_cc_me) + writer.write_collection_of_primitive_values("subjectContains", self.subject_contains) + writer.write_object_value("withinSizeRange", self.within_size_range) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/multi_value_legacy_extended_property.py b/tests/validation/validation/models/multi_value_legacy_extended_property.py new file mode 100644 index 00000000..07640946 --- /dev/null +++ b/tests/validation/validation/models/multi_value_legacy_extended_property.py @@ -0,0 +1,54 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .entity import Entity + +from .entity import Entity + +@dataclass +class MultiValueLegacyExtendedProperty(Entity): + # A collection of property values. + value: Optional[List[str]] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MultiValueLegacyExtendedProperty: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MultiValueLegacyExtendedProperty + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MultiValueLegacyExtendedProperty() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .entity import Entity + + from .entity import Entity + + fields: Dict[str, Callable[[Any], None]] = { + "value": lambda n : setattr(self, 'value', n.get_collection_of_primitive_values(str)), + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + writer.write_collection_of_primitive_values("value", self.value) + + diff --git a/tests/validation/validation/models/o_data_errors/error_details.py b/tests/validation/validation/models/o_data_errors/error_details.py new file mode 100644 index 00000000..2dbfb161 --- /dev/null +++ b/tests/validation/validation/models/o_data_errors/error_details.py @@ -0,0 +1,54 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +@dataclass +class ErrorDetails(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The code property + code: Optional[str] = None + # The message property + message: Optional[str] = None + # The target property + target: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> ErrorDetails: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: ErrorDetails + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return ErrorDetails() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + fields: Dict[str, Callable[[Any], None]] = { + "code": lambda n : setattr(self, 'code', n.get_str_value()), + "message": lambda n : setattr(self, 'message', n.get_str_value()), + "target": lambda n : setattr(self, 'target', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("code", self.code) + writer.write_str_value("message", self.message) + writer.write_str_value("target", self.target) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/o_data_errors/inner_error.py b/tests/validation/validation/models/o_data_errors/inner_error.py new file mode 100644 index 00000000..a1dd5e19 --- /dev/null +++ b/tests/validation/validation/models/o_data_errors/inner_error.py @@ -0,0 +1,45 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +@dataclass +class InnerError(AdditionalDataHolder, Parsable): + """ + The structure of this object is service-specific + """ + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> InnerError: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: InnerError + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return InnerError() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + fields: Dict[str, Callable[[Any], None]] = { + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/o_data_errors/main_error.py b/tests/validation/validation/models/o_data_errors/main_error.py new file mode 100644 index 00000000..c66cf836 --- /dev/null +++ b/tests/validation/validation/models/o_data_errors/main_error.py @@ -0,0 +1,72 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .error_details import ErrorDetails + from .inner_error import InnerError + +@dataclass +class MainError(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The code property + code: Optional[str] = None + # The details property + details: Optional[List[ErrorDetails]] = None + # The structure of this object is service-specific + inner_error: Optional[InnerError] = None + # The message property + message: Optional[str] = None + # The target property + target: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> MainError: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: MainError + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return MainError() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .error_details import ErrorDetails + from .inner_error import InnerError + + from .error_details import ErrorDetails + from .inner_error import InnerError + + fields: Dict[str, Callable[[Any], None]] = { + "code": lambda n : setattr(self, 'code', n.get_str_value()), + "details": lambda n : setattr(self, 'details', n.get_collection_of_object_values(ErrorDetails)), + "innerError": lambda n : setattr(self, 'inner_error', n.get_object_value(InnerError)), + "message": lambda n : setattr(self, 'message', n.get_str_value()), + "target": lambda n : setattr(self, 'target', n.get_str_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_str_value("code", self.code) + writer.write_collection_of_object_values("details", self.details) + writer.write_object_value("innerError", self.inner_error) + writer.write_str_value("message", self.message) + writer.write_str_value("target", self.target) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/o_data_errors/o_data_error.py b/tests/validation/validation/models/o_data_errors/o_data_error.py new file mode 100644 index 00000000..457f1d3e --- /dev/null +++ b/tests/validation/validation/models/o_data_errors/o_data_error.py @@ -0,0 +1,62 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.api_error import APIError +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .main_error import MainError + +@dataclass +class ODataError(APIError): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The error property + error: Optional[MainError] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> ODataError: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: ODataError + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return ODataError() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .main_error import MainError + + from .main_error import MainError + + fields: Dict[str, Callable[[Any], None]] = { + "error": lambda n : setattr(self, 'error', n.get_object_value(MainError)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_object_value("error", self.error) + writer.write_additional_data_value(self.additional_data) + + @property + def primary_message(self) -> str: + """ + The primary error message. + """ + if self.error is not None: + return '' if self.error.message is None else self.error.message + return '' + diff --git a/tests/validation/validation/models/outlook_item.py b/tests/validation/validation/models/outlook_item.py new file mode 100644 index 00000000..d049dcd6 --- /dev/null +++ b/tests/validation/validation/models/outlook_item.py @@ -0,0 +1,67 @@ +from __future__ import annotations +import datetime +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .entity import Entity + +from .entity import Entity + +@dataclass +class OutlookItem(Entity): + # The categories associated with the item + categories: Optional[List[str]] = None + # Identifies the version of the item. Every time the item is changed, changeKey changes as well. This allows Exchange to apply changes to the correct version of the object. Read-only. + change_key: Optional[str] = None + # The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z + created_date_time: Optional[datetime.datetime] = None + # The Timestamp type represents date and time information using ISO 8601 format and is always in UTC time. For example, midnight UTC on Jan 1, 2014 is 2014-01-01T00:00:00Z + last_modified_date_time: Optional[datetime.datetime] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> OutlookItem: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: OutlookItem + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return OutlookItem() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .entity import Entity + + from .entity import Entity + + fields: Dict[str, Callable[[Any], None]] = { + "categories": lambda n : setattr(self, 'categories', n.get_collection_of_primitive_values(str)), + "changeKey": lambda n : setattr(self, 'change_key', n.get_str_value()), + "createdDateTime": lambda n : setattr(self, 'created_date_time', n.get_datetime_value()), + "lastModifiedDateTime": lambda n : setattr(self, 'last_modified_date_time', n.get_datetime_value()), + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + writer.write_collection_of_primitive_values("categories", self.categories) + writer.write_str_value("changeKey", self.change_key) + writer.write_datetime_value("createdDateTime", self.created_date_time) + writer.write_datetime_value("lastModifiedDateTime", self.last_modified_date_time) + + diff --git a/tests/validation/validation/models/recipient.py b/tests/validation/validation/models/recipient.py new file mode 100644 index 00000000..0f610252 --- /dev/null +++ b/tests/validation/validation/models/recipient.py @@ -0,0 +1,53 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .email_address import EmailAddress + +@dataclass +class Recipient(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The emailAddress property + email_address: Optional[EmailAddress] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> Recipient: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: Recipient + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return Recipient() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .email_address import EmailAddress + + from .email_address import EmailAddress + + fields: Dict[str, Callable[[Any], None]] = { + "emailAddress": lambda n : setattr(self, 'email_address', n.get_object_value(EmailAddress)), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_object_value("emailAddress", self.email_address) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/models/sensitivity.py b/tests/validation/validation/models/sensitivity.py new file mode 100644 index 00000000..e346c229 --- /dev/null +++ b/tests/validation/validation/models/sensitivity.py @@ -0,0 +1,8 @@ +from enum import Enum + +class Sensitivity(str, Enum): + Normal = "normal", + Personal = "personal", + Private = "private", + Confidential = "confidential", + diff --git a/tests/validation/validation/models/single_value_legacy_extended_property.py b/tests/validation/validation/models/single_value_legacy_extended_property.py new file mode 100644 index 00000000..b7d6648b --- /dev/null +++ b/tests/validation/validation/models/single_value_legacy_extended_property.py @@ -0,0 +1,54 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .entity import Entity + +from .entity import Entity + +@dataclass +class SingleValueLegacyExtendedProperty(Entity): + # A property value. + value: Optional[str] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> SingleValueLegacyExtendedProperty: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: SingleValueLegacyExtendedProperty + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return SingleValueLegacyExtendedProperty() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + from .entity import Entity + + from .entity import Entity + + fields: Dict[str, Callable[[Any], None]] = { + "value": lambda n : setattr(self, 'value', n.get_str_value()), + } + super_fields = super().get_field_deserializers() + fields.update(super_fields) + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + super().serialize(writer) + writer.write_str_value("value", self.value) + + diff --git a/tests/validation/validation/models/size_range.py b/tests/validation/validation/models/size_range.py new file mode 100644 index 00000000..5645ac2e --- /dev/null +++ b/tests/validation/validation/models/size_range.py @@ -0,0 +1,50 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +@dataclass +class SizeRange(AdditionalDataHolder, Parsable): + # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well. + additional_data: Dict[str, Any] = field(default_factory=dict) + + # The maximum size (in kilobytes) that an incoming message must have in order for a condition or exception to apply. + maximum_size: Optional[int] = None + # The minimum size (in kilobytes) that an incoming message must have in order for a condition or exception to apply. + minimum_size: Optional[int] = None + + @staticmethod + def create_from_discriminator_value(parse_node: ParseNode) -> SizeRange: + """ + Creates a new instance of the appropriate class based on discriminator value + param parse_node: The parse node to use to read the discriminator value and create the object + Returns: SizeRange + """ + if parse_node is None: + raise TypeError("parse_node cannot be null.") + return SizeRange() + + def get_field_deserializers(self,) -> Dict[str, Callable[[ParseNode], None]]: + """ + The deserialization information for the current model + Returns: Dict[str, Callable[[ParseNode], None]] + """ + fields: Dict[str, Callable[[Any], None]] = { + "maximumSize": lambda n : setattr(self, 'maximum_size', n.get_int_value()), + "minimumSize": lambda n : setattr(self, 'minimum_size', n.get_int_value()), + } + return fields + + def serialize(self,writer: SerializationWriter) -> None: + """ + Serializes information the current object + param writer: Serialization writer to use to serialize this model + Returns: None + """ + if writer is None: + raise TypeError("writer cannot be null.") + writer.write_int_value("maximumSize", self.maximum_size) + writer.write_int_value("minimumSize", self.minimum_size) + writer.write_additional_data_value(self.additional_data) + + diff --git a/tests/validation/validation/users/item/inference_classification/inference_classification_request_builder.py b/tests/validation/validation/users/item/inference_classification/inference_classification_request_builder.py new file mode 100644 index 00000000..00903de4 --- /dev/null +++ b/tests/validation/validation/users/item/inference_classification/inference_classification_request_builder.py @@ -0,0 +1,161 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ....models.inference_classification import InferenceClassification + from ....models.o_data_errors.o_data_error import ODataError + from .overrides.overrides_request_builder import OverridesRequestBuilder + +class InferenceClassificationRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/inferenceClassification + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new InferenceClassificationRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/inferenceClassification{?%24expand,%24select}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[InferenceClassificationRequestBuilderGetQueryParameters]] = None) -> Optional[InferenceClassification]: + """ + Relevance classification of the user's messages based on explicit designations that override inferred relevance or importance. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[InferenceClassification] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ....models.inference_classification import InferenceClassification + + return await self.request_adapter.send_async(request_info, InferenceClassification, error_mapping) + + async def patch(self,body: InferenceClassification, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[InferenceClassification]: + """ + Update the navigation property inferenceClassification in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[InferenceClassification] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from ....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ....models.inference_classification import InferenceClassification + + return await self.request_adapter.send_async(request_info, InferenceClassification, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[InferenceClassificationRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Relevance classification of the user's messages based on explicit designations that override inferred relevance or importance. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: InferenceClassification, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property inferenceClassification in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> InferenceClassificationRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: InferenceClassificationRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return InferenceClassificationRequestBuilder(self.request_adapter, raw_url) + + @property + def overrides(self) -> OverridesRequestBuilder: + """ + The overrides property + """ + from .overrides.overrides_request_builder import OverridesRequestBuilder + + return OverridesRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class InferenceClassificationRequestBuilderGetQueryParameters(): + """ + Relevance classification of the user's messages based on explicit designations that override inferred relevance or importance. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class InferenceClassificationRequestBuilderGetRequestConfiguration(RequestConfiguration[InferenceClassificationRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class InferenceClassificationRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/inference_classification/overrides/count/count_request_builder.py b/tests/validation/validation/users/item/inference_classification/overrides/count/count_request_builder.py new file mode 100644 index 00000000..b60581fa --- /dev/null +++ b/tests/validation/validation/users/item/inference_classification/overrides/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ......models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/inferenceClassification/overrides/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/inferenceClassification/overrides/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/inference_classification/overrides/item/inference_classification_override_item_request_builder.py b/tests/validation/validation/users/item/inference_classification/overrides/item/inference_classification_override_item_request_builder.py new file mode 100644 index 00000000..0d1e2766 --- /dev/null +++ b/tests/validation/validation/users/item/inference_classification/overrides/item/inference_classification_override_item_request_builder.py @@ -0,0 +1,187 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ......models.inference_classification_override import InferenceClassificationOverride + from ......models.o_data_errors.o_data_error import ODataError + +class InferenceClassificationOverrideItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/inferenceClassification/overrides/{inferenceClassificationOverride-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new InferenceClassificationOverrideItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/inferenceClassification/overrides/{inferenceClassificationOverride%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property overrides for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[InferenceClassificationOverrideItemRequestBuilderGetQueryParameters]] = None) -> Optional[InferenceClassificationOverride]: + """ + A set of overrides for a user to always classify messages from specific senders in certain ways: focused, or other. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[InferenceClassificationOverride] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.inference_classification_override import InferenceClassificationOverride + + return await self.request_adapter.send_async(request_info, InferenceClassificationOverride, error_mapping) + + async def patch(self,body: InferenceClassificationOverride, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[InferenceClassificationOverride]: + """ + Update the navigation property overrides in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[InferenceClassificationOverride] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.inference_classification_override import InferenceClassificationOverride + + return await self.request_adapter.send_async(request_info, InferenceClassificationOverride, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property overrides for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[InferenceClassificationOverrideItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + A set of overrides for a user to always classify messages from specific senders in certain ways: focused, or other. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: InferenceClassificationOverride, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property overrides in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> InferenceClassificationOverrideItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: InferenceClassificationOverrideItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return InferenceClassificationOverrideItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class InferenceClassificationOverrideItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class InferenceClassificationOverrideItemRequestBuilderGetQueryParameters(): + """ + A set of overrides for a user to always classify messages from specific senders in certain ways: focused, or other. Read-only. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class InferenceClassificationOverrideItemRequestBuilderGetRequestConfiguration(RequestConfiguration[InferenceClassificationOverrideItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class InferenceClassificationOverrideItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/inference_classification/overrides/overrides_request_builder.py b/tests/validation/validation/users/item/inference_classification/overrides/overrides_request_builder.py new file mode 100644 index 00000000..eb812873 --- /dev/null +++ b/tests/validation/validation/users/item/inference_classification/overrides/overrides_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .....models.inference_classification_override import InferenceClassificationOverride + from .....models.inference_classification_override_collection_response import InferenceClassificationOverrideCollectionResponse + from .....models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.inference_classification_override_item_request_builder import InferenceClassificationOverrideItemRequestBuilder + +class OverridesRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/inferenceClassification/overrides + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new OverridesRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/inferenceClassification/overrides{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_inference_classification_override_id(self,inference_classification_override_id: str) -> InferenceClassificationOverrideItemRequestBuilder: + """ + Gets an item from the validation.users.item.inferenceClassification.overrides.item collection + param inference_classification_override_id: The unique identifier of inferenceClassificationOverride + Returns: InferenceClassificationOverrideItemRequestBuilder + """ + if inference_classification_override_id is None: + raise TypeError("inference_classification_override_id cannot be null.") + from .item.inference_classification_override_item_request_builder import InferenceClassificationOverrideItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["inferenceClassificationOverride%2Did"] = inference_classification_override_id + return InferenceClassificationOverrideItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[OverridesRequestBuilderGetQueryParameters]] = None) -> Optional[InferenceClassificationOverrideCollectionResponse]: + """ + A set of overrides for a user to always classify messages from specific senders in certain ways: focused, or other. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[InferenceClassificationOverrideCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .....models.inference_classification_override_collection_response import InferenceClassificationOverrideCollectionResponse + + return await self.request_adapter.send_async(request_info, InferenceClassificationOverrideCollectionResponse, error_mapping) + + async def post(self,body: InferenceClassificationOverride, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[InferenceClassificationOverride]: + """ + Create new navigation property to overrides for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[InferenceClassificationOverride] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .....models.inference_classification_override import InferenceClassificationOverride + + return await self.request_adapter.send_async(request_info, InferenceClassificationOverride, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[OverridesRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + A set of overrides for a user to always classify messages from specific senders in certain ways: focused, or other. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: InferenceClassificationOverride, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to overrides for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> OverridesRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: OverridesRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return OverridesRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class OverridesRequestBuilderGetQueryParameters(): + """ + A set of overrides for a user to always classify messages from specific senders in certain ways: focused, or other. Read-only. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class OverridesRequestBuilderGetRequestConfiguration(RequestConfiguration[OverridesRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class OverridesRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/count/count_request_builder.py new file mode 100644 index 00000000..79f58a35 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .....models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/child_folders_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/child_folders_request_builder.py new file mode 100644 index 00000000..131d454d --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/child_folders_request_builder.py @@ -0,0 +1,212 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ......models.mail_folder import MailFolder + from ......models.mail_folder_collection_response import MailFolderCollectionResponse + from ......models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.mail_folder_item_request_builder import MailFolderItemRequestBuilder + +class ChildFoldersRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ChildFoldersRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top,includeHiddenFolders}", path_parameters) + + def by_mail_folder_id1(self,mail_folder_id1: str) -> MailFolderItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item.childFolders.item collection + param mail_folder_id1: The unique identifier of mailFolder + Returns: MailFolderItemRequestBuilder + """ + if mail_folder_id1 is None: + raise TypeError("mail_folder_id1 cannot be null.") + from .item.mail_folder_item_request_builder import MailFolderItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["mailFolder%2Did1"] = mail_folder_id1 + return MailFolderItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[ChildFoldersRequestBuilderGetQueryParameters]] = None) -> Optional[MailFolderCollectionResponse]: + """ + The collection of child folders in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MailFolderCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.mail_folder_collection_response import MailFolderCollectionResponse + + return await self.request_adapter.send_async(request_info, MailFolderCollectionResponse, error_mapping) + + async def post(self,body: MailFolder, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[MailFolder]: + """ + Create new navigation property to childFolders for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MailFolder] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.mail_folder import MailFolder + + return await self.request_adapter.send_async(request_info, MailFolder, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[ChildFoldersRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of child folders in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: MailFolder, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to childFolders for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> ChildFoldersRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ChildFoldersRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ChildFoldersRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class ChildFoldersRequestBuilderGetQueryParameters(): + """ + The collection of child folders in the mailFolder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "include_hidden_folders": + return "includeHiddenFolders" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Include Hidden Folders + include_hidden_folders: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class ChildFoldersRequestBuilderGetRequestConfiguration(RequestConfiguration[ChildFoldersRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ChildFoldersRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/count/count_request_builder.py new file mode 100644 index 00000000..c41b4fcb --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/mail_folder_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/mail_folder_item_request_builder.py new file mode 100644 index 00000000..0beeb2f2 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/mail_folder_item_request_builder.py @@ -0,0 +1,212 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.mail_folder import MailFolder + from .......models.o_data_errors.o_data_error import ODataError + from .messages.messages_request_builder import MessagesRequestBuilder + from .message_rules.message_rules_request_builder import MessageRulesRequestBuilder + +class MailFolderItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MailFolderItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}{?%24expand,%24select,includeHiddenFolders}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property childFolders for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[MailFolderItemRequestBuilderGetQueryParameters]] = None) -> Optional[MailFolder]: + """ + The collection of child folders in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MailFolder] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .......models.mail_folder import MailFolder + + return await self.request_adapter.send_async(request_info, MailFolder, error_mapping) + + async def patch(self,body: MailFolder, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[MailFolder]: + """ + Update the navigation property childFolders in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MailFolder] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .......models.mail_folder import MailFolder + + return await self.request_adapter.send_async(request_info, MailFolder, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property childFolders for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MailFolderItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of child folders in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: MailFolder, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property childFolders in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MailFolderItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MailFolderItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MailFolderItemRequestBuilder(self.request_adapter, raw_url) + + @property + def message_rules(self) -> MessageRulesRequestBuilder: + """ + The messageRules property + """ + from .message_rules.message_rules_request_builder import MessageRulesRequestBuilder + + return MessageRulesRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def messages(self) -> MessagesRequestBuilder: + """ + The messages property + """ + from .messages.messages_request_builder import MessagesRequestBuilder + + return MessagesRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MailFolderItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MailFolderItemRequestBuilderGetQueryParameters(): + """ + The collection of child folders in the mailFolder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "include_hidden_folders": + return "includeHiddenFolders" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Include Hidden Folders + include_hidden_folders: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class MailFolderItemRequestBuilderGetRequestConfiguration(RequestConfiguration[MailFolderItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MailFolderItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/message_rules/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/message_rules/count/count_request_builder.py new file mode 100644 index 00000000..8add6ac5 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/message_rules/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .........models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messageRules/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/message_rules/item/message_rule_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/message_rules/item/message_rule_item_request_builder.py new file mode 100644 index 00000000..c3d61f8c --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/message_rules/item/message_rule_item_request_builder.py @@ -0,0 +1,187 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .........models.message_rule import MessageRule + from .........models.o_data_errors.o_data_error import ODataError + +class MessageRuleItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules/{messageRule-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessageRuleItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messageRules/{messageRule%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property messageRules for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessageRuleItemRequestBuilderGetQueryParameters]] = None) -> Optional[MessageRule]: + """ + The collection of rules that apply to the user's Inbox folder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageRule] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .........models.message_rule import MessageRule + + return await self.request_adapter.send_async(request_info, MessageRule, error_mapping) + + async def patch(self,body: MessageRule, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[MessageRule]: + """ + Update the navigation property messageRules in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageRule] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .........models.message_rule import MessageRule + + return await self.request_adapter.send_async(request_info, MessageRule, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property messageRules for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessageRuleItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of rules that apply to the user's Inbox folder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: MessageRule, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property messageRules in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessageRuleItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessageRuleItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessageRuleItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class MessageRuleItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageRuleItemRequestBuilderGetQueryParameters(): + """ + The collection of rules that apply to the user's Inbox folder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class MessageRuleItemRequestBuilderGetRequestConfiguration(RequestConfiguration[MessageRuleItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageRuleItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/message_rules/message_rules_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/message_rules/message_rules_request_builder.py new file mode 100644 index 00000000..0b91eefc --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/message_rules/message_rules_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ........models.message_rule import MessageRule + from ........models.message_rule_collection_response import MessageRuleCollectionResponse + from ........models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.message_rule_item_request_builder import MessageRuleItemRequestBuilder + +class MessageRulesRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messageRules + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessageRulesRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messageRules{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_message_rule_id(self,message_rule_id: str) -> MessageRuleItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item.childFolders.item.messageRules.item collection + param message_rule_id: The unique identifier of messageRule + Returns: MessageRuleItemRequestBuilder + """ + if message_rule_id is None: + raise TypeError("message_rule_id cannot be null.") + from .item.message_rule_item_request_builder import MessageRuleItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["messageRule%2Did"] = message_rule_id + return MessageRuleItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessageRulesRequestBuilderGetQueryParameters]] = None) -> Optional[MessageRuleCollectionResponse]: + """ + The collection of rules that apply to the user's Inbox folder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageRuleCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ........models.message_rule_collection_response import MessageRuleCollectionResponse + + return await self.request_adapter.send_async(request_info, MessageRuleCollectionResponse, error_mapping) + + async def post(self,body: MessageRule, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[MessageRule]: + """ + Create new navigation property to messageRules for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageRule] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ........models.message_rule import MessageRule + + return await self.request_adapter.send_async(request_info, MessageRule, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessageRulesRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of rules that apply to the user's Inbox folder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: MessageRule, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to messageRules for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessageRulesRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessageRulesRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessageRulesRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MessageRulesRequestBuilderGetQueryParameters(): + """ + The collection of rules that apply to the user's Inbox folder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class MessageRulesRequestBuilderGetRequestConfiguration(RequestConfiguration[MessageRulesRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageRulesRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/count/count_request_builder.py new file mode 100644 index 00000000..c0dca306 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .........models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/attachments/attachments_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/attachments/attachments_request_builder.py new file mode 100644 index 00000000..25a618df --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/attachments/attachments_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ..........models.attachment import Attachment + from ..........models.attachment_collection_response import AttachmentCollectionResponse + from ..........models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.attachment_item_request_builder import AttachmentItemRequestBuilder + +class AttachmentsRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new AttachmentsRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages/{message%2Did}/attachments{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_attachment_id(self,attachment_id: str) -> AttachmentItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item.childFolders.item.messages.item.attachments.item collection + param attachment_id: The unique identifier of attachment + Returns: AttachmentItemRequestBuilder + """ + if attachment_id is None: + raise TypeError("attachment_id cannot be null.") + from .item.attachment_item_request_builder import AttachmentItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["attachment%2Did"] = attachment_id + return AttachmentItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[AttachmentsRequestBuilderGetQueryParameters]] = None) -> Optional[AttachmentCollectionResponse]: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[AttachmentCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ..........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ..........models.attachment_collection_response import AttachmentCollectionResponse + + return await self.request_adapter.send_async(request_info, AttachmentCollectionResponse, error_mapping) + + async def post(self,body: Attachment, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Attachment]: + """ + Create new navigation property to attachments for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Attachment] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ..........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ..........models.attachment import Attachment + + return await self.request_adapter.send_async(request_info, Attachment, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[AttachmentsRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: Attachment, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to attachments for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> AttachmentsRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: AttachmentsRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return AttachmentsRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class AttachmentsRequestBuilderGetQueryParameters(): + """ + The fileAttachment and itemAttachment attachments for the message. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class AttachmentsRequestBuilderGetRequestConfiguration(RequestConfiguration[AttachmentsRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class AttachmentsRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/attachments/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/attachments/count/count_request_builder.py new file mode 100644 index 00000000..a3180704 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/attachments/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ...........models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages/{message%2Did}/attachments/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ...........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/attachments/item/attachment_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/attachments/item/attachment_item_request_builder.py new file mode 100644 index 00000000..17f4f117 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/attachments/item/attachment_item_request_builder.py @@ -0,0 +1,142 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ...........models.attachment import Attachment + from ...........models.o_data_errors.o_data_error import ODataError + +class AttachmentItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/attachments/{attachment-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new AttachmentItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages/{message%2Did}/attachments/{attachment%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property attachments for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from ...........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[AttachmentItemRequestBuilderGetQueryParameters]] = None) -> Optional[Attachment]: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Attachment] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ...........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ...........models.attachment import Attachment + + return await self.request_adapter.send_async(request_info, Attachment, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property attachments for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[AttachmentItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def with_url(self,raw_url: str) -> AttachmentItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: AttachmentItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return AttachmentItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class AttachmentItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class AttachmentItemRequestBuilderGetQueryParameters(): + """ + The fileAttachment and itemAttachment attachments for the message. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class AttachmentItemRequestBuilderGetRequestConfiguration(RequestConfiguration[AttachmentItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/extensions/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/extensions/count/count_request_builder.py new file mode 100644 index 00000000..f52a1922 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/extensions/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ...........models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/extensions/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages/{message%2Did}/extensions/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ...........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/extensions/extensions_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/extensions/extensions_request_builder.py new file mode 100644 index 00000000..6c693940 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/extensions/extensions_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ..........models.extension import Extension + from ..........models.extension_collection_response import ExtensionCollectionResponse + from ..........models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.extension_item_request_builder import ExtensionItemRequestBuilder + +class ExtensionsRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/extensions + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ExtensionsRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages/{message%2Did}/extensions{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_extension_id(self,extension_id: str) -> ExtensionItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item.childFolders.item.messages.item.extensions.item collection + param extension_id: The unique identifier of extension + Returns: ExtensionItemRequestBuilder + """ + if extension_id is None: + raise TypeError("extension_id cannot be null.") + from .item.extension_item_request_builder import ExtensionItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["extension%2Did"] = extension_id + return ExtensionItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[ExtensionsRequestBuilderGetQueryParameters]] = None) -> Optional[ExtensionCollectionResponse]: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[ExtensionCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ..........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ..........models.extension_collection_response import ExtensionCollectionResponse + + return await self.request_adapter.send_async(request_info, ExtensionCollectionResponse, error_mapping) + + async def post(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Extension]: + """ + Create new navigation property to extensions for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Extension] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ..........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ..........models.extension import Extension + + return await self.request_adapter.send_async(request_info, Extension, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[ExtensionsRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to extensions for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> ExtensionsRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ExtensionsRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ExtensionsRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class ExtensionsRequestBuilderGetQueryParameters(): + """ + The collection of open extensions defined for the message. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class ExtensionsRequestBuilderGetRequestConfiguration(RequestConfiguration[ExtensionsRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ExtensionsRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/extensions/item/extension_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/extensions/item/extension_item_request_builder.py new file mode 100644 index 00000000..7f30b76a --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/extensions/item/extension_item_request_builder.py @@ -0,0 +1,187 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ...........models.extension import Extension + from ...........models.o_data_errors.o_data_error import ODataError + +class ExtensionItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/extensions/{extension-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ExtensionItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages/{message%2Did}/extensions/{extension%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property extensions for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from ...........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[ExtensionItemRequestBuilderGetQueryParameters]] = None) -> Optional[Extension]: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Extension] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ...........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ...........models.extension import Extension + + return await self.request_adapter.send_async(request_info, Extension, error_mapping) + + async def patch(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Extension]: + """ + Update the navigation property extensions in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Extension] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from ...........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ...........models.extension import Extension + + return await self.request_adapter.send_async(request_info, Extension, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property extensions for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[ExtensionItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property extensions in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> ExtensionItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ExtensionItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ExtensionItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class ExtensionItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ExtensionItemRequestBuilderGetQueryParameters(): + """ + The collection of open extensions defined for the message. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class ExtensionItemRequestBuilderGetRequestConfiguration(RequestConfiguration[ExtensionItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ExtensionItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/message_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/message_item_request_builder.py new file mode 100644 index 00000000..97810a44 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/message_item_request_builder.py @@ -0,0 +1,217 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .........models.message import Message + from .........models.o_data_errors.o_data_error import ODataError + from .attachments.attachments_request_builder import AttachmentsRequestBuilder + from .extensions.extensions_request_builder import ExtensionsRequestBuilder + from .value.content_request_builder import ContentRequestBuilder + +class MessageItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessageItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages/{message%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property messages for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessageItemRequestBuilderGetQueryParameters]] = None) -> Optional[Message]: + """ + The collection of messages in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Message] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .........models.message import Message + + return await self.request_adapter.send_async(request_info, Message, error_mapping) + + async def patch(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Message]: + """ + Update the navigation property messages in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Message] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .........models.message import Message + + return await self.request_adapter.send_async(request_info, Message, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property messages for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessageItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of messages in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property messages in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessageItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessageItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessageItemRequestBuilder(self.request_adapter, raw_url) + + @property + def attachments(self) -> AttachmentsRequestBuilder: + """ + The attachments property + """ + from .attachments.attachments_request_builder import AttachmentsRequestBuilder + + return AttachmentsRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def content(self) -> ContentRequestBuilder: + """ + The Content property + """ + from .value.content_request_builder import ContentRequestBuilder + + return ContentRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def extensions(self) -> ExtensionsRequestBuilder: + """ + The extensions property + """ + from .extensions.extensions_request_builder import ExtensionsRequestBuilder + + return ExtensionsRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MessageItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageItemRequestBuilderGetQueryParameters(): + """ + The collection of messages in the mailFolder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class MessageItemRequestBuilderGetRequestConfiguration(RequestConfiguration[MessageItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/value/content_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/value/content_request_builder.py new file mode 100644 index 00000000..3c7fa831 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/item/value/content_request_builder.py @@ -0,0 +1,156 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ..........models.o_data_errors.o_data_error import ODataError + +class ContentRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages/{message-id}/$value + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ContentRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages/{message%2Did}/$value", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from ..........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ..........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def put(self,body: bytes, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + The unique identifier for an entity. Read-only. + param body: Binary request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_put_request_information( + body, request_configuration + ) + from ..........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/octet-stream, application/json") + return request_info + + def to_put_request_information(self,body: bytes, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + The unique identifier for an entity. Read-only. + param body: Binary request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PUT, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_stream_content(body, "application/octet-stream") + return request_info + + def with_url(self,raw_url: str) -> ContentRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ContentRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ContentRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class ContentRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ContentRequestBuilderGetRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ContentRequestBuilderPutRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/messages_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/messages_request_builder.py new file mode 100644 index 00000000..888ddf73 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/child_folders/item/messages/messages_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ........models.message import Message + from ........models.message_collection_response import MessageCollectionResponse + from ........models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.message_item_request_builder import MessageItemRequestBuilder + +class MessagesRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/childFolders/{mailFolder-id1}/messages + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessagesRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/childFolders/{mailFolder%2Did1}/messages{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_message_id(self,message_id: str) -> MessageItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item.childFolders.item.messages.item collection + param message_id: The unique identifier of message + Returns: MessageItemRequestBuilder + """ + if message_id is None: + raise TypeError("message_id cannot be null.") + from .item.message_item_request_builder import MessageItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["message%2Did"] = message_id + return MessageItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessagesRequestBuilderGetQueryParameters]] = None) -> Optional[MessageCollectionResponse]: + """ + The collection of messages in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ........models.message_collection_response import MessageCollectionResponse + + return await self.request_adapter.send_async(request_info, MessageCollectionResponse, error_mapping) + + async def post(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Message]: + """ + Create new navigation property to messages for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Message] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ........models.message import Message + + return await self.request_adapter.send_async(request_info, Message, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessagesRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of messages in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to messages for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessagesRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessagesRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessagesRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MessagesRequestBuilderGetQueryParameters(): + """ + The collection of messages in the mailFolder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class MessagesRequestBuilderGetRequestConfiguration(RequestConfiguration[MessagesRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessagesRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/mail_folder_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/mail_folder_item_request_builder.py new file mode 100644 index 00000000..a6a7e0bf --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/mail_folder_item_request_builder.py @@ -0,0 +1,222 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .....models.mail_folder import MailFolder + from .....models.o_data_errors.o_data_error import ODataError + from .child_folders.child_folders_request_builder import ChildFoldersRequestBuilder + from .messages.messages_request_builder import MessagesRequestBuilder + from .message_rules.message_rules_request_builder import MessageRulesRequestBuilder + +class MailFolderItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MailFolderItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}{?%24expand,%24select,includeHiddenFolders}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property mailFolders for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[MailFolderItemRequestBuilderGetQueryParameters]] = None) -> Optional[MailFolder]: + """ + The user's mail folders. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MailFolder] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .....models.mail_folder import MailFolder + + return await self.request_adapter.send_async(request_info, MailFolder, error_mapping) + + async def patch(self,body: MailFolder, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[MailFolder]: + """ + Update the navigation property mailFolders in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MailFolder] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .....models.mail_folder import MailFolder + + return await self.request_adapter.send_async(request_info, MailFolder, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property mailFolders for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MailFolderItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The user's mail folders. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: MailFolder, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property mailFolders in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MailFolderItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MailFolderItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MailFolderItemRequestBuilder(self.request_adapter, raw_url) + + @property + def child_folders(self) -> ChildFoldersRequestBuilder: + """ + The childFolders property + """ + from .child_folders.child_folders_request_builder import ChildFoldersRequestBuilder + + return ChildFoldersRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def message_rules(self) -> MessageRulesRequestBuilder: + """ + The messageRules property + """ + from .message_rules.message_rules_request_builder import MessageRulesRequestBuilder + + return MessageRulesRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def messages(self) -> MessagesRequestBuilder: + """ + The messages property + """ + from .messages.messages_request_builder import MessagesRequestBuilder + + return MessagesRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MailFolderItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MailFolderItemRequestBuilderGetQueryParameters(): + """ + The user's mail folders. Read-only. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "include_hidden_folders": + return "includeHiddenFolders" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Include Hidden Folders + include_hidden_folders: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class MailFolderItemRequestBuilderGetRequestConfiguration(RequestConfiguration[MailFolderItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MailFolderItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/message_rules/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/message_rules/count/count_request_builder.py new file mode 100644 index 00000000..65a739a3 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/message_rules/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messageRules/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messageRules/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/message_rules/item/message_rule_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/message_rules/item/message_rule_item_request_builder.py new file mode 100644 index 00000000..0f992668 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/message_rules/item/message_rule_item_request_builder.py @@ -0,0 +1,187 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.message_rule import MessageRule + from .......models.o_data_errors.o_data_error import ODataError + +class MessageRuleItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messageRules/{messageRule-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessageRuleItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messageRules/{messageRule%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property messageRules for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessageRuleItemRequestBuilderGetQueryParameters]] = None) -> Optional[MessageRule]: + """ + The collection of rules that apply to the user's Inbox folder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageRule] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .......models.message_rule import MessageRule + + return await self.request_adapter.send_async(request_info, MessageRule, error_mapping) + + async def patch(self,body: MessageRule, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[MessageRule]: + """ + Update the navigation property messageRules in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageRule] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .......models.message_rule import MessageRule + + return await self.request_adapter.send_async(request_info, MessageRule, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property messageRules for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessageRuleItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of rules that apply to the user's Inbox folder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: MessageRule, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property messageRules in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessageRuleItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessageRuleItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessageRuleItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class MessageRuleItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageRuleItemRequestBuilderGetQueryParameters(): + """ + The collection of rules that apply to the user's Inbox folder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class MessageRuleItemRequestBuilderGetRequestConfiguration(RequestConfiguration[MessageRuleItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageRuleItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/message_rules/message_rules_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/message_rules/message_rules_request_builder.py new file mode 100644 index 00000000..f84bdf33 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/message_rules/message_rules_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ......models.message_rule import MessageRule + from ......models.message_rule_collection_response import MessageRuleCollectionResponse + from ......models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.message_rule_item_request_builder import MessageRuleItemRequestBuilder + +class MessageRulesRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messageRules + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessageRulesRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messageRules{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_message_rule_id(self,message_rule_id: str) -> MessageRuleItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item.messageRules.item collection + param message_rule_id: The unique identifier of messageRule + Returns: MessageRuleItemRequestBuilder + """ + if message_rule_id is None: + raise TypeError("message_rule_id cannot be null.") + from .item.message_rule_item_request_builder import MessageRuleItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["messageRule%2Did"] = message_rule_id + return MessageRuleItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessageRulesRequestBuilderGetQueryParameters]] = None) -> Optional[MessageRuleCollectionResponse]: + """ + The collection of rules that apply to the user's Inbox folder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageRuleCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.message_rule_collection_response import MessageRuleCollectionResponse + + return await self.request_adapter.send_async(request_info, MessageRuleCollectionResponse, error_mapping) + + async def post(self,body: MessageRule, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[MessageRule]: + """ + Create new navigation property to messageRules for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageRule] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.message_rule import MessageRule + + return await self.request_adapter.send_async(request_info, MessageRule, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessageRulesRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of rules that apply to the user's Inbox folder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: MessageRule, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to messageRules for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessageRulesRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessageRulesRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessageRulesRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MessageRulesRequestBuilderGetQueryParameters(): + """ + The collection of rules that apply to the user's Inbox folder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class MessageRulesRequestBuilderGetRequestConfiguration(RequestConfiguration[MessageRulesRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageRulesRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/count/count_request_builder.py new file mode 100644 index 00000000..1e9a7945 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/item/attachments/attachments_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/item/attachments/attachments_request_builder.py new file mode 100644 index 00000000..b64468a0 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/item/attachments/attachments_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ........models.attachment import Attachment + from ........models.attachment_collection_response import AttachmentCollectionResponse + from ........models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.attachment_item_request_builder import AttachmentItemRequestBuilder + +class AttachmentsRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/attachments + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new AttachmentsRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages/{message%2Did}/attachments{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_attachment_id(self,attachment_id: str) -> AttachmentItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item.messages.item.attachments.item collection + param attachment_id: The unique identifier of attachment + Returns: AttachmentItemRequestBuilder + """ + if attachment_id is None: + raise TypeError("attachment_id cannot be null.") + from .item.attachment_item_request_builder import AttachmentItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["attachment%2Did"] = attachment_id + return AttachmentItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[AttachmentsRequestBuilderGetQueryParameters]] = None) -> Optional[AttachmentCollectionResponse]: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[AttachmentCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ........models.attachment_collection_response import AttachmentCollectionResponse + + return await self.request_adapter.send_async(request_info, AttachmentCollectionResponse, error_mapping) + + async def post(self,body: Attachment, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Attachment]: + """ + Create new navigation property to attachments for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Attachment] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ........models.attachment import Attachment + + return await self.request_adapter.send_async(request_info, Attachment, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[AttachmentsRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: Attachment, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to attachments for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> AttachmentsRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: AttachmentsRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return AttachmentsRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class AttachmentsRequestBuilderGetQueryParameters(): + """ + The fileAttachment and itemAttachment attachments for the message. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class AttachmentsRequestBuilderGetRequestConfiguration(RequestConfiguration[AttachmentsRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class AttachmentsRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/item/attachments/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/item/attachments/count/count_request_builder.py new file mode 100644 index 00000000..832da87b --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/item/attachments/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .........models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/attachments/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages/{message%2Did}/attachments/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/item/attachments/item/attachment_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/item/attachments/item/attachment_item_request_builder.py new file mode 100644 index 00000000..35401b9d --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/item/attachments/item/attachment_item_request_builder.py @@ -0,0 +1,142 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .........models.attachment import Attachment + from .........models.o_data_errors.o_data_error import ODataError + +class AttachmentItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/attachments/{attachment-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new AttachmentItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages/{message%2Did}/attachments/{attachment%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property attachments for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[AttachmentItemRequestBuilderGetQueryParameters]] = None) -> Optional[Attachment]: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Attachment] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .........models.attachment import Attachment + + return await self.request_adapter.send_async(request_info, Attachment, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property attachments for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[AttachmentItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def with_url(self,raw_url: str) -> AttachmentItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: AttachmentItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return AttachmentItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class AttachmentItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class AttachmentItemRequestBuilderGetQueryParameters(): + """ + The fileAttachment and itemAttachment attachments for the message. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class AttachmentItemRequestBuilderGetRequestConfiguration(RequestConfiguration[AttachmentItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/item/extensions/count/count_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/item/extensions/count/count_request_builder.py new file mode 100644 index 00000000..bd136b2b --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/item/extensions/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .........models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/extensions/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages/{message%2Did}/extensions/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/item/extensions/extensions_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/item/extensions/extensions_request_builder.py new file mode 100644 index 00000000..95f080c2 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/item/extensions/extensions_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ........models.extension import Extension + from ........models.extension_collection_response import ExtensionCollectionResponse + from ........models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.extension_item_request_builder import ExtensionItemRequestBuilder + +class ExtensionsRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/extensions + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ExtensionsRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages/{message%2Did}/extensions{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_extension_id(self,extension_id: str) -> ExtensionItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item.messages.item.extensions.item collection + param extension_id: The unique identifier of extension + Returns: ExtensionItemRequestBuilder + """ + if extension_id is None: + raise TypeError("extension_id cannot be null.") + from .item.extension_item_request_builder import ExtensionItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["extension%2Did"] = extension_id + return ExtensionItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[ExtensionsRequestBuilderGetQueryParameters]] = None) -> Optional[ExtensionCollectionResponse]: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[ExtensionCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ........models.extension_collection_response import ExtensionCollectionResponse + + return await self.request_adapter.send_async(request_info, ExtensionCollectionResponse, error_mapping) + + async def post(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Extension]: + """ + Create new navigation property to extensions for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Extension] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ........models.extension import Extension + + return await self.request_adapter.send_async(request_info, Extension, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[ExtensionsRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to extensions for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> ExtensionsRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ExtensionsRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ExtensionsRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class ExtensionsRequestBuilderGetQueryParameters(): + """ + The collection of open extensions defined for the message. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class ExtensionsRequestBuilderGetRequestConfiguration(RequestConfiguration[ExtensionsRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ExtensionsRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/item/extensions/item/extension_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/item/extensions/item/extension_item_request_builder.py new file mode 100644 index 00000000..e71f7811 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/item/extensions/item/extension_item_request_builder.py @@ -0,0 +1,187 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .........models.extension import Extension + from .........models.o_data_errors.o_data_error import ODataError + +class ExtensionItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/extensions/{extension-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ExtensionItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages/{message%2Did}/extensions/{extension%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property extensions for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[ExtensionItemRequestBuilderGetQueryParameters]] = None) -> Optional[Extension]: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Extension] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .........models.extension import Extension + + return await self.request_adapter.send_async(request_info, Extension, error_mapping) + + async def patch(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Extension]: + """ + Update the navigation property extensions in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Extension] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from .........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .........models.extension import Extension + + return await self.request_adapter.send_async(request_info, Extension, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property extensions for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[ExtensionItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property extensions in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> ExtensionItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ExtensionItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ExtensionItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class ExtensionItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ExtensionItemRequestBuilderGetQueryParameters(): + """ + The collection of open extensions defined for the message. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class ExtensionItemRequestBuilderGetRequestConfiguration(RequestConfiguration[ExtensionItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ExtensionItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/item/message_item_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/item/message_item_request_builder.py new file mode 100644 index 00000000..d6a807cf --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/item/message_item_request_builder.py @@ -0,0 +1,217 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.message import Message + from .......models.o_data_errors.o_data_error import ODataError + from .attachments.attachments_request_builder import AttachmentsRequestBuilder + from .extensions.extensions_request_builder import ExtensionsRequestBuilder + from .value.content_request_builder import ContentRequestBuilder + +class MessageItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessageItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages/{message%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property messages for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessageItemRequestBuilderGetQueryParameters]] = None) -> Optional[Message]: + """ + The collection of messages in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Message] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .......models.message import Message + + return await self.request_adapter.send_async(request_info, Message, error_mapping) + + async def patch(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Message]: + """ + Update the navigation property messages in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Message] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .......models.message import Message + + return await self.request_adapter.send_async(request_info, Message, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property messages for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessageItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of messages in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property messages in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessageItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessageItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessageItemRequestBuilder(self.request_adapter, raw_url) + + @property + def attachments(self) -> AttachmentsRequestBuilder: + """ + The attachments property + """ + from .attachments.attachments_request_builder import AttachmentsRequestBuilder + + return AttachmentsRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def content(self) -> ContentRequestBuilder: + """ + The Content property + """ + from .value.content_request_builder import ContentRequestBuilder + + return ContentRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def extensions(self) -> ExtensionsRequestBuilder: + """ + The extensions property + """ + from .extensions.extensions_request_builder import ExtensionsRequestBuilder + + return ExtensionsRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MessageItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageItemRequestBuilderGetQueryParameters(): + """ + The collection of messages in the mailFolder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class MessageItemRequestBuilderGetRequestConfiguration(RequestConfiguration[MessageItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/item/value/content_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/item/value/content_request_builder.py new file mode 100644 index 00000000..7806350c --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/item/value/content_request_builder.py @@ -0,0 +1,156 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ........models.o_data_errors.o_data_error import ODataError + +class ContentRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages/{message-id}/$value + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ContentRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages/{message%2Did}/$value", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def put(self,body: bytes, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + The unique identifier for an entity. Read-only. + param body: Binary request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_put_request_information( + body, request_configuration + ) + from ........models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/octet-stream, application/json") + return request_info + + def to_put_request_information(self,body: bytes, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + The unique identifier for an entity. Read-only. + param body: Binary request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PUT, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_stream_content(body, "application/octet-stream") + return request_info + + def with_url(self,raw_url: str) -> ContentRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ContentRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ContentRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class ContentRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ContentRequestBuilderGetRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ContentRequestBuilderPutRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/item/messages/messages_request_builder.py b/tests/validation/validation/users/item/mail_folders/item/messages/messages_request_builder.py new file mode 100644 index 00000000..988580f0 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/item/messages/messages_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ......models.message import Message + from ......models.message_collection_response import MessageCollectionResponse + from ......models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.message_item_request_builder import MessageItemRequestBuilder + +class MessagesRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders/{mailFolder-id}/messages + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessagesRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders/{mailFolder%2Did}/messages{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_message_id(self,message_id: str) -> MessageItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item.messages.item collection + param message_id: The unique identifier of message + Returns: MessageItemRequestBuilder + """ + if message_id is None: + raise TypeError("message_id cannot be null.") + from .item.message_item_request_builder import MessageItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["message%2Did"] = message_id + return MessageItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessagesRequestBuilderGetQueryParameters]] = None) -> Optional[MessageCollectionResponse]: + """ + The collection of messages in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.message_collection_response import MessageCollectionResponse + + return await self.request_adapter.send_async(request_info, MessageCollectionResponse, error_mapping) + + async def post(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Message]: + """ + Create new navigation property to messages for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Message] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.message import Message + + return await self.request_adapter.send_async(request_info, Message, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessagesRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of messages in the mailFolder. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to messages for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessagesRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessagesRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessagesRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MessagesRequestBuilderGetQueryParameters(): + """ + The collection of messages in the mailFolder. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class MessagesRequestBuilderGetRequestConfiguration(RequestConfiguration[MessagesRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessagesRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/mail_folders/mail_folders_request_builder.py b/tests/validation/validation/users/item/mail_folders/mail_folders_request_builder.py new file mode 100644 index 00000000..2f8f9714 --- /dev/null +++ b/tests/validation/validation/users/item/mail_folders/mail_folders_request_builder.py @@ -0,0 +1,212 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ....models.mail_folder import MailFolder + from ....models.mail_folder_collection_response import MailFolderCollectionResponse + from ....models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.mail_folder_item_request_builder import MailFolderItemRequestBuilder + +class MailFoldersRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/mailFolders + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MailFoldersRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/mailFolders{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top,includeHiddenFolders}", path_parameters) + + def by_mail_folder_id(self,mail_folder_id: str) -> MailFolderItemRequestBuilder: + """ + Gets an item from the validation.users.item.mailFolders.item collection + param mail_folder_id: The unique identifier of mailFolder + Returns: MailFolderItemRequestBuilder + """ + if mail_folder_id is None: + raise TypeError("mail_folder_id cannot be null.") + from .item.mail_folder_item_request_builder import MailFolderItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["mailFolder%2Did"] = mail_folder_id + return MailFolderItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[MailFoldersRequestBuilderGetQueryParameters]] = None) -> Optional[MailFolderCollectionResponse]: + """ + The user's mail folders. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MailFolderCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ....models.mail_folder_collection_response import MailFolderCollectionResponse + + return await self.request_adapter.send_async(request_info, MailFolderCollectionResponse, error_mapping) + + async def post(self,body: MailFolder, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[MailFolder]: + """ + Create new navigation property to mailFolders for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MailFolder] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ....models.mail_folder import MailFolder + + return await self.request_adapter.send_async(request_info, MailFolder, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MailFoldersRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The user's mail folders. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: MailFolder, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to mailFolders for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MailFoldersRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MailFoldersRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MailFoldersRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MailFoldersRequestBuilderGetQueryParameters(): + """ + The user's mail folders. Read-only. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "include_hidden_folders": + return "includeHiddenFolders" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Include Hidden Folders + include_hidden_folders: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class MailFoldersRequestBuilderGetRequestConfiguration(RequestConfiguration[MailFoldersRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MailFoldersRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/count/count_request_builder.py b/tests/validation/validation/users/item/messages/count/count_request_builder.py new file mode 100644 index 00000000..4ed3506b --- /dev/null +++ b/tests/validation/validation/users/item/messages/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .....models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/item/attachments/attachments_request_builder.py b/tests/validation/validation/users/item/messages/item/attachments/attachments_request_builder.py new file mode 100644 index 00000000..8ef8cd26 --- /dev/null +++ b/tests/validation/validation/users/item/messages/item/attachments/attachments_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ......models.attachment import Attachment + from ......models.attachment_collection_response import AttachmentCollectionResponse + from ......models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.attachment_item_request_builder import AttachmentItemRequestBuilder + +class AttachmentsRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages/{message-id}/attachments + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new AttachmentsRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages/{message%2Did}/attachments{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_attachment_id(self,attachment_id: str) -> AttachmentItemRequestBuilder: + """ + Gets an item from the validation.users.item.messages.item.attachments.item collection + param attachment_id: The unique identifier of attachment + Returns: AttachmentItemRequestBuilder + """ + if attachment_id is None: + raise TypeError("attachment_id cannot be null.") + from .item.attachment_item_request_builder import AttachmentItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["attachment%2Did"] = attachment_id + return AttachmentItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[AttachmentsRequestBuilderGetQueryParameters]] = None) -> Optional[AttachmentCollectionResponse]: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[AttachmentCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.attachment_collection_response import AttachmentCollectionResponse + + return await self.request_adapter.send_async(request_info, AttachmentCollectionResponse, error_mapping) + + async def post(self,body: Attachment, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Attachment]: + """ + Create new navigation property to attachments for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Attachment] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.attachment import Attachment + + return await self.request_adapter.send_async(request_info, Attachment, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[AttachmentsRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: Attachment, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to attachments for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> AttachmentsRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: AttachmentsRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return AttachmentsRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class AttachmentsRequestBuilderGetQueryParameters(): + """ + The fileAttachment and itemAttachment attachments for the message. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class AttachmentsRequestBuilderGetRequestConfiguration(RequestConfiguration[AttachmentsRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class AttachmentsRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/item/attachments/count/count_request_builder.py b/tests/validation/validation/users/item/messages/item/attachments/count/count_request_builder.py new file mode 100644 index 00000000..dab51799 --- /dev/null +++ b/tests/validation/validation/users/item/messages/item/attachments/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages/{message-id}/attachments/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages/{message%2Did}/attachments/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/item/attachments/item/attachment_item_request_builder.py b/tests/validation/validation/users/item/messages/item/attachments/item/attachment_item_request_builder.py new file mode 100644 index 00000000..2307493f --- /dev/null +++ b/tests/validation/validation/users/item/messages/item/attachments/item/attachment_item_request_builder.py @@ -0,0 +1,142 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.attachment import Attachment + from .......models.o_data_errors.o_data_error import ODataError + +class AttachmentItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages/{message-id}/attachments/{attachment-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new AttachmentItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages/{message%2Did}/attachments/{attachment%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property attachments for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[AttachmentItemRequestBuilderGetQueryParameters]] = None) -> Optional[Attachment]: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Attachment] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .......models.attachment import Attachment + + return await self.request_adapter.send_async(request_info, Attachment, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property attachments for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[AttachmentItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The fileAttachment and itemAttachment attachments for the message. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def with_url(self,raw_url: str) -> AttachmentItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: AttachmentItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return AttachmentItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class AttachmentItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class AttachmentItemRequestBuilderGetQueryParameters(): + """ + The fileAttachment and itemAttachment attachments for the message. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class AttachmentItemRequestBuilderGetRequestConfiguration(RequestConfiguration[AttachmentItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/item/extensions/count/count_request_builder.py b/tests/validation/validation/users/item/messages/item/extensions/count/count_request_builder.py new file mode 100644 index 00000000..0bd7629a --- /dev/null +++ b/tests/validation/validation/users/item/messages/item/extensions/count/count_request_builder.py @@ -0,0 +1,103 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.o_data_errors.o_data_error import ODataError + +class CountRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages/{message-id}/extensions/$count + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new CountRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages/{message%2Did}/extensions/$count{?%24filter,%24search}", path_parameters) + + async def get(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> Optional[int]: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[int] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[CountRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + Get the number of the resource + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "text/plain;q=0.9") + return request_info + + def with_url(self,raw_url: str) -> CountRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: CountRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return CountRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class CountRequestBuilderGetQueryParameters(): + """ + Get the number of the resource + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "filter": + return "%24filter" + if original_name == "search": + return "%24search" + return original_name + + # Filter items by property values + filter: Optional[str] = None + + # Search items by search phrases + search: Optional[str] = None + + + @dataclass + class CountRequestBuilderGetRequestConfiguration(RequestConfiguration[CountRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/item/extensions/extensions_request_builder.py b/tests/validation/validation/users/item/messages/item/extensions/extensions_request_builder.py new file mode 100644 index 00000000..20cd2e37 --- /dev/null +++ b/tests/validation/validation/users/item/messages/item/extensions/extensions_request_builder.py @@ -0,0 +1,207 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ......models.extension import Extension + from ......models.extension_collection_response import ExtensionCollectionResponse + from ......models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.extension_item_request_builder import ExtensionItemRequestBuilder + +class ExtensionsRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages/{message-id}/extensions + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ExtensionsRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages/{message%2Did}/extensions{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top}", path_parameters) + + def by_extension_id(self,extension_id: str) -> ExtensionItemRequestBuilder: + """ + Gets an item from the validation.users.item.messages.item.extensions.item collection + param extension_id: The unique identifier of extension + Returns: ExtensionItemRequestBuilder + """ + if extension_id is None: + raise TypeError("extension_id cannot be null.") + from .item.extension_item_request_builder import ExtensionItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["extension%2Did"] = extension_id + return ExtensionItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[ExtensionsRequestBuilderGetQueryParameters]] = None) -> Optional[ExtensionCollectionResponse]: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[ExtensionCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.extension_collection_response import ExtensionCollectionResponse + + return await self.request_adapter.send_async(request_info, ExtensionCollectionResponse, error_mapping) + + async def post(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Extension]: + """ + Create new navigation property to extensions for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Extension] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ......models.extension import Extension + + return await self.request_adapter.send_async(request_info, Extension, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[ExtensionsRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to extensions for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> ExtensionsRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ExtensionsRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ExtensionsRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class ExtensionsRequestBuilderGetQueryParameters(): + """ + The collection of open extensions defined for the message. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class ExtensionsRequestBuilderGetRequestConfiguration(RequestConfiguration[ExtensionsRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ExtensionsRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/item/extensions/item/extension_item_request_builder.py b/tests/validation/validation/users/item/messages/item/extensions/item/extension_item_request_builder.py new file mode 100644 index 00000000..1bb2199b --- /dev/null +++ b/tests/validation/validation/users/item/messages/item/extensions/item/extension_item_request_builder.py @@ -0,0 +1,187 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .......models.extension import Extension + from .......models.o_data_errors.o_data_error import ODataError + +class ExtensionItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages/{message-id}/extensions/{extension-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ExtensionItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages/{message%2Did}/extensions/{extension%2Did}{?%24expand,%24select}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property extensions for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[ExtensionItemRequestBuilderGetQueryParameters]] = None) -> Optional[Extension]: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Extension] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .......models.extension import Extension + + return await self.request_adapter.send_async(request_info, Extension, error_mapping) + + async def patch(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Extension]: + """ + Update the navigation property extensions in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Extension] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from .......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .......models.extension import Extension + + return await self.request_adapter.send_async(request_info, Extension, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property extensions for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[ExtensionItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The collection of open extensions defined for the message. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: Extension, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property extensions in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> ExtensionItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ExtensionItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ExtensionItemRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class ExtensionItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ExtensionItemRequestBuilderGetQueryParameters(): + """ + The collection of open extensions defined for the message. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class ExtensionItemRequestBuilderGetRequestConfiguration(RequestConfiguration[ExtensionItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ExtensionItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/item/message_item_request_builder.py b/tests/validation/validation/users/item/messages/item/message_item_request_builder.py new file mode 100644 index 00000000..03e4a16d --- /dev/null +++ b/tests/validation/validation/users/item/messages/item/message_item_request_builder.py @@ -0,0 +1,222 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from .....models.message import Message + from .....models.o_data_errors.o_data_error import ODataError + from .attachments.attachments_request_builder import AttachmentsRequestBuilder + from .extensions.extensions_request_builder import ExtensionsRequestBuilder + from .value.content_request_builder import ContentRequestBuilder + +class MessageItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages/{message-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessageItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages/{message%2Did}{?%24expand,%24select,includeHiddenMessages}", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + Delete navigation property messages for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessageItemRequestBuilderGetQueryParameters]] = None) -> Optional[Message]: + """ + The messages in a mailbox or folder. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Message] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .....models.message import Message + + return await self.request_adapter.send_async(request_info, Message, error_mapping) + + async def patch(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Message]: + """ + Update the navigation property messages in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Message] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_patch_request_information( + body, request_configuration + ) + from .....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from .....models.message import Message + + return await self.request_adapter.send_async(request_info, Message, error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Delete navigation property messages for users + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessageItemRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The messages in a mailbox or folder. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_patch_request_information(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Update the navigation property messages in users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PATCH, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessageItemRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessageItemRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessageItemRequestBuilder(self.request_adapter, raw_url) + + @property + def attachments(self) -> AttachmentsRequestBuilder: + """ + The attachments property + """ + from .attachments.attachments_request_builder import AttachmentsRequestBuilder + + return AttachmentsRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def content(self) -> ContentRequestBuilder: + """ + The Content property + """ + from .value.content_request_builder import ContentRequestBuilder + + return ContentRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def extensions(self) -> ExtensionsRequestBuilder: + """ + The extensions property + """ + from .extensions.extensions_request_builder import ExtensionsRequestBuilder + + return ExtensionsRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MessageItemRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageItemRequestBuilderGetQueryParameters(): + """ + The messages in a mailbox or folder. Read-only. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "expand": + return "%24expand" + if original_name == "include_hidden_messages": + return "includeHiddenMessages" + if original_name == "select": + return "%24select" + return original_name + + # Expand related entities + expand: Optional[List[str]] = None + + # Include Hidden Messages + include_hidden_messages: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + + @dataclass + class MessageItemRequestBuilderGetRequestConfiguration(RequestConfiguration[MessageItemRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessageItemRequestBuilderPatchRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/item/value/content_request_builder.py b/tests/validation/validation/users/item/messages/item/value/content_request_builder.py new file mode 100644 index 00000000..588714de --- /dev/null +++ b/tests/validation/validation/users/item/messages/item/value/content_request_builder.py @@ -0,0 +1,156 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ......models.o_data_errors.o_data_error import ODataError + +class ContentRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages/{message-id}/$value + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new ContentRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages/{message%2Did}/$value", path_parameters) + + async def delete(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_delete_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def get(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + async def put(self,body: bytes, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]: + """ + The unique identifier for an entity. Read-only. + param body: Binary request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: bytes + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_put_request_information( + body, request_configuration + ) + from ......models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping) + + def to_delete_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.DELETE, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + The unique identifier for an entity. Read-only. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/octet-stream, application/json") + return request_info + + def to_put_request_information(self,body: bytes, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + The unique identifier for an entity. Read-only. + param body: Binary request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.PUT, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_stream_content(body, "application/octet-stream") + return request_info + + def with_url(self,raw_url: str) -> ContentRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: ContentRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return ContentRequestBuilder(self.request_adapter, raw_url) + + @dataclass + class ContentRequestBuilderDeleteRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ContentRequestBuilderGetRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class ContentRequestBuilderPutRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/messages/messages_request_builder.py b/tests/validation/validation/users/item/messages/messages_request_builder.py new file mode 100644 index 00000000..28f7ab25 --- /dev/null +++ b/tests/validation/validation/users/item/messages/messages_request_builder.py @@ -0,0 +1,212 @@ +from __future__ import annotations +from dataclasses import dataclass, field +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.base_request_configuration import RequestConfiguration +from kiota_abstractions.default_query_parameters import QueryParameters +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.method import Method +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.request_information import RequestInformation +from kiota_abstractions.request_option import RequestOption +from kiota_abstractions.serialization import Parsable, ParsableFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union +from warnings import warn + +if TYPE_CHECKING: + from ....models.message import Message + from ....models.message_collection_response import MessageCollectionResponse + from ....models.o_data_errors.o_data_error import ODataError + from .count.count_request_builder import CountRequestBuilder + from .item.message_item_request_builder import MessageItemRequestBuilder + +class MessagesRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id}/messages + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new MessagesRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}/messages{?%24count,%24expand,%24filter,%24orderby,%24search,%24select,%24skip,%24top,includeHiddenMessages}", path_parameters) + + def by_message_id(self,message_id: str) -> MessageItemRequestBuilder: + """ + Gets an item from the validation.users.item.messages.item collection + param message_id: The unique identifier of message + Returns: MessageItemRequestBuilder + """ + if message_id is None: + raise TypeError("message_id cannot be null.") + from .item.message_item_request_builder import MessageItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["message%2Did"] = message_id + return MessageItemRequestBuilder(self.request_adapter, url_tpl_params) + + async def get(self,request_configuration: Optional[RequestConfiguration[MessagesRequestBuilderGetQueryParameters]] = None) -> Optional[MessageCollectionResponse]: + """ + The messages in a mailbox or folder. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[MessageCollectionResponse] + """ + request_info = self.to_get_request_information( + request_configuration + ) + from ....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ....models.message_collection_response import MessageCollectionResponse + + return await self.request_adapter.send_async(request_info, MessageCollectionResponse, error_mapping) + + async def post(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[Message]: + """ + Create new navigation property to messages for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: Optional[Message] + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = self.to_post_request_information( + body, request_configuration + ) + from ....models.o_data_errors.o_data_error import ODataError + + error_mapping: Dict[str, type[ParsableFactory]] = { + "XXX": ODataError, + } + if not self.request_adapter: + raise Exception("Http core is null") + from ....models.message import Message + + return await self.request_adapter.send_async(request_info, Message, error_mapping) + + def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[MessagesRequestBuilderGetQueryParameters]] = None) -> RequestInformation: + """ + The messages in a mailbox or folder. Read-only. Nullable. + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + return request_info + + def to_post_request_information(self,body: Message, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation: + """ + Create new navigation property to messages for users + param body: The request body + param request_configuration: Configuration for the request such as headers, query parameters, and middleware options. + Returns: RequestInformation + """ + if body is None: + raise TypeError("body cannot be null.") + request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters) + request_info.configure(request_configuration) + request_info.headers.try_add("Accept", "application/json") + request_info.set_content_from_parsable(self.request_adapter, "application/json", body) + return request_info + + def with_url(self,raw_url: str) -> MessagesRequestBuilder: + """ + Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored. + param raw_url: The raw URL to use for the request builder. + Returns: MessagesRequestBuilder + """ + if raw_url is None: + raise TypeError("raw_url cannot be null.") + return MessagesRequestBuilder(self.request_adapter, raw_url) + + @property + def count(self) -> CountRequestBuilder: + """ + The Count property + """ + from .count.count_request_builder import CountRequestBuilder + + return CountRequestBuilder(self.request_adapter, self.path_parameters) + + @dataclass + class MessagesRequestBuilderGetQueryParameters(): + """ + The messages in a mailbox or folder. Read-only. Nullable. + """ + def get_query_parameter(self,original_name: str) -> str: + """ + Maps the query parameters names to their encoded names for the URI template parsing. + param original_name: The original query parameter name in the class. + Returns: str + """ + if original_name is None: + raise TypeError("original_name cannot be null.") + if original_name == "count": + return "%24count" + if original_name == "expand": + return "%24expand" + if original_name == "filter": + return "%24filter" + if original_name == "include_hidden_messages": + return "includeHiddenMessages" + if original_name == "orderby": + return "%24orderby" + if original_name == "search": + return "%24search" + if original_name == "select": + return "%24select" + if original_name == "skip": + return "%24skip" + if original_name == "top": + return "%24top" + return original_name + + # Include count of items + count: Optional[bool] = None + + # Expand related entities + expand: Optional[List[str]] = None + + # Filter items by property values + filter: Optional[str] = None + + # Include Hidden Messages + include_hidden_messages: Optional[str] = None + + # Order items by property values + orderby: Optional[List[str]] = None + + # Search items by search phrases + search: Optional[str] = None + + # Select properties to be returned + select: Optional[List[str]] = None + + # Skip the first n items + skip: Optional[int] = None + + # Show only the first n items + top: Optional[int] = None + + + @dataclass + class MessagesRequestBuilderGetRequestConfiguration(RequestConfiguration[MessagesRequestBuilderGetQueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + @dataclass + class MessagesRequestBuilderPostRequestConfiguration(RequestConfiguration[QueryParameters]): + """ + Configuration for the request such as headers, query parameters, and middleware options. + """ + warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning) + + diff --git a/tests/validation/validation/users/item/user_item_request_builder.py b/tests/validation/validation/users/item/user_item_request_builder.py new file mode 100644 index 00000000..cef08815 --- /dev/null +++ b/tests/validation/validation/users/item/user_item_request_builder.py @@ -0,0 +1,52 @@ +from __future__ import annotations +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.request_adapter import RequestAdapter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .inference_classification.inference_classification_request_builder import InferenceClassificationRequestBuilder + from .mail_folders.mail_folders_request_builder import MailFoldersRequestBuilder + from .messages.messages_request_builder import MessagesRequestBuilder + +class UserItemRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users/{user-id} + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new UserItemRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users/{user%2Did}", path_parameters) + + @property + def inference_classification(self) -> InferenceClassificationRequestBuilder: + """ + The inferenceClassification property + """ + from .inference_classification.inference_classification_request_builder import InferenceClassificationRequestBuilder + + return InferenceClassificationRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def mail_folders(self) -> MailFoldersRequestBuilder: + """ + The mailFolders property + """ + from .mail_folders.mail_folders_request_builder import MailFoldersRequestBuilder + + return MailFoldersRequestBuilder(self.request_adapter, self.path_parameters) + + @property + def messages(self) -> MessagesRequestBuilder: + """ + The messages property + """ + from .messages.messages_request_builder import MessagesRequestBuilder + + return MessagesRequestBuilder(self.request_adapter, self.path_parameters) + + diff --git a/tests/validation/validation/users/users_request_builder.py b/tests/validation/validation/users/users_request_builder.py new file mode 100644 index 00000000..377ec1dc --- /dev/null +++ b/tests/validation/validation/users/users_request_builder.py @@ -0,0 +1,37 @@ +from __future__ import annotations +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.request_adapter import RequestAdapter +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .item.user_item_request_builder import UserItemRequestBuilder + +class UsersRequestBuilder(BaseRequestBuilder): + """ + Builds and executes requests for operations under /users + """ + def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, Dict[str, Any]]) -> None: + """ + Instantiates a new UsersRequestBuilder and sets the default values. + param path_parameters: The raw url or the url-template parameters for the request. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + super().__init__(request_adapter, "{+baseurl}/users", path_parameters) + + def by_user_id(self,user_id: str) -> UserItemRequestBuilder: + """ + Gets an item from the validation.users.item collection + param user_id: The unique identifier of user + Returns: UserItemRequestBuilder + """ + if user_id is None: + raise TypeError("user_id cannot be null.") + from .item.user_item_request_builder import UserItemRequestBuilder + + url_tpl_params = get_path_parameters(self.path_parameters) + url_tpl_params["user%2Did"] = user_id + return UserItemRequestBuilder(self.request_adapter, url_tpl_params) + + diff --git a/tests/validation/validation/validation_client.py b/tests/validation/validation/validation_client.py new file mode 100644 index 00000000..3a74785d --- /dev/null +++ b/tests/validation/validation/validation_client.py @@ -0,0 +1,52 @@ +from __future__ import annotations +from kiota_abstractions.api_client_builder import enable_backing_store_for_serialization_writer_factory, register_default_deserializer, register_default_serializer +from kiota_abstractions.base_request_builder import BaseRequestBuilder +from kiota_abstractions.get_path_parameters import get_path_parameters +from kiota_abstractions.request_adapter import RequestAdapter +from kiota_abstractions.serialization import ParseNodeFactoryRegistry, SerializationWriterFactoryRegistry +from kiota_serialization_form.form_parse_node_factory import FormParseNodeFactory +from kiota_serialization_form.form_serialization_writer_factory import FormSerializationWriterFactory +from kiota_serialization_json.json_parse_node_factory import JsonParseNodeFactory +from kiota_serialization_json.json_serialization_writer_factory import JsonSerializationWriterFactory +from kiota_serialization_multipart.multipart_serialization_writer_factory import MultipartSerializationWriterFactory +from kiota_serialization_text.text_parse_node_factory import TextParseNodeFactory +from kiota_serialization_text.text_serialization_writer_factory import TextSerializationWriterFactory +from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING, Union + +if TYPE_CHECKING: + from .users.users_request_builder import UsersRequestBuilder + +class ValidationClient(BaseRequestBuilder): + """ + The main entry point of the SDK, exposes the configuration and the fluent API. + """ + def __init__(self,request_adapter: RequestAdapter) -> None: + """ + Instantiates a new ValidationClient and sets the default values. + param request_adapter: The request adapter to use to execute the requests. + Returns: None + """ + if request_adapter is None: + raise TypeError("request_adapter cannot be null.") + super().__init__(request_adapter, "{+baseurl}", None) + register_default_serializer(JsonSerializationWriterFactory) + register_default_serializer(TextSerializationWriterFactory) + register_default_serializer(FormSerializationWriterFactory) + register_default_serializer(MultipartSerializationWriterFactory) + register_default_deserializer(JsonParseNodeFactory) + register_default_deserializer(TextParseNodeFactory) + register_default_deserializer(FormParseNodeFactory) + if not self.request_adapter.base_url: + self.request_adapter.base_url = "https://graph.microsoft.com/v1.0" + self.path_parameters["base_url"] = self.request_adapter.base_url + + @property + def users(self) -> UsersRequestBuilder: + """ + The users property + """ + from .users.users_request_builder import UsersRequestBuilder + + return UsersRequestBuilder(self.request_adapter, self.path_parameters) + +