miro_api.models.board_members_paged_response

Miro Developer Platform

### Miro Developer Platform concepts - New to the Miro Developer Platform? Interested in learning more about platform concepts?? Read our introduction page and familiarize yourself with the Miro Developer Platform capabilities in a few minutes. ### Getting started with the Miro REST API - Quickstart (video): try the REST API in less than 3 minutes. - Quickstart (article): get started and try the REST API in less than 3 minutes. ### Miro REST API tutorials Check out our how-to articles with step-by-step instructions and code examples so you can: - Get started with OAuth 2.0 and Miro ### Miro App Examples Clone our Miro App Examples repository to get inspiration, customize, and explore apps built on top of Miro's Developer Platform 2.0.

The version of the OpenAPI document: v2.0 Generated by OpenAPI Generator (https://openapi-generator.tech)

Do not edit the class manually.

  1# coding: utf-8
  2
  3"""
  4Miro Developer Platform
  5
  6<img src=\"https://content.pstmn.io/47449ea6-0ef7-4af2-bac1-e58a70e61c58/aW1hZ2UucG5n\" width=\"1685\" height=\"593\">  ### Miro Developer Platform concepts  - New to the Miro Developer Platform? Interested in learning more about platform concepts?? [Read our introduction page](https://beta.developers.miro.com/docs/introduction) and familiarize yourself with the Miro Developer Platform capabilities in a few minutes.   ### Getting started with the Miro REST API  - [Quickstart (video):](https://beta.developers.miro.com/docs/try-out-the-rest-api-in-less-than-3-minutes) try the REST API in less than 3 minutes. - [Quickstart (article):](https://beta.developers.miro.com/docs/build-your-first-hello-world-app-1) get started and try the REST API in less than 3 minutes.   ### Miro REST API tutorials  Check out our how-to articles with step-by-step instructions and code examples so you can:  - [Get started with OAuth 2.0 and Miro](https://beta.developers.miro.com/docs/getting-started-with-oauth)   ### Miro App Examples  Clone our [Miro App Examples repository](https://github.com/miroapp/app-examples) to get inspiration, customize, and explore apps built on top of Miro's Developer Platform 2.0.
  7
  8The version of the OpenAPI document: v2.0
  9Generated by OpenAPI Generator (https://openapi-generator.tech)
 10
 11Do not edit the class manually.
 12"""  # noqa: E501
 13
 14from __future__ import annotations
 15import pprint
 16import re  # noqa: F401
 17import json
 18
 19from pydantic import BaseModel, Field, StrictInt, StrictStr
 20from typing import Any, ClassVar, Dict, List, Optional
 21from miro_api.models.board_member import BoardMember
 22from miro_api.models.page_links import PageLinks
 23from typing import Optional, Set
 24from typing_extensions import Self
 25
 26
 27class BoardMembersPagedResponse(BaseModel):
 28    """
 29    BoardMembersPagedResponse
 30    """  # noqa: E501
 31
 32    data: Optional[List[BoardMember]] = Field(default=None, description="Contains the result data.")
 33    total: Optional[StrictInt] = Field(
 34        default=None,
 35        description="Total number of results available. If the value of the `total` parameter is higher than the value of the `size` parameter, this means that there are more results that you can retrieve. To retrieve more results, you can make another request and set the `offset` value accordingly. For example, if there are `30` results, and the request has the `offset` set to `0` and the `limit` set to `20`, the `size` parameter will return `20` and the `total` parameter will return `30`. This means that there are 9 more results to retrieve (as the offset is zero-based).",
 36    )
 37    size: Optional[StrictInt] = Field(
 38        default=None,
 39        description="Number of results returned in the response. The `size` is the number of results returned considering the `offset` and the `limit` values sent in the request. For example, if there are `30` results, and the request has the offset set to `0` and the `limit` set to `20`, the `size` of the results will be `20`.<br>If there are `10` results, and the request has the offset set to `0` and the `limit` set to `20`, the `size` of the results will be `10`.<br>If there are `30` results, and the request has the offset set to `28` and the `limit` set to `20`, the `size` of the results will be `2` as the `offset` is the zero-based offset of the first item in the collection.",
 40    )
 41    offset: Optional[StrictInt] = Field(
 42        default=None,
 43        description="Zero-based index of the first item in the collection. For example, If there are `30` results, and the request has the offset set to `28`, the response will return `2` results.",
 44    )
 45    limit: Optional[StrictInt] = Field(
 46        default=None,
 47        description="Maximum number of results returned based on the `limit` specified in the request. For example, if there are `30` results, and the request has the offset set to `0` and the `limit` set to `20`, the `size` of the results will be `20`. The rest of the results will not be returned. To retrieve the rest of the results, you must make another request and set the appropriate value for the offset parameter. In this example, you will set the offset parameter to 20 as the offset is zero-based. ",
 48    )
 49    links: Optional[PageLinks] = None
 50    type: Optional[StrictStr] = None
 51    additional_properties: Dict[str, Any] = {}
 52    __properties: ClassVar[List[str]] = ["data", "total", "size", "offset", "limit", "links", "type"]
 53
 54    model_config = {
 55        "populate_by_name": True,
 56        "validate_assignment": True,
 57        "protected_namespaces": (),
 58    }
 59
 60    def to_str(self) -> str:
 61        """Returns the string representation of the model using alias"""
 62        return pprint.pformat(self.model_dump(by_alias=True))
 63
 64    def to_json(self) -> str:
 65        """Returns the JSON representation of the model using alias"""
 66        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
 67        return json.dumps(self.to_dict())
 68
 69    @classmethod
 70    def from_json(cls, json_str: str) -> Optional[Self]:
 71        """Create an instance of BoardMembersPagedResponse from a JSON string"""
 72        return cls.from_dict(json.loads(json_str))
 73
 74    def to_dict(self) -> Dict[str, Any]:
 75        """Return the dictionary representation of the model using alias.
 76
 77        This has the following differences from calling pydantic's
 78        `self.model_dump(by_alias=True)`:
 79
 80        * `None` is only added to the output dict for nullable fields that
 81          were set at model initialization. Other fields with value `None`
 82          are ignored.
 83        * Fields in `self.additional_properties` are added to the output dict.
 84        """
 85        excluded_fields: Set[str] = set(
 86            [
 87                "additional_properties",
 88            ]
 89        )
 90
 91        _dict = self.model_dump(
 92            by_alias=True,
 93            exclude=excluded_fields,
 94            exclude_none=True,
 95        )
 96        # override the default output from pydantic by calling `to_dict()` of each item in data (list)
 97        _items = []
 98        if self.data:
 99            for _item in self.data:
100                if _item:
101                    _items.append(_item.to_dict())
102            _dict["data"] = _items
103        # override the default output from pydantic by calling `to_dict()` of links
104        if self.links:
105            _dict["links"] = self.links.to_dict()
106        # puts key-value pairs in additional_properties in the top level
107        if self.additional_properties is not None:
108            for _key, _value in self.additional_properties.items():
109                _dict[_key] = _value
110
111        return _dict
112
113    @classmethod
114    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
115        """Create an instance of BoardMembersPagedResponse from a dict"""
116        if obj is None:
117            return None
118
119        if not isinstance(obj, dict):
120            return cls.model_validate(obj)
121
122        _obj = cls.model_validate(
123            {
124                "data": (
125                    [BoardMember.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None
126                ),
127                "total": obj.get("total"),
128                "size": obj.get("size"),
129                "offset": obj.get("offset"),
130                "limit": obj.get("limit"),
131                "links": PageLinks.from_dict(obj["links"]) if obj.get("links") is not None else None,
132                "type": obj.get("type"),
133            }
134        )
135        # store additional fields in additional_properties
136        for _key in obj.keys():
137            if _key not in cls.__properties:
138                _obj.additional_properties[_key] = obj.get(_key)
139
140        return _obj
class BoardMembersPagedResponse(pydantic.main.BaseModel):
 28class BoardMembersPagedResponse(BaseModel):
 29    """
 30    BoardMembersPagedResponse
 31    """  # noqa: E501
 32
 33    data: Optional[List[BoardMember]] = Field(default=None, description="Contains the result data.")
 34    total: Optional[StrictInt] = Field(
 35        default=None,
 36        description="Total number of results available. If the value of the `total` parameter is higher than the value of the `size` parameter, this means that there are more results that you can retrieve. To retrieve more results, you can make another request and set the `offset` value accordingly. For example, if there are `30` results, and the request has the `offset` set to `0` and the `limit` set to `20`, the `size` parameter will return `20` and the `total` parameter will return `30`. This means that there are 9 more results to retrieve (as the offset is zero-based).",
 37    )
 38    size: Optional[StrictInt] = Field(
 39        default=None,
 40        description="Number of results returned in the response. The `size` is the number of results returned considering the `offset` and the `limit` values sent in the request. For example, if there are `30` results, and the request has the offset set to `0` and the `limit` set to `20`, the `size` of the results will be `20`.<br>If there are `10` results, and the request has the offset set to `0` and the `limit` set to `20`, the `size` of the results will be `10`.<br>If there are `30` results, and the request has the offset set to `28` and the `limit` set to `20`, the `size` of the results will be `2` as the `offset` is the zero-based offset of the first item in the collection.",
 41    )
 42    offset: Optional[StrictInt] = Field(
 43        default=None,
 44        description="Zero-based index of the first item in the collection. For example, If there are `30` results, and the request has the offset set to `28`, the response will return `2` results.",
 45    )
 46    limit: Optional[StrictInt] = Field(
 47        default=None,
 48        description="Maximum number of results returned based on the `limit` specified in the request. For example, if there are `30` results, and the request has the offset set to `0` and the `limit` set to `20`, the `size` of the results will be `20`. The rest of the results will not be returned. To retrieve the rest of the results, you must make another request and set the appropriate value for the offset parameter. In this example, you will set the offset parameter to 20 as the offset is zero-based. ",
 49    )
 50    links: Optional[PageLinks] = None
 51    type: Optional[StrictStr] = None
 52    additional_properties: Dict[str, Any] = {}
 53    __properties: ClassVar[List[str]] = ["data", "total", "size", "offset", "limit", "links", "type"]
 54
 55    model_config = {
 56        "populate_by_name": True,
 57        "validate_assignment": True,
 58        "protected_namespaces": (),
 59    }
 60
 61    def to_str(self) -> str:
 62        """Returns the string representation of the model using alias"""
 63        return pprint.pformat(self.model_dump(by_alias=True))
 64
 65    def to_json(self) -> str:
 66        """Returns the JSON representation of the model using alias"""
 67        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
 68        return json.dumps(self.to_dict())
 69
 70    @classmethod
 71    def from_json(cls, json_str: str) -> Optional[Self]:
 72        """Create an instance of BoardMembersPagedResponse from a JSON string"""
 73        return cls.from_dict(json.loads(json_str))
 74
 75    def to_dict(self) -> Dict[str, Any]:
 76        """Return the dictionary representation of the model using alias.
 77
 78        This has the following differences from calling pydantic's
 79        `self.model_dump(by_alias=True)`:
 80
 81        * `None` is only added to the output dict for nullable fields that
 82          were set at model initialization. Other fields with value `None`
 83          are ignored.
 84        * Fields in `self.additional_properties` are added to the output dict.
 85        """
 86        excluded_fields: Set[str] = set(
 87            [
 88                "additional_properties",
 89            ]
 90        )
 91
 92        _dict = self.model_dump(
 93            by_alias=True,
 94            exclude=excluded_fields,
 95            exclude_none=True,
 96        )
 97        # override the default output from pydantic by calling `to_dict()` of each item in data (list)
 98        _items = []
 99        if self.data:
100            for _item in self.data:
101                if _item:
102                    _items.append(_item.to_dict())
103            _dict["data"] = _items
104        # override the default output from pydantic by calling `to_dict()` of links
105        if self.links:
106            _dict["links"] = self.links.to_dict()
107        # puts key-value pairs in additional_properties in the top level
108        if self.additional_properties is not None:
109            for _key, _value in self.additional_properties.items():
110                _dict[_key] = _value
111
112        return _dict
113
114    @classmethod
115    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
116        """Create an instance of BoardMembersPagedResponse from a dict"""
117        if obj is None:
118            return None
119
120        if not isinstance(obj, dict):
121            return cls.model_validate(obj)
122
123        _obj = cls.model_validate(
124            {
125                "data": (
126                    [BoardMember.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None
127                ),
128                "total": obj.get("total"),
129                "size": obj.get("size"),
130                "offset": obj.get("offset"),
131                "limit": obj.get("limit"),
132                "links": PageLinks.from_dict(obj["links"]) if obj.get("links") is not None else None,
133                "type": obj.get("type"),
134            }
135        )
136        # store additional fields in additional_properties
137        for _key in obj.keys():
138            if _key not in cls.__properties:
139                _obj.additional_properties[_key] = obj.get(_key)
140
141        return _obj

BoardMembersPagedResponse

total: Optional[Annotated[int, Strict(strict=True)]]
size: Optional[Annotated[int, Strict(strict=True)]]
offset: Optional[Annotated[int, Strict(strict=True)]]
limit: Optional[Annotated[int, Strict(strict=True)]]
type: Optional[Annotated[str, Strict(strict=True)]]
additional_properties: Dict[str, Any]
model_config = {'populate_by_name': True, 'validate_assignment': True, 'protected_namespaces': ()}
def to_str(self) -> str:
61    def to_str(self) -> str:
62        """Returns the string representation of the model using alias"""
63        return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

def to_json(self) -> str:
65    def to_json(self) -> str:
66        """Returns the JSON representation of the model using alias"""
67        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
68        return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

@classmethod
def from_json(cls, json_str: str) -> Optional[typing_extensions.Self]:
70    @classmethod
71    def from_json(cls, json_str: str) -> Optional[Self]:
72        """Create an instance of BoardMembersPagedResponse from a JSON string"""
73        return cls.from_dict(json.loads(json_str))

Create an instance of BoardMembersPagedResponse from a JSON string

def to_dict(self) -> Dict[str, Any]:
 75    def to_dict(self) -> Dict[str, Any]:
 76        """Return the dictionary representation of the model using alias.
 77
 78        This has the following differences from calling pydantic's
 79        `self.model_dump(by_alias=True)`:
 80
 81        * `None` is only added to the output dict for nullable fields that
 82          were set at model initialization. Other fields with value `None`
 83          are ignored.
 84        * Fields in `self.additional_properties` are added to the output dict.
 85        """
 86        excluded_fields: Set[str] = set(
 87            [
 88                "additional_properties",
 89            ]
 90        )
 91
 92        _dict = self.model_dump(
 93            by_alias=True,
 94            exclude=excluded_fields,
 95            exclude_none=True,
 96        )
 97        # override the default output from pydantic by calling `to_dict()` of each item in data (list)
 98        _items = []
 99        if self.data:
100            for _item in self.data:
101                if _item:
102                    _items.append(_item.to_dict())
103            _dict["data"] = _items
104        # override the default output from pydantic by calling `to_dict()` of links
105        if self.links:
106            _dict["links"] = self.links.to_dict()
107        # puts key-value pairs in additional_properties in the top level
108        if self.additional_properties is not None:
109            for _key, _value in self.additional_properties.items():
110                _dict[_key] = _value
111
112        return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

  • None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.
  • Fields in self.additional_properties are added to the output dict.
@classmethod
def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[typing_extensions.Self]:
114    @classmethod
115    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
116        """Create an instance of BoardMembersPagedResponse from a dict"""
117        if obj is None:
118            return None
119
120        if not isinstance(obj, dict):
121            return cls.model_validate(obj)
122
123        _obj = cls.model_validate(
124            {
125                "data": (
126                    [BoardMember.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None
127                ),
128                "total": obj.get("total"),
129                "size": obj.get("size"),
130                "offset": obj.get("offset"),
131                "limit": obj.get("limit"),
132                "links": PageLinks.from_dict(obj["links"]) if obj.get("links") is not None else None,
133                "type": obj.get("type"),
134            }
135        )
136        # store additional fields in additional_properties
137        for _key in obj.keys():
138            if _key not in cls.__properties:
139                _obj.additional_properties[_key] = obj.get(_key)
140
141        return _obj

Create an instance of BoardMembersPagedResponse from a dict

def model_post_init(self: pydantic.main.BaseModel, __context: Any) -> None:
265def init_private_attributes(self: BaseModel, __context: Any) -> None:
266    """This function is meant to behave like a BaseModel method to initialise private attributes.
267
268    It takes context as an argument since that's what pydantic-core passes when calling it.
269
270    Args:
271        self: The BaseModel instance.
272        __context: The context.
273    """
274    if getattr(self, '__pydantic_private__', None) is None:
275        pydantic_private = {}
276        for name, private_attr in self.__private_attributes__.items():
277            default = private_attr.get_default()
278            if default is not PydanticUndefined:
279                pydantic_private[name] = default
280        object_setattr(self, '__pydantic_private__', pydantic_private)

This function is meant to behave like a BaseModel method to initialise private attributes.

It takes context as an argument since that's what pydantic-core passes when calling it.

Args: self: The BaseModel instance. __context: The context.

model_fields = {'data': FieldInfo(annotation=Union[List[miro_api.models.board_member.BoardMember], NoneType], required=False, description='Contains the result data.'), 'total': FieldInfo(annotation=Union[Annotated[int, Strict(strict=True)], NoneType], required=False, description='Total number of results available. If the value of the `total` parameter is higher than the value of the `size` parameter, this means that there are more results that you can retrieve. To retrieve more results, you can make another request and set the `offset` value accordingly. For example, if there are `30` results, and the request has the `offset` set to `0` and the `limit` set to `20`, the `size` parameter will return `20` and the `total` parameter will return `30`. This means that there are 9 more results to retrieve (as the offset is zero-based).'), 'size': FieldInfo(annotation=Union[Annotated[int, Strict(strict=True)], NoneType], required=False, description='Number of results returned in the response. The `size` is the number of results returned considering the `offset` and the `limit` values sent in the request. For example, if there are `30` results, and the request has the offset set to `0` and the `limit` set to `20`, the `size` of the results will be `20`.<br>If there are `10` results, and the request has the offset set to `0` and the `limit` set to `20`, the `size` of the results will be `10`.<br>If there are `30` results, and the request has the offset set to `28` and the `limit` set to `20`, the `size` of the results will be `2` as the `offset` is the zero-based offset of the first item in the collection.'), 'offset': FieldInfo(annotation=Union[Annotated[int, Strict(strict=True)], NoneType], required=False, description='Zero-based index of the first item in the collection. For example, If there are `30` results, and the request has the offset set to `28`, the response will return `2` results.'), 'limit': FieldInfo(annotation=Union[Annotated[int, Strict(strict=True)], NoneType], required=False, description='Maximum number of results returned based on the `limit` specified in the request. For example, if there are `30` results, and the request has the offset set to `0` and the `limit` set to `20`, the `size` of the results will be `20`. The rest of the results will not be returned. To retrieve the rest of the results, you must make another request and set the appropriate value for the offset parameter. In this example, you will set the offset parameter to 20 as the offset is zero-based. '), 'links': FieldInfo(annotation=Union[PageLinks, NoneType], required=False), 'type': FieldInfo(annotation=Union[Annotated[str, Strict(strict=True)], NoneType], required=False), 'additional_properties': FieldInfo(annotation=Dict[str, Any], required=False, default={})}
model_computed_fields = {}
Inherited Members
pydantic.main.BaseModel
BaseModel
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_rebuild
model_validate
model_validate_json
model_validate_strings
dict
json
parse_obj
parse_raw
parse_file
from_orm
construct
copy
schema
schema_json
validate
update_forward_refs