miro_api .api

Rate limiting

:param app_id: ID of the app to get metrics for. (required) :type app_id: str :param start_date: Start date of the period in UTC format. For example, 2024-12-31. (required) :type start_date: date :param end_date: End date of the period in UTC format. For example, 2024-12-31. (required) :type end_date: date :param period: Group data by this time period. :type period: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_metrics_total( self, app_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='ID of the app to get total metrics for.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.get_metrics_total200_response.GetMetricsTotal200Response: View Source

344    @validate_call
345    def get_metrics_total(
346        self,
347        app_id: Annotated[StrictStr, Field(description="ID of the app to get total metrics for.")],
348        _request_timeout: Union[
349            None,
350            Annotated[StrictFloat, Field(gt=0)],
351            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
352        ] = None,
353        _request_auth: Optional[Dict[StrictStr, Any]] = None,
354        _content_type: Optional[StrictStr] = None,
355        _headers: Optional[Dict[StrictStr, Any]] = None,
356        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
357    ) -> GetMetricsTotal200Response:
358        """Get total app metrics
359
360        Returns total usage metrics for a specific app since the app was created.  This endpoint requires an app management API token. It can be generated in <a href=\"https://developers.miro.com/?features=appMetricsToken#your-apps\">your apps</a> section of Developer Hub.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a><br/> <h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
361
362        :param app_id: ID of the app to get total metrics for. (required)
363        :type app_id: str
364        :param _request_timeout: timeout setting for this request. If one
365                                 number provided, it will be total request
366                                 timeout. It can also be a pair (tuple) of
367                                 (connection, read) timeouts.
368        :type _request_timeout: int, tuple(int, int), optional
369        :param _request_auth: set to override the auth_settings for an a single
370                              request; this effectively ignores the
371                              authentication in the spec for a single request.
372        :type _request_auth: dict, optional
373        :param _content_type: force content-type for the request.
374        :type _content_type: str, Optional
375        :param _headers: set to override the headers for a single
376                         request; this effectively ignores the headers
377                         in the spec for a single request.
378        :type _headers: dict, optional
379        :param _host_index: set to override the host_index for a single
380                            request; this effectively ignores the host_index
381                            in the spec for a single request.
382        :type _host_index: int, optional
383        :return: Returns the result object.
384        """  # noqa: E501
385
386        _param = self._get_metrics_total_serialize(
387            app_id=app_id,
388            _request_auth=_request_auth,
389            _content_type=_content_type,
390            _headers=_headers,
391            _host_index=_host_index,
392        )
393
394        _response_types_map: Dict[str, Optional[str]] = {
395            "200": "GetMetricsTotal200Response",
396            "404": "GetMetricsTotal404Response",
397        }
398        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
399        response_data.read()
400        return self.api_client.response_deserialize(
401            response_data=response_data,
402            response_types_map=_response_types_map,
403        ).data

Get total app metrics

Returns total usage metrics for a specific app since the app was created. This endpoint requires an app management API token. It can be generated in your apps section of Developer Hub.

Required scope

Rate limiting

:param app_id: ID of the app to get total metrics for. (required) :type app_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_audit_logs( self, created_after: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Retrieve audit logs created after the date and time provided. This is the start date of the duration for which you want to retrieve audit logs. For example, if you want to retrieve audit logs between `2023-03-30T17:26:50.000Z` and `2023-04-30T17:26:50.000Z`, provide `2023-03-30T17:26:50.000Z` as the value for the `createdAfter` parameter.<br>Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), including milliseconds and a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC))." ')], created_before: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Retrieve audit logs created before the date and time provided. This is the end date of the duration for which you want to retrieve audit logs. For example, if you want to retrieve audit logs between `2023-03-30T17:26:50.000Z` and `2023-04-30T17:26:50.000Z`, provide `2023-04-30T17:26:50.000Z` as the value for the `createdBefore` parameter.<br>Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), including milliseconds and a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)). ')], cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A cursor-paginated method returns a portion of the total set of results based on the `limit` specified and a `cursor` that points to the next portion of the results. To retrieve the next set of results of the collection, set the `cursor` parameter in your next request to the appropriate cursor value returned in the response.')] = None, limit: Annotated[Optional[Annotated[int, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Maximum number of results returned based on the `limit` specified in the request. For example, if there are `30` results, the request has no `cursor` value, and the `limit` is 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 `cursor` parameter value that you obtained from the response.<br>Default: `100` ')] = None, sorting: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Sort order in which you want to view the result set. Based on the value you provide, the results are sorted in an ascending or descending order of the audit log creation date (audit log `createdAt` parameter).<br>Default: `ASC` ')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.audit_page.AuditPage: View Source

454    @validate_call
455    def enterprise_get_audit_logs(
456        self,
457        created_after: Annotated[
458            StrictStr,
459            Field(
460                description='Retrieve audit logs created after the date and time provided. This is the start date of the duration for which you want to retrieve audit logs. For example, if you want to retrieve audit logs between `2023-03-30T17:26:50.000Z` and `2023-04-30T17:26:50.000Z`, provide `2023-03-30T17:26:50.000Z` as the value for the `createdAfter` parameter.<br>Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), including milliseconds and a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC))." '
461            ),
462        ],
463        created_before: Annotated[
464            StrictStr,
465            Field(
466                description="Retrieve audit logs created before the date and time provided. This is the end date of the duration for which you want to retrieve audit logs. For example, if you want to retrieve audit logs between `2023-03-30T17:26:50.000Z` and `2023-04-30T17:26:50.000Z`, provide `2023-04-30T17:26:50.000Z` as the value for the `createdBefore` parameter.<br>Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), including milliseconds and a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)). "
467            ),
468        ],
469        cursor: Annotated[
470            Optional[StrictStr],
471            Field(
472                description="A cursor-paginated method returns a portion of the total set of results based on the `limit` specified and a `cursor` that points to the next portion of the results. To retrieve the next set of results of the collection, set the `cursor` parameter in your next request to the appropriate cursor value returned in the response."
473            ),
474        ] = None,
475        limit: Annotated[
476            Optional[StrictInt],
477            Field(
478                description="Maximum number of results returned based on the `limit` specified in the request. For example, if there are `30` results, the request has no `cursor` value, and the `limit` is 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 `cursor` parameter value that  you obtained from the response.<br>Default: `100` "
479            ),
480        ] = None,
481        sorting: Annotated[
482            Optional[StrictStr],
483            Field(
484                description="Sort order in which you want to view the result set. Based on the value you provide, the results are sorted in an ascending or descending order of the audit log creation date (audit log `createdAt` parameter).<br>Default: `ASC` "
485            ),
486        ] = None,
487        _request_timeout: Union[
488            None,
489            Annotated[StrictFloat, Field(gt=0)],
490            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
491        ] = None,
492        _request_auth: Optional[Dict[StrictStr, Any]] = None,
493        _content_type: Optional[StrictStr] = None,
494        _headers: Optional[Dict[StrictStr, Any]] = None,
495        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
496    ) -> AuditPage:
497        """Get audit logs
498
499        Retrieves a page of audit events from the last 90 days. If you want to retrieve data that is older than 90 days, you can use the <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/360017571434-Audit-logs#h_01J7EY4E0F67EFTRQ7BT688HW0\">CSV export feature</a>.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>auditlogs:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a>
500
501        :param created_after: Retrieve audit logs created after the date and time provided. This is the start date of the duration for which you want to retrieve audit logs. For example, if you want to retrieve audit logs between `2023-03-30T17:26:50.000Z` and `2023-04-30T17:26:50.000Z`, provide `2023-03-30T17:26:50.000Z` as the value for the `createdAfter` parameter.<br>Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), including milliseconds and a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)).\"  (required)
502        :type created_after: str
503        :param created_before: Retrieve audit logs created before the date and time provided. This is the end date of the duration for which you want to retrieve audit logs. For example, if you want to retrieve audit logs between `2023-03-30T17:26:50.000Z` and `2023-04-30T17:26:50.000Z`, provide `2023-04-30T17:26:50.000Z` as the value for the `createdBefore` parameter.<br>Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), including milliseconds and a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)).  (required)
504        :type created_before: str
505        :param cursor: A cursor-paginated method returns a portion of the total set of results based on the `limit` specified and a `cursor` that points to the next portion of the results. To retrieve the next set of results of the collection, set the `cursor` parameter in your next request to the appropriate cursor value returned in the response.
506        :type cursor: str
507        :param limit: Maximum number of results returned based on the `limit` specified in the request. For example, if there are `30` results, the request has no `cursor` value, and the `limit` is 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 `cursor` parameter value that  you obtained from the response.<br>Default: `100`
508        :type limit: int
509        :param sorting: Sort order in which you want to view the result set. Based on the value you provide, the results are sorted in an ascending or descending order of the audit log creation date (audit log `createdAt` parameter).<br>Default: `ASC`
510        :type sorting: str
511        :param _request_timeout: timeout setting for this request. If one
512                                 number provided, it will be total request
513                                 timeout. It can also be a pair (tuple) of
514                                 (connection, read) timeouts.
515        :type _request_timeout: int, tuple(int, int), optional
516        :param _request_auth: set to override the auth_settings for an a single
517                              request; this effectively ignores the
518                              authentication in the spec for a single request.
519        :type _request_auth: dict, optional
520        :param _content_type: force content-type for the request.
521        :type _content_type: str, Optional
522        :param _headers: set to override the headers for a single
523                         request; this effectively ignores the headers
524                         in the spec for a single request.
525        :type _headers: dict, optional
526        :param _host_index: set to override the host_index for a single
527                            request; this effectively ignores the host_index
528                            in the spec for a single request.
529        :type _host_index: int, optional
530        :return: Returns the result object.
531        """  # noqa: E501
532
533        _param = self._enterprise_get_audit_logs_serialize(
534            created_after=created_after,
535            created_before=created_before,
536            cursor=cursor,
537            limit=limit,
538            sorting=sorting,
539            _request_auth=_request_auth,
540            _content_type=_content_type,
541            _headers=_headers,
542            _host_index=_host_index,
543        )
544
545        _response_types_map: Dict[str, Optional[str]] = {
546            "200": "AuditPage",
547            "400": None,
548            "401": None,
549            "403": None,
550            "404": None,
551            "409": None,
552            "429": None,
553        }
554        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
555        response_data.read()
556        return self.api_client.response_deserialize(
557            response_data=response_data,
558            response_types_map=_response_types_map,
559        ).data

Get audit logs

Retrieves a page of audit events from the last 90 days. If you want to retrieve data that is older than 90 days, you can use the CSV export feature.

Required scope

auditlogs:read

Rate limiting

:param created_after: Retrieve audit logs created after the date and time provided. This is the start date of the duration for which you want to retrieve audit logs. For example, if you want to retrieve audit logs between 2023-03-30T17:26:50.000Z and 2023-04-30T17:26:50.000Z, provide 2023-03-30T17:26:50.000Z as the value for the createdAfter parameter.
Format: UTC, adheres to ISO 8601, including milliseconds and a trailing Z offset." (required) :type created_after: str :param created_before: Retrieve audit logs created before the date and time provided. This is the end date of the duration for which you want to retrieve audit logs. For example, if you want to retrieve audit logs between 2023-03-30T17:26:50.000Z and 2023-04-30T17:26:50.000Z, provide 2023-04-30T17:26:50.000Z as the value for the createdBefore parameter.
Format: UTC, adheres to ISO 8601, including milliseconds and a trailing Z offset. (required) :type created_before: str :param cursor: A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next set of results of the collection, set the cursor parameter in your next request to the appropriate cursor value returned in the response. :type cursor: str :param limit: Maximum number of results returned based on the limit specified in the request. For example, if there are 30 results, the request has no cursor value, and the limit is 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 cursor parameter value that you obtained from the response.
Default: 100 :type limit: int :param sorting: Sort order in which you want to view the result set. Based on the value you provide, the results are sorted in an ascending or descending order of the audit log creation date (audit log createdAt parameter).
Default: ASC :type sorting: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_board_content_item_logs_fetch( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the organization.')], var_from: typing.Annotated[datetime.datetime, FieldInfo(annotation=NoneType, required=True, description='Filter content logs based on the date and time when the board item was last modified. This is the start date and time for the modified date duration. Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), includes a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)). ')], to: typing.Annotated[datetime.datetime, FieldInfo(annotation=NoneType, required=True, description='Filter content logs based on the date and time when the board item was last modified. This is the end date and time for the modified date duration. Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), includes a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)). ')], board_ids: Annotated[Optional[Annotated[List[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=15)])]], FieldInfo(annotation=NoneType, required=True, description='List of board IDs for which you want to retrieve the content logs.')] = None, emails: Annotated[Optional[Annotated[List[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, metadata=[MaxLen(max_length=15)])]], FieldInfo(annotation=NoneType, required=True, description='Filter content logs based on the list of emails of users who created, modified, or deleted the board item.')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, set the cursor parameter equal to the cursor value you received in the response of the previous request. ')] = None, limit: Annotated[Optional[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=1), Le(le=1000)])]], FieldInfo(annotation=NoneType, required=True, description='The maximum number of results to return per call. If the number of logs in the response is greater than the limit specified, the response returns the cursor parameter with a value. ')] = None, sorting: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Sort order in which you want to view the result set based on the modified date. To sort by an ascending modified date, specify `asc`. To sort by a descending modified date, specify `desc`. ')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.get_board_item_content_logs_response.GetBoardItemContentLogsResponse: View Source

632    @validate_call
633    def enterprise_board_content_item_logs_fetch(
634        self,
635        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
636        var_from: Annotated[
637            datetime,
638            Field(
639                description="Filter content logs based on the date and time when the board item was last modified. This is the start date and time for the modified date duration. Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), includes a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)). "
640            ),
641        ],
642        to: Annotated[
643            datetime,
644            Field(
645                description="Filter content logs based on the date and time when the board item was last modified. This is the end date and time for the modified date duration. Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), includes a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)). "
646            ),
647        ],
648        board_ids: Annotated[
649            Optional[Annotated[List[StrictStr], Field(max_length=15)]],
650            Field(description="List of board IDs for which you want to retrieve the content logs."),
651        ] = None,
652        emails: Annotated[
653            Optional[Annotated[List[StrictStr], Field(max_length=15)]],
654            Field(
655                description="Filter content logs based on the list of emails of users who created, modified, or deleted the board item."
656            ),
657        ] = None,
658        cursor: Annotated[
659            Optional[StrictStr],
660            Field(
661                description="A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, set the cursor parameter equal to the cursor value you received in the response of the previous request. "
662            ),
663        ] = None,
664        limit: Annotated[
665            Optional[Annotated[int, Field(le=1000, strict=True, ge=1)]],
666            Field(
667                description="The maximum number of results to return per call. If the number of logs in the response is greater than the limit specified, the response returns the cursor parameter with a value. "
668            ),
669        ] = None,
670        sorting: Annotated[
671            Optional[StrictStr],
672            Field(
673                description="Sort order in which you want to view the result set based on the modified date. To sort by an ascending modified date, specify `asc`. To sort by a descending modified date, specify `desc`. "
674            ),
675        ] = None,
676        _request_timeout: Union[
677            None,
678            Annotated[StrictFloat, Field(gt=0)],
679            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
680        ] = None,
681        _request_auth: Optional[Dict[StrictStr, Any]] = None,
682        _content_type: Optional[StrictStr] = None,
683        _headers: Optional[Dict[StrictStr, Any]] = None,
684        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
685    ) -> GetBoardItemContentLogsResponse:
686        """Retrieve content change logs of board items
687
688        Retrieves content changes for board items within your organization. Content changes are actions that users can perform on board items, such as updating a sticky note's text. You can retrieve results for a specific time period. You can also filter results based on the board IDs and the emails of users who created, modified, or deleted a board item. Additionally, results can be paginated for easier viewing and processing. <br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>contentlogs:export</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin.</p>
689
690        :param org_id: Unique identifier of the organization. (required)
691        :type org_id: str
692        :param var_from: Filter content logs based on the date and time when the board item was last modified. This is the start date and time for the modified date duration. Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), includes a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)).  (required)
693        :type var_from: datetime
694        :param to: Filter content logs based on the date and time when the board item was last modified. This is the end date and time for the modified date duration. Format: UTC, adheres to [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), includes a [trailing Z offset](https://en.wikipedia.org/wiki/ISO_8601#Coordinated_Universal_Time_(UTC)).  (required)
695        :type to: datetime
696        :param board_ids: List of board IDs for which you want to retrieve the content logs.
697        :type board_ids: List[str]
698        :param emails: Filter content logs based on the list of emails of users who created, modified, or deleted the board item.
699        :type emails: List[str]
700        :param cursor: A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, set the cursor parameter equal to the cursor value you received in the response of the previous request.
701        :type cursor: str
702        :param limit: The maximum number of results to return per call. If the number of logs in the response is greater than the limit specified, the response returns the cursor parameter with a value.
703        :type limit: int
704        :param sorting: Sort order in which you want to view the result set based on the modified date. To sort by an ascending modified date, specify `asc`. To sort by a descending modified date, specify `desc`.
705        :type sorting: str
706        :param _request_timeout: timeout setting for this request. If one
707                                 number provided, it will be total request
708                                 timeout. It can also be a pair (tuple) of
709                                 (connection, read) timeouts.
710        :type _request_timeout: int, tuple(int, int), optional
711        :param _request_auth: set to override the auth_settings for an a single
712                              request; this effectively ignores the
713                              authentication in the spec for a single request.
714        :type _request_auth: dict, optional
715        :param _content_type: force content-type for the request.
716        :type _content_type: str, Optional
717        :param _headers: set to override the headers for a single
718                         request; this effectively ignores the headers
719                         in the spec for a single request.
720        :type _headers: dict, optional
721        :param _host_index: set to override the host_index for a single
722                            request; this effectively ignores the host_index
723                            in the spec for a single request.
724        :type _host_index: int, optional
725        :return: Returns the result object.
726        """  # noqa: E501
727
728        _param = self._enterprise_board_content_item_logs_fetch_serialize(
729            org_id=org_id,
730            var_from=var_from,
731            to=to,
732            board_ids=board_ids,
733            emails=emails,
734            cursor=cursor,
735            limit=limit,
736            sorting=sorting,
737            _request_auth=_request_auth,
738            _content_type=_content_type,
739            _headers=_headers,
740            _host_index=_host_index,
741        )
742
743        _response_types_map: Dict[str, Optional[str]] = {
744            "200": "GetBoardItemContentLogsResponse",
745            "400": None,
746            "401": None,
747            "403": None,
748            "404": None,
749            "429": None,
750        }
751        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
752        response_data.read()
753        return self.api_client.response_deserialize(
754            response_data=response_data,
755            response_types_map=_response_types_map,
756        ).data

Retrieve content change logs of board items

Retrieves content changes for board items within your organization. Content changes are actions that users can perform on board items, such as updating a sticky note's text. You can retrieve results for a specific time period. You can also filter results based on the board IDs and the emails of users who created, modified, or deleted a board item. Additionally, results can be paginated for easier viewing and processing.

Required scope

contentlogs:export

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin.

:param org_id: Unique identifier of the organization. (required) :type org_id: str :param var_from: Filter content logs based on the date and time when the board item was last modified. This is the start date and time for the modified date duration. Format: UTC, adheres to ISO 8601, includes a trailing Z offset. (required) :type var_from: datetime :param to: Filter content logs based on the date and time when the board item was last modified. This is the end date and time for the modified date duration. Format: UTC, adheres to ISO 8601, includes a trailing Z offset. (required) :type to: datetime :param board_ids: List of board IDs for which you want to retrieve the content logs. :type board_ids: List[str] :param emails: Filter content logs based on the list of emails of users who created, modified, or deleted the board item. :type emails: List[str] :param cursor: A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, set the cursor parameter equal to the cursor value you received in the response of the previous request. :type cursor: str :param limit: The maximum number of results to return per call. If the number of logs in the response is greater than the limit specified, the response returns the cursor parameter with a value. :type limit: int :param sorting: Sort order in which you want to view the result set based on the modified date. To sort by an ascending modified date, specify asc. To sort by a descending modified date, specify desc. :type sorting: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_board_export_job_results( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the organization.')], job_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the job.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_export_result.BoardExportResult: View Source

849    @validate_call
850    def enterprise_board_export_job_results(
851        self,
852        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
853        job_id: Annotated[StrictStr, Field(description="Unique identifier of the job.")],
854        _request_timeout: Union[
855            None,
856            Annotated[StrictFloat, Field(gt=0)],
857            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
858        ] = None,
859        _request_auth: Optional[Dict[StrictStr, Any]] = None,
860        _content_type: Optional[StrictStr] = None,
861        _headers: Optional[Dict[StrictStr, Any]] = None,
862        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
863    ) -> BoardExportResult:
864        """Get results for board export job
865
866        Retrieves the result of the board export job. The response provides more information about the board export job, such as the S3 link to the files created.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:export</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin and eDiscovery is enabled in the Settings. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
867
868        :param org_id: Unique identifier of the organization. (required)
869        :type org_id: str
870        :param job_id: Unique identifier of the job. (required)
871        :type job_id: str
872        :param _request_timeout: timeout setting for this request. If one
873                                 number provided, it will be total request
874                                 timeout. It can also be a pair (tuple) of
875                                 (connection, read) timeouts.
876        :type _request_timeout: int, tuple(int, int), optional
877        :param _request_auth: set to override the auth_settings for an a single
878                              request; this effectively ignores the
879                              authentication in the spec for a single request.
880        :type _request_auth: dict, optional
881        :param _content_type: force content-type for the request.
882        :type _content_type: str, Optional
883        :param _headers: set to override the headers for a single
884                         request; this effectively ignores the headers
885                         in the spec for a single request.
886        :type _headers: dict, optional
887        :param _host_index: set to override the host_index for a single
888                            request; this effectively ignores the host_index
889                            in the spec for a single request.
890        :type _host_index: int, optional
891        :return: Returns the result object.
892        """  # noqa: E501
893
894        _param = self._enterprise_board_export_job_results_serialize(
895            org_id=org_id,
896            job_id=job_id,
897            _request_auth=_request_auth,
898            _content_type=_content_type,
899            _headers=_headers,
900            _host_index=_host_index,
901        )
902
903        _response_types_map: Dict[str, Optional[str]] = {
904            "200": "BoardExportResult",
905            "400": None,
906            "401": None,
907            "403": None,
908            "404": None,
909            "429": None,
910        }
911        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
912        response_data.read()
913        return self.api_client.response_deserialize(
914            response_data=response_data,
915            response_types_map=_response_types_map,
916        ).data

Get results for board export job

Retrieves the result of the board export job. The response provides more information about the board export job, such as the S3 link to the files created.

Required scope

boards:export

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin and eDiscovery is enabled in the Settings. You can request temporary access to Enterprise APIs using this form.

:param org_id: Unique identifier of the organization. (required) :type org_id: str :param job_id: Unique identifier of the job. (required) :type job_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_board_export_job_status( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the organization.')], job_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the board export job.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_export_job_status.BoardExportJobStatus: View Source

 970    @validate_call
 971    def enterprise_board_export_job_status(
 972        self,
 973        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
 974        job_id: Annotated[StrictStr, Field(description="Unique identifier of the board export job.")],
 975        _request_timeout: Union[
 976            None,
 977            Annotated[StrictFloat, Field(gt=0)],
 978            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
 979        ] = None,
 980        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 981        _content_type: Optional[StrictStr] = None,
 982        _headers: Optional[Dict[StrictStr, Any]] = None,
 983        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 984    ) -> BoardExportJobStatus:
 985        """Get board export job status
 986
 987        Retrieves the status of the board export job.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:export</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin and eDiscovery is enabled in the Settings. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
 988
 989        :param org_id: Unique identifier of the organization. (required)
 990        :type org_id: str
 991        :param job_id: Unique identifier of the board export job. (required)
 992        :type job_id: str
 993        :param _request_timeout: timeout setting for this request. If one
 994                                 number provided, it will be total request
 995                                 timeout. It can also be a pair (tuple) of
 996                                 (connection, read) timeouts.
 997        :type _request_timeout: int, tuple(int, int), optional
 998        :param _request_auth: set to override the auth_settings for an a single
 999                              request; this effectively ignores the
1000                              authentication in the spec for a single request.
1001        :type _request_auth: dict, optional
1002        :param _content_type: force content-type for the request.
1003        :type _content_type: str, Optional
1004        :param _headers: set to override the headers for a single
1005                         request; this effectively ignores the headers
1006                         in the spec for a single request.
1007        :type _headers: dict, optional
1008        :param _host_index: set to override the host_index for a single
1009                            request; this effectively ignores the host_index
1010                            in the spec for a single request.
1011        :type _host_index: int, optional
1012        :return: Returns the result object.
1013        """  # noqa: E501
1014
1015        _param = self._enterprise_board_export_job_status_serialize(
1016            org_id=org_id,
1017            job_id=job_id,
1018            _request_auth=_request_auth,
1019            _content_type=_content_type,
1020            _headers=_headers,
1021            _host_index=_host_index,
1022        )
1023
1024        _response_types_map: Dict[str, Optional[str]] = {
1025            "200": "BoardExportJobStatus",
1026            "400": None,
1027            "401": None,
1028            "403": None,
1029            "404": None,
1030            "429": None,
1031        }
1032        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1033        response_data.read()
1034        return self.api_client.response_deserialize(
1035            response_data=response_data,
1036            response_types_map=_response_types_map,
1037        ).data

Get board export job status

Retrieves the status of the board export job.

Required scope

boards:export

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin and eDiscovery is enabled in the Settings. You can request temporary access to Enterprise APIs using this form.

:param org_id: Unique identifier of the organization. (required) :type org_id: str :param job_id: Unique identifier of the board export job. (required) :type job_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_create_board_export( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the organization.')], request_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the board export job.')], create_board_export_request: miro_api.models.create_board_export_request.CreateBoardExportRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_export_job_id.BoardExportJobId: View Source

1091    @validate_call
1092    def enterprise_create_board_export(
1093        self,
1094        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
1095        request_id: Annotated[StrictStr, Field(description="Unique identifier of the board export job.")],
1096        create_board_export_request: CreateBoardExportRequest,
1097        _request_timeout: Union[
1098            None,
1099            Annotated[StrictFloat, Field(gt=0)],
1100            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1101        ] = None,
1102        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1103        _content_type: Optional[StrictStr] = None,
1104        _headers: Optional[Dict[StrictStr, Any]] = None,
1105        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1106    ) -> BoardExportJobId:
1107        """Create board export job
1108
1109        Creates an export job for one or more boards.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:export</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin and eDiscovery is enabled in the Settings. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
1110
1111        :param org_id: Unique identifier of the organization. (required)
1112        :type org_id: str
1113        :param request_id: Unique identifier of the board export job. (required)
1114        :type request_id: str
1115        :param create_board_export_request: (required)
1116        :type create_board_export_request: CreateBoardExportRequest
1117        :param _request_timeout: timeout setting for this request. If one
1118                                 number provided, it will be total request
1119                                 timeout. It can also be a pair (tuple) of
1120                                 (connection, read) timeouts.
1121        :type _request_timeout: int, tuple(int, int), optional
1122        :param _request_auth: set to override the auth_settings for an a single
1123                              request; this effectively ignores the
1124                              authentication in the spec for a single request.
1125        :type _request_auth: dict, optional
1126        :param _content_type: force content-type for the request.
1127        :type _content_type: str, Optional
1128        :param _headers: set to override the headers for a single
1129                         request; this effectively ignores the headers
1130                         in the spec for a single request.
1131        :type _headers: dict, optional
1132        :param _host_index: set to override the host_index for a single
1133                            request; this effectively ignores the host_index
1134                            in the spec for a single request.
1135        :type _host_index: int, optional
1136        :return: Returns the result object.
1137        """  # noqa: E501
1138
1139        _param = self._enterprise_create_board_export_serialize(
1140            org_id=org_id,
1141            request_id=request_id,
1142            create_board_export_request=create_board_export_request,
1143            _request_auth=_request_auth,
1144            _content_type=_content_type,
1145            _headers=_headers,
1146            _host_index=_host_index,
1147        )
1148
1149        _response_types_map: Dict[str, Optional[str]] = {
1150            "200": "BoardExportJobId",
1151            "400": None,
1152            "401": None,
1153            "403": None,
1154            "404": None,
1155            "429": None,
1156        }
1157        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1158        response_data.read()
1159        return self.api_client.response_deserialize(
1160            response_data=response_data,
1161            response_types_map=_response_types_map,
1162        ).data

Create board export job

Creates an export job for one or more boards.

Required scope

boards:export

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin and eDiscovery is enabled in the Settings. You can request temporary access to Enterprise APIs using this form.

:param org_id: Unique identifier of the organization. (required) :type org_id: str :param request_id: Unique identifier of the board export job. (required) :type request_id: str :param create_board_export_request: (required) :type create_board_export_request: CreateBoardExportRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_dataclassification_board_get( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the team')], board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the board that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_data_classification_label.BoardDataClassificationLabel: View Source

1229    @validate_call
1230    def enterprise_dataclassification_board_get(
1231        self,
1232        org_id: Annotated[StrictStr, Field(description="id of the organization")],
1233        team_id: Annotated[StrictStr, Field(description="id of the team")],
1234        board_id: Annotated[StrictStr, Field(description="Unique identifier of the board that you want to retrieve.")],
1235        _request_timeout: Union[
1236            None,
1237            Annotated[StrictFloat, Field(gt=0)],
1238            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1239        ] = None,
1240        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1241        _content_type: Optional[StrictStr] = None,
1242        _headers: Optional[Dict[StrictStr, Any]] = None,
1243        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1244    ) -> BoardDataClassificationLabel:
1245        """Get board classification
1246
1247        Retrieves board classification for a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
1248
1249        :param org_id: id of the organization (required)
1250        :type org_id: str
1251        :param team_id: id of the team (required)
1252        :type team_id: str
1253        :param board_id: Unique identifier of the board that you want to retrieve. (required)
1254        :type board_id: str
1255        :param _request_timeout: timeout setting for this request. If one
1256                                 number provided, it will be total request
1257                                 timeout. It can also be a pair (tuple) of
1258                                 (connection, read) timeouts.
1259        :type _request_timeout: int, tuple(int, int), optional
1260        :param _request_auth: set to override the auth_settings for an a single
1261                              request; this effectively ignores the
1262                              authentication in the spec for a single request.
1263        :type _request_auth: dict, optional
1264        :param _content_type: force content-type for the request.
1265        :type _content_type: str, Optional
1266        :param _headers: set to override the headers for a single
1267                         request; this effectively ignores the headers
1268                         in the spec for a single request.
1269        :type _headers: dict, optional
1270        :param _host_index: set to override the host_index for a single
1271                            request; this effectively ignores the host_index
1272                            in the spec for a single request.
1273        :type _host_index: int, optional
1274        :return: Returns the result object.
1275        """  # noqa: E501
1276
1277        _param = self._enterprise_dataclassification_board_get_serialize(
1278            org_id=org_id,
1279            team_id=team_id,
1280            board_id=board_id,
1281            _request_auth=_request_auth,
1282            _content_type=_content_type,
1283            _headers=_headers,
1284            _host_index=_host_index,
1285        )
1286
1287        _response_types_map: Dict[str, Optional[str]] = {
1288            "200": "BoardDataClassificationLabel",
1289            "400": None,
1290            "401": None,
1291            "403": None,
1292            "404": None,
1293            "429": None,
1294        }
1295        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1296        response_data.read()
1297        return self.api_client.response_deserialize(
1298            response_data=response_data,
1299            response_types_map=_response_types_map,
1300        ).data

Get board classification

Retrieves board classification for a board.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: id of the organization (required) :type org_id: str :param team_id: id of the team (required) :type team_id: str :param board_id: Unique identifier of the board that you want to retrieve. (required) :type board_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_dataclassification_board_set( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the team')], board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the board that you want to update.')], data_classification_label_id: miro_api.models.data_classification_label_id.DataClassificationLabelId, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_data_classification_label.BoardDataClassificationLabel: View Source

1357    @validate_call
1358    def enterprise_dataclassification_board_set(
1359        self,
1360        org_id: Annotated[StrictStr, Field(description="id of the organization")],
1361        team_id: Annotated[StrictStr, Field(description="id of the team")],
1362        board_id: Annotated[StrictStr, Field(description="Unique identifier of the board that you want to update.")],
1363        data_classification_label_id: DataClassificationLabelId,
1364        _request_timeout: Union[
1365            None,
1366            Annotated[StrictFloat, Field(gt=0)],
1367            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1368        ] = None,
1369        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1370        _content_type: Optional[StrictStr] = None,
1371        _headers: Optional[Dict[StrictStr, Any]] = None,
1372        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1373    ) -> BoardDataClassificationLabel:
1374        """Update board classification
1375
1376        Updates board classification for an existing board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
1377
1378        :param org_id: id of the organization (required)
1379        :type org_id: str
1380        :param team_id: id of the team (required)
1381        :type team_id: str
1382        :param board_id: Unique identifier of the board that you want to update. (required)
1383        :type board_id: str
1384        :param data_classification_label_id: (required)
1385        :type data_classification_label_id: DataClassificationLabelId
1386        :param _request_timeout: timeout setting for this request. If one
1387                                 number provided, it will be total request
1388                                 timeout. It can also be a pair (tuple) of
1389                                 (connection, read) timeouts.
1390        :type _request_timeout: int, tuple(int, int), optional
1391        :param _request_auth: set to override the auth_settings for an a single
1392                              request; this effectively ignores the
1393                              authentication in the spec for a single request.
1394        :type _request_auth: dict, optional
1395        :param _content_type: force content-type for the request.
1396        :type _content_type: str, Optional
1397        :param _headers: set to override the headers for a single
1398                         request; this effectively ignores the headers
1399                         in the spec for a single request.
1400        :type _headers: dict, optional
1401        :param _host_index: set to override the host_index for a single
1402                            request; this effectively ignores the host_index
1403                            in the spec for a single request.
1404        :type _host_index: int, optional
1405        :return: Returns the result object.
1406        """  # noqa: E501
1407
1408        _param = self._enterprise_dataclassification_board_set_serialize(
1409            org_id=org_id,
1410            team_id=team_id,
1411            board_id=board_id,
1412            data_classification_label_id=data_classification_label_id,
1413            _request_auth=_request_auth,
1414            _content_type=_content_type,
1415            _headers=_headers,
1416            _host_index=_host_index,
1417        )
1418
1419        _response_types_map: Dict[str, Optional[str]] = {
1420            "200": "BoardDataClassificationLabel",
1421            "400": None,
1422            "401": None,
1423            "403": None,
1424            "404": None,
1425            "429": None,
1426        }
1427        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1428        response_data.read()
1429        return self.api_client.response_deserialize(
1430            response_data=response_data,
1431            response_types_map=_response_types_map,
1432        ).data

Update board classification

Updates board classification for an existing board.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: id of the organization (required) :type org_id: str :param team_id: id of the team (required) :type team_id: str :param board_id: Unique identifier of the board that you want to update. (required) :type board_id: str :param data_classification_label_id: (required) :type data_classification_label_id: DataClassificationLabelId :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_dataclassification_organization_settings_get( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.data_classification_organization_settings.DataClassificationOrganizationSettings: View Source

1500    @validate_call
1501    def enterprise_dataclassification_organization_settings_get(
1502        self,
1503        org_id: Annotated[StrictStr, Field(description="id of the organization")],
1504        _request_timeout: Union[
1505            None,
1506            Annotated[StrictFloat, Field(gt=0)],
1507            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1508        ] = None,
1509        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1510        _content_type: Optional[StrictStr] = None,
1511        _headers: Optional[Dict[StrictStr, Any]] = None,
1512        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1513    ) -> DataClassificationOrganizationSettings:
1514        """Get organization settings
1515
1516        Retrieves board classification settings for an existing organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
1517
1518        :param org_id: id of the organization (required)
1519        :type org_id: str
1520        :param _request_timeout: timeout setting for this request. If one
1521                                 number provided, it will be total request
1522                                 timeout. It can also be a pair (tuple) of
1523                                 (connection, read) timeouts.
1524        :type _request_timeout: int, tuple(int, int), optional
1525        :param _request_auth: set to override the auth_settings for an a single
1526                              request; this effectively ignores the
1527                              authentication in the spec for a single request.
1528        :type _request_auth: dict, optional
1529        :param _content_type: force content-type for the request.
1530        :type _content_type: str, Optional
1531        :param _headers: set to override the headers for a single
1532                         request; this effectively ignores the headers
1533                         in the spec for a single request.
1534        :type _headers: dict, optional
1535        :param _host_index: set to override the host_index for a single
1536                            request; this effectively ignores the host_index
1537                            in the spec for a single request.
1538        :type _host_index: int, optional
1539        :return: Returns the result object.
1540        """  # noqa: E501
1541
1542        _param = self._enterprise_dataclassification_organization_settings_get_serialize(
1543            org_id=org_id,
1544            _request_auth=_request_auth,
1545            _content_type=_content_type,
1546            _headers=_headers,
1547            _host_index=_host_index,
1548        )
1549
1550        _response_types_map: Dict[str, Optional[str]] = {
1551            "200": "DataClassificationOrganizationSettings",
1552            "400": None,
1553            "401": None,
1554            "403": None,
1555            "404": None,
1556            "429": None,
1557        }
1558        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1559        response_data.read()
1560        return self.api_client.response_deserialize(
1561            response_data=response_data,
1562            response_types_map=_response_types_map,
1563        ).data

Get organization settings

Retrieves board classification settings for an existing organization.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: id of the organization (required) :type org_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_dataclassification_team_boards_bulk( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the team')], update_boards_data_classification_label_request: miro_api.models.update_boards_data_classification_label_request.UpdateBoardsDataClassificationLabelRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.update_boards_data_classification_label.UpdateBoardsDataClassificationLabel: View Source

1614    @validate_call
1615    def enterprise_dataclassification_team_boards_bulk(
1616        self,
1617        org_id: Annotated[StrictStr, Field(description="id of the organization")],
1618        team_id: Annotated[StrictStr, Field(description="id of the team")],
1619        update_boards_data_classification_label_request: UpdateBoardsDataClassificationLabelRequest,
1620        _request_timeout: Union[
1621            None,
1622            Annotated[StrictFloat, Field(gt=0)],
1623            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1624        ] = None,
1625        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1626        _content_type: Optional[StrictStr] = None,
1627        _headers: Optional[Dict[StrictStr, Any]] = None,
1628        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1629    ) -> UpdateBoardsDataClassificationLabel:
1630        """Bulk update boards classification
1631
1632        Updates board classification for not-classified only or all boards in an existing team.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
1633
1634        :param org_id: id of the organization (required)
1635        :type org_id: str
1636        :param team_id: id of the team (required)
1637        :type team_id: str
1638        :param update_boards_data_classification_label_request: (required)
1639        :type update_boards_data_classification_label_request: UpdateBoardsDataClassificationLabelRequest
1640        :param _request_timeout: timeout setting for this request. If one
1641                                 number provided, it will be total request
1642                                 timeout. It can also be a pair (tuple) of
1643                                 (connection, read) timeouts.
1644        :type _request_timeout: int, tuple(int, int), optional
1645        :param _request_auth: set to override the auth_settings for an a single
1646                              request; this effectively ignores the
1647                              authentication in the spec for a single request.
1648        :type _request_auth: dict, optional
1649        :param _content_type: force content-type for the request.
1650        :type _content_type: str, Optional
1651        :param _headers: set to override the headers for a single
1652                         request; this effectively ignores the headers
1653                         in the spec for a single request.
1654        :type _headers: dict, optional
1655        :param _host_index: set to override the host_index for a single
1656                            request; this effectively ignores the host_index
1657                            in the spec for a single request.
1658        :type _host_index: int, optional
1659        :return: Returns the result object.
1660        """  # noqa: E501
1661
1662        _param = self._enterprise_dataclassification_team_boards_bulk_serialize(
1663            org_id=org_id,
1664            team_id=team_id,
1665            update_boards_data_classification_label_request=update_boards_data_classification_label_request,
1666            _request_auth=_request_auth,
1667            _content_type=_content_type,
1668            _headers=_headers,
1669            _host_index=_host_index,
1670        )
1671
1672        _response_types_map: Dict[str, Optional[str]] = {
1673            "200": "UpdateBoardsDataClassificationLabel",
1674            "400": None,
1675            "401": None,
1676            "403": None,
1677            "404": None,
1678            "429": None,
1679        }
1680        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1681        response_data.read()
1682        return self.api_client.response_deserialize(
1683            response_data=response_data,
1684            response_types_map=_response_types_map,
1685        ).data

Bulk update boards classification

Updates board classification for not-classified only or all boards in an existing team.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: id of the organization (required) :type org_id: str :param team_id: id of the team (required) :type team_id: str :param update_boards_data_classification_label_request: (required) :type update_boards_data_classification_label_request: UpdateBoardsDataClassificationLabelRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_dataclassification_team_settings_get( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the team')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.data_classification_team_settings.DataClassificationTeamSettings: View Source

1750    @validate_call
1751    def enterprise_dataclassification_team_settings_get(
1752        self,
1753        org_id: Annotated[StrictStr, Field(description="id of the organization")],
1754        team_id: Annotated[StrictStr, Field(description="id of the team")],
1755        _request_timeout: Union[
1756            None,
1757            Annotated[StrictFloat, Field(gt=0)],
1758            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1759        ] = None,
1760        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1761        _content_type: Optional[StrictStr] = None,
1762        _headers: Optional[Dict[StrictStr, Any]] = None,
1763        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1764    ) -> DataClassificationTeamSettings:
1765        """Get team settings
1766
1767        Retrieves board classification settings for an existing team.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
1768
1769        :param org_id: id of the organization (required)
1770        :type org_id: str
1771        :param team_id: id of the team (required)
1772        :type team_id: str
1773        :param _request_timeout: timeout setting for this request. If one
1774                                 number provided, it will be total request
1775                                 timeout. It can also be a pair (tuple) of
1776                                 (connection, read) timeouts.
1777        :type _request_timeout: int, tuple(int, int), optional
1778        :param _request_auth: set to override the auth_settings for an a single
1779                              request; this effectively ignores the
1780                              authentication in the spec for a single request.
1781        :type _request_auth: dict, optional
1782        :param _content_type: force content-type for the request.
1783        :type _content_type: str, Optional
1784        :param _headers: set to override the headers for a single
1785                         request; this effectively ignores the headers
1786                         in the spec for a single request.
1787        :type _headers: dict, optional
1788        :param _host_index: set to override the host_index for a single
1789                            request; this effectively ignores the host_index
1790                            in the spec for a single request.
1791        :type _host_index: int, optional
1792        :return: Returns the result object.
1793        """  # noqa: E501
1794
1795        _param = self._enterprise_dataclassification_team_settings_get_serialize(
1796            org_id=org_id,
1797            team_id=team_id,
1798            _request_auth=_request_auth,
1799            _content_type=_content_type,
1800            _headers=_headers,
1801            _host_index=_host_index,
1802        )
1803
1804        _response_types_map: Dict[str, Optional[str]] = {
1805            "200": "DataClassificationTeamSettings",
1806            "400": None,
1807            "401": None,
1808            "403": None,
1809            "404": None,
1810            "429": None,
1811        }
1812        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1813        response_data.read()
1814        return self.api_client.response_deserialize(
1815            response_data=response_data,
1816            response_types_map=_response_types_map,
1817        ).data

Get team settings

Retrieves board classification settings for an existing team.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: id of the organization (required) :type org_id: str :param team_id: id of the team (required) :type team_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_dataclassification_team_settings_set( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the team')], update_team_settings_request: miro_api.models.update_team_settings_request.UpdateTeamSettingsRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.data_classification_team_settings.DataClassificationTeamSettings: View Source

1871    @validate_call
1872    def enterprise_dataclassification_team_settings_set(
1873        self,
1874        org_id: Annotated[StrictStr, Field(description="id of the organization")],
1875        team_id: Annotated[StrictStr, Field(description="id of the team")],
1876        update_team_settings_request: UpdateTeamSettingsRequest,
1877        _request_timeout: Union[
1878            None,
1879            Annotated[StrictFloat, Field(gt=0)],
1880            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1881        ] = None,
1882        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1883        _content_type: Optional[StrictStr] = None,
1884        _headers: Optional[Dict[StrictStr, Any]] = None,
1885        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1886    ) -> DataClassificationTeamSettings:
1887        """Update team settings
1888
1889        Updates board classification settings for an existing team.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
1890
1891        :param org_id: id of the organization (required)
1892        :type org_id: str
1893        :param team_id: id of the team (required)
1894        :type team_id: str
1895        :param update_team_settings_request: (required)
1896        :type update_team_settings_request: UpdateTeamSettingsRequest
1897        :param _request_timeout: timeout setting for this request. If one
1898                                 number provided, it will be total request
1899                                 timeout. It can also be a pair (tuple) of
1900                                 (connection, read) timeouts.
1901        :type _request_timeout: int, tuple(int, int), optional
1902        :param _request_auth: set to override the auth_settings for an a single
1903                              request; this effectively ignores the
1904                              authentication in the spec for a single request.
1905        :type _request_auth: dict, optional
1906        :param _content_type: force content-type for the request.
1907        :type _content_type: str, Optional
1908        :param _headers: set to override the headers for a single
1909                         request; this effectively ignores the headers
1910                         in the spec for a single request.
1911        :type _headers: dict, optional
1912        :param _host_index: set to override the host_index for a single
1913                            request; this effectively ignores the host_index
1914                            in the spec for a single request.
1915        :type _host_index: int, optional
1916        :return: Returns the result object.
1917        """  # noqa: E501
1918
1919        _param = self._enterprise_dataclassification_team_settings_set_serialize(
1920            org_id=org_id,
1921            team_id=team_id,
1922            update_team_settings_request=update_team_settings_request,
1923            _request_auth=_request_auth,
1924            _content_type=_content_type,
1925            _headers=_headers,
1926            _host_index=_host_index,
1927        )
1928
1929        _response_types_map: Dict[str, Optional[str]] = {
1930            "200": "DataClassificationTeamSettings",
1931            "400": None,
1932            "401": None,
1933            "403": None,
1934            "404": None,
1935            "429": None,
1936        }
1937        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1938        response_data.read()
1939        return self.api_client.response_deserialize(
1940            response_data=response_data,
1941            response_types_map=_response_types_map,
1942        ).data

Update team settings

Updates board classification settings for an existing team.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: id of the organization (required) :type org_id: str :param team_id: id of the team (required) :type team_id: str :param update_team_settings_request: (required) :type update_team_settings_request: UpdateTeamSettingsRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_items( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], item_create: Annotated[List[miro_api.models.item_create.ItemCreate], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=20)])], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.items.Items: View Source

2007    @validate_call
2008    def create_items(
2009        self,
2010        board_id: Annotated[
2011            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
2012        ],
2013        item_create: Annotated[List[ItemCreate], Field(min_length=1, max_length=20)],
2014        _request_timeout: Union[
2015            None,
2016            Annotated[StrictFloat, Field(gt=0)],
2017            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2018        ] = None,
2019        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2020        _content_type: Optional[StrictStr] = None,
2021        _headers: Optional[Dict[StrictStr, Any]] = None,
2022        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2023    ) -> Items:
2024        """Create items in bulk
2025
2026        Adds different types of items to a board. You can add up to 20 items of the same or different type per create call. For example, you can create 3 shape items, 4 card items, and 5 sticky notes in one create call. The bulk create operation is transactional. If any item's create operation fails, the create operation for all the remaining items also fails, and none of the items will be created. <br/><br>To try out this API in our documentation:<br/><br>1. In the **BODY PARAMS** section, scroll down until you see **ADD OBJECT** (Figure 1).<br><br><img alt=“add src=\"https://files.readme.io/570dac1-small-add_object.png\"><br>Figure 1. Add object user interface in readme<br><br>2. Click **ADD OBJECT**, and then select or enter the appropriate values for parameters of the item that you want to add.<br><br>3. Repeat steps 1 and 2 for each item that you want to add.<br> <br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> per item. For example, if you want to create one sticky note, one card, and one shape item in one call, the rate limiting applicable will be 300 credits. This is because create item calls take Level 2 rate limiting of 100 credits each, 100 for sticky note, 100 for card, and 100 for shape item.
2027
2028        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
2029        :type board_id: str
2030        :param item_create: (required)
2031        :type item_create: List[ItemCreate]
2032        :param _request_timeout: timeout setting for this request. If one
2033                                 number provided, it will be total request
2034                                 timeout. It can also be a pair (tuple) of
2035                                 (connection, read) timeouts.
2036        :type _request_timeout: int, tuple(int, int), optional
2037        :param _request_auth: set to override the auth_settings for an a single
2038                              request; this effectively ignores the
2039                              authentication in the spec for a single request.
2040        :type _request_auth: dict, optional
2041        :param _content_type: force content-type for the request.
2042        :type _content_type: str, Optional
2043        :param _headers: set to override the headers for a single
2044                         request; this effectively ignores the headers
2045                         in the spec for a single request.
2046        :type _headers: dict, optional
2047        :param _host_index: set to override the host_index for a single
2048                            request; this effectively ignores the host_index
2049                            in the spec for a single request.
2050        :type _host_index: int, optional
2051        :return: Returns the result object.
2052        """  # noqa: E501
2053
2054        _param = self._create_items_serialize(
2055            board_id=board_id,
2056            item_create=item_create,
2057            _request_auth=_request_auth,
2058            _content_type=_content_type,
2059            _headers=_headers,
2060            _host_index=_host_index,
2061        )
2062
2063        _response_types_map: Dict[str, Optional[str]] = {
2064            "201": "Items",
2065            "400": "BulkOperationError",
2066            "429": "Error",
2067        }
2068        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2069        response_data.read()
2070        return self.api_client.response_deserialize(
2071            response_data=response_data,
2072            response_types_map=_response_types_map,
2073        ).data

Create items in bulk

Adds different types of items to a board. You can add up to 20 items of the same or different type per create call. For example, you can create 3 shape items, 4 card items, and 5 sticky notes in one create call. The bulk create operation is transactional. If any item's create operation fails, the create operation for all the remaining items also fails, and none of the items will be created.

To try out this API in our documentation:

1. In the BODY PARAMS section, scroll down until you see ADD OBJECT (Figure 1).

“add
Figure 1. Add object user interface in readme

2. Click ADD OBJECT, and then select or enter the appropriate values for parameters of the item that you want to add.

3. Repeat steps 1 and 2 for each item that you want to add.

Required scope

Rate limiting

Level 2 per item. For example, if you want to create one sticky note, one card, and one shape item in one call, the rate limiting applicable will be 300 credits. This is because create item calls take Level 2 rate limiting of 100 credits each, 100 for sticky note, 100 for card, and 100 for shape item.

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param item_create: (required) :type item_create: List[ItemCreate] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_items_in_bulk_using_file_from_device( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], data: Annotated[Union[Annotated[bytes, Strict(strict=True)], Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='JSON file containing bulk data, where each object represents an item to be created. For details, see [JSON file example](https://developers.miro.com/reference/json-data-example).')], resources: Annotated[List[Union[Annotated[bytes, Strict(strict=True)], Annotated[str, Strict(strict=True)]]], FieldInfo(annotation=NoneType, required=True, description='Array of items to create (PDFs, images, etc.). Maximum of 20 items.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.items.Items: View Source

2137    @validate_call
2138    def create_items_in_bulk_using_file_from_device(
2139        self,
2140        board_id: Annotated[
2141            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
2142        ],
2143        data: Annotated[
2144            Union[StrictBytes, StrictStr],
2145            Field(
2146                description="JSON file containing bulk data, where each object represents an item to be created. For details, see [JSON file example](https://developers.miro.com/reference/json-data-example)."
2147            ),
2148        ],
2149        resources: Annotated[
2150            List[Union[StrictBytes, StrictStr]],
2151            Field(description="Array of items to create (PDFs, images, etc.). Maximum of 20 items."),
2152        ],
2153        _request_timeout: Union[
2154            None,
2155            Annotated[StrictFloat, Field(gt=0)],
2156            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2157        ] = None,
2158        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2159        _content_type: Optional[StrictStr] = None,
2160        _headers: Optional[Dict[StrictStr, Any]] = None,
2161        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2162    ) -> Items:
2163        """Create items in bulk using file from device
2164
2165        Adds different types of items to a board using files from a device. You can add up to 20 items of the same or different type per create call. For example, you can create 5 document items and 5 images in one create call.  The bulk create operation is transactional. If any item's create operation fails, the create operation for all the remaining items also fails, and none of the items will be created. To try out this API in our documentation: 1. In the **BODY PARAMS** section, select **ADD FILE**, and then upload a local file. Repeat for each item that you want to add. 2. Upload a JSON file that contains the bulk data for the items you want to create.  <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/> <h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> per item<br/>
2166
2167        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
2168        :type board_id: str
2169        :param data: JSON file containing bulk data, where each object represents an item to be created. For details, see [JSON file example](https://developers.miro.com/reference/json-data-example). (required)
2170        :type data: bytearray
2171        :param resources: Array of items to create (PDFs, images, etc.). Maximum of 20 items. (required)
2172        :type resources: List[bytearray]
2173        :param _request_timeout: timeout setting for this request. If one
2174                                 number provided, it will be total request
2175                                 timeout. It can also be a pair (tuple) of
2176                                 (connection, read) timeouts.
2177        :type _request_timeout: int, tuple(int, int), optional
2178        :param _request_auth: set to override the auth_settings for an a single
2179                              request; this effectively ignores the
2180                              authentication in the spec for a single request.
2181        :type _request_auth: dict, optional
2182        :param _content_type: force content-type for the request.
2183        :type _content_type: str, Optional
2184        :param _headers: set to override the headers for a single
2185                         request; this effectively ignores the headers
2186                         in the spec for a single request.
2187        :type _headers: dict, optional
2188        :param _host_index: set to override the host_index for a single
2189                            request; this effectively ignores the host_index
2190                            in the spec for a single request.
2191        :type _host_index: int, optional
2192        :return: Returns the result object.
2193        """  # noqa: E501
2194
2195        _param = self._create_items_in_bulk_using_file_from_device_serialize(
2196            board_id=board_id,
2197            data=data,
2198            resources=resources,
2199            _request_auth=_request_auth,
2200            _content_type=_content_type,
2201            _headers=_headers,
2202            _host_index=_host_index,
2203        )
2204
2205        _response_types_map: Dict[str, Optional[str]] = {
2206            "201": "Items",
2207        }
2208        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2209        response_data.read()
2210        return self.api_client.response_deserialize(
2211            response_data=response_data,
2212            response_types_map=_response_types_map,
2213        ).data

Create items in bulk using file from device

Adds different types of items to a board using files from a device. You can add up to 20 items of the same or different type per create call. For example, you can create 5 document items and 5 images in one create call. The bulk create operation is transactional. If any item's create operation fails, the create operation for all the remaining items also fails, and none of the items will be created. To try out this API in our documentation: 1. In the BODY PARAMS section, select ADD FILE, and then upload a local file. Repeat for each item that you want to add. 2. Upload a JSON file that contains the bulk data for the items you want to create.

Required scope

Rate limiting

Level 2 per item

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param data: JSON file containing bulk data, where each object represents an item to be created. For details, see JSON file example. (required) :type data: bytearray :param resources: Array of items to create (PDFs, images, etc.). Maximum of 20 items. (required) :type resources: List[bytearray] :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_shape_item_flowchart( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], shape_create_request: miro_api.models.shape_create_request.ShapeCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.shape_item.ShapeItem: View Source

2280    @validate_call
2281    def create_shape_item_flowchart(
2282        self,
2283        board_id: Annotated[
2284            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
2285        ],
2286        shape_create_request: ShapeCreateRequest,
2287        _request_timeout: Union[
2288            None,
2289            Annotated[StrictFloat, Field(gt=0)],
2290            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2291        ] = None,
2292        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2293        _content_type: Optional[StrictStr] = None,
2294        _headers: Optional[Dict[StrictStr, Any]] = None,
2295        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2296    ) -> ShapeItem:
2297        """Create shape item
2298
2299        Adds a flowchart shape item to a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
2300
2301        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
2302        :type board_id: str
2303        :param shape_create_request: (required)
2304        :type shape_create_request: ShapeCreateRequest
2305        :param _request_timeout: timeout setting for this request. If one
2306                                 number provided, it will be total request
2307                                 timeout. It can also be a pair (tuple) of
2308                                 (connection, read) timeouts.
2309        :type _request_timeout: int, tuple(int, int), optional
2310        :param _request_auth: set to override the auth_settings for an a single
2311                              request; this effectively ignores the
2312                              authentication in the spec for a single request.
2313        :type _request_auth: dict, optional
2314        :param _content_type: force content-type for the request.
2315        :type _content_type: str, Optional
2316        :param _headers: set to override the headers for a single
2317                         request; this effectively ignores the headers
2318                         in the spec for a single request.
2319        :type _headers: dict, optional
2320        :param _host_index: set to override the host_index for a single
2321                            request; this effectively ignores the host_index
2322                            in the spec for a single request.
2323        :type _host_index: int, optional
2324        :return: Returns the result object.
2325        """  # noqa: E501
2326
2327        _param = self._create_shape_item_flowchart_serialize(
2328            board_id=board_id,
2329            shape_create_request=shape_create_request,
2330            _request_auth=_request_auth,
2331            _content_type=_content_type,
2332            _headers=_headers,
2333            _host_index=_host_index,
2334        )
2335
2336        _response_types_map: Dict[str, Optional[str]] = {
2337            "201": "ShapeItem",
2338            "400": "CreateFrameItem400Response",
2339            "404": "CreateFrameItem400Response",
2340            "429": "CreateFrameItem400Response",
2341        }
2342        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2343        response_data.read()
2344        return self.api_client.response_deserialize(
2345            response_data=response_data,
2346            response_types_map=_response_types_map,
2347        ).data

Create shape item

Adds a flowchart shape item to a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param shape_create_request: (required) :type shape_create_request: ShapeCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_shape_item_flowchart( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

2409    @validate_call
2410    def delete_shape_item_flowchart(
2411        self,
2412        board_id: Annotated[
2413            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
2414        ],
2415        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
2416        _request_timeout: Union[
2417            None,
2418            Annotated[StrictFloat, Field(gt=0)],
2419            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2420        ] = None,
2421        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2422        _content_type: Optional[StrictStr] = None,
2423        _headers: Optional[Dict[StrictStr, Any]] = None,
2424        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2425    ) -> object:
2426        """Delete shape item
2427
2428        Deletes a flowchart shape item from the board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
2429
2430        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
2431        :type board_id: str
2432        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
2433        :type item_id: str
2434        :param _request_timeout: timeout setting for this request. If one
2435                                 number provided, it will be total request
2436                                 timeout. It can also be a pair (tuple) of
2437                                 (connection, read) timeouts.
2438        :type _request_timeout: int, tuple(int, int), optional
2439        :param _request_auth: set to override the auth_settings for an a single
2440                              request; this effectively ignores the
2441                              authentication in the spec for a single request.
2442        :type _request_auth: dict, optional
2443        :param _content_type: force content-type for the request.
2444        :type _content_type: str, Optional
2445        :param _headers: set to override the headers for a single
2446                         request; this effectively ignores the headers
2447                         in the spec for a single request.
2448        :type _headers: dict, optional
2449        :param _host_index: set to override the host_index for a single
2450                            request; this effectively ignores the host_index
2451                            in the spec for a single request.
2452        :type _host_index: int, optional
2453        :return: Returns the result object.
2454        """  # noqa: E501
2455
2456        _param = self._delete_shape_item_flowchart_serialize(
2457            board_id=board_id,
2458            item_id=item_id,
2459            _request_auth=_request_auth,
2460            _content_type=_content_type,
2461            _headers=_headers,
2462            _host_index=_host_index,
2463        )
2464
2465        _response_types_map: Dict[str, Optional[str]] = {
2466            "204": "object",
2467            "400": "CreateFrameItem400Response",
2468            "404": "CreateFrameItem400Response",
2469            "429": "CreateFrameItem400Response",
2470        }
2471        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2472        response_data.read()
2473        return self.api_client.response_deserialize(
2474            response_data=response_data,
2475            response_types_map=_response_types_map,
2476        ).data

Delete shape item

Deletes a flowchart shape item from the board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_items_experimental( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board for which you want to retrieve the list of available items.')], limit: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] = None, type: Optional[Annotated[str, Strict(strict=True)]] = None, cursor: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.generic_item_cursor_paged.GenericItemCursorPaged: View Source

2530    @validate_call
2531    def get_items_experimental(
2532        self,
2533        board_id: Annotated[
2534            StrictStr,
2535            Field(
2536                description="Unique identifier (ID) of the board for which you want to retrieve the list of available items."
2537            ),
2538        ],
2539        limit: Optional[Annotated[str, Field(strict=True)]] = None,
2540        type: Optional[StrictStr] = None,
2541        cursor: Optional[StrictStr] = None,
2542        _request_timeout: Union[
2543            None,
2544            Annotated[StrictFloat, Field(gt=0)],
2545            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2546        ] = None,
2547        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2548        _content_type: Optional[StrictStr] = None,
2549        _headers: Optional[Dict[StrictStr, Any]] = None,
2550        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2551    ) -> GenericItemCursorPaged:
2552        """Get items on board
2553
2554        Retrieves a list of items for a specific board. You can retrieve all items on the board, a list of child items inside a parent item, or a list of specific types of items by specifying URL query parameter values.  This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the `cursor` parameter equal to the `cursor` value you received in the response of the previous request. For example, if you set the `limit` query parameter to `10` and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is `foo`. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to `foo`.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
2555
2556        :param board_id: Unique identifier (ID) of the board for which you want to retrieve the list of available items. (required)
2557        :type board_id: str
2558        :param limit:
2559        :type limit: str
2560        :param type:
2561        :type type: str
2562        :param cursor:
2563        :type cursor: str
2564        :param _request_timeout: timeout setting for this request. If one
2565                                 number provided, it will be total request
2566                                 timeout. It can also be a pair (tuple) of
2567                                 (connection, read) timeouts.
2568        :type _request_timeout: int, tuple(int, int), optional
2569        :param _request_auth: set to override the auth_settings for an a single
2570                              request; this effectively ignores the
2571                              authentication in the spec for a single request.
2572        :type _request_auth: dict, optional
2573        :param _content_type: force content-type for the request.
2574        :type _content_type: str, Optional
2575        :param _headers: set to override the headers for a single
2576                         request; this effectively ignores the headers
2577                         in the spec for a single request.
2578        :type _headers: dict, optional
2579        :param _host_index: set to override the host_index for a single
2580                            request; this effectively ignores the host_index
2581                            in the spec for a single request.
2582        :type _host_index: int, optional
2583        :return: Returns the result object.
2584        """  # noqa: E501
2585
2586        _param = self._get_items_experimental_serialize(
2587            board_id=board_id,
2588            limit=limit,
2589            type=type,
2590            cursor=cursor,
2591            _request_auth=_request_auth,
2592            _content_type=_content_type,
2593            _headers=_headers,
2594            _host_index=_host_index,
2595        )
2596
2597        _response_types_map: Dict[str, Optional[str]] = {
2598            "200": "GenericItemCursorPaged",
2599            "400": "CreateFrameItem400Response",
2600            "404": "CreateFrameItem400Response",
2601            "429": "CreateFrameItem400Response",
2602        }
2603        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2604        response_data.read()
2605        return self.api_client.response_deserialize(
2606            response_data=response_data,
2607            response_types_map=_response_types_map,
2608        ).data

Get items on board

Retrieves a list of items for a specific board. You can retrieve all items on the board, a list of child items inside a parent item, or a list of specific types of items by specifying URL query parameter values. This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the cursor parameter equal to the cursor value you received in the response of the previous request. For example, if you set the limit query parameter to 10 and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is foo. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to foo.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board for which you want to retrieve the list of available items. (required) :type board_id: str :param limit: :type limit: str :param type: :type type: str :param cursor: :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_shape_item_flowchart( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.shape_item.ShapeItem: View Source

2674    @validate_call
2675    def get_shape_item_flowchart(
2676        self,
2677        board_id: Annotated[
2678            StrictStr,
2679            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
2680        ],
2681        item_id: Annotated[
2682            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
2683        ],
2684        _request_timeout: Union[
2685            None,
2686            Annotated[StrictFloat, Field(gt=0)],
2687            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2688        ] = None,
2689        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2690        _content_type: Optional[StrictStr] = None,
2691        _headers: Optional[Dict[StrictStr, Any]] = None,
2692        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2693    ) -> ShapeItem:
2694        """Get shape item
2695
2696        Retrieves information for a specific shape item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
2697
2698        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
2699        :type board_id: str
2700        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
2701        :type item_id: str
2702        :param _request_timeout: timeout setting for this request. If one
2703                                 number provided, it will be total request
2704                                 timeout. It can also be a pair (tuple) of
2705                                 (connection, read) timeouts.
2706        :type _request_timeout: int, tuple(int, int), optional
2707        :param _request_auth: set to override the auth_settings for an a single
2708                              request; this effectively ignores the
2709                              authentication in the spec for a single request.
2710        :type _request_auth: dict, optional
2711        :param _content_type: force content-type for the request.
2712        :type _content_type: str, Optional
2713        :param _headers: set to override the headers for a single
2714                         request; this effectively ignores the headers
2715                         in the spec for a single request.
2716        :type _headers: dict, optional
2717        :param _host_index: set to override the host_index for a single
2718                            request; this effectively ignores the host_index
2719                            in the spec for a single request.
2720        :type _host_index: int, optional
2721        :return: Returns the result object.
2722        """  # noqa: E501
2723
2724        _param = self._get_shape_item_flowchart_serialize(
2725            board_id=board_id,
2726            item_id=item_id,
2727            _request_auth=_request_auth,
2728            _content_type=_content_type,
2729            _headers=_headers,
2730            _host_index=_host_index,
2731        )
2732
2733        _response_types_map: Dict[str, Optional[str]] = {
2734            "200": "ShapeItem",
2735            "400": "CreateFrameItem400Response",
2736            "404": "CreateFrameItem400Response",
2737            "429": "CreateFrameItem400Response",
2738        }
2739        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2740        response_data.read()
2741        return self.api_client.response_deserialize(
2742            response_data=response_data,
2743            response_types_map=_response_types_map,
2744        ).data

Get shape item

Retrieves information for a specific shape item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_specific_item_experimental( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.generic_item.GenericItem: View Source

2798    @validate_call
2799    def get_specific_item_experimental(
2800        self,
2801        board_id: Annotated[
2802            StrictStr,
2803            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
2804        ],
2805        item_id: Annotated[
2806            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
2807        ],
2808        _request_timeout: Union[
2809            None,
2810            Annotated[StrictFloat, Field(gt=0)],
2811            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2812        ] = None,
2813        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2814        _content_type: Optional[StrictStr] = None,
2815        _headers: Optional[Dict[StrictStr, Any]] = None,
2816        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2817    ) -> GenericItem:
2818        """Get specific item on board
2819
2820        Retrieves information for a specific item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
2821
2822        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
2823        :type board_id: str
2824        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
2825        :type item_id: str
2826        :param _request_timeout: timeout setting for this request. If one
2827                                 number provided, it will be total request
2828                                 timeout. It can also be a pair (tuple) of
2829                                 (connection, read) timeouts.
2830        :type _request_timeout: int, tuple(int, int), optional
2831        :param _request_auth: set to override the auth_settings for an a single
2832                              request; this effectively ignores the
2833                              authentication in the spec for a single request.
2834        :type _request_auth: dict, optional
2835        :param _content_type: force content-type for the request.
2836        :type _content_type: str, Optional
2837        :param _headers: set to override the headers for a single
2838                         request; this effectively ignores the headers
2839                         in the spec for a single request.
2840        :type _headers: dict, optional
2841        :param _host_index: set to override the host_index for a single
2842                            request; this effectively ignores the host_index
2843                            in the spec for a single request.
2844        :type _host_index: int, optional
2845        :return: Returns the result object.
2846        """  # noqa: E501
2847
2848        _param = self._get_specific_item_experimental_serialize(
2849            board_id=board_id,
2850            item_id=item_id,
2851            _request_auth=_request_auth,
2852            _content_type=_content_type,
2853            _headers=_headers,
2854            _host_index=_host_index,
2855        )
2856
2857        _response_types_map: Dict[str, Optional[str]] = {
2858            "200": "GenericItem",
2859            "400": "CreateFrameItem400Response",
2860            "404": "CreateFrameItem400Response",
2861            "429": "CreateFrameItem400Response",
2862        }
2863        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2864        response_data.read()
2865        return self.api_client.response_deserialize(
2866            response_data=response_data,
2867            response_types_map=_response_types_map,
2868        ).data

Get specific item on board

Retrieves information for a specific item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_shape_item_flowchart( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], shape_update_request: miro_api.models.shape_update_request.ShapeUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.shape_item.ShapeItem: View Source

2922    @validate_call
2923    def update_shape_item_flowchart(
2924        self,
2925        board_id: Annotated[
2926            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
2927        ],
2928        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
2929        shape_update_request: ShapeUpdateRequest,
2930        _request_timeout: Union[
2931            None,
2932            Annotated[StrictFloat, Field(gt=0)],
2933            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2934        ] = None,
2935        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2936        _content_type: Optional[StrictStr] = None,
2937        _headers: Optional[Dict[StrictStr, Any]] = None,
2938        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2939    ) -> ShapeItem:
2940        """Update shape item
2941
2942        Updates a flowchart shape item on a board based on the data and style properties provided in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
2943
2944        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
2945        :type board_id: str
2946        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
2947        :type item_id: str
2948        :param shape_update_request: (required)
2949        :type shape_update_request: ShapeUpdateRequest
2950        :param _request_timeout: timeout setting for this request. If one
2951                                 number provided, it will be total request
2952                                 timeout. It can also be a pair (tuple) of
2953                                 (connection, read) timeouts.
2954        :type _request_timeout: int, tuple(int, int), optional
2955        :param _request_auth: set to override the auth_settings for an a single
2956                              request; this effectively ignores the
2957                              authentication in the spec for a single request.
2958        :type _request_auth: dict, optional
2959        :param _content_type: force content-type for the request.
2960        :type _content_type: str, Optional
2961        :param _headers: set to override the headers for a single
2962                         request; this effectively ignores the headers
2963                         in the spec for a single request.
2964        :type _headers: dict, optional
2965        :param _host_index: set to override the host_index for a single
2966                            request; this effectively ignores the host_index
2967                            in the spec for a single request.
2968        :type _host_index: int, optional
2969        :return: Returns the result object.
2970        """  # noqa: E501
2971
2972        _param = self._update_shape_item_flowchart_serialize(
2973            board_id=board_id,
2974            item_id=item_id,
2975            shape_update_request=shape_update_request,
2976            _request_auth=_request_auth,
2977            _content_type=_content_type,
2978            _headers=_headers,
2979            _host_index=_host_index,
2980        )
2981
2982        _response_types_map: Dict[str, Optional[str]] = {
2983            "200": "ShapeItem",
2984            "400": "CreateFrameItem400Response",
2985            "404": "CreateFrameItem400Response",
2986            "429": "CreateFrameItem400Response",
2987        }
2988        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2989        response_data.read()
2990        return self.api_client.response_deserialize(
2991            response_data=response_data,
2992            response_types_map=_response_types_map,
2993        ).data

Update shape item

Updates a flowchart shape item on a board based on the data and style properties provided in the request body.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param shape_update_request: (required) :type shape_update_request: ShapeUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_all_cases( self, limit: typing.Annotated[int, FieldInfo(annotation=NoneType, required=True, description='The maximum number of items in the result list.', metadata=[Strict(strict=True), Ge(ge=1), Le(le=100)])], org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization for which you want to retrieve the list of cases.', metadata=[Strict(strict=True)])], cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. ')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.paginated_case_response.PaginatedCaseResponse: View Source

3058    @validate_call
3059    def get_all_cases(
3060        self,
3061        limit: Annotated[
3062            int, Field(le=100, strict=True, ge=1, description="The maximum number of items in the result list.")
3063        ],
3064        org_id: Annotated[
3065            str,
3066            Field(
3067                strict=True, description="The ID of the organization for which you want to retrieve the list of cases."
3068            ),
3069        ],
3070        cursor: Annotated[
3071            Optional[StrictStr],
3072            Field(
3073                description="An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. "
3074            ),
3075        ] = None,
3076        _request_timeout: Union[
3077            None,
3078            Annotated[StrictFloat, Field(gt=0)],
3079            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3080        ] = None,
3081        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3082        _content_type: Optional[StrictStr] = None,
3083        _headers: Optional[Dict[StrictStr, Any]] = None,
3084        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3085    ) -> PaginatedCaseResponse:
3086        """Get all cases
3087
3088        Retrieves the list of eDiscovery cases in an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organization:cases:management</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise Guard only</h3> <p>This API is available only for Enterprise plan users with the <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15699815402514-Enterprise-Guard-overview\">Enterprise Guard add-on</a>. You can only use this endpoint if you have both the Company Admin and <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15695755655954-Understand-admin-roles-and-their-privileges-Beta#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
3089
3090        :param limit: The maximum number of items in the result list. (required)
3091        :type limit: int
3092        :param org_id: The ID of the organization for which you want to retrieve the list of cases. (required)
3093        :type org_id: str
3094        :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.
3095        :type cursor: str
3096        :param _request_timeout: timeout setting for this request. If one
3097                                 number provided, it will be total request
3098                                 timeout. It can also be a pair (tuple) of
3099                                 (connection, read) timeouts.
3100        :type _request_timeout: int, tuple(int, int), optional
3101        :param _request_auth: set to override the auth_settings for an a single
3102                              request; this effectively ignores the
3103                              authentication in the spec for a single request.
3104        :type _request_auth: dict, optional
3105        :param _content_type: force content-type for the request.
3106        :type _content_type: str, Optional
3107        :param _headers: set to override the headers for a single
3108                         request; this effectively ignores the headers
3109                         in the spec for a single request.
3110        :type _headers: dict, optional
3111        :param _host_index: set to override the host_index for a single
3112                            request; this effectively ignores the host_index
3113                            in the spec for a single request.
3114        :type _host_index: int, optional
3115        :return: Returns the result object.
3116        """  # noqa: E501
3117
3118        _param = self._get_all_cases_serialize(
3119            limit=limit,
3120            org_id=org_id,
3121            cursor=cursor,
3122            _request_auth=_request_auth,
3123            _content_type=_content_type,
3124            _headers=_headers,
3125            _host_index=_host_index,
3126        )
3127
3128        _response_types_map: Dict[str, Optional[str]] = {
3129            "200": "PaginatedCaseResponse",
3130            "400": None,
3131            "401": None,
3132            "403": None,
3133            "404": None,
3134            "429": None,
3135        }
3136        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3137        response_data.read()
3138        return self.api_client.response_deserialize(
3139            response_data=response_data,
3140            response_types_map=_response_types_map,
3141        ).data

Get all cases

Retrieves the list of eDiscovery cases in an organization.

Required scope

Rate limiting

Enterprise Guard only

This API is available only for Enterprise plan users with the Enterprise Guard add-on. You can only use this endpoint if you have both the Company Admin and eDiscovery Admin roles.

:param limit: The maximum number of items in the result list. (required) :type limit: int :param org_id: The ID of the organization for which you want to retrieve the list of cases. (required) :type org_id: str :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_all_legal_holds( self, limit: typing.Annotated[int, FieldInfo(annotation=NoneType, required=True, description='The maximum number of items in the result list.', metadata=[Strict(strict=True), Ge(ge=1), Le(le=100)])], org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization for which you want to retrieve the list of legal holds within a case.', metadata=[Strict(strict=True)])], case_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the case for which you want to retrieve the list of legal holds.', metadata=[Strict(strict=True)])], cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. ')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.paginated_legal_hold_response.PaginatedLegalHoldResponse: View Source

3202    @validate_call
3203    def get_all_legal_holds(
3204        self,
3205        limit: Annotated[
3206            int, Field(le=100, strict=True, ge=1, description="The maximum number of items in the result list.")
3207        ],
3208        org_id: Annotated[
3209            str,
3210            Field(
3211                strict=True,
3212                description="The ID of the organization for which you want to retrieve the list of legal holds within a case.",
3213            ),
3214        ],
3215        case_id: Annotated[
3216            str,
3217            Field(
3218                strict=True, description="The ID of the case for which you want to retrieve the list of legal holds."
3219            ),
3220        ],
3221        cursor: Annotated[
3222            Optional[StrictStr],
3223            Field(
3224                description="An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. "
3225            ),
3226        ] = None,
3227        _request_timeout: Union[
3228            None,
3229            Annotated[StrictFloat, Field(gt=0)],
3230            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3231        ] = None,
3232        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3233        _content_type: Optional[StrictStr] = None,
3234        _headers: Optional[Dict[StrictStr, Any]] = None,
3235        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3236    ) -> PaginatedLegalHoldResponse:
3237        """Get all legal holds within a case
3238
3239        Retrieves the list of all legal holds within a case for an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organization:cases:management</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise Guard only</h3> <p>This API is available only for Enterprise plan users with the <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15699815402514-Enterprise-Guard-overview\">Enterprise Guard add-on</a>. You can only use this endpoint if you have both the Company Admin and <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15695755655954-Understand-admin-roles-and-their-privileges-Beta#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
3240
3241        :param limit: The maximum number of items in the result list. (required)
3242        :type limit: int
3243        :param org_id: The ID of the organization for which you want to retrieve the list of legal holds within a case. (required)
3244        :type org_id: str
3245        :param case_id: The ID of the case for which you want to retrieve the list of legal holds. (required)
3246        :type case_id: str
3247        :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.
3248        :type cursor: str
3249        :param _request_timeout: timeout setting for this request. If one
3250                                 number provided, it will be total request
3251                                 timeout. It can also be a pair (tuple) of
3252                                 (connection, read) timeouts.
3253        :type _request_timeout: int, tuple(int, int), optional
3254        :param _request_auth: set to override the auth_settings for an a single
3255                              request; this effectively ignores the
3256                              authentication in the spec for a single request.
3257        :type _request_auth: dict, optional
3258        :param _content_type: force content-type for the request.
3259        :type _content_type: str, Optional
3260        :param _headers: set to override the headers for a single
3261                         request; this effectively ignores the headers
3262                         in the spec for a single request.
3263        :type _headers: dict, optional
3264        :param _host_index: set to override the host_index for a single
3265                            request; this effectively ignores the host_index
3266                            in the spec for a single request.
3267        :type _host_index: int, optional
3268        :return: Returns the result object.
3269        """  # noqa: E501
3270
3271        _param = self._get_all_legal_holds_serialize(
3272            limit=limit,
3273            org_id=org_id,
3274            case_id=case_id,
3275            cursor=cursor,
3276            _request_auth=_request_auth,
3277            _content_type=_content_type,
3278            _headers=_headers,
3279            _host_index=_host_index,
3280        )
3281
3282        _response_types_map: Dict[str, Optional[str]] = {
3283            "200": "PaginatedLegalHoldResponse",
3284            "400": None,
3285            "401": None,
3286            "403": None,
3287            "404": None,
3288            "429": None,
3289        }
3290        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3291        response_data.read()
3292        return self.api_client.response_deserialize(
3293            response_data=response_data,
3294            response_types_map=_response_types_map,
3295        ).data

Get all legal holds within a case

Retrieves the list of all legal holds within a case for an organization.

Required scope

Rate limiting

Enterprise Guard only

This API is available only for Enterprise plan users with the Enterprise Guard add-on. You can only use this endpoint if you have both the Company Admin and eDiscovery Admin roles.

:param limit: The maximum number of items in the result list. (required) :type limit: int :param org_id: The ID of the organization for which you want to retrieve the list of legal holds within a case. (required) :type org_id: str :param case_id: The ID of the case for which you want to retrieve the list of legal holds. (required) :type case_id: str :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_case( self, org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization for which you want to retrieve the case information.', metadata=[Strict(strict=True)])], case_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the case you want to retrieve.', metadata=[Strict(strict=True)])], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.case_response.CaseResponse: View Source

3359    @validate_call
3360    def get_case(
3361        self,
3362        org_id: Annotated[
3363            str,
3364            Field(
3365                strict=True,
3366                description="The ID of the organization for which you want to retrieve the case information.",
3367            ),
3368        ],
3369        case_id: Annotated[str, Field(strict=True, description="The ID of the case you want to retrieve.")],
3370        _request_timeout: Union[
3371            None,
3372            Annotated[StrictFloat, Field(gt=0)],
3373            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3374        ] = None,
3375        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3376        _content_type: Optional[StrictStr] = None,
3377        _headers: Optional[Dict[StrictStr, Any]] = None,
3378        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3379    ) -> CaseResponse:
3380        """Get case
3381
3382        Retrieves information about a case in an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organization:cases:management</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a> <br/><h3>Enterprise Guard only</h3> <p>This API is available only for Enterprise plan users with the <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15699815402514-Enterprise-Guard-overview\">Enterprise Guard add-on</a>. You can only use this endpoint if you have both the Company Admin and <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15695755655954-Understand-admin-roles-and-their-privileges-Beta#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
3383
3384        :param org_id: The ID of the organization for which you want to retrieve the case information. (required)
3385        :type org_id: str
3386        :param case_id: The ID of the case you want to retrieve. (required)
3387        :type case_id: str
3388        :param _request_timeout: timeout setting for this request. If one
3389                                 number provided, it will be total request
3390                                 timeout. It can also be a pair (tuple) of
3391                                 (connection, read) timeouts.
3392        :type _request_timeout: int, tuple(int, int), optional
3393        :param _request_auth: set to override the auth_settings for an a single
3394                              request; this effectively ignores the
3395                              authentication in the spec for a single request.
3396        :type _request_auth: dict, optional
3397        :param _content_type: force content-type for the request.
3398        :type _content_type: str, Optional
3399        :param _headers: set to override the headers for a single
3400                         request; this effectively ignores the headers
3401                         in the spec for a single request.
3402        :type _headers: dict, optional
3403        :param _host_index: set to override the host_index for a single
3404                            request; this effectively ignores the host_index
3405                            in the spec for a single request.
3406        :type _host_index: int, optional
3407        :return: Returns the result object.
3408        """  # noqa: E501
3409
3410        _param = self._get_case_serialize(
3411            org_id=org_id,
3412            case_id=case_id,
3413            _request_auth=_request_auth,
3414            _content_type=_content_type,
3415            _headers=_headers,
3416            _host_index=_host_index,
3417        )
3418
3419        _response_types_map: Dict[str, Optional[str]] = {
3420            "200": "CaseResponse",
3421            "400": None,
3422            "401": None,
3423            "403": None,
3424            "404": None,
3425            "429": None,
3426        }
3427        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3428        response_data.read()
3429        return self.api_client.response_deserialize(
3430            response_data=response_data,
3431            response_types_map=_response_types_map,
3432        ).data

Get case

Retrieves information about a case in an organization.

Required scope

Rate limiting

Enterprise Guard only

This API is available only for Enterprise plan users with the Enterprise Guard add-on. You can only use this endpoint if you have both the Company Admin and eDiscovery Admin roles.

:param org_id: The ID of the organization for which you want to retrieve the case information. (required) :type org_id: str :param case_id: The ID of the case you want to retrieve. (required) :type case_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_legal_hold( self, org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization for which you want to retrieve the legal hold information.', metadata=[Strict(strict=True)])], case_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the case for which you want to retrieve the legal hold information.', metadata=[Strict(strict=True)])], legal_hold_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the legal hold you want to retrieve.', metadata=[Strict(strict=True)])], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.legal_hold_response.LegalHoldResponse: View Source

3486    @validate_call
3487    def get_legal_hold(
3488        self,
3489        org_id: Annotated[
3490            str,
3491            Field(
3492                strict=True,
3493                description="The ID of the organization for which you want to retrieve the legal hold information.",
3494            ),
3495        ],
3496        case_id: Annotated[
3497            str,
3498            Field(
3499                strict=True, description="The ID of the case for which you want to retrieve the legal hold information."
3500            ),
3501        ],
3502        legal_hold_id: Annotated[str, Field(strict=True, description="The ID of the legal hold you want to retrieve.")],
3503        _request_timeout: Union[
3504            None,
3505            Annotated[StrictFloat, Field(gt=0)],
3506            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3507        ] = None,
3508        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3509        _content_type: Optional[StrictStr] = None,
3510        _headers: Optional[Dict[StrictStr, Any]] = None,
3511        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3512    ) -> LegalHoldResponse:
3513        """Get legal hold information
3514
3515        Retrieves information about a legal hold within a case for an organization. <br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organization:cases:management</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a> <br/><h3>Enterprise Guard only</h3> <p>This API is available only for Enterprise plan users with the <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15699815402514-Enterprise-Guard-overview\">Enterprise Guard add-on</a>. You can only use this endpoint if you have both the Company Admin and <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15695755655954-Understand-admin-roles-and-their-privileges-Beta#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
3516
3517        :param org_id: The ID of the organization for which you want to retrieve the legal hold information. (required)
3518        :type org_id: str
3519        :param case_id: The ID of the case for which you want to retrieve the legal hold information. (required)
3520        :type case_id: str
3521        :param legal_hold_id: The ID of the legal hold you want to retrieve. (required)
3522        :type legal_hold_id: str
3523        :param _request_timeout: timeout setting for this request. If one
3524                                 number provided, it will be total request
3525                                 timeout. It can also be a pair (tuple) of
3526                                 (connection, read) timeouts.
3527        :type _request_timeout: int, tuple(int, int), optional
3528        :param _request_auth: set to override the auth_settings for an a single
3529                              request; this effectively ignores the
3530                              authentication in the spec for a single request.
3531        :type _request_auth: dict, optional
3532        :param _content_type: force content-type for the request.
3533        :type _content_type: str, Optional
3534        :param _headers: set to override the headers for a single
3535                         request; this effectively ignores the headers
3536                         in the spec for a single request.
3537        :type _headers: dict, optional
3538        :param _host_index: set to override the host_index for a single
3539                            request; this effectively ignores the host_index
3540                            in the spec for a single request.
3541        :type _host_index: int, optional
3542        :return: Returns the result object.
3543        """  # noqa: E501
3544
3545        _param = self._get_legal_hold_serialize(
3546            org_id=org_id,
3547            case_id=case_id,
3548            legal_hold_id=legal_hold_id,
3549            _request_auth=_request_auth,
3550            _content_type=_content_type,
3551            _headers=_headers,
3552            _host_index=_host_index,
3553        )
3554
3555        _response_types_map: Dict[str, Optional[str]] = {
3556            "200": "LegalHoldResponse",
3557            "400": None,
3558            "401": None,
3559            "403": None,
3560            "404": None,
3561            "429": None,
3562        }
3563        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3564        response_data.read()
3565        return self.api_client.response_deserialize(
3566            response_data=response_data,
3567            response_types_map=_response_types_map,
3568        ).data

Get legal hold information

Retrieves information about a legal hold within a case for an organization.

Required scope

Rate limiting

Enterprise Guard only

This API is available only for Enterprise plan users with the Enterprise Guard add-on. You can only use this endpoint if you have both the Company Admin and eDiscovery Admin roles.

:param org_id: The ID of the organization for which you want to retrieve the legal hold information. (required) :type org_id: str :param case_id: The ID of the case for which you want to retrieve the legal hold information. (required) :type case_id: str :param legal_hold_id: The ID of the legal hold you want to retrieve. (required) :type legal_hold_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_legal_hold_content_items( self, org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization for which you want to retrieve the list of content items under hold.', metadata=[Strict(strict=True)])], case_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the case for which you want to retrieve the list of content items under hold.', metadata=[Strict(strict=True)])], legal_hold_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the legal hold for which you want to retrieve the list of content items under hold.', metadata=[Strict(strict=True)])], limit: typing.Annotated[int, FieldInfo(annotation=NoneType, required=True, description='The maximum number of items in the result list.', metadata=[Strict(strict=True), Ge(ge=1), Le(le=100)])], cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. ')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.paginated_legal_hold_content_items_response.PaginatedLegalHoldContentItemsResponse: View Source

3625    @validate_call
3626    def get_legal_hold_content_items(
3627        self,
3628        org_id: Annotated[
3629            str,
3630            Field(
3631                strict=True,
3632                description="The ID of the organization for which you want to retrieve the list of content items under hold.",
3633            ),
3634        ],
3635        case_id: Annotated[
3636            str,
3637            Field(
3638                strict=True,
3639                description="The ID of the case for which you want to retrieve the list of content items under hold.",
3640            ),
3641        ],
3642        legal_hold_id: Annotated[
3643            str,
3644            Field(
3645                strict=True,
3646                description="The ID of the legal hold for which you want to retrieve the list of content items under hold.",
3647            ),
3648        ],
3649        limit: Annotated[
3650            int, Field(le=100, strict=True, ge=1, description="The maximum number of items in the result list.")
3651        ],
3652        cursor: Annotated[
3653            Optional[StrictStr],
3654            Field(
3655                description="An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. "
3656            ),
3657        ] = None,
3658        _request_timeout: Union[
3659            None,
3660            Annotated[StrictFloat, Field(gt=0)],
3661            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3662        ] = None,
3663        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3664        _content_type: Optional[StrictStr] = None,
3665        _headers: Optional[Dict[StrictStr, Any]] = None,
3666        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3667    ) -> PaginatedLegalHoldContentItemsResponse:
3668        """Get content items under legal hold
3669
3670        Once a legal hold is in place you can review or explore the preserved Miro boards to ensure that all relevant data is intact and ready for legal proceedings or investigations. For more information, see our <a href=\"https://help.miro.com/hc/en-us/articles/22120628583570-Review-boards-under-legal-hold\" target=_blank>Help Center page on reviewing boards under legal hold</a>. <br><br>This API lists all content items under a specific legal hold in a case for an organization. Please verify that the legal hold is in 'ACTIVE' state to guarantee that the legal hold has finished processing the full list of content items under hold. <br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organization:cases:management</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a> <br/><h3>Enterprise Guard only</h3> <p>This API is available only for Enterprise plan users with the <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15699815402514-Enterprise-Guard-overview\">Enterprise Guard add-on</a>. You can only use this endpoint if you have both the Company Admin and <a target=_blank href=\"https://help.miro.com/hc/en-us/articles/15695755655954-Understand-admin-roles-and-their-privileges-Beta#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
3671
3672        :param org_id: The ID of the organization for which you want to retrieve the list of content items under hold. (required)
3673        :type org_id: str
3674        :param case_id: The ID of the case for which you want to retrieve the list of content items under hold. (required)
3675        :type case_id: str
3676        :param legal_hold_id: The ID of the legal hold for which you want to retrieve the list of content items under hold. (required)
3677        :type legal_hold_id: str
3678        :param limit: The maximum number of items in the result list. (required)
3679        :type limit: int
3680        :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.
3681        :type cursor: str
3682        :param _request_timeout: timeout setting for this request. If one
3683                                 number provided, it will be total request
3684                                 timeout. It can also be a pair (tuple) of
3685                                 (connection, read) timeouts.
3686        :type _request_timeout: int, tuple(int, int), optional
3687        :param _request_auth: set to override the auth_settings for an a single
3688                              request; this effectively ignores the
3689                              authentication in the spec for a single request.
3690        :type _request_auth: dict, optional
3691        :param _content_type: force content-type for the request.
3692        :type _content_type: str, Optional
3693        :param _headers: set to override the headers for a single
3694                         request; this effectively ignores the headers
3695                         in the spec for a single request.
3696        :type _headers: dict, optional
3697        :param _host_index: set to override the host_index for a single
3698                            request; this effectively ignores the host_index
3699                            in the spec for a single request.
3700        :type _host_index: int, optional
3701        :return: Returns the result object.
3702        """  # noqa: E501
3703
3704        _param = self._get_legal_hold_content_items_serialize(
3705            org_id=org_id,
3706            case_id=case_id,
3707            legal_hold_id=legal_hold_id,
3708            limit=limit,
3709            cursor=cursor,
3710            _request_auth=_request_auth,
3711            _content_type=_content_type,
3712            _headers=_headers,
3713            _host_index=_host_index,
3714        )
3715
3716        _response_types_map: Dict[str, Optional[str]] = {
3717            "200": "PaginatedLegalHoldContentItemsResponse",
3718            "400": None,
3719            "401": None,
3720            "403": None,
3721            "404": None,
3722            "429": None,
3723        }
3724        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3725        response_data.read()
3726        return self.api_client.response_deserialize(
3727            response_data=response_data,
3728            response_types_map=_response_types_map,
3729        ).data

Get content items under legal hold

Once a legal hold is in place you can review or explore the preserved Miro boards to ensure that all relevant data is intact and ready for legal proceedings or investigations. For more information, see our Help Center page on reviewing boards under legal hold.

This API lists all content items under a specific legal hold in a case for an organization. Please verify that the legal hold is in 'ACTIVE' state to guarantee that the legal hold has finished processing the full list of content items under hold.

Required scope

Rate limiting

Enterprise Guard only

This API is available only for Enterprise plan users with the Enterprise Guard add-on. You can only use this endpoint if you have both the Company Admin and eDiscovery Admin roles.

:param org_id: The ID of the organization for which you want to retrieve the list of content items under hold. (required) :type org_id: str :param case_id: The ID of the case for which you want to retrieve the list of content items under hold. (required) :type case_id: str :param legal_hold_id: The ID of the legal hold for which you want to retrieve the list of content items under hold. (required) :type legal_hold_id: str :param limit: The maximum number of items in the result list. (required) :type limit: int :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_mindmap_nodes_experimental( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], mindmap_create_request: miro_api.models.mindmap_create_request.MindmapCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.mindmap_item.MindmapItem: View Source

3796    @validate_call
3797    def create_mindmap_nodes_experimental(
3798        self,
3799        board_id: Annotated[
3800            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
3801        ],
3802        mindmap_create_request: MindmapCreateRequest,
3803        _request_timeout: Union[
3804            None,
3805            Annotated[StrictFloat, Field(gt=0)],
3806            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3807        ] = None,
3808        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3809        _content_type: Optional[StrictStr] = None,
3810        _headers: Optional[Dict[StrictStr, Any]] = None,
3811        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3812    ) -> MindmapItem:
3813        """Create mind map node
3814
3815        Adds a mind map node to a board. A root node is the starting point of a mind map. A node that is created under a root node is a child node. For information on mind maps, use cases, mind map structure, and more, see the <a href=\"https://developers.miro.com/docs/mind-maps\" target=_blank>Mind Map Overview</a> page. <br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/><br/> <b>Known limitations on node placement: </b> Currently, the create API supports explicit positions for nodes. This means that users can only place nodes based on the x, y coordinates provided in the position parameters. If the position is not provided in the request, nodes default to coordinates x=0, y=0, effectively placing them at the center of the board. <br /><br /><b>Upcoming changes:</b> We understand the importance of flexibility in node placement. We are actively working on implementing changes to support positioning nodes relative to their parent node as well. This enhancement offers a more dynamic and intuitive mind mapping experience. <br /><br />Additionally, we are actively working on providing the update API, further enhancing the functionality of mind map APIs.
3816
3817        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
3818        :type board_id: str
3819        :param mindmap_create_request: (required)
3820        :type mindmap_create_request: MindmapCreateRequest
3821        :param _request_timeout: timeout setting for this request. If one
3822                                 number provided, it will be total request
3823                                 timeout. It can also be a pair (tuple) of
3824                                 (connection, read) timeouts.
3825        :type _request_timeout: int, tuple(int, int), optional
3826        :param _request_auth: set to override the auth_settings for an a single
3827                              request; this effectively ignores the
3828                              authentication in the spec for a single request.
3829        :type _request_auth: dict, optional
3830        :param _content_type: force content-type for the request.
3831        :type _content_type: str, Optional
3832        :param _headers: set to override the headers for a single
3833                         request; this effectively ignores the headers
3834                         in the spec for a single request.
3835        :type _headers: dict, optional
3836        :param _host_index: set to override the host_index for a single
3837                            request; this effectively ignores the host_index
3838                            in the spec for a single request.
3839        :type _host_index: int, optional
3840        :return: Returns the result object.
3841        """  # noqa: E501
3842
3843        _param = self._create_mindmap_nodes_experimental_serialize(
3844            board_id=board_id,
3845            mindmap_create_request=mindmap_create_request,
3846            _request_auth=_request_auth,
3847            _content_type=_content_type,
3848            _headers=_headers,
3849            _host_index=_host_index,
3850        )
3851
3852        _response_types_map: Dict[str, Optional[str]] = {
3853            "201": "MindmapItem",
3854            "400": "CreateFrameItem400Response",
3855            "404": "CreateFrameItem400Response",
3856            "429": "CreateFrameItem400Response",
3857        }
3858        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3859        response_data.read()
3860        return self.api_client.response_deserialize(
3861            response_data=response_data,
3862            response_types_map=_response_types_map,
3863        ).data

Create mind map node

Adds a mind map node to a board. A root node is the starting point of a mind map. A node that is created under a root node is a child node. For information on mind maps, use cases, mind map structure, and more, see the Mind Map Overview page.

Required scope

Rate limiting

Level 2

Known limitations on node placement: Currently, the create API supports explicit positions for nodes. This means that users can only place nodes based on the x, y coordinates provided in the position parameters. If the position is not provided in the request, nodes default to coordinates x=0, y=0, effectively placing them at the center of the board.

Upcoming changes: We understand the importance of flexibility in node placement. We are actively working on implementing changes to support positioning nodes relative to their parent node as well. This enhancement offers a more dynamic and intuitive mind mapping experience.

Additionally, we are actively working on providing the update API, further enhancing the functionality of mind map APIs.

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param mindmap_create_request: (required) :type mindmap_create_request: MindmapCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_mindmap_node_experimental( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the mind map node.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the mind map node that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

3925    @validate_call
3926    def delete_mindmap_node_experimental(
3927        self,
3928        board_id: Annotated[
3929            StrictStr,
3930            Field(description="Unique identifier (ID) of the board from which you want to delete the mind map node."),
3931        ],
3932        item_id: Annotated[
3933            StrictStr, Field(description="Unique identifier (ID) of the mind map node that you want to delete.")
3934        ],
3935        _request_timeout: Union[
3936            None,
3937            Annotated[StrictFloat, Field(gt=0)],
3938            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3939        ] = None,
3940        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3941        _content_type: Optional[StrictStr] = None,
3942        _headers: Optional[Dict[StrictStr, Any]] = None,
3943        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3944    ) -> object:
3945        """Delete mind map node
3946
3947        Deletes a mind map node item and its child nodes from the board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
3948
3949        :param board_id: Unique identifier (ID) of the board from which you want to delete the mind map node. (required)
3950        :type board_id: str
3951        :param item_id: Unique identifier (ID) of the mind map node that you want to delete. (required)
3952        :type item_id: str
3953        :param _request_timeout: timeout setting for this request. If one
3954                                 number provided, it will be total request
3955                                 timeout. It can also be a pair (tuple) of
3956                                 (connection, read) timeouts.
3957        :type _request_timeout: int, tuple(int, int), optional
3958        :param _request_auth: set to override the auth_settings for an a single
3959                              request; this effectively ignores the
3960                              authentication in the spec for a single request.
3961        :type _request_auth: dict, optional
3962        :param _content_type: force content-type for the request.
3963        :type _content_type: str, Optional
3964        :param _headers: set to override the headers for a single
3965                         request; this effectively ignores the headers
3966                         in the spec for a single request.
3967        :type _headers: dict, optional
3968        :param _host_index: set to override the host_index for a single
3969                            request; this effectively ignores the host_index
3970                            in the spec for a single request.
3971        :type _host_index: int, optional
3972        :return: Returns the result object.
3973        """  # noqa: E501
3974
3975        _param = self._delete_mindmap_node_experimental_serialize(
3976            board_id=board_id,
3977            item_id=item_id,
3978            _request_auth=_request_auth,
3979            _content_type=_content_type,
3980            _headers=_headers,
3981            _host_index=_host_index,
3982        )
3983
3984        _response_types_map: Dict[str, Optional[str]] = {
3985            "204": "object",
3986            "400": "CreateFrameItem400Response",
3987            "404": "CreateFrameItem400Response",
3988            "429": "CreateFrameItem400Response",
3989        }
3990        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3991        response_data.read()
3992        return self.api_client.response_deserialize(
3993            response_data=response_data,
3994            response_types_map=_response_types_map,
3995        ).data

Delete mind map node

Deletes a mind map node item and its child nodes from the board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the mind map node. (required) :type board_id: str :param item_id: Unique identifier (ID) of the mind map node that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_mindmap_node_experimental( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a mind map node.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the mind map node that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.mindmap_item.MindmapItem: View Source

4049    @validate_call
4050    def get_mindmap_node_experimental(
4051        self,
4052        board_id: Annotated[
4053            StrictStr,
4054            Field(description="Unique identifier (ID) of the board from which you want to retrieve a mind map node."),
4055        ],
4056        item_id: Annotated[
4057            StrictStr, Field(description="Unique identifier (ID) of the mind map node that you want to retrieve.")
4058        ],
4059        _request_timeout: Union[
4060            None,
4061            Annotated[StrictFloat, Field(gt=0)],
4062            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4063        ] = None,
4064        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4065        _content_type: Optional[StrictStr] = None,
4066        _headers: Optional[Dict[StrictStr, Any]] = None,
4067        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4068    ) -> MindmapItem:
4069        """Get specific mind map node
4070
4071        Retrieves information for a specific mind map node on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
4072
4073        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a mind map node. (required)
4074        :type board_id: str
4075        :param item_id: Unique identifier (ID) of the mind map node that you want to retrieve. (required)
4076        :type item_id: str
4077        :param _request_timeout: timeout setting for this request. If one
4078                                 number provided, it will be total request
4079                                 timeout. It can also be a pair (tuple) of
4080                                 (connection, read) timeouts.
4081        :type _request_timeout: int, tuple(int, int), optional
4082        :param _request_auth: set to override the auth_settings for an a single
4083                              request; this effectively ignores the
4084                              authentication in the spec for a single request.
4085        :type _request_auth: dict, optional
4086        :param _content_type: force content-type for the request.
4087        :type _content_type: str, Optional
4088        :param _headers: set to override the headers for a single
4089                         request; this effectively ignores the headers
4090                         in the spec for a single request.
4091        :type _headers: dict, optional
4092        :param _host_index: set to override the host_index for a single
4093                            request; this effectively ignores the host_index
4094                            in the spec for a single request.
4095        :type _host_index: int, optional
4096        :return: Returns the result object.
4097        """  # noqa: E501
4098
4099        _param = self._get_mindmap_node_experimental_serialize(
4100            board_id=board_id,
4101            item_id=item_id,
4102            _request_auth=_request_auth,
4103            _content_type=_content_type,
4104            _headers=_headers,
4105            _host_index=_host_index,
4106        )
4107
4108        _response_types_map: Dict[str, Optional[str]] = {
4109            "200": "MindmapItem",
4110        }
4111        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4112        response_data.read()
4113        return self.api_client.response_deserialize(
4114            response_data=response_data,
4115            response_types_map=_response_types_map,
4116        ).data

Get specific mind map node

Retrieves information for a specific mind map node on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a mind map node. (required) :type board_id: str :param item_id: Unique identifier (ID) of the mind map node that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_mindmap_nodes_experimental( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve mind map nodes.')], limit: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Maximum number of results returned')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Points to the next portion of the results set')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.mindmap_cursor_paged.MindmapCursorPaged: View Source

4170    @validate_call
4171    def get_mindmap_nodes_experimental(
4172        self,
4173        board_id: Annotated[
4174            StrictStr,
4175            Field(description="Unique identifier (ID) of the board from which you want to retrieve mind map nodes."),
4176        ],
4177        limit: Annotated[Optional[StrictStr], Field(description="Maximum number of results returned")] = None,
4178        cursor: Annotated[
4179            Optional[StrictStr], Field(description="Points to the next portion of the results set")
4180        ] = None,
4181        _request_timeout: Union[
4182            None,
4183            Annotated[StrictFloat, Field(gt=0)],
4184            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4185        ] = None,
4186        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4187        _content_type: Optional[StrictStr] = None,
4188        _headers: Optional[Dict[StrictStr, Any]] = None,
4189        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4190    ) -> MindmapCursorPaged:
4191        """Get mind map nodes
4192
4193        Retrieves a list of mind map nodes for a specific board.  This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the `cursor` parameter equal to the `cursor` value you received in the response of the previous request. For example, if you set the `limit` query parameter to `10` and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is `foo`. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to `foo`.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
4194
4195        :param board_id: Unique identifier (ID) of the board from which you want to retrieve mind map nodes. (required)
4196        :type board_id: str
4197        :param limit: Maximum number of results returned
4198        :type limit: str
4199        :param cursor: Points to the next portion of the results set
4200        :type cursor: str
4201        :param _request_timeout: timeout setting for this request. If one
4202                                 number provided, it will be total request
4203                                 timeout. It can also be a pair (tuple) of
4204                                 (connection, read) timeouts.
4205        :type _request_timeout: int, tuple(int, int), optional
4206        :param _request_auth: set to override the auth_settings for an a single
4207                              request; this effectively ignores the
4208                              authentication in the spec for a single request.
4209        :type _request_auth: dict, optional
4210        :param _content_type: force content-type for the request.
4211        :type _content_type: str, Optional
4212        :param _headers: set to override the headers for a single
4213                         request; this effectively ignores the headers
4214                         in the spec for a single request.
4215        :type _headers: dict, optional
4216        :param _host_index: set to override the host_index for a single
4217                            request; this effectively ignores the host_index
4218                            in the spec for a single request.
4219        :type _host_index: int, optional
4220        :return: Returns the result object.
4221        """  # noqa: E501
4222
4223        _param = self._get_mindmap_nodes_experimental_serialize(
4224            board_id=board_id,
4225            limit=limit,
4226            cursor=cursor,
4227            _request_auth=_request_auth,
4228            _content_type=_content_type,
4229            _headers=_headers,
4230            _host_index=_host_index,
4231        )
4232
4233        _response_types_map: Dict[str, Optional[str]] = {
4234            "200": "MindmapCursorPaged",
4235        }
4236        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4237        response_data.read()
4238        return self.api_client.response_deserialize(
4239            response_data=response_data,
4240            response_types_map=_response_types_map,
4241        ).data

Get mind map nodes

Retrieves a list of mind map nodes for a specific board. This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the cursor parameter equal to the cursor value you received in the response of the previous request. For example, if you set the limit query parameter to 10 and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is foo. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to foo.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve mind map nodes. (required) :type board_id: str :param limit: Maximum number of results returned :type limit: str :param cursor: Points to the next portion of the results set :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def revoke_token_v2( self, revoke_token_request: miro_api.models.revoke_token_request.RevokeTokenRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> None: View Source

4302    @validate_call
4303    def revoke_token_v2(
4304        self,
4305        revoke_token_request: RevokeTokenRequest,
4306        _request_timeout: Union[
4307            None,
4308            Annotated[StrictFloat, Field(gt=0)],
4309            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4310        ] = None,
4311        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4312        _content_type: Optional[StrictStr] = None,
4313        _headers: Optional[Dict[StrictStr, Any]] = None,
4314        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4315    ) -> None:
4316        """Revoke token (v2)
4317
4318        Revoke the current access token. Revoking an access token means that the access token will no longer work. When an access token is revoked, the refresh token is also revoked and no longer valid. This does not uninstall the application for the user.
4319
4320        :param revoke_token_request: (required)
4321        :type revoke_token_request: RevokeTokenRequest
4322        :param _request_timeout: timeout setting for this request. If one
4323                                 number provided, it will be total request
4324                                 timeout. It can also be a pair (tuple) of
4325                                 (connection, read) timeouts.
4326        :type _request_timeout: int, tuple(int, int), optional
4327        :param _request_auth: set to override the auth_settings for an a single
4328                              request; this effectively ignores the
4329                              authentication in the spec for a single request.
4330        :type _request_auth: dict, optional
4331        :param _content_type: force content-type for the request.
4332        :type _content_type: str, Optional
4333        :param _headers: set to override the headers for a single
4334                         request; this effectively ignores the headers
4335                         in the spec for a single request.
4336        :type _headers: dict, optional
4337        :param _host_index: set to override the host_index for a single
4338                            request; this effectively ignores the host_index
4339                            in the spec for a single request.
4340        :type _host_index: int, optional
4341        :return: Returns the result object.
4342        """  # noqa: E501
4343
4344        _param = self._revoke_token_v2_serialize(
4345            revoke_token_request=revoke_token_request,
4346            _request_auth=_request_auth,
4347            _content_type=_content_type,
4348            _headers=_headers,
4349            _host_index=_host_index,
4350        )
4351
4352        _response_types_map: Dict[str, Optional[str]] = {
4353            "204": None,
4354            "404": "ErrorResponse",
4355        }
4356        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4357        response_data.read()
4358        return self.api_client.response_deserialize(
4359            response_data=response_data,
4360            response_types_map=_response_types_map,
4361        ).data

Revoke token (v2)

Revoke the current access token. Revoking an access token means that the access token will no longer work. When an access token is revoked, the refresh token is also revoked and no longer valid. This does not uninstall the application for the user.

:param revoke_token_request: (required) :type revoke_token_request: RevokeTokenRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_organization_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization')], member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization member')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.organization_member.OrganizationMember: View Source

4420    @validate_call
4421    def enterprise_get_organization_member(
4422        self,
4423        org_id: Annotated[StrictStr, Field(description="id of the organization")],
4424        member_id: Annotated[StrictStr, Field(description="id of the organization member")],
4425        _request_timeout: Union[
4426            None,
4427            Annotated[StrictFloat, Field(gt=0)],
4428            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4429        ] = None,
4430        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4431        _content_type: Optional[StrictStr] = None,
4432        _headers: Optional[Dict[StrictStr, Any]] = None,
4433        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4434    ) -> OrganizationMember:
4435        """Get organization member
4436
4437        Retrieves organization member information for an existing organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
4438
4439        :param org_id: id of the organization (required)
4440        :type org_id: str
4441        :param member_id: id of the organization member (required)
4442        :type member_id: str
4443        :param _request_timeout: timeout setting for this request. If one
4444                                 number provided, it will be total request
4445                                 timeout. It can also be a pair (tuple) of
4446                                 (connection, read) timeouts.
4447        :type _request_timeout: int, tuple(int, int), optional
4448        :param _request_auth: set to override the auth_settings for an a single
4449                              request; this effectively ignores the
4450                              authentication in the spec for a single request.
4451        :type _request_auth: dict, optional
4452        :param _content_type: force content-type for the request.
4453        :type _content_type: str, Optional
4454        :param _headers: set to override the headers for a single
4455                         request; this effectively ignores the headers
4456                         in the spec for a single request.
4457        :type _headers: dict, optional
4458        :param _host_index: set to override the host_index for a single
4459                            request; this effectively ignores the host_index
4460                            in the spec for a single request.
4461        :type _host_index: int, optional
4462        :return: Returns the result object.
4463        """  # noqa: E501
4464
4465        _param = self._enterprise_get_organization_member_serialize(
4466            org_id=org_id,
4467            member_id=member_id,
4468            _request_auth=_request_auth,
4469            _content_type=_content_type,
4470            _headers=_headers,
4471            _host_index=_host_index,
4472        )
4473
4474        _response_types_map: Dict[str, Optional[str]] = {
4475            "200": "OrganizationMember",
4476            "400": None,
4477            "401": None,
4478            "403": None,
4479            "404": None,
4480            "409": None,
4481            "429": None,
4482        }
4483        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4484        response_data.read()
4485        return self.api_client.response_deserialize(
4486            response_data=response_data,
4487            response_types_map=_response_types_map,
4488        ).data

Get organization member

Retrieves organization member information for an existing organization.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: id of the organization (required) :type org_id: str :param member_id: id of the organization member (required) :type member_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_organization_members( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization')], emails: Optional[Annotated[str, Strict(strict=True)]] = None, role: Optional[Annotated[str, Strict(strict=True)]] = None, license: Optional[Annotated[str, Strict(strict=True)]] = None, active: Optional[Annotated[bool, Strict(strict=True)]] = None, cursor: Optional[Annotated[str, Strict(strict=True)]] = None, limit: Optional[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=1), Le(le=100)])]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.enterprise_get_organization_members200_response.EnterpriseGetOrganizationMembers200Response: View Source

4542    @validate_call
4543    def enterprise_get_organization_members(
4544        self,
4545        org_id: Annotated[StrictStr, Field(description="id of the organization")],
4546        emails: Optional[StrictStr] = None,
4547        role: Optional[StrictStr] = None,
4548        license: Optional[StrictStr] = None,
4549        active: Optional[StrictBool] = None,
4550        cursor: Optional[StrictStr] = None,
4551        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
4552        _request_timeout: Union[
4553            None,
4554            Annotated[StrictFloat, Field(gt=0)],
4555            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4556        ] = None,
4557        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4558        _content_type: Optional[StrictStr] = None,
4559        _headers: Optional[Dict[StrictStr, Any]] = None,
4560        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4561    ) -> EnterpriseGetOrganizationMembers200Response:
4562        """Get organization members
4563
4564        Retrieves organization members based on the organization ID and the cursor, or based on the user emails provided in the request.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
4565
4566        :param org_id: id of the organization (required)
4567        :type org_id: str
4568        :param emails:
4569        :type emails: str
4570        :param role:
4571        :type role: str
4572        :param license:
4573        :type license: str
4574        :param active:
4575        :type active: bool
4576        :param cursor:
4577        :type cursor: str
4578        :param limit:
4579        :type limit: int
4580        :param _request_timeout: timeout setting for this request. If one
4581                                 number provided, it will be total request
4582                                 timeout. It can also be a pair (tuple) of
4583                                 (connection, read) timeouts.
4584        :type _request_timeout: int, tuple(int, int), optional
4585        :param _request_auth: set to override the auth_settings for an a single
4586                              request; this effectively ignores the
4587                              authentication in the spec for a single request.
4588        :type _request_auth: dict, optional
4589        :param _content_type: force content-type for the request.
4590        :type _content_type: str, Optional
4591        :param _headers: set to override the headers for a single
4592                         request; this effectively ignores the headers
4593                         in the spec for a single request.
4594        :type _headers: dict, optional
4595        :param _host_index: set to override the host_index for a single
4596                            request; this effectively ignores the host_index
4597                            in the spec for a single request.
4598        :type _host_index: int, optional
4599        :return: Returns the result object.
4600        """  # noqa: E501
4601
4602        _param = self._enterprise_get_organization_members_serialize(
4603            org_id=org_id,
4604            emails=emails,
4605            role=role,
4606            license=license,
4607            active=active,
4608            cursor=cursor,
4609            limit=limit,
4610            _request_auth=_request_auth,
4611            _content_type=_content_type,
4612            _headers=_headers,
4613            _host_index=_host_index,
4614        )
4615
4616        _response_types_map: Dict[str, Optional[str]] = {
4617            "200": "EnterpriseGetOrganizationMembers200Response",
4618            "400": None,
4619            "401": None,
4620            "403": None,
4621            "404": None,
4622            "409": None,
4623            "429": None,
4624        }
4625        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4626        response_data.read()
4627        return self.api_client.response_deserialize(
4628            response_data=response_data,
4629            response_types_map=_response_types_map,
4630        ).data

Get organization members

Retrieves organization members based on the organization ID and the cursor, or based on the user emails provided in the request.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: id of the organization (required) :type org_id: str :param emails: :type emails: str :param role: :type role: str :param license: :type license: str :param active: :type active: bool :param cursor: :type cursor: str :param limit: :type limit: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_organization( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='id of the organization')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.organization.Organization: View Source

4711    @validate_call
4712    def enterprise_get_organization(
4713        self,
4714        org_id: Annotated[StrictStr, Field(description="id of the organization")],
4715        _request_timeout: Union[
4716            None,
4717            Annotated[StrictFloat, Field(gt=0)],
4718            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4719        ] = None,
4720        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4721        _content_type: Optional[StrictStr] = None,
4722        _headers: Optional[Dict[StrictStr, Any]] = None,
4723        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4724    ) -> Organization:
4725        """Get organization info
4726
4727        Retrieves organization information.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
4728
4729        :param org_id: id of the organization (required)
4730        :type org_id: str
4731        :param _request_timeout: timeout setting for this request. If one
4732                                 number provided, it will be total request
4733                                 timeout. It can also be a pair (tuple) of
4734                                 (connection, read) timeouts.
4735        :type _request_timeout: int, tuple(int, int), optional
4736        :param _request_auth: set to override the auth_settings for an a single
4737                              request; this effectively ignores the
4738                              authentication in the spec for a single request.
4739        :type _request_auth: dict, optional
4740        :param _content_type: force content-type for the request.
4741        :type _content_type: str, Optional
4742        :param _headers: set to override the headers for a single
4743                         request; this effectively ignores the headers
4744                         in the spec for a single request.
4745        :type _headers: dict, optional
4746        :param _host_index: set to override the host_index for a single
4747                            request; this effectively ignores the host_index
4748                            in the spec for a single request.
4749        :type _host_index: int, optional
4750        :return: Returns the result object.
4751        """  # noqa: E501
4752
4753        _param = self._enterprise_get_organization_serialize(
4754            org_id=org_id,
4755            _request_auth=_request_auth,
4756            _content_type=_content_type,
4757            _headers=_headers,
4758            _host_index=_host_index,
4759        )
4760
4761        _response_types_map: Dict[str, Optional[str]] = {
4762            "200": "Organization",
4763            "400": None,
4764            "401": None,
4765            "403": None,
4766            "404": None,
4767            "409": None,
4768            "429": None,
4769        }
4770        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4771        response_data.read()
4772        return self.api_client.response_deserialize(
4773            response_data=response_data,
4774            response_types_map=_response_types_map,
4775        ).data

Get organization info

Retrieves organization information.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: id of the organization (required) :type org_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_add_project_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization to which the project belongs.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team to which the project belongs.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to which you want to add a user.')], add_project_member_request: miro_api.models.add_project_member_request.AddProjectMemberRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project_member.ProjectMember: View Source

4826    @validate_call
4827    def enterprise_add_project_member(
4828        self,
4829        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
4830        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
4831        project_id: Annotated[StrictStr, Field(description="The ID of the project to which you want to add a user.")],
4832        add_project_member_request: AddProjectMemberRequest,
4833        _request_timeout: Union[
4834            None,
4835            Annotated[StrictFloat, Field(gt=0)],
4836            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4837        ] = None,
4838        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4839        _content_type: Optional[StrictStr] = None,
4840        _headers: Optional[Dict[StrictStr, Any]] = None,
4841        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4842    ) -> ProjectMember:
4843        """Add member in a project
4844
4845        Add a Miro user to a project.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
4846
4847        :param org_id: The ID of the organization to which the project belongs. (required)
4848        :type org_id: str
4849        :param team_id: The ID of the team to which the project belongs. (required)
4850        :type team_id: str
4851        :param project_id: The ID of the project to which you want to add a user. (required)
4852        :type project_id: str
4853        :param add_project_member_request: (required)
4854        :type add_project_member_request: AddProjectMemberRequest
4855        :param _request_timeout: timeout setting for this request. If one
4856                                 number provided, it will be total request
4857                                 timeout. It can also be a pair (tuple) of
4858                                 (connection, read) timeouts.
4859        :type _request_timeout: int, tuple(int, int), optional
4860        :param _request_auth: set to override the auth_settings for an a single
4861                              request; this effectively ignores the
4862                              authentication in the spec for a single request.
4863        :type _request_auth: dict, optional
4864        :param _content_type: force content-type for the request.
4865        :type _content_type: str, Optional
4866        :param _headers: set to override the headers for a single
4867                         request; this effectively ignores the headers
4868                         in the spec for a single request.
4869        :type _headers: dict, optional
4870        :param _host_index: set to override the host_index for a single
4871                            request; this effectively ignores the host_index
4872                            in the spec for a single request.
4873        :type _host_index: int, optional
4874        :return: Returns the result object.
4875        """  # noqa: E501
4876
4877        _param = self._enterprise_add_project_member_serialize(
4878            org_id=org_id,
4879            team_id=team_id,
4880            project_id=project_id,
4881            add_project_member_request=add_project_member_request,
4882            _request_auth=_request_auth,
4883            _content_type=_content_type,
4884            _headers=_headers,
4885            _host_index=_host_index,
4886        )
4887
4888        _response_types_map: Dict[str, Optional[str]] = {
4889            "201": "ProjectMember",
4890            "400": "Error400",
4891            "401": "Error401",
4892            "403": "Error403",
4893            "404": "Error404",
4894            "409": "Error409",
4895            "429": "Error429",
4896        }
4897        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4898        response_data.read()
4899        return self.api_client.response_deserialize(
4900            response_data=response_data,
4901            response_types_map=_response_types_map,
4902        ).data

Add member in a project

Add a Miro user to a project.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization to which the project belongs. (required) :type org_id: str :param team_id: The ID of the team to which the project belongs. (required) :type team_id: str :param project_id: The ID of the project to which you want to add a user. (required) :type project_id: str :param add_project_member_request: (required) :type add_project_member_request: AddProjectMemberRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_delete_project_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization to which the project belongs.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team to which the project belongs.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project from which you want to remove a member.')], member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the member that you want to remove from a project.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> None: View Source

4970    @validate_call
4971    def enterprise_delete_project_member(
4972        self,
4973        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
4974        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
4975        project_id: Annotated[
4976            StrictStr, Field(description="The ID of the project from which you want to remove a member.")
4977        ],
4978        member_id: Annotated[
4979            StrictStr, Field(description="The ID of the member that you want to remove from a project.")
4980        ],
4981        _request_timeout: Union[
4982            None,
4983            Annotated[StrictFloat, Field(gt=0)],
4984            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4985        ] = None,
4986        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4987        _content_type: Optional[StrictStr] = None,
4988        _headers: Optional[Dict[StrictStr, Any]] = None,
4989        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4990    ) -> None:
4991        """Remove project member
4992
4993        Remove a member from a project. The user remains in the team even after the member is removed from a project.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
4994
4995        :param org_id: The ID of the organization to which the project belongs. (required)
4996        :type org_id: str
4997        :param team_id: The ID of the team to which the project belongs. (required)
4998        :type team_id: str
4999        :param project_id: The ID of the project from which you want to remove a member. (required)
5000        :type project_id: str
5001        :param member_id: The ID of the member that you want to remove from a project. (required)
5002        :type member_id: str
5003        :param _request_timeout: timeout setting for this request. If one
5004                                 number provided, it will be total request
5005                                 timeout. It can also be a pair (tuple) of
5006                                 (connection, read) timeouts.
5007        :type _request_timeout: int, tuple(int, int), optional
5008        :param _request_auth: set to override the auth_settings for an a single
5009                              request; this effectively ignores the
5010                              authentication in the spec for a single request.
5011        :type _request_auth: dict, optional
5012        :param _content_type: force content-type for the request.
5013        :type _content_type: str, Optional
5014        :param _headers: set to override the headers for a single
5015                         request; this effectively ignores the headers
5016                         in the spec for a single request.
5017        :type _headers: dict, optional
5018        :param _host_index: set to override the host_index for a single
5019                            request; this effectively ignores the host_index
5020                            in the spec for a single request.
5021        :type _host_index: int, optional
5022        :return: Returns the result object.
5023        """  # noqa: E501
5024
5025        _param = self._enterprise_delete_project_member_serialize(
5026            org_id=org_id,
5027            team_id=team_id,
5028            project_id=project_id,
5029            member_id=member_id,
5030            _request_auth=_request_auth,
5031            _content_type=_content_type,
5032            _headers=_headers,
5033            _host_index=_host_index,
5034        )
5035
5036        _response_types_map: Dict[str, Optional[str]] = {
5037            "204": None,
5038            "400": "Error400",
5039            "401": "Error401",
5040            "403": "Error403",
5041            "404": "Error404",
5042            "409": "Error409",
5043            "429": "Error429",
5044        }
5045        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5046        response_data.read()
5047        return self.api_client.response_deserialize(
5048            response_data=response_data,
5049            response_types_map=_response_types_map,
5050        ).data

Remove project member

Remove a member from a project. The user remains in the team even after the member is removed from a project.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization to which the project belongs. (required) :type org_id: str :param team_id: The ID of the team to which the project belongs. (required) :type team_id: str :param project_id: The ID of the project from which you want to remove a member. (required) :type project_id: str :param member_id: The ID of the member that you want to remove from a project. (required) :type member_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_project_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization to which the project belongs.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team to which the project belongs.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project from which you want to retrieve specific member information.')], member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the member for which you want to retrieve information.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project_member.ProjectMember: View Source

5110    @validate_call
5111    def enterprise_get_project_member(
5112        self,
5113        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
5114        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
5115        project_id: Annotated[
5116            StrictStr,
5117            Field(description="The ID of the project from which you want to retrieve specific member information."),
5118        ],
5119        member_id: Annotated[
5120            StrictStr, Field(description="The ID of the member for which you want to retrieve information.")
5121        ],
5122        _request_timeout: Union[
5123            None,
5124            Annotated[StrictFloat, Field(gt=0)],
5125            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5126        ] = None,
5127        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5128        _content_type: Optional[StrictStr] = None,
5129        _headers: Optional[Dict[StrictStr, Any]] = None,
5130        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5131    ) -> ProjectMember:
5132        """Get project member
5133
5134        Retrieves information for a specific project member.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
5135
5136        :param org_id: The ID of the organization to which the project belongs. (required)
5137        :type org_id: str
5138        :param team_id: The ID of the team to which the project belongs. (required)
5139        :type team_id: str
5140        :param project_id: The ID of the project from which you want to retrieve specific member information. (required)
5141        :type project_id: str
5142        :param member_id: The ID of the member for which you want to retrieve information. (required)
5143        :type member_id: str
5144        :param _request_timeout: timeout setting for this request. If one
5145                                 number provided, it will be total request
5146                                 timeout. It can also be a pair (tuple) of
5147                                 (connection, read) timeouts.
5148        :type _request_timeout: int, tuple(int, int), optional
5149        :param _request_auth: set to override the auth_settings for an a single
5150                              request; this effectively ignores the
5151                              authentication in the spec for a single request.
5152        :type _request_auth: dict, optional
5153        :param _content_type: force content-type for the request.
5154        :type _content_type: str, Optional
5155        :param _headers: set to override the headers for a single
5156                         request; this effectively ignores the headers
5157                         in the spec for a single request.
5158        :type _headers: dict, optional
5159        :param _host_index: set to override the host_index for a single
5160                            request; this effectively ignores the host_index
5161                            in the spec for a single request.
5162        :type _host_index: int, optional
5163        :return: Returns the result object.
5164        """  # noqa: E501
5165
5166        _param = self._enterprise_get_project_member_serialize(
5167            org_id=org_id,
5168            team_id=team_id,
5169            project_id=project_id,
5170            member_id=member_id,
5171            _request_auth=_request_auth,
5172            _content_type=_content_type,
5173            _headers=_headers,
5174            _host_index=_host_index,
5175        )
5176
5177        _response_types_map: Dict[str, Optional[str]] = {
5178            "200": "ProjectMember",
5179            "400": "Error400",
5180            "401": "Error401",
5181            "403": "Error403",
5182            "404": "Error404",
5183            "409": "Error409",
5184            "429": "Error429",
5185        }
5186        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5187        response_data.read()
5188        return self.api_client.response_deserialize(
5189            response_data=response_data,
5190            response_types_map=_response_types_map,
5191        ).data

Get project member

Retrieves information for a specific project member.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization to which the project belongs. (required) :type org_id: str :param team_id: The ID of the team to which the project belongs. (required) :type team_id: str :param project_id: The ID of the project from which you want to retrieve specific member information. (required) :type project_id: str :param member_id: The ID of the member for which you want to retrieve information. (required) :type member_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_project_members( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization to which the project belongs.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team to which the project belongs.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project for which you want to retrieve the list of members.')], limit: Annotated[Optional[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=1), Le(le=100)])]], FieldInfo(annotation=NoneType, required=True, description='The maximum number of results to return per call. If the number of project members in the response is greater than the limit specified, the response returns the cursor parameter with a value.')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project_member_page.ProjectMemberPage: View Source

5251    @validate_call
5252    def enterprise_get_project_members(
5253        self,
5254        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
5255        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
5256        project_id: Annotated[
5257            StrictStr, Field(description="The ID of the project for which you want to retrieve the list of members.")
5258        ],
5259        limit: Annotated[
5260            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
5261            Field(
5262                description="The maximum number of results to return per call. If the number of project members in the response is greater than the limit specified, the response returns the cursor parameter with a value."
5263            ),
5264        ] = None,
5265        cursor: Annotated[
5266            Optional[StrictStr],
5267            Field(
5268                description="An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request."
5269            ),
5270        ] = None,
5271        _request_timeout: Union[
5272            None,
5273            Annotated[StrictFloat, Field(gt=0)],
5274            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5275        ] = None,
5276        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5277        _content_type: Optional[StrictStr] = None,
5278        _headers: Optional[Dict[StrictStr, Any]] = None,
5279        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5280    ) -> ProjectMemberPage:
5281        """List of project members
5282
5283        Retrieves the list of members for a specific project.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
5284
5285        :param org_id: The ID of the organization to which the project belongs. (required)
5286        :type org_id: str
5287        :param team_id: The ID of the team to which the project belongs. (required)
5288        :type team_id: str
5289        :param project_id: The ID of the project for which you want to retrieve the list of members. (required)
5290        :type project_id: str
5291        :param limit: The maximum number of results to return per call. If the number of project members in the response is greater than the limit specified, the response returns the cursor parameter with a value.
5292        :type limit: int
5293        :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.
5294        :type cursor: str
5295        :param _request_timeout: timeout setting for this request. If one
5296                                 number provided, it will be total request
5297                                 timeout. It can also be a pair (tuple) of
5298                                 (connection, read) timeouts.
5299        :type _request_timeout: int, tuple(int, int), optional
5300        :param _request_auth: set to override the auth_settings for an a single
5301                              request; this effectively ignores the
5302                              authentication in the spec for a single request.
5303        :type _request_auth: dict, optional
5304        :param _content_type: force content-type for the request.
5305        :type _content_type: str, Optional
5306        :param _headers: set to override the headers for a single
5307                         request; this effectively ignores the headers
5308                         in the spec for a single request.
5309        :type _headers: dict, optional
5310        :param _host_index: set to override the host_index for a single
5311                            request; this effectively ignores the host_index
5312                            in the spec for a single request.
5313        :type _host_index: int, optional
5314        :return: Returns the result object.
5315        """  # noqa: E501
5316
5317        _param = self._enterprise_get_project_members_serialize(
5318            org_id=org_id,
5319            team_id=team_id,
5320            project_id=project_id,
5321            limit=limit,
5322            cursor=cursor,
5323            _request_auth=_request_auth,
5324            _content_type=_content_type,
5325            _headers=_headers,
5326            _host_index=_host_index,
5327        )
5328
5329        _response_types_map: Dict[str, Optional[str]] = {
5330            "200": "ProjectMemberPage",
5331            "400": "Error400",
5332            "401": "Error401",
5333            "403": "Error403",
5334            "404": "Error404",
5335            "409": "Error409",
5336            "429": "Error429",
5337        }
5338        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5339        response_data.read()
5340        return self.api_client.response_deserialize(
5341            response_data=response_data,
5342            response_types_map=_response_types_map,
5343        ).data

List of project members

Retrieves the list of members for a specific project.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization to which the project belongs. (required) :type org_id: str :param team_id: The ID of the team to which the project belongs. (required) :type team_id: str :param project_id: The ID of the project for which you want to retrieve the list of members. (required) :type project_id: str :param limit: The maximum number of results to return per call. If the number of project members in the response is greater than the limit specified, the response returns the cursor parameter with a value. :type limit: int :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_update_project_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization to which the project member belongs.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team to which the project member belongs.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a Project.')], member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the member whose details you want to update.')], update_project_member_request: miro_api.models.update_project_member_request.UpdateProjectMemberRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project_member.ProjectMember: View Source

5410    @validate_call
5411    def enterprise_update_project_member(
5412        self,
5413        org_id: Annotated[
5414            StrictStr, Field(description="The ID of the organization to which the project member belongs.")
5415        ],
5416        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project member belongs.")],
5417        project_id: Annotated[StrictStr, Field(description="The ID of a Project.")],
5418        member_id: Annotated[StrictStr, Field(description="The ID of the member whose details you want to update.")],
5419        update_project_member_request: UpdateProjectMemberRequest,
5420        _request_timeout: Union[
5421            None,
5422            Annotated[StrictFloat, Field(gt=0)],
5423            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5424        ] = None,
5425        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5426        _content_type: Optional[StrictStr] = None,
5427        _headers: Optional[Dict[StrictStr, Any]] = None,
5428        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5429    ) -> ProjectMember:
5430        """Update project member
5431
5432        Updates details of a project member, such as the member's role.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
5433
5434        :param org_id: The ID of the organization to which the project member belongs. (required)
5435        :type org_id: str
5436        :param team_id: The ID of the team to which the project member belongs. (required)
5437        :type team_id: str
5438        :param project_id: The ID of a Project. (required)
5439        :type project_id: str
5440        :param member_id: The ID of the member whose details you want to update. (required)
5441        :type member_id: str
5442        :param update_project_member_request: (required)
5443        :type update_project_member_request: UpdateProjectMemberRequest
5444        :param _request_timeout: timeout setting for this request. If one
5445                                 number provided, it will be total request
5446                                 timeout. It can also be a pair (tuple) of
5447                                 (connection, read) timeouts.
5448        :type _request_timeout: int, tuple(int, int), optional
5449        :param _request_auth: set to override the auth_settings for an a single
5450                              request; this effectively ignores the
5451                              authentication in the spec for a single request.
5452        :type _request_auth: dict, optional
5453        :param _content_type: force content-type for the request.
5454        :type _content_type: str, Optional
5455        :param _headers: set to override the headers for a single
5456                         request; this effectively ignores the headers
5457                         in the spec for a single request.
5458        :type _headers: dict, optional
5459        :param _host_index: set to override the host_index for a single
5460                            request; this effectively ignores the host_index
5461                            in the spec for a single request.
5462        :type _host_index: int, optional
5463        :return: Returns the result object.
5464        """  # noqa: E501
5465
5466        _param = self._enterprise_update_project_member_serialize(
5467            org_id=org_id,
5468            team_id=team_id,
5469            project_id=project_id,
5470            member_id=member_id,
5471            update_project_member_request=update_project_member_request,
5472            _request_auth=_request_auth,
5473            _content_type=_content_type,
5474            _headers=_headers,
5475            _host_index=_host_index,
5476        )
5477
5478        _response_types_map: Dict[str, Optional[str]] = {
5479            "200": "ProjectMember",
5480            "400": "Error400",
5481            "401": "Error401",
5482            "403": "Error403",
5483            "404": "Error404",
5484            "409": "Error409",
5485            "429": "Error429",
5486        }
5487        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5488        response_data.read()
5489        return self.api_client.response_deserialize(
5490            response_data=response_data,
5491            response_types_map=_response_types_map,
5492        ).data

Update project member

Updates details of a project member, such as the member's role.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization to which the project member belongs. (required) :type org_id: str :param team_id: The ID of the team to which the project member belongs. (required) :type team_id: str :param project_id: The ID of a Project. (required) :type project_id: str :param member_id: The ID of the member whose details you want to update. (required) :type member_id: str :param update_project_member_request: (required) :type update_project_member_request: UpdateProjectMemberRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_project_settings( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization to which the project belongs.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team to which the project belongs.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project for which you want to retrieve the project settings.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project_settings.ProjectSettings: View Source

5563    @validate_call
5564    def enterprise_get_project_settings(
5565        self,
5566        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
5567        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
5568        project_id: Annotated[
5569            StrictStr, Field(description="The ID of the project for which you want to retrieve the project settings.")
5570        ],
5571        _request_timeout: Union[
5572            None,
5573            Annotated[StrictFloat, Field(gt=0)],
5574            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5575        ] = None,
5576        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5577        _content_type: Optional[StrictStr] = None,
5578        _headers: Optional[Dict[StrictStr, Any]] = None,
5579        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5580    ) -> ProjectSettings:
5581        """Get project settings
5582
5583        Retrieves the project settings.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
5584
5585        :param org_id: The ID of the organization to which the project belongs. (required)
5586        :type org_id: str
5587        :param team_id: The ID of the team to which the project belongs. (required)
5588        :type team_id: str
5589        :param project_id: The ID of the project for which you want to retrieve the project settings. (required)
5590        :type project_id: str
5591        :param _request_timeout: timeout setting for this request. If one
5592                                 number provided, it will be total request
5593                                 timeout. It can also be a pair (tuple) of
5594                                 (connection, read) timeouts.
5595        :type _request_timeout: int, tuple(int, int), optional
5596        :param _request_auth: set to override the auth_settings for an a single
5597                              request; this effectively ignores the
5598                              authentication in the spec for a single request.
5599        :type _request_auth: dict, optional
5600        :param _content_type: force content-type for the request.
5601        :type _content_type: str, Optional
5602        :param _headers: set to override the headers for a single
5603                         request; this effectively ignores the headers
5604                         in the spec for a single request.
5605        :type _headers: dict, optional
5606        :param _host_index: set to override the host_index for a single
5607                            request; this effectively ignores the host_index
5608                            in the spec for a single request.
5609        :type _host_index: int, optional
5610        :return: Returns the result object.
5611        """  # noqa: E501
5612
5613        _param = self._enterprise_get_project_settings_serialize(
5614            org_id=org_id,
5615            team_id=team_id,
5616            project_id=project_id,
5617            _request_auth=_request_auth,
5618            _content_type=_content_type,
5619            _headers=_headers,
5620            _host_index=_host_index,
5621        )
5622
5623        _response_types_map: Dict[str, Optional[str]] = {
5624            "200": "ProjectSettings",
5625            "400": "Error400",
5626            "401": "Error401",
5627            "403": "Error403",
5628            "404": "Error404",
5629            "429": "Error429",
5630        }
5631        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5632        response_data.read()
5633        return self.api_client.response_deserialize(
5634            response_data=response_data,
5635            response_types_map=_response_types_map,
5636        ).data

Get project settings

Retrieves the project settings.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization to which the project belongs. (required) :type org_id: str :param team_id: The ID of the team to which the project belongs. (required) :type team_id: str :param project_id: The ID of the project for which you want to retrieve the project settings. (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_update_project_settings( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization to which the project belongs.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team to which the project belongs.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project whose settings you want to update.')], update_project_settings_request: miro_api.models.update_project_settings_request.UpdateProjectSettingsRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project_settings.ProjectSettings: View Source

5693    @validate_call
5694    def enterprise_update_project_settings(
5695        self,
5696        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
5697        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
5698        project_id: Annotated[StrictStr, Field(description="The ID of the project whose settings you want to update.")],
5699        update_project_settings_request: UpdateProjectSettingsRequest,
5700        _request_timeout: Union[
5701            None,
5702            Annotated[StrictFloat, Field(gt=0)],
5703            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5704        ] = None,
5705        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5706        _content_type: Optional[StrictStr] = None,
5707        _headers: Optional[Dict[StrictStr, Any]] = None,
5708        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5709    ) -> ProjectSettings:
5710        """Update project settings
5711
5712        Updates the settings of a project.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
5713
5714        :param org_id: The ID of the organization to which the project belongs. (required)
5715        :type org_id: str
5716        :param team_id: The ID of the team to which the project belongs. (required)
5717        :type team_id: str
5718        :param project_id: The ID of the project whose settings you want to update. (required)
5719        :type project_id: str
5720        :param update_project_settings_request: (required)
5721        :type update_project_settings_request: UpdateProjectSettingsRequest
5722        :param _request_timeout: timeout setting for this request. If one
5723                                 number provided, it will be total request
5724                                 timeout. It can also be a pair (tuple) of
5725                                 (connection, read) timeouts.
5726        :type _request_timeout: int, tuple(int, int), optional
5727        :param _request_auth: set to override the auth_settings for an a single
5728                              request; this effectively ignores the
5729                              authentication in the spec for a single request.
5730        :type _request_auth: dict, optional
5731        :param _content_type: force content-type for the request.
5732        :type _content_type: str, Optional
5733        :param _headers: set to override the headers for a single
5734                         request; this effectively ignores the headers
5735                         in the spec for a single request.
5736        :type _headers: dict, optional
5737        :param _host_index: set to override the host_index for a single
5738                            request; this effectively ignores the host_index
5739                            in the spec for a single request.
5740        :type _host_index: int, optional
5741        :return: Returns the result object.
5742        """  # noqa: E501
5743
5744        _param = self._enterprise_update_project_settings_serialize(
5745            org_id=org_id,
5746            team_id=team_id,
5747            project_id=project_id,
5748            update_project_settings_request=update_project_settings_request,
5749            _request_auth=_request_auth,
5750            _content_type=_content_type,
5751            _headers=_headers,
5752            _host_index=_host_index,
5753        )
5754
5755        _response_types_map: Dict[str, Optional[str]] = {
5756            "200": "ProjectSettings",
5757            "400": "Error400",
5758            "401": "Error401",
5759            "403": "Error403",
5760            "404": "Error404",
5761            "409": "Error409",
5762            "429": "Error429",
5763        }
5764        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5765        response_data.read()
5766        return self.api_client.response_deserialize(
5767            response_data=response_data,
5768            response_types_map=_response_types_map,
5769        ).data

Update project settings

Updates the settings of a project.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization to which the project belongs. (required) :type org_id: str :param team_id: The ID of the team to which the project belongs. (required) :type team_id: str :param project_id: The ID of the project whose settings you want to update. (required) :type project_id: str :param update_project_settings_request: (required) :type update_project_settings_request: UpdateProjectSettingsRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_create_project( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization within which you you want to create a project.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team within which you you want to create a project.')], create_project_request: miro_api.models.create_project_request.CreateProjectRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project.Project: View Source

5837    @validate_call
5838    def enterprise_create_project(
5839        self,
5840        org_id: Annotated[
5841            StrictStr, Field(description="The ID of the organization within which you you want to create a project.")
5842        ],
5843        team_id: Annotated[
5844            StrictStr, Field(description="The ID of the team within which you you want to create a project.")
5845        ],
5846        create_project_request: CreateProjectRequest,
5847        _request_timeout: Union[
5848            None,
5849            Annotated[StrictFloat, Field(gt=0)],
5850            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5851        ] = None,
5852        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5853        _content_type: Optional[StrictStr] = None,
5854        _headers: Optional[Dict[StrictStr, Any]] = None,
5855        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5856    ) -> Project:
5857        """Create project
5858
5859        Projects are essentially folders of boards with the option to manage user access for a smaller group of people within a team. Projects are here to help you organize your boards and make them easier to find and share. In other words, a project is a group of boards that you can share with your teammates all at once. For more information, see our <a href=\"https://help.miro.com/hc/en-us/articles/360018262033-Projects\" target=_blank>Help Center page on Projects</a>. <br><br>This API creates a new project in an existing team of an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
5860
5861        :param org_id: The ID of the organization within which you you want to create a project. (required)
5862        :type org_id: str
5863        :param team_id: The ID of the team within which you you want to create a project. (required)
5864        :type team_id: str
5865        :param create_project_request: (required)
5866        :type create_project_request: CreateProjectRequest
5867        :param _request_timeout: timeout setting for this request. If one
5868                                 number provided, it will be total request
5869                                 timeout. It can also be a pair (tuple) of
5870                                 (connection, read) timeouts.
5871        :type _request_timeout: int, tuple(int, int), optional
5872        :param _request_auth: set to override the auth_settings for an a single
5873                              request; this effectively ignores the
5874                              authentication in the spec for a single request.
5875        :type _request_auth: dict, optional
5876        :param _content_type: force content-type for the request.
5877        :type _content_type: str, Optional
5878        :param _headers: set to override the headers for a single
5879                         request; this effectively ignores the headers
5880                         in the spec for a single request.
5881        :type _headers: dict, optional
5882        :param _host_index: set to override the host_index for a single
5883                            request; this effectively ignores the host_index
5884                            in the spec for a single request.
5885        :type _host_index: int, optional
5886        :return: Returns the result object.
5887        """  # noqa: E501
5888
5889        _param = self._enterprise_create_project_serialize(
5890            org_id=org_id,
5891            team_id=team_id,
5892            create_project_request=create_project_request,
5893            _request_auth=_request_auth,
5894            _content_type=_content_type,
5895            _headers=_headers,
5896            _host_index=_host_index,
5897        )
5898
5899        _response_types_map: Dict[str, Optional[str]] = {
5900            "201": "Project",
5901            "400": "Error400",
5902            "401": "Error401",
5903            "403": "Error403",
5904            "404": "Error404",
5905            "409": "Error409",
5906            "429": "Error429",
5907        }
5908        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5909        response_data.read()
5910        return self.api_client.response_deserialize(
5911            response_data=response_data,
5912            response_types_map=_response_types_map,
5913        ).data

Create project

Projects are essentially folders of boards with the option to manage user access for a smaller group of people within a team. Projects are here to help you organize your boards and make them easier to find and share. In other words, a project is a group of boards that you can share with your teammates all at once. For more information, see our Help Center page on Projects.

This API creates a new project in an existing team of an organization.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization within which you you want to create a project. (required) :type org_id: str :param team_id: The ID of the team within which you you want to create a project. (required) :type team_id: str :param create_project_request: (required) :type create_project_request: CreateProjectRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_delete_project( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization from which you want to delete a project.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team from which you want to delete a project.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> None: View Source

5978    @validate_call
5979    def enterprise_delete_project(
5980        self,
5981        org_id: Annotated[
5982            StrictStr, Field(description="The ID of the organization from which you want to delete a project.")
5983        ],
5984        team_id: Annotated[StrictStr, Field(description="The ID of the team from which you want to delete a project.")],
5985        project_id: Annotated[StrictStr, Field(description="The ID of the project that you want to delete.")],
5986        _request_timeout: Union[
5987            None,
5988            Annotated[StrictFloat, Field(gt=0)],
5989            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5990        ] = None,
5991        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5992        _content_type: Optional[StrictStr] = None,
5993        _headers: Optional[Dict[StrictStr, Any]] = None,
5994        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5995    ) -> None:
5996        """Delete project
5997
5998        Deletes a project. After a project is deleted, all boards and users that belong to the project remain in the team.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
5999
6000        :param org_id: The ID of the organization from which you want to delete a project. (required)
6001        :type org_id: str
6002        :param team_id: The ID of the team from which you want to delete a project. (required)
6003        :type team_id: str
6004        :param project_id: The ID of the project that you want to delete. (required)
6005        :type project_id: str
6006        :param _request_timeout: timeout setting for this request. If one
6007                                 number provided, it will be total request
6008                                 timeout. It can also be a pair (tuple) of
6009                                 (connection, read) timeouts.
6010        :type _request_timeout: int, tuple(int, int), optional
6011        :param _request_auth: set to override the auth_settings for an a single
6012                              request; this effectively ignores the
6013                              authentication in the spec for a single request.
6014        :type _request_auth: dict, optional
6015        :param _content_type: force content-type for the request.
6016        :type _content_type: str, Optional
6017        :param _headers: set to override the headers for a single
6018                         request; this effectively ignores the headers
6019                         in the spec for a single request.
6020        :type _headers: dict, optional
6021        :param _host_index: set to override the host_index for a single
6022                            request; this effectively ignores the host_index
6023                            in the spec for a single request.
6024        :type _host_index: int, optional
6025        :return: Returns the result object.
6026        """  # noqa: E501
6027
6028        _param = self._enterprise_delete_project_serialize(
6029            org_id=org_id,
6030            team_id=team_id,
6031            project_id=project_id,
6032            _request_auth=_request_auth,
6033            _content_type=_content_type,
6034            _headers=_headers,
6035            _host_index=_host_index,
6036        )
6037
6038        _response_types_map: Dict[str, Optional[str]] = {
6039            "204": None,
6040            "400": "Error400",
6041            "401": "Error401",
6042            "403": "Error403",
6043            "404": "Error404",
6044            "409": "Error409",
6045            "429": "Error429",
6046        }
6047        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6048        response_data.read()
6049        return self.api_client.response_deserialize(
6050            response_data=response_data,
6051            response_types_map=_response_types_map,
6052        ).data

Delete project

Deletes a project. After a project is deleted, all boards and users that belong to the project remain in the team.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization from which you want to delete a project. (required) :type org_id: str :param team_id: The ID of the team from which you want to delete a project. (required) :type team_id: str :param project_id: The ID of the project that you want to delete. (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_project( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization from which you want to retrieve the project information.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team from which you want to retrieve the project information.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project for which you want to retrieve the information.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project.Project: View Source

6109    @validate_call
6110    def enterprise_get_project(
6111        self,
6112        org_id: Annotated[
6113            StrictStr,
6114            Field(description="The ID of the organization from which you want to retrieve the project information."),
6115        ],
6116        team_id: Annotated[
6117            StrictStr, Field(description="The ID of the team from which you want to retrieve the project information.")
6118        ],
6119        project_id: Annotated[
6120            StrictStr, Field(description="The ID of the project for which you want to retrieve the information.")
6121        ],
6122        _request_timeout: Union[
6123            None,
6124            Annotated[StrictFloat, Field(gt=0)],
6125            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6126        ] = None,
6127        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6128        _content_type: Optional[StrictStr] = None,
6129        _headers: Optional[Dict[StrictStr, Any]] = None,
6130        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6131    ) -> Project:
6132        """Get project
6133
6134        Retrieves project information, such as a name for an existing project.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
6135
6136        :param org_id: The ID of the organization from which you want to retrieve the project information. (required)
6137        :type org_id: str
6138        :param team_id: The ID of the team from which you want to retrieve the project information. (required)
6139        :type team_id: str
6140        :param project_id: The ID of the project for which you want to retrieve the information. (required)
6141        :type project_id: str
6142        :param _request_timeout: timeout setting for this request. If one
6143                                 number provided, it will be total request
6144                                 timeout. It can also be a pair (tuple) of
6145                                 (connection, read) timeouts.
6146        :type _request_timeout: int, tuple(int, int), optional
6147        :param _request_auth: set to override the auth_settings for an a single
6148                              request; this effectively ignores the
6149                              authentication in the spec for a single request.
6150        :type _request_auth: dict, optional
6151        :param _content_type: force content-type for the request.
6152        :type _content_type: str, Optional
6153        :param _headers: set to override the headers for a single
6154                         request; this effectively ignores the headers
6155                         in the spec for a single request.
6156        :type _headers: dict, optional
6157        :param _host_index: set to override the host_index for a single
6158                            request; this effectively ignores the host_index
6159                            in the spec for a single request.
6160        :type _host_index: int, optional
6161        :return: Returns the result object.
6162        """  # noqa: E501
6163
6164        _param = self._enterprise_get_project_serialize(
6165            org_id=org_id,
6166            team_id=team_id,
6167            project_id=project_id,
6168            _request_auth=_request_auth,
6169            _content_type=_content_type,
6170            _headers=_headers,
6171            _host_index=_host_index,
6172        )
6173
6174        _response_types_map: Dict[str, Optional[str]] = {
6175            "200": "Project",
6176            "400": "Error400",
6177            "401": "Error401",
6178            "403": "Error403",
6179            "404": "Error404",
6180            "429": "Error429",
6181        }
6182        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6183        response_data.read()
6184        return self.api_client.response_deserialize(
6185            response_data=response_data,
6186            response_types_map=_response_types_map,
6187        ).data

Get project

Retrieves project information, such as a name for an existing project.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization from which you want to retrieve the project information. (required) :type org_id: str :param team_id: The ID of the team from which you want to retrieve the project information. (required) :type team_id: str :param project_id: The ID of the project for which you want to retrieve the information. (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_projects( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the organization from which you want to retrieve the list of available projects.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the team from which you want to retrieve the list of available projects.')], limit: Annotated[Optional[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=1), Le(le=100)])]], FieldInfo(annotation=NoneType, required=True, description='The maximum number of results to return per call. If the number of projects in the response is greater than the limit specified, the response returns the cursor parameter with a value.')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project_page.ProjectPage: View Source

6244    @validate_call
6245    def enterprise_get_projects(
6246        self,
6247        org_id: Annotated[
6248            StrictStr,
6249            Field(
6250                description="The ID of the organization from which you want to retrieve the list of available projects."
6251            ),
6252        ],
6253        team_id: Annotated[
6254            StrictStr,
6255            Field(description="The ID of the team from which you want to retrieve the list of available projects."),
6256        ],
6257        limit: Annotated[
6258            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
6259            Field(
6260                description="The maximum number of results to return per call. If the number of projects in the response is greater than the limit specified, the response returns the cursor parameter with a value."
6261            ),
6262        ] = None,
6263        cursor: Annotated[
6264            Optional[StrictStr],
6265            Field(
6266                description="An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request."
6267            ),
6268        ] = None,
6269        _request_timeout: Union[
6270            None,
6271            Annotated[StrictFloat, Field(gt=0)],
6272            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6273        ] = None,
6274        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6275        _content_type: Optional[StrictStr] = None,
6276        _headers: Optional[Dict[StrictStr, Any]] = None,
6277        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6278    ) -> ProjectPage:
6279        """List of projects
6280
6281        Retrieves the list of projects in an existing team of an organization. You can retrieve all projects, including all private projects (projects that haven't been specifically shared with you) by enabling Content Admin permissions. To enable Content Admin permissions, see [Content Admin permissions for Company Admins](https://help.miro.com/hc/en-us/articles/360012777280-Content-Admin-permissions-for-Company-Admins).<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
6282
6283        :param org_id: The ID of the organization from which you want to retrieve the list of available projects. (required)
6284        :type org_id: str
6285        :param team_id: The ID of the team from which you want to retrieve the list of available projects. (required)
6286        :type team_id: str
6287        :param limit: The maximum number of results to return per call. If the number of projects in the response is greater than the limit specified, the response returns the cursor parameter with a value.
6288        :type limit: int
6289        :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.
6290        :type cursor: str
6291        :param _request_timeout: timeout setting for this request. If one
6292                                 number provided, it will be total request
6293                                 timeout. It can also be a pair (tuple) of
6294                                 (connection, read) timeouts.
6295        :type _request_timeout: int, tuple(int, int), optional
6296        :param _request_auth: set to override the auth_settings for an a single
6297                              request; this effectively ignores the
6298                              authentication in the spec for a single request.
6299        :type _request_auth: dict, optional
6300        :param _content_type: force content-type for the request.
6301        :type _content_type: str, Optional
6302        :param _headers: set to override the headers for a single
6303                         request; this effectively ignores the headers
6304                         in the spec for a single request.
6305        :type _headers: dict, optional
6306        :param _host_index: set to override the host_index for a single
6307                            request; this effectively ignores the host_index
6308                            in the spec for a single request.
6309        :type _host_index: int, optional
6310        :return: Returns the result object.
6311        """  # noqa: E501
6312
6313        _param = self._enterprise_get_projects_serialize(
6314            org_id=org_id,
6315            team_id=team_id,
6316            limit=limit,
6317            cursor=cursor,
6318            _request_auth=_request_auth,
6319            _content_type=_content_type,
6320            _headers=_headers,
6321            _host_index=_host_index,
6322        )
6323
6324        _response_types_map: Dict[str, Optional[str]] = {
6325            "200": "ProjectPage",
6326            "400": "Error400",
6327            "401": "Error401",
6328            "403": "Error403",
6329            "404": "Error404",
6330            "429": "Error429",
6331        }
6332        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6333        response_data.read()
6334        return self.api_client.response_deserialize(
6335            response_data=response_data,
6336            response_types_map=_response_types_map,
6337        ).data

List of projects

Retrieves the list of projects in an existing team of an organization. You can retrieve all projects, including all private projects (projects that haven't been specifically shared with you) by enabling Content Admin permissions. To enable Content Admin permissions, see Content Admin permissions for Company Admins.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of the organization from which you want to retrieve the list of available projects. (required) :type org_id: str :param team_id: The ID of the team from which you want to retrieve the list of available projects. (required) :type team_id: str :param limit: The maximum number of results to return per call. If the number of projects in the response is greater than the limit specified, the response returns the cursor parameter with a value. :type limit: int :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_update_project( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a Team.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a Project.')], update_project_request: miro_api.models.update_project_request.UpdateProjectRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.project.Project: View Source

6401    @validate_call
6402    def enterprise_update_project(
6403        self,
6404        org_id: Annotated[StrictStr, Field(description="The ID of an Organization.")],
6405        team_id: Annotated[StrictStr, Field(description="The ID of a Team.")],
6406        project_id: Annotated[StrictStr, Field(description="The ID of a Project.")],
6407        update_project_request: UpdateProjectRequest,
6408        _request_timeout: Union[
6409            None,
6410            Annotated[StrictFloat, Field(gt=0)],
6411            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6412        ] = None,
6413        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6414        _content_type: Optional[StrictStr] = None,
6415        _headers: Optional[Dict[StrictStr, Any]] = None,
6416        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6417    ) -> Project:
6418        """Update project
6419
6420        Update information about a project, such as the project name.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
6421
6422        :param org_id: The ID of an Organization. (required)
6423        :type org_id: str
6424        :param team_id: The ID of a Team. (required)
6425        :type team_id: str
6426        :param project_id: The ID of a Project. (required)
6427        :type project_id: str
6428        :param update_project_request: (required)
6429        :type update_project_request: UpdateProjectRequest
6430        :param _request_timeout: timeout setting for this request. If one
6431                                 number provided, it will be total request
6432                                 timeout. It can also be a pair (tuple) of
6433                                 (connection, read) timeouts.
6434        :type _request_timeout: int, tuple(int, int), optional
6435        :param _request_auth: set to override the auth_settings for an a single
6436                              request; this effectively ignores the
6437                              authentication in the spec for a single request.
6438        :type _request_auth: dict, optional
6439        :param _content_type: force content-type for the request.
6440        :type _content_type: str, Optional
6441        :param _headers: set to override the headers for a single
6442                         request; this effectively ignores the headers
6443                         in the spec for a single request.
6444        :type _headers: dict, optional
6445        :param _host_index: set to override the host_index for a single
6446                            request; this effectively ignores the host_index
6447                            in the spec for a single request.
6448        :type _host_index: int, optional
6449        :return: Returns the result object.
6450        """  # noqa: E501
6451
6452        _param = self._enterprise_update_project_serialize(
6453            org_id=org_id,
6454            team_id=team_id,
6455            project_id=project_id,
6456            update_project_request=update_project_request,
6457            _request_auth=_request_auth,
6458            _content_type=_content_type,
6459            _headers=_headers,
6460            _host_index=_host_index,
6461        )
6462
6463        _response_types_map: Dict[str, Optional[str]] = {
6464            "200": "Project",
6465            "400": "Error400",
6466            "401": "Error401",
6467            "403": "Error403",
6468            "404": "Error404",
6469            "409": "Error409",
6470            "429": "Error429",
6471        }
6472        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6473        response_data.read()
6474        return self.api_client.response_deserialize(
6475            response_data=response_data,
6476            response_types_map=_response_types_map,
6477        ).data

Update project

Update information about a project, such as the project name.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The ID of an Organization. (required) :type org_id: str :param team_id: The ID of a Team. (required) :type team_id: str :param project_id: The ID of a Project. (required) :type project_id: str :param update_project_request: (required) :type update_project_request: UpdateProjectRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_post_user_sessions_reset( self, email: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Email ID of the user whose sessions you want to reset. Note that this user will be signed out from all devices.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> None: View Source

6545    @validate_call
6546    def enterprise_post_user_sessions_reset(
6547        self,
6548        email: Annotated[
6549            StrictStr,
6550            Field(
6551                description="Email ID of the user whose sessions you want to reset. Note that this user will be signed out from all devices."
6552            ),
6553        ],
6554        _request_timeout: Union[
6555            None,
6556            Annotated[StrictFloat, Field(gt=0)],
6557            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6558        ] = None,
6559        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6560        _content_type: Optional[StrictStr] = None,
6561        _headers: Optional[Dict[StrictStr, Any]] = None,
6562        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6563    ) -> None:
6564        """Reset all sessions of a user
6565
6566        Reset all sessions of a user.  Admins can now take immediate action to restrict user access to company data in case of security concerns. Calling this API ends all active Miro sessions across devices for a particular user, requiring the user to sign in again. This is useful in situations where a user leaves the company, their credentials are compromised, or there's suspicious activity on their account.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>sessions:delete</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
6567
6568        :param email: Email ID of the user whose sessions you want to reset. Note that this user will be signed out from all devices. (required)
6569        :type email: str
6570        :param _request_timeout: timeout setting for this request. If one
6571                                 number provided, it will be total request
6572                                 timeout. It can also be a pair (tuple) of
6573                                 (connection, read) timeouts.
6574        :type _request_timeout: int, tuple(int, int), optional
6575        :param _request_auth: set to override the auth_settings for an a single
6576                              request; this effectively ignores the
6577                              authentication in the spec for a single request.
6578        :type _request_auth: dict, optional
6579        :param _content_type: force content-type for the request.
6580        :type _content_type: str, Optional
6581        :param _headers: set to override the headers for a single
6582                         request; this effectively ignores the headers
6583                         in the spec for a single request.
6584        :type _headers: dict, optional
6585        :param _host_index: set to override the host_index for a single
6586                            request; this effectively ignores the host_index
6587                            in the spec for a single request.
6588        :type _host_index: int, optional
6589        :return: Returns the result object.
6590        """  # noqa: E501
6591
6592        _param = self._enterprise_post_user_sessions_reset_serialize(
6593            email=email,
6594            _request_auth=_request_auth,
6595            _content_type=_content_type,
6596            _headers=_headers,
6597            _host_index=_host_index,
6598        )
6599
6600        _response_types_map: Dict[str, Optional[str]] = {
6601            "200": None,
6602            "400": None,
6603            "401": None,
6604            "403": None,
6605            "404": None,
6606            "429": None,
6607        }
6608        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6609        response_data.read()
6610        return self.api_client.response_deserialize(
6611            response_data=response_data,
6612            response_types_map=_response_types_map,
6613        ).data

Reset all sessions of a user

Reset all sessions of a user. Admins can now take immediate action to restrict user access to company data in case of security concerns. Calling this API ends all active Miro sessions across devices for a particular user, requiring the user to sign in again. This is useful in situations where a user leaves the company, their credentials are compromised, or there's suspicious activity on their account.

Required scope

sessions:delete

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param email: Email ID of the user whose sessions you want to reset. Note that this user will be signed out from all devices. (required) :type email: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_delete_team_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team Member')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> None: View Source

6663    @validate_call
6664    def enterprise_delete_team_member(
6665        self,
6666        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
6667        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
6668        member_id: Annotated[StrictStr, Field(description="The id of the Team Member")],
6669        _request_timeout: Union[
6670            None,
6671            Annotated[StrictFloat, Field(gt=0)],
6672            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6673        ] = None,
6674        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6675        _content_type: Optional[StrictStr] = None,
6676        _headers: Optional[Dict[StrictStr, Any]] = None,
6677        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6678    ) -> None:
6679        """Delete team member from team
6680
6681        Deletes team member from team by id.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
6682
6683        :param org_id: The id of the Organization. (required)
6684        :type org_id: str
6685        :param team_id: The id of the Team. (required)
6686        :type team_id: str
6687        :param member_id: The id of the Team Member (required)
6688        :type member_id: str
6689        :param _request_timeout: timeout setting for this request. If one
6690                                 number provided, it will be total request
6691                                 timeout. It can also be a pair (tuple) of
6692                                 (connection, read) timeouts.
6693        :type _request_timeout: int, tuple(int, int), optional
6694        :param _request_auth: set to override the auth_settings for an a single
6695                              request; this effectively ignores the
6696                              authentication in the spec for a single request.
6697        :type _request_auth: dict, optional
6698        :param _content_type: force content-type for the request.
6699        :type _content_type: str, Optional
6700        :param _headers: set to override the headers for a single
6701                         request; this effectively ignores the headers
6702                         in the spec for a single request.
6703        :type _headers: dict, optional
6704        :param _host_index: set to override the host_index for a single
6705                            request; this effectively ignores the host_index
6706                            in the spec for a single request.
6707        :type _host_index: int, optional
6708        :return: Returns the result object.
6709        """  # noqa: E501
6710
6711        _param = self._enterprise_delete_team_member_serialize(
6712            org_id=org_id,
6713            team_id=team_id,
6714            member_id=member_id,
6715            _request_auth=_request_auth,
6716            _content_type=_content_type,
6717            _headers=_headers,
6718            _host_index=_host_index,
6719        )
6720
6721        _response_types_map: Dict[str, Optional[str]] = {
6722            "204": None,
6723            "400": None,
6724            "401": None,
6725            "403": None,
6726            "404": None,
6727            "409": None,
6728            "429": None,
6729        }
6730        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6731        response_data.read()
6732        return self.api_client.response_deserialize(
6733            response_data=response_data,
6734            response_types_map=_response_types_map,
6735        ).data

Delete team member from team

Deletes team member from team by id.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param member_id: The id of the Team Member (required) :type member_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_team_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team Member')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team_member.TeamMember: View Source

6789    @validate_call
6790    def enterprise_get_team_member(
6791        self,
6792        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
6793        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
6794        member_id: Annotated[StrictStr, Field(description="The id of the Team Member")],
6795        _request_timeout: Union[
6796            None,
6797            Annotated[StrictFloat, Field(gt=0)],
6798            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6799        ] = None,
6800        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6801        _content_type: Optional[StrictStr] = None,
6802        _headers: Optional[Dict[StrictStr, Any]] = None,
6803        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6804    ) -> TeamMember:
6805        """Get team member
6806
6807        Retrieves team member by id.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
6808
6809        :param org_id: The id of the Organization. (required)
6810        :type org_id: str
6811        :param team_id: The id of the Team. (required)
6812        :type team_id: str
6813        :param member_id: The id of the Team Member (required)
6814        :type member_id: str
6815        :param _request_timeout: timeout setting for this request. If one
6816                                 number provided, it will be total request
6817                                 timeout. It can also be a pair (tuple) of
6818                                 (connection, read) timeouts.
6819        :type _request_timeout: int, tuple(int, int), optional
6820        :param _request_auth: set to override the auth_settings for an a single
6821                              request; this effectively ignores the
6822                              authentication in the spec for a single request.
6823        :type _request_auth: dict, optional
6824        :param _content_type: force content-type for the request.
6825        :type _content_type: str, Optional
6826        :param _headers: set to override the headers for a single
6827                         request; this effectively ignores the headers
6828                         in the spec for a single request.
6829        :type _headers: dict, optional
6830        :param _host_index: set to override the host_index for a single
6831                            request; this effectively ignores the host_index
6832                            in the spec for a single request.
6833        :type _host_index: int, optional
6834        :return: Returns the result object.
6835        """  # noqa: E501
6836
6837        _param = self._enterprise_get_team_member_serialize(
6838            org_id=org_id,
6839            team_id=team_id,
6840            member_id=member_id,
6841            _request_auth=_request_auth,
6842            _content_type=_content_type,
6843            _headers=_headers,
6844            _host_index=_host_index,
6845        )
6846
6847        _response_types_map: Dict[str, Optional[str]] = {
6848            "200": "TeamMember",
6849            "400": None,
6850            "401": None,
6851            "403": None,
6852            "404": None,
6853            "429": None,
6854        }
6855        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6856        response_data.read()
6857        return self.api_client.response_deserialize(
6858            response_data=response_data,
6859            response_types_map=_response_types_map,
6860        ).data

Get team member

Retrieves team member by id.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param member_id: The id of the Team Member (required) :type member_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_team_members( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], limit: Optional[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=1), Le(le=100)])]] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.')] = None, role: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description=' Role query. Filters members by role using full word match. Accepted values are: * "member": Team member with full member permissions. * "admin": Admin of a team. Team member with permission to manage team. * "non_team": External user, non-team user. * "team_guest": Team-guest user, user with access only to a team without access to organization. ')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team_members_page.TeamMembersPage: View Source

6917    @validate_call
6918    def enterprise_get_team_members(
6919        self,
6920        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
6921        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
6922        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
6923        cursor: Annotated[
6924            Optional[StrictStr],
6925            Field(
6926                description="An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request."
6927            ),
6928        ] = None,
6929        role: Annotated[
6930            Optional[StrictStr],
6931            Field(
6932                description=' Role query. Filters members by role using full word match. Accepted values are: * "member":     Team member with full member permissions. * "admin":      Admin of a team. Team member with permission to manage team. * "non_team":   External user, non-team user. * "team_guest": Team-guest user, user with access only to a team without access to organization. '
6933            ),
6934        ] = None,
6935        _request_timeout: Union[
6936            None,
6937            Annotated[StrictFloat, Field(gt=0)],
6938            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6939        ] = None,
6940        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6941        _content_type: Optional[StrictStr] = None,
6942        _headers: Optional[Dict[StrictStr, Any]] = None,
6943        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6944    ) -> TeamMembersPage:
6945        """List team members
6946
6947        Retrieves team members by cursor.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
6948
6949        :param org_id: The id of the Organization. (required)
6950        :type org_id: str
6951        :param team_id: The id of the Team. (required)
6952        :type team_id: str
6953        :param limit:
6954        :type limit: int
6955        :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.
6956        :type cursor: str
6957        :param role:  Role query. Filters members by role using full word match. Accepted values are: * \"member\":     Team member with full member permissions. * \"admin\":      Admin of a team. Team member with permission to manage team. * \"non_team\":   External user, non-team user. * \"team_guest\": Team-guest user, user with access only to a team without access to organization.
6958        :type role: str
6959        :param _request_timeout: timeout setting for this request. If one
6960                                 number provided, it will be total request
6961                                 timeout. It can also be a pair (tuple) of
6962                                 (connection, read) timeouts.
6963        :type _request_timeout: int, tuple(int, int), optional
6964        :param _request_auth: set to override the auth_settings for an a single
6965                              request; this effectively ignores the
6966                              authentication in the spec for a single request.
6967        :type _request_auth: dict, optional
6968        :param _content_type: force content-type for the request.
6969        :type _content_type: str, Optional
6970        :param _headers: set to override the headers for a single
6971                         request; this effectively ignores the headers
6972                         in the spec for a single request.
6973        :type _headers: dict, optional
6974        :param _host_index: set to override the host_index for a single
6975                            request; this effectively ignores the host_index
6976                            in the spec for a single request.
6977        :type _host_index: int, optional
6978        :return: Returns the result object.
6979        """  # noqa: E501
6980
6981        _param = self._enterprise_get_team_members_serialize(
6982            org_id=org_id,
6983            team_id=team_id,
6984            limit=limit,
6985            cursor=cursor,
6986            role=role,
6987            _request_auth=_request_auth,
6988            _content_type=_content_type,
6989            _headers=_headers,
6990            _host_index=_host_index,
6991        )
6992
6993        _response_types_map: Dict[str, Optional[str]] = {
6994            "200": "TeamMembersPage",
6995            "400": None,
6996            "401": None,
6997            "403": None,
6998            "404": None,
6999            "429": None,
7000        }
7001        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7002        response_data.read()
7003        return self.api_client.response_deserialize(
7004            response_data=response_data,
7005            response_types_map=_response_types_map,
7006        ).data

List team members

Retrieves team members by cursor.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param limit: :type limit: int :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. :type cursor: str :param role: Role query. Filters members by role using full word match. Accepted values are: * "member": Team member with full member permissions. * "admin": Admin of a team. Team member with permission to manage team. * "non_team": External user, non-team user. * "team_guest": Team-guest user, user with access only to a team without access to organization. :type role: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_invite_team_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], team_member_invite: miro_api.models.team_member_invite.TeamMemberInvite, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team_member.TeamMember: View Source

7075    @validate_call
7076    def enterprise_invite_team_member(
7077        self,
7078        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
7079        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
7080        team_member_invite: TeamMemberInvite,
7081        _request_timeout: Union[
7082            None,
7083            Annotated[StrictFloat, Field(gt=0)],
7084            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7085        ] = None,
7086        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7087        _content_type: Optional[StrictStr] = None,
7088        _headers: Optional[Dict[StrictStr, Any]] = None,
7089        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7090    ) -> TeamMember:
7091        """Invite team members
7092
7093        Invites a new Miro user to an existing team. The user must exist in your Miro organization. Users who do not exist in your Miro organization can be invited to the team via [SCIM](https://developers.miro.com/docs/scim) and an external identity provider, such as Okta or Azure Active Directory.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
7094
7095        :param org_id: The id of the Organization. (required)
7096        :type org_id: str
7097        :param team_id: The id of the Team. (required)
7098        :type team_id: str
7099        :param team_member_invite: (required)
7100        :type team_member_invite: TeamMemberInvite
7101        :param _request_timeout: timeout setting for this request. If one
7102                                 number provided, it will be total request
7103                                 timeout. It can also be a pair (tuple) of
7104                                 (connection, read) timeouts.
7105        :type _request_timeout: int, tuple(int, int), optional
7106        :param _request_auth: set to override the auth_settings for an a single
7107                              request; this effectively ignores the
7108                              authentication in the spec for a single request.
7109        :type _request_auth: dict, optional
7110        :param _content_type: force content-type for the request.
7111        :type _content_type: str, Optional
7112        :param _headers: set to override the headers for a single
7113                         request; this effectively ignores the headers
7114                         in the spec for a single request.
7115        :type _headers: dict, optional
7116        :param _host_index: set to override the host_index for a single
7117                            request; this effectively ignores the host_index
7118                            in the spec for a single request.
7119        :type _host_index: int, optional
7120        :return: Returns the result object.
7121        """  # noqa: E501
7122
7123        _param = self._enterprise_invite_team_member_serialize(
7124            org_id=org_id,
7125            team_id=team_id,
7126            team_member_invite=team_member_invite,
7127            _request_auth=_request_auth,
7128            _content_type=_content_type,
7129            _headers=_headers,
7130            _host_index=_host_index,
7131        )
7132
7133        _response_types_map: Dict[str, Optional[str]] = {
7134            "201": "TeamMember",
7135            "400": None,
7136            "401": None,
7137            "403": None,
7138            "404": None,
7139            "409": None,
7140            "429": None,
7141        }
7142        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7143        response_data.read()
7144        return self.api_client.response_deserialize(
7145            response_data=response_data,
7146            response_types_map=_response_types_map,
7147        ).data

Invite team members

Invites a new Miro user to an existing team. The user must exist in your Miro organization. Users who do not exist in your Miro organization can be invited to the team via SCIM and an external identity provider, such as Okta or Azure Active Directory.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param team_member_invite: (required) :type team_member_invite: TeamMemberInvite :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_update_team_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team Member')], team_member_changes: miro_api.models.team_member_changes.TeamMemberChanges, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team_member.TeamMember: View Source

7212    @validate_call
7213    def enterprise_update_team_member(
7214        self,
7215        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
7216        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
7217        member_id: Annotated[StrictStr, Field(description="The id of the Team Member")],
7218        team_member_changes: TeamMemberChanges,
7219        _request_timeout: Union[
7220            None,
7221            Annotated[StrictFloat, Field(gt=0)],
7222            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7223        ] = None,
7224        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7225        _content_type: Optional[StrictStr] = None,
7226        _headers: Optional[Dict[StrictStr, Any]] = None,
7227        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7228    ) -> TeamMember:
7229        """Update team member
7230
7231        Updates team member role in team by id.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
7232
7233        :param org_id: The id of the Organization. (required)
7234        :type org_id: str
7235        :param team_id: The id of the Team. (required)
7236        :type team_id: str
7237        :param member_id: The id of the Team Member (required)
7238        :type member_id: str
7239        :param team_member_changes: (required)
7240        :type team_member_changes: TeamMemberChanges
7241        :param _request_timeout: timeout setting for this request. If one
7242                                 number provided, it will be total request
7243                                 timeout. It can also be a pair (tuple) of
7244                                 (connection, read) timeouts.
7245        :type _request_timeout: int, tuple(int, int), optional
7246        :param _request_auth: set to override the auth_settings for an a single
7247                              request; this effectively ignores the
7248                              authentication in the spec for a single request.
7249        :type _request_auth: dict, optional
7250        :param _content_type: force content-type for the request.
7251        :type _content_type: str, Optional
7252        :param _headers: set to override the headers for a single
7253                         request; this effectively ignores the headers
7254                         in the spec for a single request.
7255        :type _headers: dict, optional
7256        :param _host_index: set to override the host_index for a single
7257                            request; this effectively ignores the host_index
7258                            in the spec for a single request.
7259        :type _host_index: int, optional
7260        :return: Returns the result object.
7261        """  # noqa: E501
7262
7263        _param = self._enterprise_update_team_member_serialize(
7264            org_id=org_id,
7265            team_id=team_id,
7266            member_id=member_id,
7267            team_member_changes=team_member_changes,
7268            _request_auth=_request_auth,
7269            _content_type=_content_type,
7270            _headers=_headers,
7271            _host_index=_host_index,
7272        )
7273
7274        _response_types_map: Dict[str, Optional[str]] = {
7275            "200": "TeamMember",
7276            "400": None,
7277            "401": None,
7278            "403": None,
7279            "404": None,
7280            "409": None,
7281            "429": None,
7282        }
7283        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7284        response_data.read()
7285        return self.api_client.response_deserialize(
7286            response_data=response_data,
7287            response_types_map=_response_types_map,
7288        ).data

Update team member

Updates team member role in team by id.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param member_id: The id of the Team Member (required) :type member_id: str :param team_member_changes: (required) :type team_member_changes: TeamMemberChanges :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_default_team_settings( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of an Organization.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team_settings.TeamSettings: View Source

7356    @validate_call
7357    def enterprise_get_default_team_settings(
7358        self,
7359        org_id: Annotated[StrictStr, Field(description="The id of an Organization.")],
7360        _request_timeout: Union[
7361            None,
7362            Annotated[StrictFloat, Field(gt=0)],
7363            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7364        ] = None,
7365        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7366        _content_type: Optional[StrictStr] = None,
7367        _headers: Optional[Dict[StrictStr, Any]] = None,
7368        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7369    ) -> TeamSettings:
7370        """Get default team settings
7371
7372        Retrieves default team settings of an existing organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
7373
7374        :param org_id: The id of an Organization. (required)
7375        :type org_id: str
7376        :param _request_timeout: timeout setting for this request. If one
7377                                 number provided, it will be total request
7378                                 timeout. It can also be a pair (tuple) of
7379                                 (connection, read) timeouts.
7380        :type _request_timeout: int, tuple(int, int), optional
7381        :param _request_auth: set to override the auth_settings for an a single
7382                              request; this effectively ignores the
7383                              authentication in the spec for a single request.
7384        :type _request_auth: dict, optional
7385        :param _content_type: force content-type for the request.
7386        :type _content_type: str, Optional
7387        :param _headers: set to override the headers for a single
7388                         request; this effectively ignores the headers
7389                         in the spec for a single request.
7390        :type _headers: dict, optional
7391        :param _host_index: set to override the host_index for a single
7392                            request; this effectively ignores the host_index
7393                            in the spec for a single request.
7394        :type _host_index: int, optional
7395        :return: Returns the result object.
7396        """  # noqa: E501
7397
7398        _param = self._enterprise_get_default_team_settings_serialize(
7399            org_id=org_id,
7400            _request_auth=_request_auth,
7401            _content_type=_content_type,
7402            _headers=_headers,
7403            _host_index=_host_index,
7404        )
7405
7406        _response_types_map: Dict[str, Optional[str]] = {
7407            "200": "TeamSettings",
7408            "400": None,
7409            "401": None,
7410            "403": None,
7411            "404": None,
7412            "429": None,
7413        }
7414        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7415        response_data.read()
7416        return self.api_client.response_deserialize(
7417            response_data=response_data,
7418            response_types_map=_response_types_map,
7419        ).data

Get default team settings

Retrieves default team settings of an existing organization.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of an Organization. (required) :type org_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_team_settings( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team_settings.TeamSettings: View Source

7470    @validate_call
7471    def enterprise_get_team_settings(
7472        self,
7473        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
7474        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
7475        _request_timeout: Union[
7476            None,
7477            Annotated[StrictFloat, Field(gt=0)],
7478            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7479        ] = None,
7480        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7481        _content_type: Optional[StrictStr] = None,
7482        _headers: Optional[Dict[StrictStr, Any]] = None,
7483        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7484    ) -> TeamSettings:
7485        """Get team settings
7486
7487        Retrieves team settings of an existing team.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
7488
7489        :param org_id: The id of the Organization. (required)
7490        :type org_id: str
7491        :param team_id: The id of the Team. (required)
7492        :type team_id: str
7493        :param _request_timeout: timeout setting for this request. If one
7494                                 number provided, it will be total request
7495                                 timeout. It can also be a pair (tuple) of
7496                                 (connection, read) timeouts.
7497        :type _request_timeout: int, tuple(int, int), optional
7498        :param _request_auth: set to override the auth_settings for an a single
7499                              request; this effectively ignores the
7500                              authentication in the spec for a single request.
7501        :type _request_auth: dict, optional
7502        :param _content_type: force content-type for the request.
7503        :type _content_type: str, Optional
7504        :param _headers: set to override the headers for a single
7505                         request; this effectively ignores the headers
7506                         in the spec for a single request.
7507        :type _headers: dict, optional
7508        :param _host_index: set to override the host_index for a single
7509                            request; this effectively ignores the host_index
7510                            in the spec for a single request.
7511        :type _host_index: int, optional
7512        :return: Returns the result object.
7513        """  # noqa: E501
7514
7515        _param = self._enterprise_get_team_settings_serialize(
7516            org_id=org_id,
7517            team_id=team_id,
7518            _request_auth=_request_auth,
7519            _content_type=_content_type,
7520            _headers=_headers,
7521            _host_index=_host_index,
7522        )
7523
7524        _response_types_map: Dict[str, Optional[str]] = {
7525            "200": "TeamSettings",
7526            "400": None,
7527            "401": None,
7528            "403": None,
7529            "404": None,
7530            "429": None,
7531        }
7532        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7533        response_data.read()
7534        return self.api_client.response_deserialize(
7535            response_data=response_data,
7536            response_types_map=_response_types_map,
7537        ).data

Get team settings

Retrieves team settings of an existing team.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_update_team_settings( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], team_settings_changes: miro_api.models.team_settings_changes.TeamSettingsChanges, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team_settings.TeamSettings: View Source

7591    @validate_call
7592    def enterprise_update_team_settings(
7593        self,
7594        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
7595        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
7596        team_settings_changes: TeamSettingsChanges,
7597        _request_timeout: Union[
7598            None,
7599            Annotated[StrictFloat, Field(gt=0)],
7600            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7601        ] = None,
7602        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7603        _content_type: Optional[StrictStr] = None,
7604        _headers: Optional[Dict[StrictStr, Any]] = None,
7605        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7606    ) -> TeamSettings:
7607        """Update team settings
7608
7609        Updates team settings of an existing team.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
7610
7611        :param org_id: The id of the Organization. (required)
7612        :type org_id: str
7613        :param team_id: The id of the Team. (required)
7614        :type team_id: str
7615        :param team_settings_changes: (required)
7616        :type team_settings_changes: TeamSettingsChanges
7617        :param _request_timeout: timeout setting for this request. If one
7618                                 number provided, it will be total request
7619                                 timeout. It can also be a pair (tuple) of
7620                                 (connection, read) timeouts.
7621        :type _request_timeout: int, tuple(int, int), optional
7622        :param _request_auth: set to override the auth_settings for an a single
7623                              request; this effectively ignores the
7624                              authentication in the spec for a single request.
7625        :type _request_auth: dict, optional
7626        :param _content_type: force content-type for the request.
7627        :type _content_type: str, Optional
7628        :param _headers: set to override the headers for a single
7629                         request; this effectively ignores the headers
7630                         in the spec for a single request.
7631        :type _headers: dict, optional
7632        :param _host_index: set to override the host_index for a single
7633                            request; this effectively ignores the host_index
7634                            in the spec for a single request.
7635        :type _host_index: int, optional
7636        :return: Returns the result object.
7637        """  # noqa: E501
7638
7639        _param = self._enterprise_update_team_settings_serialize(
7640            org_id=org_id,
7641            team_id=team_id,
7642            team_settings_changes=team_settings_changes,
7643            _request_auth=_request_auth,
7644            _content_type=_content_type,
7645            _headers=_headers,
7646            _host_index=_host_index,
7647        )
7648
7649        _response_types_map: Dict[str, Optional[str]] = {
7650            "200": "TeamSettings",
7651            "400": None,
7652            "401": None,
7653            "403": None,
7654            "404": None,
7655            "409": None,
7656            "429": None,
7657        }
7658        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7659        response_data.read()
7660        return self.api_client.response_deserialize(
7661            response_data=response_data,
7662            response_types_map=_response_types_map,
7663        ).data

Update team settings

Updates team settings of an existing team.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param team_settings_changes: (required) :type team_settings_changes: TeamSettingsChanges :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_create_team( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], create_team_request: miro_api.models.create_team_request.CreateTeamRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team.Team: View Source

7728    @validate_call
7729    def enterprise_create_team(
7730        self,
7731        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
7732        create_team_request: CreateTeamRequest,
7733        _request_timeout: Union[
7734            None,
7735            Annotated[StrictFloat, Field(gt=0)],
7736            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7737        ] = None,
7738        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7739        _content_type: Optional[StrictStr] = None,
7740        _headers: Optional[Dict[StrictStr, Any]] = None,
7741        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7742    ) -> Team:
7743        """Create team
7744
7745        Creates a new team in an existing organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
7746
7747        :param org_id: The id of the Organization. (required)
7748        :type org_id: str
7749        :param create_team_request: (required)
7750        :type create_team_request: CreateTeamRequest
7751        :param _request_timeout: timeout setting for this request. If one
7752                                 number provided, it will be total request
7753                                 timeout. It can also be a pair (tuple) of
7754                                 (connection, read) timeouts.
7755        :type _request_timeout: int, tuple(int, int), optional
7756        :param _request_auth: set to override the auth_settings for an a single
7757                              request; this effectively ignores the
7758                              authentication in the spec for a single request.
7759        :type _request_auth: dict, optional
7760        :param _content_type: force content-type for the request.
7761        :type _content_type: str, Optional
7762        :param _headers: set to override the headers for a single
7763                         request; this effectively ignores the headers
7764                         in the spec for a single request.
7765        :type _headers: dict, optional
7766        :param _host_index: set to override the host_index for a single
7767                            request; this effectively ignores the host_index
7768                            in the spec for a single request.
7769        :type _host_index: int, optional
7770        :return: Returns the result object.
7771        """  # noqa: E501
7772
7773        _param = self._enterprise_create_team_serialize(
7774            org_id=org_id,
7775            create_team_request=create_team_request,
7776            _request_auth=_request_auth,
7777            _content_type=_content_type,
7778            _headers=_headers,
7779            _host_index=_host_index,
7780        )
7781
7782        _response_types_map: Dict[str, Optional[str]] = {
7783            "201": "Team",
7784            "400": None,
7785            "401": None,
7786            "403": None,
7787            "404": None,
7788            "429": None,
7789        }
7790        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7791        response_data.read()
7792        return self.api_client.response_deserialize(
7793            response_data=response_data,
7794            response_types_map=_response_types_map,
7795        ).data

Create team

Creates a new team in an existing organization.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param create_team_request: (required) :type create_team_request: CreateTeamRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_delete_team( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> None: View Source

7857    @validate_call
7858    def enterprise_delete_team(
7859        self,
7860        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
7861        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
7862        _request_timeout: Union[
7863            None,
7864            Annotated[StrictFloat, Field(gt=0)],
7865            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7866        ] = None,
7867        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7868        _content_type: Optional[StrictStr] = None,
7869        _headers: Optional[Dict[StrictStr, Any]] = None,
7870        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7871    ) -> None:
7872        """Delete team
7873
7874        Deletes an existing team.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
7875
7876        :param org_id: The id of the Organization. (required)
7877        :type org_id: str
7878        :param team_id: The id of the Team. (required)
7879        :type team_id: str
7880        :param _request_timeout: timeout setting for this request. If one
7881                                 number provided, it will be total request
7882                                 timeout. It can also be a pair (tuple) of
7883                                 (connection, read) timeouts.
7884        :type _request_timeout: int, tuple(int, int), optional
7885        :param _request_auth: set to override the auth_settings for an a single
7886                              request; this effectively ignores the
7887                              authentication in the spec for a single request.
7888        :type _request_auth: dict, optional
7889        :param _content_type: force content-type for the request.
7890        :type _content_type: str, Optional
7891        :param _headers: set to override the headers for a single
7892                         request; this effectively ignores the headers
7893                         in the spec for a single request.
7894        :type _headers: dict, optional
7895        :param _host_index: set to override the host_index for a single
7896                            request; this effectively ignores the host_index
7897                            in the spec for a single request.
7898        :type _host_index: int, optional
7899        :return: Returns the result object.
7900        """  # noqa: E501
7901
7902        _param = self._enterprise_delete_team_serialize(
7903            org_id=org_id,
7904            team_id=team_id,
7905            _request_auth=_request_auth,
7906            _content_type=_content_type,
7907            _headers=_headers,
7908            _host_index=_host_index,
7909        )
7910
7911        _response_types_map: Dict[str, Optional[str]] = {
7912            "204": None,
7913            "400": None,
7914            "401": None,
7915            "403": None,
7916            "404": None,
7917            "429": None,
7918        }
7919        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7920        response_data.read()
7921        return self.api_client.response_deserialize(
7922            response_data=response_data,
7923            response_types_map=_response_types_map,
7924        ).data

Delete team

Deletes an existing team.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_team( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team.Team: View Source

7975    @validate_call
7976    def enterprise_get_team(
7977        self,
7978        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
7979        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
7980        _request_timeout: Union[
7981            None,
7982            Annotated[StrictFloat, Field(gt=0)],
7983            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7984        ] = None,
7985        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7986        _content_type: Optional[StrictStr] = None,
7987        _headers: Optional[Dict[StrictStr, Any]] = None,
7988        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7989    ) -> Team:
7990        """Get team
7991
7992        Retrieves team information for an existing team.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
7993
7994        :param org_id: The id of the Organization. (required)
7995        :type org_id: str
7996        :param team_id: The id of the Team. (required)
7997        :type team_id: str
7998        :param _request_timeout: timeout setting for this request. If one
7999                                 number provided, it will be total request
8000                                 timeout. It can also be a pair (tuple) of
8001                                 (connection, read) timeouts.
8002        :type _request_timeout: int, tuple(int, int), optional
8003        :param _request_auth: set to override the auth_settings for an a single
8004                              request; this effectively ignores the
8005                              authentication in the spec for a single request.
8006        :type _request_auth: dict, optional
8007        :param _content_type: force content-type for the request.
8008        :type _content_type: str, Optional
8009        :param _headers: set to override the headers for a single
8010                         request; this effectively ignores the headers
8011                         in the spec for a single request.
8012        :type _headers: dict, optional
8013        :param _host_index: set to override the host_index for a single
8014                            request; this effectively ignores the host_index
8015                            in the spec for a single request.
8016        :type _host_index: int, optional
8017        :return: Returns the result object.
8018        """  # noqa: E501
8019
8020        _param = self._enterprise_get_team_serialize(
8021            org_id=org_id,
8022            team_id=team_id,
8023            _request_auth=_request_auth,
8024            _content_type=_content_type,
8025            _headers=_headers,
8026            _host_index=_host_index,
8027        )
8028
8029        _response_types_map: Dict[str, Optional[str]] = {
8030            "200": "Team",
8031            "400": None,
8032            "401": None,
8033            "403": None,
8034            "404": None,
8035            "429": None,
8036        }
8037        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8038        response_data.read()
8039        return self.api_client.response_deserialize(
8040            response_data=response_data,
8041            response_types_map=_response_types_map,
8042        ).data

Get team

Retrieves team information for an existing team.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_get_teams( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], limit: Optional[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=1), Le(le=100)])]] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.')] = None, name: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Name query. Filters teams by name using case insensitive partial match. A value "dev" will return both "Developer\'s team" and "Team for developers".')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.teams_page.TeamsPage: View Source

8096    @validate_call
8097    def enterprise_get_teams(
8098        self,
8099        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
8100        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
8101        cursor: Annotated[
8102            Optional[StrictStr],
8103            Field(
8104                description="An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request."
8105            ),
8106        ] = None,
8107        name: Annotated[
8108            Optional[StrictStr],
8109            Field(
8110                description='Name query. Filters teams by name using case insensitive partial match. A value "dev" will return both "Developer\'s team" and "Team for developers".'
8111            ),
8112        ] = None,
8113        _request_timeout: Union[
8114            None,
8115            Annotated[StrictFloat, Field(gt=0)],
8116            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8117        ] = None,
8118        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8119        _content_type: Optional[StrictStr] = None,
8120        _headers: Optional[Dict[StrictStr, Any]] = None,
8121        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8122    ) -> TeamsPage:
8123        """List teams
8124
8125        Retrieves list of teams in an existing organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
8126
8127        :param org_id: The id of the Organization. (required)
8128        :type org_id: str
8129        :param limit:
8130        :type limit: int
8131        :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request.
8132        :type cursor: str
8133        :param name: Name query. Filters teams by name using case insensitive partial match. A value \"dev\" will return both \"Developer's team\" and \"Team for developers\".
8134        :type name: str
8135        :param _request_timeout: timeout setting for this request. If one
8136                                 number provided, it will be total request
8137                                 timeout. It can also be a pair (tuple) of
8138                                 (connection, read) timeouts.
8139        :type _request_timeout: int, tuple(int, int), optional
8140        :param _request_auth: set to override the auth_settings for an a single
8141                              request; this effectively ignores the
8142                              authentication in the spec for a single request.
8143        :type _request_auth: dict, optional
8144        :param _content_type: force content-type for the request.
8145        :type _content_type: str, Optional
8146        :param _headers: set to override the headers for a single
8147                         request; this effectively ignores the headers
8148                         in the spec for a single request.
8149        :type _headers: dict, optional
8150        :param _host_index: set to override the host_index for a single
8151                            request; this effectively ignores the host_index
8152                            in the spec for a single request.
8153        :type _host_index: int, optional
8154        :return: Returns the result object.
8155        """  # noqa: E501
8156
8157        _param = self._enterprise_get_teams_serialize(
8158            org_id=org_id,
8159            limit=limit,
8160            cursor=cursor,
8161            name=name,
8162            _request_auth=_request_auth,
8163            _content_type=_content_type,
8164            _headers=_headers,
8165            _host_index=_host_index,
8166        )
8167
8168        _response_types_map: Dict[str, Optional[str]] = {
8169            "200": "TeamsPage",
8170            "400": None,
8171            "401": None,
8172            "403": None,
8173            "404": None,
8174            "429": None,
8175        }
8176        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8177        response_data.read()
8178        return self.api_client.response_deserialize(
8179            response_data=response_data,
8180            response_types_map=_response_types_map,
8181        ).data

List teams

Retrieves list of teams in an existing organization.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param limit: :type limit: int :param cursor: An indicator of the position of a page in the full set of results. To obtain the first page leave it empty. To obtain subsequent pages set it to the value returned in the cursor field of the previous request. :type cursor: str :param name: Name query. Filters teams by name using case insensitive partial match. A value "dev" will return both "Developer's team" and "Team for developers". :type name: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def enterprise_update_team( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the Team.')], team_changes: miro_api.models.team_changes.TeamChanges, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.team.Team: View Source

8247    @validate_call
8248    def enterprise_update_team(
8249        self,
8250        org_id: Annotated[StrictStr, Field(description="The id of the Organization.")],
8251        team_id: Annotated[StrictStr, Field(description="The id of the Team.")],
8252        team_changes: TeamChanges,
8253        _request_timeout: Union[
8254            None,
8255            Annotated[StrictFloat, Field(gt=0)],
8256            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8257        ] = None,
8258        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8259        _content_type: Optional[StrictStr] = None,
8260        _headers: Optional[Dict[StrictStr, Any]] = None,
8261        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8262    ) -> Team:
8263        """Update team
8264
8265        Updates an existing team.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a> <br/><h3>Enterprise only</h3> <p>This API is available only for <a target=_blank href=\"/reference/api-reference#enterprise-plan\">Enterprise plan</a> users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using <a target=_blank href=\"https://q2oeb0jrhgi.typeform.com/to/BVPTNWJ9\">this form</a>.</p>
8266
8267        :param org_id: The id of the Organization. (required)
8268        :type org_id: str
8269        :param team_id: The id of the Team. (required)
8270        :type team_id: str
8271        :param team_changes: (required)
8272        :type team_changes: TeamChanges
8273        :param _request_timeout: timeout setting for this request. If one
8274                                 number provided, it will be total request
8275                                 timeout. It can also be a pair (tuple) of
8276                                 (connection, read) timeouts.
8277        :type _request_timeout: int, tuple(int, int), optional
8278        :param _request_auth: set to override the auth_settings for an a single
8279                              request; this effectively ignores the
8280                              authentication in the spec for a single request.
8281        :type _request_auth: dict, optional
8282        :param _content_type: force content-type for the request.
8283        :type _content_type: str, Optional
8284        :param _headers: set to override the headers for a single
8285                         request; this effectively ignores the headers
8286                         in the spec for a single request.
8287        :type _headers: dict, optional
8288        :param _host_index: set to override the host_index for a single
8289                            request; this effectively ignores the host_index
8290                            in the spec for a single request.
8291        :type _host_index: int, optional
8292        :return: Returns the result object.
8293        """  # noqa: E501
8294
8295        _param = self._enterprise_update_team_serialize(
8296            org_id=org_id,
8297            team_id=team_id,
8298            team_changes=team_changes,
8299            _request_auth=_request_auth,
8300            _content_type=_content_type,
8301            _headers=_headers,
8302            _host_index=_host_index,
8303        )
8304
8305        _response_types_map: Dict[str, Optional[str]] = {
8306            "200": "Team",
8307            "400": None,
8308            "401": None,
8309            "403": None,
8310            "404": None,
8311            "429": None,
8312        }
8313        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8314        response_data.read()
8315        return self.api_client.response_deserialize(
8316            response_data=response_data,
8317            response_types_map=_response_types_map,
8318        ).data

Update team

Updates an existing team.

Required scope

Rate limiting

Enterprise only

This API is available only for Enterprise plan users. You can only use this endpoint if you have the role of a Company Admin. You can request temporary access to Enterprise APIs using this form.

:param org_id: The id of the Organization. (required) :type org_id: str :param team_id: The id of the Team. (required) :type team_id: str :param team_changes: (required) :type team_changes: TeamChanges :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_board_subscription( self, create_board_subscription_request: miro_api.models.create_board_subscription_request.CreateBoardSubscriptionRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_subscription.BoardSubscription: View Source

8383    @validate_call
8384    def create_board_subscription(
8385        self,
8386        create_board_subscription_request: CreateBoardSubscriptionRequest,
8387        _request_timeout: Union[
8388            None,
8389            Annotated[StrictFloat, Field(gt=0)],
8390            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8391        ] = None,
8392        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8393        _content_type: Optional[StrictStr] = None,
8394        _headers: Optional[Dict[StrictStr, Any]] = None,
8395        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8396    ) -> BoardSubscription:
8397        """Create webhook subscription
8398
8399        Creates a webhook subscription to receive notifications when an item on a board is updated. Subscriptions are created per user, per board. You can create multiple subscriptions. We currently support all board items except tags, connectors, and comments.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
8400
8401        :param create_board_subscription_request: (required)
8402        :type create_board_subscription_request: CreateBoardSubscriptionRequest
8403        :param _request_timeout: timeout setting for this request. If one
8404                                 number provided, it will be total request
8405                                 timeout. It can also be a pair (tuple) of
8406                                 (connection, read) timeouts.
8407        :type _request_timeout: int, tuple(int, int), optional
8408        :param _request_auth: set to override the auth_settings for an a single
8409                              request; this effectively ignores the
8410                              authentication in the spec for a single request.
8411        :type _request_auth: dict, optional
8412        :param _content_type: force content-type for the request.
8413        :type _content_type: str, Optional
8414        :param _headers: set to override the headers for a single
8415                         request; this effectively ignores the headers
8416                         in the spec for a single request.
8417        :type _headers: dict, optional
8418        :param _host_index: set to override the host_index for a single
8419                            request; this effectively ignores the host_index
8420                            in the spec for a single request.
8421        :type _host_index: int, optional
8422        :return: Returns the result object.
8423        """  # noqa: E501
8424
8425        _param = self._create_board_subscription_serialize(
8426            create_board_subscription_request=create_board_subscription_request,
8427            _request_auth=_request_auth,
8428            _content_type=_content_type,
8429            _headers=_headers,
8430            _host_index=_host_index,
8431        )
8432
8433        _response_types_map: Dict[str, Optional[str]] = {
8434            "201": "BoardSubscription",
8435            "400": "CreateFrameItem400Response",
8436            "404": "CreateFrameItem400Response",
8437            "429": "CreateFrameItem400Response",
8438        }
8439        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8440        response_data.read()
8441        return self.api_client.response_deserialize(
8442            response_data=response_data,
8443            response_types_map=_response_types_map,
8444        ).data

Create webhook subscription

Creates a webhook subscription to receive notifications when an item on a board is updated. Subscriptions are created per user, per board. You can create multiple subscriptions. We currently support all board items except tags, connectors, and comments.

Required scope

Rate limiting

:param create_board_subscription_request: (required) :type create_board_subscription_request: CreateBoardSubscriptionRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_subscription_by_id( self, subscription_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the subscription that you want to delete')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

8503    @validate_call
8504    def delete_subscription_by_id(
8505        self,
8506        subscription_id: Annotated[
8507            StrictStr, Field(description="Unique identifier (ID) of the subscription that you want to delete")
8508        ],
8509        _request_timeout: Union[
8510            None,
8511            Annotated[StrictFloat, Field(gt=0)],
8512            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8513        ] = None,
8514        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8515        _content_type: Optional[StrictStr] = None,
8516        _headers: Optional[Dict[StrictStr, Any]] = None,
8517        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8518    ) -> object:
8519        """Delete webhook subscription
8520
8521        Deletes the specified webhook subscription.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
8522
8523        :param subscription_id: Unique identifier (ID) of the subscription that you want to delete (required)
8524        :type subscription_id: str
8525        :param _request_timeout: timeout setting for this request. If one
8526                                 number provided, it will be total request
8527                                 timeout. It can also be a pair (tuple) of
8528                                 (connection, read) timeouts.
8529        :type _request_timeout: int, tuple(int, int), optional
8530        :param _request_auth: set to override the auth_settings for an a single
8531                              request; this effectively ignores the
8532                              authentication in the spec for a single request.
8533        :type _request_auth: dict, optional
8534        :param _content_type: force content-type for the request.
8535        :type _content_type: str, Optional
8536        :param _headers: set to override the headers for a single
8537                         request; this effectively ignores the headers
8538                         in the spec for a single request.
8539        :type _headers: dict, optional
8540        :param _host_index: set to override the host_index for a single
8541                            request; this effectively ignores the host_index
8542                            in the spec for a single request.
8543        :type _host_index: int, optional
8544        :return: Returns the result object.
8545        """  # noqa: E501
8546
8547        _param = self._delete_subscription_by_id_serialize(
8548            subscription_id=subscription_id,
8549            _request_auth=_request_auth,
8550            _content_type=_content_type,
8551            _headers=_headers,
8552            _host_index=_host_index,
8553        )
8554
8555        _response_types_map: Dict[str, Optional[str]] = {
8556            "204": "object",
8557            "400": "CreateFrameItem400Response",
8558            "404": "CreateFrameItem400Response",
8559            "429": "CreateFrameItem400Response",
8560        }
8561        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8562        response_data.read()
8563        return self.api_client.response_deserialize(
8564            response_data=response_data,
8565            response_types_map=_response_types_map,
8566        ).data

Delete webhook subscription

Deletes the specified webhook subscription.

Required scope

Rate limiting

:param subscription_id: Unique identifier (ID) of the subscription that you want to delete (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_subscription_by_id( self, subscription_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the subscription that you want to retrieve')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.generic_subscription.GenericSubscription: View Source

8617    @validate_call
8618    def get_subscription_by_id(
8619        self,
8620        subscription_id: Annotated[
8621            StrictStr, Field(description="Unique identifier (ID) of the subscription that you want to retrieve")
8622        ],
8623        _request_timeout: Union[
8624            None,
8625            Annotated[StrictFloat, Field(gt=0)],
8626            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8627        ] = None,
8628        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8629        _content_type: Optional[StrictStr] = None,
8630        _headers: Optional[Dict[StrictStr, Any]] = None,
8631        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8632    ) -> GenericSubscription:
8633        """Get specific webhook subscription
8634
8635        Retrieves information for a specific webhook subscription.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
8636
8637        :param subscription_id: Unique identifier (ID) of the subscription that you want to retrieve (required)
8638        :type subscription_id: str
8639        :param _request_timeout: timeout setting for this request. If one
8640                                 number provided, it will be total request
8641                                 timeout. It can also be a pair (tuple) of
8642                                 (connection, read) timeouts.
8643        :type _request_timeout: int, tuple(int, int), optional
8644        :param _request_auth: set to override the auth_settings for an a single
8645                              request; this effectively ignores the
8646                              authentication in the spec for a single request.
8647        :type _request_auth: dict, optional
8648        :param _content_type: force content-type for the request.
8649        :type _content_type: str, Optional
8650        :param _headers: set to override the headers for a single
8651                         request; this effectively ignores the headers
8652                         in the spec for a single request.
8653        :type _headers: dict, optional
8654        :param _host_index: set to override the host_index for a single
8655                            request; this effectively ignores the host_index
8656                            in the spec for a single request.
8657        :type _host_index: int, optional
8658        :return: Returns the result object.
8659        """  # noqa: E501
8660
8661        _param = self._get_subscription_by_id_serialize(
8662            subscription_id=subscription_id,
8663            _request_auth=_request_auth,
8664            _content_type=_content_type,
8665            _headers=_headers,
8666            _host_index=_host_index,
8667        )
8668
8669        _response_types_map: Dict[str, Optional[str]] = {
8670            "200": "GenericSubscription",
8671            "400": "CreateFrameItem400Response",
8672            "404": "CreateFrameItem400Response",
8673            "429": "CreateFrameItem400Response",
8674        }
8675        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8676        response_data.read()
8677        return self.api_client.response_deserialize(
8678            response_data=response_data,
8679            response_types_map=_response_types_map,
8680        ).data

Get specific webhook subscription

Retrieves information for a specific webhook subscription.

Required scope

Rate limiting

:param subscription_id: Unique identifier (ID) of the subscription that you want to retrieve (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_user_subscriptions( self, limit: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] = None, cursor: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.generic_subscriptions_cursor_paged.GenericSubscriptionsCursorPaged: View Source

8731    @validate_call
8732    def get_user_subscriptions(
8733        self,
8734        limit: Optional[Annotated[str, Field(strict=True)]] = None,
8735        cursor: Optional[StrictStr] = None,
8736        _request_timeout: Union[
8737            None,
8738            Annotated[StrictFloat, Field(gt=0)],
8739            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8740        ] = None,
8741        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8742        _content_type: Optional[StrictStr] = None,
8743        _headers: Optional[Dict[StrictStr, Any]] = None,
8744        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8745    ) -> GenericSubscriptionsCursorPaged:
8746        """Get webhook subscriptions
8747
8748        Retrieves information about all webhook subscriptions for a specific user.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a><br/>
8749
8750        :param limit:
8751        :type limit: str
8752        :param cursor:
8753        :type cursor: str
8754        :param _request_timeout: timeout setting for this request. If one
8755                                 number provided, it will be total request
8756                                 timeout. It can also be a pair (tuple) of
8757                                 (connection, read) timeouts.
8758        :type _request_timeout: int, tuple(int, int), optional
8759        :param _request_auth: set to override the auth_settings for an a single
8760                              request; this effectively ignores the
8761                              authentication in the spec for a single request.
8762        :type _request_auth: dict, optional
8763        :param _content_type: force content-type for the request.
8764        :type _content_type: str, Optional
8765        :param _headers: set to override the headers for a single
8766                         request; this effectively ignores the headers
8767                         in the spec for a single request.
8768        :type _headers: dict, optional
8769        :param _host_index: set to override the host_index for a single
8770                            request; this effectively ignores the host_index
8771                            in the spec for a single request.
8772        :type _host_index: int, optional
8773        :return: Returns the result object.
8774        """  # noqa: E501
8775
8776        _param = self._get_user_subscriptions_serialize(
8777            limit=limit,
8778            cursor=cursor,
8779            _request_auth=_request_auth,
8780            _content_type=_content_type,
8781            _headers=_headers,
8782            _host_index=_host_index,
8783        )
8784
8785        _response_types_map: Dict[str, Optional[str]] = {
8786            "200": "GenericSubscriptionsCursorPaged",
8787            "400": "CreateFrameItem400Response",
8788            "404": "CreateFrameItem400Response",
8789            "429": "CreateFrameItem400Response",
8790        }
8791        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8792        response_data.read()
8793        return self.api_client.response_deserialize(
8794            response_data=response_data,
8795            response_types_map=_response_types_map,
8796        ).data

Get webhook subscriptions

Retrieves information about all webhook subscriptions for a specific user.

Required scope

Rate limiting

:param limit: :type limit: str :param cursor: :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_board_subscription( self, subscription_id: typing.Annotated[str, Strict(strict=True)], update_board_subscription_request: miro_api.models.update_board_subscription_request.UpdateBoardSubscriptionRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_subscription.BoardSubscription: View Source

8854    @validate_call
8855    def update_board_subscription(
8856        self,
8857        subscription_id: StrictStr,
8858        update_board_subscription_request: UpdateBoardSubscriptionRequest,
8859        _request_timeout: Union[
8860            None,
8861            Annotated[StrictFloat, Field(gt=0)],
8862            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8863        ] = None,
8864        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8865        _content_type: Optional[StrictStr] = None,
8866        _headers: Optional[Dict[StrictStr, Any]] = None,
8867        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8868    ) -> BoardSubscription:
8869        """Update webhook subscription
8870
8871        Updates the status or the callback URL of an existing webhook subscription.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
8872
8873        :param subscription_id: (required)
8874        :type subscription_id: str
8875        :param update_board_subscription_request: (required)
8876        :type update_board_subscription_request: UpdateBoardSubscriptionRequest
8877        :param _request_timeout: timeout setting for this request. If one
8878                                 number provided, it will be total request
8879                                 timeout. It can also be a pair (tuple) of
8880                                 (connection, read) timeouts.
8881        :type _request_timeout: int, tuple(int, int), optional
8882        :param _request_auth: set to override the auth_settings for an a single
8883                              request; this effectively ignores the
8884                              authentication in the spec for a single request.
8885        :type _request_auth: dict, optional
8886        :param _content_type: force content-type for the request.
8887        :type _content_type: str, Optional
8888        :param _headers: set to override the headers for a single
8889                         request; this effectively ignores the headers
8890                         in the spec for a single request.
8891        :type _headers: dict, optional
8892        :param _host_index: set to override the host_index for a single
8893                            request; this effectively ignores the host_index
8894                            in the spec for a single request.
8895        :type _host_index: int, optional
8896        :return: Returns the result object.
8897        """  # noqa: E501
8898
8899        _param = self._update_board_subscription_serialize(
8900            subscription_id=subscription_id,
8901            update_board_subscription_request=update_board_subscription_request,
8902            _request_auth=_request_auth,
8903            _content_type=_content_type,
8904            _headers=_headers,
8905            _host_index=_host_index,
8906        )
8907
8908        _response_types_map: Dict[str, Optional[str]] = {
8909            "200": "BoardSubscription",
8910            "400": "CreateFrameItem400Response",
8911            "404": "CreateFrameItem400Response",
8912            "429": "CreateFrameItem400Response",
8913        }
8914        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8915        response_data.read()
8916        return self.api_client.response_deserialize(
8917            response_data=response_data,
8918            response_types_map=_response_types_map,
8919        ).data

Update webhook subscription

Updates the status or the callback URL of an existing webhook subscription.

Required scope

Rate limiting

:param subscription_id: (required) :type subscription_id: str :param update_board_subscription_request: (required) :type update_board_subscription_request: UpdateBoardSubscriptionRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_app_card_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], app_card_create_request: miro_api.models.app_card_create_request.AppCardCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.app_card_item.AppCardItem: View Source

8981    @validate_call
8982    def create_app_card_item(
8983        self,
8984        board_id: Annotated[
8985            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
8986        ],
8987        app_card_create_request: AppCardCreateRequest,
8988        _request_timeout: Union[
8989            None,
8990            Annotated[StrictFloat, Field(gt=0)],
8991            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8992        ] = None,
8993        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8994        _content_type: Optional[StrictStr] = None,
8995        _headers: Optional[Dict[StrictStr, Any]] = None,
8996        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8997    ) -> AppCardItem:
8998        """Create app card item
8999
9000        Adds an app card item to a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
9001
9002        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
9003        :type board_id: str
9004        :param app_card_create_request: (required)
9005        :type app_card_create_request: AppCardCreateRequest
9006        :param _request_timeout: timeout setting for this request. If one
9007                                 number provided, it will be total request
9008                                 timeout. It can also be a pair (tuple) of
9009                                 (connection, read) timeouts.
9010        :type _request_timeout: int, tuple(int, int), optional
9011        :param _request_auth: set to override the auth_settings for an a single
9012                              request; this effectively ignores the
9013                              authentication in the spec for a single request.
9014        :type _request_auth: dict, optional
9015        :param _content_type: force content-type for the request.
9016        :type _content_type: str, Optional
9017        :param _headers: set to override the headers for a single
9018                         request; this effectively ignores the headers
9019                         in the spec for a single request.
9020        :type _headers: dict, optional
9021        :param _host_index: set to override the host_index for a single
9022                            request; this effectively ignores the host_index
9023                            in the spec for a single request.
9024        :type _host_index: int, optional
9025        :return: Returns the result object.
9026        """  # noqa: E501
9027
9028        _param = self._create_app_card_item_serialize(
9029            board_id=board_id,
9030            app_card_create_request=app_card_create_request,
9031            _request_auth=_request_auth,
9032            _content_type=_content_type,
9033            _headers=_headers,
9034            _host_index=_host_index,
9035        )
9036
9037        _response_types_map: Dict[str, Optional[str]] = {
9038            "201": "AppCardItem",
9039            "400": None,
9040            "404": None,
9041            "429": None,
9042        }
9043        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9044        response_data.read()
9045        return self.api_client.response_deserialize(
9046            response_data=response_data,
9047            response_types_map=_response_types_map,
9048        ).data

Create app card item

Adds an app card item to a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param app_card_create_request: (required) :type app_card_create_request: AppCardCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_app_card_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete an item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

9110    @validate_call
9111    def delete_app_card_item(
9112        self,
9113        board_id: Annotated[
9114            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete an item.")
9115        ],
9116        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
9117        _request_timeout: Union[
9118            None,
9119            Annotated[StrictFloat, Field(gt=0)],
9120            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9121        ] = None,
9122        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9123        _content_type: Optional[StrictStr] = None,
9124        _headers: Optional[Dict[StrictStr, Any]] = None,
9125        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9126    ) -> object:
9127        """Delete app card item
9128
9129        Deletes an app card item from a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
9130
9131        :param board_id: Unique identifier (ID) of the board from which you want to delete an item. (required)
9132        :type board_id: str
9133        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
9134        :type item_id: str
9135        :param _request_timeout: timeout setting for this request. If one
9136                                 number provided, it will be total request
9137                                 timeout. It can also be a pair (tuple) of
9138                                 (connection, read) timeouts.
9139        :type _request_timeout: int, tuple(int, int), optional
9140        :param _request_auth: set to override the auth_settings for an a single
9141                              request; this effectively ignores the
9142                              authentication in the spec for a single request.
9143        :type _request_auth: dict, optional
9144        :param _content_type: force content-type for the request.
9145        :type _content_type: str, Optional
9146        :param _headers: set to override the headers for a single
9147                         request; this effectively ignores the headers
9148                         in the spec for a single request.
9149        :type _headers: dict, optional
9150        :param _host_index: set to override the host_index for a single
9151                            request; this effectively ignores the host_index
9152                            in the spec for a single request.
9153        :type _host_index: int, optional
9154        :return: Returns the result object.
9155        """  # noqa: E501
9156
9157        _param = self._delete_app_card_item_serialize(
9158            board_id=board_id,
9159            item_id=item_id,
9160            _request_auth=_request_auth,
9161            _content_type=_content_type,
9162            _headers=_headers,
9163            _host_index=_host_index,
9164        )
9165
9166        _response_types_map: Dict[str, Optional[str]] = {
9167            "204": "object",
9168            "400": None,
9169            "404": None,
9170            "429": None,
9171        }
9172        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9173        response_data.read()
9174        return self.api_client.response_deserialize(
9175            response_data=response_data,
9176            response_types_map=_response_types_map,
9177        ).data

Delete app card item

Deletes an app card item from a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete an item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_app_card_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.app_card_item.AppCardItem: View Source

9231    @validate_call
9232    def get_app_card_item(
9233        self,
9234        board_id: Annotated[
9235            StrictStr,
9236            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
9237        ],
9238        item_id: Annotated[
9239            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
9240        ],
9241        _request_timeout: Union[
9242            None,
9243            Annotated[StrictFloat, Field(gt=0)],
9244            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9245        ] = None,
9246        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9247        _content_type: Optional[StrictStr] = None,
9248        _headers: Optional[Dict[StrictStr, Any]] = None,
9249        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9250    ) -> AppCardItem:
9251        """Get app card item
9252
9253        Retrieves information for a specific app card item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
9254
9255        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
9256        :type board_id: str
9257        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
9258        :type item_id: str
9259        :param _request_timeout: timeout setting for this request. If one
9260                                 number provided, it will be total request
9261                                 timeout. It can also be a pair (tuple) of
9262                                 (connection, read) timeouts.
9263        :type _request_timeout: int, tuple(int, int), optional
9264        :param _request_auth: set to override the auth_settings for an a single
9265                              request; this effectively ignores the
9266                              authentication in the spec for a single request.
9267        :type _request_auth: dict, optional
9268        :param _content_type: force content-type for the request.
9269        :type _content_type: str, Optional
9270        :param _headers: set to override the headers for a single
9271                         request; this effectively ignores the headers
9272                         in the spec for a single request.
9273        :type _headers: dict, optional
9274        :param _host_index: set to override the host_index for a single
9275                            request; this effectively ignores the host_index
9276                            in the spec for a single request.
9277        :type _host_index: int, optional
9278        :return: Returns the result object.
9279        """  # noqa: E501
9280
9281        _param = self._get_app_card_item_serialize(
9282            board_id=board_id,
9283            item_id=item_id,
9284            _request_auth=_request_auth,
9285            _content_type=_content_type,
9286            _headers=_headers,
9287            _host_index=_host_index,
9288        )
9289
9290        _response_types_map: Dict[str, Optional[str]] = {
9291            "200": "AppCardItem",
9292            "400": None,
9293            "404": None,
9294            "429": None,
9295        }
9296        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9297        response_data.read()
9298        return self.api_client.response_deserialize(
9299            response_data=response_data,
9300            response_types_map=_response_types_map,
9301        ).data

Get app card item

Retrieves information for a specific app card item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_app_card_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], app_card_update_request: miro_api.models.app_card_update_request.AppCardUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.app_card_item.AppCardItem: View Source

9355    @validate_call
9356    def update_app_card_item(
9357        self,
9358        board_id: Annotated[
9359            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
9360        ],
9361        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
9362        app_card_update_request: AppCardUpdateRequest,
9363        _request_timeout: Union[
9364            None,
9365            Annotated[StrictFloat, Field(gt=0)],
9366            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9367        ] = None,
9368        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9369        _content_type: Optional[StrictStr] = None,
9370        _headers: Optional[Dict[StrictStr, Any]] = None,
9371        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9372    ) -> AppCardItem:
9373        """Update app card item
9374
9375        Updates an app card item on a board based on the data and style properties provided in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
9376
9377        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
9378        :type board_id: str
9379        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
9380        :type item_id: str
9381        :param app_card_update_request: (required)
9382        :type app_card_update_request: AppCardUpdateRequest
9383        :param _request_timeout: timeout setting for this request. If one
9384                                 number provided, it will be total request
9385                                 timeout. It can also be a pair (tuple) of
9386                                 (connection, read) timeouts.
9387        :type _request_timeout: int, tuple(int, int), optional
9388        :param _request_auth: set to override the auth_settings for an a single
9389                              request; this effectively ignores the
9390                              authentication in the spec for a single request.
9391        :type _request_auth: dict, optional
9392        :param _content_type: force content-type for the request.
9393        :type _content_type: str, Optional
9394        :param _headers: set to override the headers for a single
9395                         request; this effectively ignores the headers
9396                         in the spec for a single request.
9397        :type _headers: dict, optional
9398        :param _host_index: set to override the host_index for a single
9399                            request; this effectively ignores the host_index
9400                            in the spec for a single request.
9401        :type _host_index: int, optional
9402        :return: Returns the result object.
9403        """  # noqa: E501
9404
9405        _param = self._update_app_card_item_serialize(
9406            board_id=board_id,
9407            item_id=item_id,
9408            app_card_update_request=app_card_update_request,
9409            _request_auth=_request_auth,
9410            _content_type=_content_type,
9411            _headers=_headers,
9412            _host_index=_host_index,
9413        )
9414
9415        _response_types_map: Dict[str, Optional[str]] = {
9416            "200": "AppCardItem",
9417            "400": None,
9418            "404": None,
9419            "409": None,
9420            "429": None,
9421        }
9422        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9423        response_data.read()
9424        return self.api_client.response_deserialize(
9425            response_data=response_data,
9426            response_types_map=_response_types_map,
9427        ).data

Update app card item

Updates an app card item on a board based on the data and style properties provided in the request body.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param app_card_update_request: (required) :type app_card_update_request: AppCardUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_board_members( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board to which the board member belongs.')], limit: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] = None, offset: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_members_paged_response.BoardMembersPagedResponse: View Source

9492    @validate_call
9493    def get_board_members(
9494        self,
9495        board_id: Annotated[
9496            StrictStr, Field(description="Unique identifier (ID) of the board to which the board member belongs.")
9497        ],
9498        limit: Optional[Annotated[str, Field(strict=True)]] = None,
9499        offset: Optional[StrictStr] = None,
9500        _request_timeout: Union[
9501            None,
9502            Annotated[StrictFloat, Field(gt=0)],
9503            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9504        ] = None,
9505        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9506        _content_type: Optional[StrictStr] = None,
9507        _headers: Optional[Dict[StrictStr, Any]] = None,
9508        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9509    ) -> BoardMembersPagedResponse:
9510        """Get all board members
9511
9512        Retrieves a pageable list of members for a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
9513
9514        :param board_id: Unique identifier (ID) of the board to which the board member belongs. (required)
9515        :type board_id: str
9516        :param limit:
9517        :type limit: str
9518        :param offset:
9519        :type offset: str
9520        :param _request_timeout: timeout setting for this request. If one
9521                                 number provided, it will be total request
9522                                 timeout. It can also be a pair (tuple) of
9523                                 (connection, read) timeouts.
9524        :type _request_timeout: int, tuple(int, int), optional
9525        :param _request_auth: set to override the auth_settings for an a single
9526                              request; this effectively ignores the
9527                              authentication in the spec for a single request.
9528        :type _request_auth: dict, optional
9529        :param _content_type: force content-type for the request.
9530        :type _content_type: str, Optional
9531        :param _headers: set to override the headers for a single
9532                         request; this effectively ignores the headers
9533                         in the spec for a single request.
9534        :type _headers: dict, optional
9535        :param _host_index: set to override the host_index for a single
9536                            request; this effectively ignores the host_index
9537                            in the spec for a single request.
9538        :type _host_index: int, optional
9539        :return: Returns the result object.
9540        """  # noqa: E501
9541
9542        _param = self._get_board_members_serialize(
9543            board_id=board_id,
9544            limit=limit,
9545            offset=offset,
9546            _request_auth=_request_auth,
9547            _content_type=_content_type,
9548            _headers=_headers,
9549            _host_index=_host_index,
9550        )
9551
9552        _response_types_map: Dict[str, Optional[str]] = {
9553            "200": "BoardMembersPagedResponse",
9554            "400": None,
9555            "404": None,
9556            "429": None,
9557        }
9558        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9559        response_data.read()
9560        return self.api_client.response_deserialize(
9561            response_data=response_data,
9562            response_types_map=_response_types_map,
9563        ).data

Get all board members

Retrieves a pageable list of members for a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board to which the board member belongs. (required) :type board_id: str :param limit: :type limit: str :param offset: :type offset: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_specific_board_member( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board to which the board member belongs.')], board_member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board member whose role you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_member_with_links.BoardMemberWithLinks: View Source

9624    @validate_call
9625    def get_specific_board_member(
9626        self,
9627        board_id: Annotated[
9628            StrictStr, Field(description="Unique identifier (ID) of the board to which the board member belongs.")
9629        ],
9630        board_member_id: Annotated[
9631            StrictStr, Field(description="Unique identifier (ID) of the board member whose role you want to retrieve.")
9632        ],
9633        _request_timeout: Union[
9634            None,
9635            Annotated[StrictFloat, Field(gt=0)],
9636            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9637        ] = None,
9638        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9639        _content_type: Optional[StrictStr] = None,
9640        _headers: Optional[Dict[StrictStr, Any]] = None,
9641        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9642    ) -> BoardMemberWithLinks:
9643        """Get specific board member
9644
9645        Retrieves information for a board member.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
9646
9647        :param board_id: Unique identifier (ID) of the board to which the board member belongs. (required)
9648        :type board_id: str
9649        :param board_member_id: Unique identifier (ID) of the board member whose role you want to retrieve. (required)
9650        :type board_member_id: str
9651        :param _request_timeout: timeout setting for this request. If one
9652                                 number provided, it will be total request
9653                                 timeout. It can also be a pair (tuple) of
9654                                 (connection, read) timeouts.
9655        :type _request_timeout: int, tuple(int, int), optional
9656        :param _request_auth: set to override the auth_settings for an a single
9657                              request; this effectively ignores the
9658                              authentication in the spec for a single request.
9659        :type _request_auth: dict, optional
9660        :param _content_type: force content-type for the request.
9661        :type _content_type: str, Optional
9662        :param _headers: set to override the headers for a single
9663                         request; this effectively ignores the headers
9664                         in the spec for a single request.
9665        :type _headers: dict, optional
9666        :param _host_index: set to override the host_index for a single
9667                            request; this effectively ignores the host_index
9668                            in the spec for a single request.
9669        :type _host_index: int, optional
9670        :return: Returns the result object.
9671        """  # noqa: E501
9672
9673        _param = self._get_specific_board_member_serialize(
9674            board_id=board_id,
9675            board_member_id=board_member_id,
9676            _request_auth=_request_auth,
9677            _content_type=_content_type,
9678            _headers=_headers,
9679            _host_index=_host_index,
9680        )
9681
9682        _response_types_map: Dict[str, Optional[str]] = {
9683            "200": "BoardMemberWithLinks",
9684            "400": None,
9685            "404": None,
9686            "429": None,
9687        }
9688        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9689        response_data.read()
9690        return self.api_client.response_deserialize(
9691            response_data=response_data,
9692            response_types_map=_response_types_map,
9693        ).data

Get specific board member

Retrieves information for a board member.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board to which the board member belongs. (required) :type board_id: str :param board_member_id: Unique identifier (ID) of the board member whose role you want to retrieve. (required) :type board_member_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def remove_board_member( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete an item.')], board_member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board member whose role you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

9747    @validate_call
9748    def remove_board_member(
9749        self,
9750        board_id: Annotated[
9751            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete an item.")
9752        ],
9753        board_member_id: Annotated[
9754            StrictStr, Field(description="Unique identifier (ID) of the board member whose role you want to delete.")
9755        ],
9756        _request_timeout: Union[
9757            None,
9758            Annotated[StrictFloat, Field(gt=0)],
9759            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9760        ] = None,
9761        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9762        _content_type: Optional[StrictStr] = None,
9763        _headers: Optional[Dict[StrictStr, Any]] = None,
9764        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9765    ) -> object:
9766        """Remove board member
9767
9768        Removes a board member from a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
9769
9770        :param board_id: Unique identifier (ID) of the board from which you want to delete an item. (required)
9771        :type board_id: str
9772        :param board_member_id: Unique identifier (ID) of the board member whose role you want to delete. (required)
9773        :type board_member_id: str
9774        :param _request_timeout: timeout setting for this request. If one
9775                                 number provided, it will be total request
9776                                 timeout. It can also be a pair (tuple) of
9777                                 (connection, read) timeouts.
9778        :type _request_timeout: int, tuple(int, int), optional
9779        :param _request_auth: set to override the auth_settings for an a single
9780                              request; this effectively ignores the
9781                              authentication in the spec for a single request.
9782        :type _request_auth: dict, optional
9783        :param _content_type: force content-type for the request.
9784        :type _content_type: str, Optional
9785        :param _headers: set to override the headers for a single
9786                         request; this effectively ignores the headers
9787                         in the spec for a single request.
9788        :type _headers: dict, optional
9789        :param _host_index: set to override the host_index for a single
9790                            request; this effectively ignores the host_index
9791                            in the spec for a single request.
9792        :type _host_index: int, optional
9793        :return: Returns the result object.
9794        """  # noqa: E501
9795
9796        _param = self._remove_board_member_serialize(
9797            board_id=board_id,
9798            board_member_id=board_member_id,
9799            _request_auth=_request_auth,
9800            _content_type=_content_type,
9801            _headers=_headers,
9802            _host_index=_host_index,
9803        )
9804
9805        _response_types_map: Dict[str, Optional[str]] = {
9806            "204": "object",
9807            "400": None,
9808            "404": None,
9809            "429": None,
9810        }
9811        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9812        response_data.read()
9813        return self.api_client.response_deserialize(
9814            response_data=response_data,
9815            response_types_map=_response_types_map,
9816        ).data

Remove board member

Removes a board member from a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete an item. (required) :type board_id: str :param board_member_id: Unique identifier (ID) of the board member whose role you want to delete. (required) :type board_member_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def share_board( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board to which the board member belongs.')], board_members_invite: miro_api.models.board_members_invite.BoardMembersInvite, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.invitation_result.InvitationResult: View Source

9870    @validate_call
9871    def share_board(
9872        self,
9873        board_id: Annotated[
9874            StrictStr, Field(description="Unique identifier (ID) of the board to which the board member belongs.")
9875        ],
9876        board_members_invite: BoardMembersInvite,
9877        _request_timeout: Union[
9878            None,
9879            Annotated[StrictFloat, Field(gt=0)],
9880            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9881        ] = None,
9882        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9883        _content_type: Optional[StrictStr] = None,
9884        _headers: Optional[Dict[StrictStr, Any]] = None,
9885        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9886    ) -> InvitationResult:
9887        """Share board
9888
9889        Shares the board and Invites new members to collaborate on a board by sending an invitation email. Depending on the board's Sharing policy, there might be various scenarios where membership in the team is required in order to share the board with a user.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
9890
9891        :param board_id: Unique identifier (ID) of the board to which the board member belongs. (required)
9892        :type board_id: str
9893        :param board_members_invite: (required)
9894        :type board_members_invite: BoardMembersInvite
9895        :param _request_timeout: timeout setting for this request. If one
9896                                 number provided, it will be total request
9897                                 timeout. It can also be a pair (tuple) of
9898                                 (connection, read) timeouts.
9899        :type _request_timeout: int, tuple(int, int), optional
9900        :param _request_auth: set to override the auth_settings for an a single
9901                              request; this effectively ignores the
9902                              authentication in the spec for a single request.
9903        :type _request_auth: dict, optional
9904        :param _content_type: force content-type for the request.
9905        :type _content_type: str, Optional
9906        :param _headers: set to override the headers for a single
9907                         request; this effectively ignores the headers
9908                         in the spec for a single request.
9909        :type _headers: dict, optional
9910        :param _host_index: set to override the host_index for a single
9911                            request; this effectively ignores the host_index
9912                            in the spec for a single request.
9913        :type _host_index: int, optional
9914        :return: Returns the result object.
9915        """  # noqa: E501
9916
9917        _param = self._share_board_serialize(
9918            board_id=board_id,
9919            board_members_invite=board_members_invite,
9920            _request_auth=_request_auth,
9921            _content_type=_content_type,
9922            _headers=_headers,
9923            _host_index=_host_index,
9924        )
9925
9926        _response_types_map: Dict[str, Optional[str]] = {
9927            "201": "InvitationResult",
9928            "400": None,
9929            "404": None,
9930            "429": None,
9931        }
9932        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9933        response_data.read()
9934        return self.api_client.response_deserialize(
9935            response_data=response_data,
9936            response_types_map=_response_types_map,
9937        ).data

Share board

Shares the board and Invites new members to collaborate on a board by sending an invitation email. Depending on the board's Sharing policy, there might be various scenarios where membership in the team is required in order to share the board with a user.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board to which the board member belongs. (required) :type board_id: str :param board_members_invite: (required) :type board_members_invite: BoardMembersInvite :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_board_member( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board for which you want to update the role of the board member.')], board_member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board member whose role you want to update.')], board_member_changes: miro_api.models.board_member_changes.BoardMemberChanges, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_member_with_links.BoardMemberWithLinks: View Source

 9999    @validate_call
10000    def update_board_member(
10001        self,
10002        board_id: Annotated[
10003            StrictStr,
10004            Field(
10005                description="Unique identifier (ID) of the board for which you want to update the role of the board member."
10006            ),
10007        ],
10008        board_member_id: Annotated[
10009            StrictStr, Field(description="Unique identifier (ID) of the board member whose role you want to update.")
10010        ],
10011        board_member_changes: BoardMemberChanges,
10012        _request_timeout: Union[
10013            None,
10014            Annotated[StrictFloat, Field(gt=0)],
10015            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10016        ] = None,
10017        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10018        _content_type: Optional[StrictStr] = None,
10019        _headers: Optional[Dict[StrictStr, Any]] = None,
10020        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10021    ) -> BoardMemberWithLinks:
10022        """Update board member
10023
10024        Updates the role of a board member.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
10025
10026        :param board_id: Unique identifier (ID) of the board for which you want to update the role of the board member. (required)
10027        :type board_id: str
10028        :param board_member_id: Unique identifier (ID) of the board member whose role you want to update. (required)
10029        :type board_member_id: str
10030        :param board_member_changes: (required)
10031        :type board_member_changes: BoardMemberChanges
10032        :param _request_timeout: timeout setting for this request. If one
10033                                 number provided, it will be total request
10034                                 timeout. It can also be a pair (tuple) of
10035                                 (connection, read) timeouts.
10036        :type _request_timeout: int, tuple(int, int), optional
10037        :param _request_auth: set to override the auth_settings for an a single
10038                              request; this effectively ignores the
10039                              authentication in the spec for a single request.
10040        :type _request_auth: dict, optional
10041        :param _content_type: force content-type for the request.
10042        :type _content_type: str, Optional
10043        :param _headers: set to override the headers for a single
10044                         request; this effectively ignores the headers
10045                         in the spec for a single request.
10046        :type _headers: dict, optional
10047        :param _host_index: set to override the host_index for a single
10048                            request; this effectively ignores the host_index
10049                            in the spec for a single request.
10050        :type _host_index: int, optional
10051        :return: Returns the result object.
10052        """  # noqa: E501
10053
10054        _param = self._update_board_member_serialize(
10055            board_id=board_id,
10056            board_member_id=board_member_id,
10057            board_member_changes=board_member_changes,
10058            _request_auth=_request_auth,
10059            _content_type=_content_type,
10060            _headers=_headers,
10061            _host_index=_host_index,
10062        )
10063
10064        _response_types_map: Dict[str, Optional[str]] = {
10065            "200": "BoardMemberWithLinks",
10066            "400": None,
10067            "404": None,
10068            "429": None,
10069        }
10070        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10071        response_data.read()
10072        return self.api_client.response_deserialize(
10073            response_data=response_data,
10074            response_types_map=_response_types_map,
10075        ).data

Update board member

Updates the role of a board member.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board for which you want to update the role of the board member. (required) :type board_id: str :param board_member_id: Unique identifier (ID) of the board member whose role you want to update. (required) :type board_member_id: str :param board_member_changes: (required) :type board_member_changes: BoardMemberChanges :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def copy_board( self, copy_from: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board that you want to copy.')], copy_board_changes: Optional[miro_api.models.copy_board_changes.CopyBoardChanges] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_with_links_and_without_project.BoardWithLinksAndWithoutProject: View Source

10140    @validate_call
10141    def copy_board(
10142        self,
10143        copy_from: Annotated[
10144            StrictStr, Field(description="Unique identifier (ID) of the board that you want to copy.")
10145        ],
10146        copy_board_changes: Optional[CopyBoardChanges] = None,
10147        _request_timeout: Union[
10148            None,
10149            Annotated[StrictFloat, Field(gt=0)],
10150            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10151        ] = None,
10152        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10153        _content_type: Optional[StrictStr] = None,
10154        _headers: Optional[Dict[StrictStr, Any]] = None,
10155        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10156    ) -> BoardWithLinksAndWithoutProject:
10157        """Copy board
10158
10159        Creates a copy of an existing board. You can also update the name, description, sharing policy, and permissions policy for the new board in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 4</a><br/>
10160
10161        :param copy_from: Unique identifier (ID) of the board that you want to copy. (required)
10162        :type copy_from: str
10163        :param copy_board_changes:
10164        :type copy_board_changes: CopyBoardChanges
10165        :param _request_timeout: timeout setting for this request. If one
10166                                 number provided, it will be total request
10167                                 timeout. It can also be a pair (tuple) of
10168                                 (connection, read) timeouts.
10169        :type _request_timeout: int, tuple(int, int), optional
10170        :param _request_auth: set to override the auth_settings for an a single
10171                              request; this effectively ignores the
10172                              authentication in the spec for a single request.
10173        :type _request_auth: dict, optional
10174        :param _content_type: force content-type for the request.
10175        :type _content_type: str, Optional
10176        :param _headers: set to override the headers for a single
10177                         request; this effectively ignores the headers
10178                         in the spec for a single request.
10179        :type _headers: dict, optional
10180        :param _host_index: set to override the host_index for a single
10181                            request; this effectively ignores the host_index
10182                            in the spec for a single request.
10183        :type _host_index: int, optional
10184        :return: Returns the result object.
10185        """  # noqa: E501
10186
10187        _param = self._copy_board_serialize(
10188            copy_from=copy_from,
10189            copy_board_changes=copy_board_changes,
10190            _request_auth=_request_auth,
10191            _content_type=_content_type,
10192            _headers=_headers,
10193            _host_index=_host_index,
10194        )
10195
10196        _response_types_map: Dict[str, Optional[str]] = {
10197            "201": "BoardWithLinksAndWithoutProject",
10198            "400": None,
10199            "404": None,
10200            "409": None,
10201            "429": None,
10202        }
10203        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10204        response_data.read()
10205        return self.api_client.response_deserialize(
10206            response_data=response_data,
10207            response_types_map=_response_types_map,
10208        ).data

Copy board

Creates a copy of an existing board. You can also update the name, description, sharing policy, and permissions policy for the new board in the request body.

Required scope

Rate limiting

:param copy_from: Unique identifier (ID) of the board that you want to copy. (required) :type copy_from: str :param copy_board_changes: :type copy_board_changes: CopyBoardChanges :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_board( self, board_changes: Optional[miro_api.models.board_changes.BoardChanges] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_with_links.BoardWithLinks: View Source

10272    @validate_call
10273    def create_board(
10274        self,
10275        board_changes: Optional[BoardChanges] = None,
10276        _request_timeout: Union[
10277            None,
10278            Annotated[StrictFloat, Field(gt=0)],
10279            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10280        ] = None,
10281        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10282        _content_type: Optional[StrictStr] = None,
10283        _headers: Optional[Dict[StrictStr, Any]] = None,
10284        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10285    ) -> BoardWithLinks:
10286        """Create board
10287
10288        Creates a board with the specified name and sharing policies.<br/><h4>Note</h4> You can only create up to 3 team boards with the free plan.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
10289
10290        :param board_changes:
10291        :type board_changes: BoardChanges
10292        :param _request_timeout: timeout setting for this request. If one
10293                                 number provided, it will be total request
10294                                 timeout. It can also be a pair (tuple) of
10295                                 (connection, read) timeouts.
10296        :type _request_timeout: int, tuple(int, int), optional
10297        :param _request_auth: set to override the auth_settings for an a single
10298                              request; this effectively ignores the
10299                              authentication in the spec for a single request.
10300        :type _request_auth: dict, optional
10301        :param _content_type: force content-type for the request.
10302        :type _content_type: str, Optional
10303        :param _headers: set to override the headers for a single
10304                         request; this effectively ignores the headers
10305                         in the spec for a single request.
10306        :type _headers: dict, optional
10307        :param _host_index: set to override the host_index for a single
10308                            request; this effectively ignores the host_index
10309                            in the spec for a single request.
10310        :type _host_index: int, optional
10311        :return: Returns the result object.
10312        """  # noqa: E501
10313
10314        _param = self._create_board_serialize(
10315            board_changes=board_changes,
10316            _request_auth=_request_auth,
10317            _content_type=_content_type,
10318            _headers=_headers,
10319            _host_index=_host_index,
10320        )
10321
10322        _response_types_map: Dict[str, Optional[str]] = {
10323            "201": "BoardWithLinks",
10324            "400": None,
10325            "404": None,
10326            "409": None,
10327            "429": None,
10328        }
10329        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10330        response_data.read()
10331        return self.api_client.response_deserialize(
10332            response_data=response_data,
10333            response_types_map=_response_types_map,
10334        ).data

Create board

Creates a board with the specified name and sharing policies.

Note

You can only create up to 3 team boards with the free plan.

Required scope

Rate limiting

:param board_changes: :type board_changes: BoardChanges :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_board( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

10393    @validate_call
10394    def delete_board(
10395        self,
10396        board_id: Annotated[
10397            StrictStr, Field(description="Unique identifier (ID) of the board that you want to delete.")
10398        ],
10399        _request_timeout: Union[
10400            None,
10401            Annotated[StrictFloat, Field(gt=0)],
10402            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10403        ] = None,
10404        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10405        _content_type: Optional[StrictStr] = None,
10406        _headers: Optional[Dict[StrictStr, Any]] = None,
10407        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10408    ) -> object:
10409        """Delete board
10410
10411        Deletes a board. Deleted boards go to Trash (on paid plans) and can be restored via UI within 90 days after deletion.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
10412
10413        :param board_id: Unique identifier (ID) of the board that you want to delete. (required)
10414        :type board_id: str
10415        :param _request_timeout: timeout setting for this request. If one
10416                                 number provided, it will be total request
10417                                 timeout. It can also be a pair (tuple) of
10418                                 (connection, read) timeouts.
10419        :type _request_timeout: int, tuple(int, int), optional
10420        :param _request_auth: set to override the auth_settings for an a single
10421                              request; this effectively ignores the
10422                              authentication in the spec for a single request.
10423        :type _request_auth: dict, optional
10424        :param _content_type: force content-type for the request.
10425        :type _content_type: str, Optional
10426        :param _headers: set to override the headers for a single
10427                         request; this effectively ignores the headers
10428                         in the spec for a single request.
10429        :type _headers: dict, optional
10430        :param _host_index: set to override the host_index for a single
10431                            request; this effectively ignores the host_index
10432                            in the spec for a single request.
10433        :type _host_index: int, optional
10434        :return: Returns the result object.
10435        """  # noqa: E501
10436
10437        _param = self._delete_board_serialize(
10438            board_id=board_id,
10439            _request_auth=_request_auth,
10440            _content_type=_content_type,
10441            _headers=_headers,
10442            _host_index=_host_index,
10443        )
10444
10445        _response_types_map: Dict[str, Optional[str]] = {
10446            "204": "object",
10447            "400": None,
10448            "404": None,
10449            "409": None,
10450            "429": None,
10451        }
10452        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10453        response_data.read()
10454        return self.api_client.response_deserialize(
10455            response_data=response_data,
10456            response_types_map=_response_types_map,
10457        ).data

Delete board

Deletes a board. Deleted boards go to Trash (on paid plans) and can be restored via UI within 90 days after deletion.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board that you want to delete. (required) :type board_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_boards( self, team_id: Optional[Annotated[str, Strict(strict=True)]] = None, project_id: Optional[Annotated[str, Strict(strict=True)]] = None, query: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=500)])]] = None, owner: Optional[Annotated[str, Strict(strict=True)]] = None, limit: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] = None, offset: Optional[Annotated[str, Strict(strict=True)]] = None, sort: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.boards_paged_response.BoardsPagedResponse: View Source

10508    @validate_call
10509    def get_boards(
10510        self,
10511        team_id: Optional[StrictStr] = None,
10512        project_id: Optional[StrictStr] = None,
10513        query: Optional[Annotated[str, Field(strict=True, max_length=500)]] = None,
10514        owner: Optional[StrictStr] = None,
10515        limit: Optional[Annotated[str, Field(strict=True)]] = None,
10516        offset: Optional[StrictStr] = None,
10517        sort: Optional[StrictStr] = None,
10518        _request_timeout: Union[
10519            None,
10520            Annotated[StrictFloat, Field(gt=0)],
10521            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10522        ] = None,
10523        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10524        _content_type: Optional[StrictStr] = None,
10525        _headers: Optional[Dict[StrictStr, Any]] = None,
10526        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10527    ) -> BoardsPagedResponse:
10528        """Get boards
10529
10530        Retrieves a list of boards accessible to the user associated with the provided access token. This endpoint supports filtering and sorting through URL query parameters. Customize the response by specifying `team_id`, `project_id`, or other query parameters. Filtering by `team_id` or `project_id` (or both) returns results instantly. For other filters, allow a few seconds for indexing of newly created boards.  If you're an Enterprise customer with Company Admin permissions:    - Enable **Content Admin** permissions to retrieve all boards, including private boards (those not explicitly shared with you). For details, see the [Content Admin Permissions for Company Admins](https://help.miro.com/hc/en-us/articles/360012777280-Content-Admin-permissions-for-Company-Admins).   - Note that **Private board contents remain inaccessible**. The API allows you to verify their existence but prevents viewing their contents to uphold security best practices. Unauthorized access attempts will return an error. <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
10531
10532        :param team_id:
10533        :type team_id: str
10534        :param project_id:
10535        :type project_id: str
10536        :param query:
10537        :type query: str
10538        :param owner:
10539        :type owner: str
10540        :param limit:
10541        :type limit: str
10542        :param offset:
10543        :type offset: str
10544        :param sort:
10545        :type sort: str
10546        :param _request_timeout: timeout setting for this request. If one
10547                                 number provided, it will be total request
10548                                 timeout. It can also be a pair (tuple) of
10549                                 (connection, read) timeouts.
10550        :type _request_timeout: int, tuple(int, int), optional
10551        :param _request_auth: set to override the auth_settings for an a single
10552                              request; this effectively ignores the
10553                              authentication in the spec for a single request.
10554        :type _request_auth: dict, optional
10555        :param _content_type: force content-type for the request.
10556        :type _content_type: str, Optional
10557        :param _headers: set to override the headers for a single
10558                         request; this effectively ignores the headers
10559                         in the spec for a single request.
10560        :type _headers: dict, optional
10561        :param _host_index: set to override the host_index for a single
10562                            request; this effectively ignores the host_index
10563                            in the spec for a single request.
10564        :type _host_index: int, optional
10565        :return: Returns the result object.
10566        """  # noqa: E501
10567
10568        _param = self._get_boards_serialize(
10569            team_id=team_id,
10570            project_id=project_id,
10571            query=query,
10572            owner=owner,
10573            limit=limit,
10574            offset=offset,
10575            sort=sort,
10576            _request_auth=_request_auth,
10577            _content_type=_content_type,
10578            _headers=_headers,
10579            _host_index=_host_index,
10580        )
10581
10582        _response_types_map: Dict[str, Optional[str]] = {
10583            "200": "BoardsPagedResponse",
10584            "400": None,
10585            "404": None,
10586            "429": None,
10587        }
10588        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10589        response_data.read()
10590        return self.api_client.response_deserialize(
10591            response_data=response_data,
10592            response_types_map=_response_types_map,
10593        ).data

Get boards

Retrieves a list of boards accessible to the user associated with the provided access token. This endpoint supports filtering and sorting through URL query parameters. Customize the response by specifying team_id, project_id, or other query parameters. Filtering by team_id or project_id (or both) returns results instantly. For other filters, allow a few seconds for indexing of newly created boards. If you're an Enterprise customer with Company Admin permissions: - Enable Content Admin permissions to retrieve all boards, including private boards (those not explicitly shared with you). For details, see the Content Admin Permissions for Company Admins. - Note that Private board contents remain inaccessible. The API allows you to verify their existence but prevents viewing their contents to uphold security best practices. Unauthorized access attempts will return an error.

Required scope

Rate limiting

:param team_id: :type team_id: str :param project_id: :type project_id: str :param query: :type query: str :param owner: :type owner: str :param limit: :type limit: str :param offset: :type offset: str :param sort: :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_specific_board( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_with_links_and_last_opened.BoardWithLinksAndLastOpened: View Source

10676    @validate_call
10677    def get_specific_board(
10678        self,
10679        board_id: Annotated[
10680            StrictStr, Field(description="Unique identifier (ID) of the board that you want to retrieve.")
10681        ],
10682        _request_timeout: Union[
10683            None,
10684            Annotated[StrictFloat, Field(gt=0)],
10685            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10686        ] = None,
10687        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10688        _content_type: Optional[StrictStr] = None,
10689        _headers: Optional[Dict[StrictStr, Any]] = None,
10690        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10691    ) -> BoardWithLinksAndLastOpened:
10692        """Get specific board
10693
10694        Retrieves information about a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
10695
10696        :param board_id: Unique identifier (ID) of the board that you want to retrieve. (required)
10697        :type board_id: str
10698        :param _request_timeout: timeout setting for this request. If one
10699                                 number provided, it will be total request
10700                                 timeout. It can also be a pair (tuple) of
10701                                 (connection, read) timeouts.
10702        :type _request_timeout: int, tuple(int, int), optional
10703        :param _request_auth: set to override the auth_settings for an a single
10704                              request; this effectively ignores the
10705                              authentication in the spec for a single request.
10706        :type _request_auth: dict, optional
10707        :param _content_type: force content-type for the request.
10708        :type _content_type: str, Optional
10709        :param _headers: set to override the headers for a single
10710                         request; this effectively ignores the headers
10711                         in the spec for a single request.
10712        :type _headers: dict, optional
10713        :param _host_index: set to override the host_index for a single
10714                            request; this effectively ignores the host_index
10715                            in the spec for a single request.
10716        :type _host_index: int, optional
10717        :return: Returns the result object.
10718        """  # noqa: E501
10719
10720        _param = self._get_specific_board_serialize(
10721            board_id=board_id,
10722            _request_auth=_request_auth,
10723            _content_type=_content_type,
10724            _headers=_headers,
10725            _host_index=_host_index,
10726        )
10727
10728        _response_types_map: Dict[str, Optional[str]] = {
10729            "200": "BoardWithLinksAndLastOpened",
10730            "400": None,
10731            "404": None,
10732            "429": None,
10733        }
10734        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10735        response_data.read()
10736        return self.api_client.response_deserialize(
10737            response_data=response_data,
10738            response_types_map=_response_types_map,
10739        ).data

Get specific board

Retrieves information about a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board that you want to retrieve. (required) :type board_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_board( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board that you want to update.')], board_changes: miro_api.models.board_changes.BoardChanges, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.board_with_links.BoardWithLinks: View Source

10790    @validate_call
10791    def update_board(
10792        self,
10793        board_id: Annotated[
10794            StrictStr, Field(description="Unique identifier (ID) of the board that you want to update.")
10795        ],
10796        board_changes: BoardChanges,
10797        _request_timeout: Union[
10798            None,
10799            Annotated[StrictFloat, Field(gt=0)],
10800            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10801        ] = None,
10802        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10803        _content_type: Optional[StrictStr] = None,
10804        _headers: Optional[Dict[StrictStr, Any]] = None,
10805        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10806    ) -> BoardWithLinks:
10807        """Update board
10808
10809        Updates a specific board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
10810
10811        :param board_id: Unique identifier (ID) of the board that you want to update. (required)
10812        :type board_id: str
10813        :param board_changes: (required)
10814        :type board_changes: BoardChanges
10815        :param _request_timeout: timeout setting for this request. If one
10816                                 number provided, it will be total request
10817                                 timeout. It can also be a pair (tuple) of
10818                                 (connection, read) timeouts.
10819        :type _request_timeout: int, tuple(int, int), optional
10820        :param _request_auth: set to override the auth_settings for an a single
10821                              request; this effectively ignores the
10822                              authentication in the spec for a single request.
10823        :type _request_auth: dict, optional
10824        :param _content_type: force content-type for the request.
10825        :type _content_type: str, Optional
10826        :param _headers: set to override the headers for a single
10827                         request; this effectively ignores the headers
10828                         in the spec for a single request.
10829        :type _headers: dict, optional
10830        :param _host_index: set to override the host_index for a single
10831                            request; this effectively ignores the host_index
10832                            in the spec for a single request.
10833        :type _host_index: int, optional
10834        :return: Returns the result object.
10835        """  # noqa: E501
10836
10837        _param = self._update_board_serialize(
10838            board_id=board_id,
10839            board_changes=board_changes,
10840            _request_auth=_request_auth,
10841            _content_type=_content_type,
10842            _headers=_headers,
10843            _host_index=_host_index,
10844        )
10845
10846        _response_types_map: Dict[str, Optional[str]] = {
10847            "200": "BoardWithLinks",
10848            "202": None,
10849            "400": None,
10850            "404": None,
10851            "409": None,
10852            "429": None,
10853        }
10854        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10855        response_data.read()
10856        return self.api_client.response_deserialize(
10857            response_data=response_data,
10858            response_types_map=_response_types_map,
10859        ).data

Update board

Updates a specific board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board that you want to update. (required) :type board_id: str :param board_changes: (required) :type board_changes: BoardChanges :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_card_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], card_create_request: miro_api.models.card_create_request.CardCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.card_item.CardItem: View Source

10921    @validate_call
10922    def create_card_item(
10923        self,
10924        board_id: Annotated[
10925            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
10926        ],
10927        card_create_request: CardCreateRequest,
10928        _request_timeout: Union[
10929            None,
10930            Annotated[StrictFloat, Field(gt=0)],
10931            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10932        ] = None,
10933        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10934        _content_type: Optional[StrictStr] = None,
10935        _headers: Optional[Dict[StrictStr, Any]] = None,
10936        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10937    ) -> CardItem:
10938        """Create card item
10939
10940        Adds a card item to a board<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
10941
10942        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
10943        :type board_id: str
10944        :param card_create_request: (required)
10945        :type card_create_request: CardCreateRequest
10946        :param _request_timeout: timeout setting for this request. If one
10947                                 number provided, it will be total request
10948                                 timeout. It can also be a pair (tuple) of
10949                                 (connection, read) timeouts.
10950        :type _request_timeout: int, tuple(int, int), optional
10951        :param _request_auth: set to override the auth_settings for an a single
10952                              request; this effectively ignores the
10953                              authentication in the spec for a single request.
10954        :type _request_auth: dict, optional
10955        :param _content_type: force content-type for the request.
10956        :type _content_type: str, Optional
10957        :param _headers: set to override the headers for a single
10958                         request; this effectively ignores the headers
10959                         in the spec for a single request.
10960        :type _headers: dict, optional
10961        :param _host_index: set to override the host_index for a single
10962                            request; this effectively ignores the host_index
10963                            in the spec for a single request.
10964        :type _host_index: int, optional
10965        :return: Returns the result object.
10966        """  # noqa: E501
10967
10968        _param = self._create_card_item_serialize(
10969            board_id=board_id,
10970            card_create_request=card_create_request,
10971            _request_auth=_request_auth,
10972            _content_type=_content_type,
10973            _headers=_headers,
10974            _host_index=_host_index,
10975        )
10976
10977        _response_types_map: Dict[str, Optional[str]] = {
10978            "201": "CardItem",
10979            "400": None,
10980            "404": None,
10981            "429": None,
10982        }
10983        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10984        response_data.read()
10985        return self.api_client.response_deserialize(
10986            response_data=response_data,
10987            response_types_map=_response_types_map,
10988        ).data

Create card item

Adds a card item to a board

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param card_create_request: (required) :type card_create_request: CardCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_card_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

11050    @validate_call
11051    def delete_card_item(
11052        self,
11053        board_id: Annotated[
11054            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
11055        ],
11056        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
11057        _request_timeout: Union[
11058            None,
11059            Annotated[StrictFloat, Field(gt=0)],
11060            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11061        ] = None,
11062        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11063        _content_type: Optional[StrictStr] = None,
11064        _headers: Optional[Dict[StrictStr, Any]] = None,
11065        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11066    ) -> object:
11067        """Delete card item
11068
11069        Deletes a card item from the board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
11070
11071        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
11072        :type board_id: str
11073        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
11074        :type item_id: str
11075        :param _request_timeout: timeout setting for this request. If one
11076                                 number provided, it will be total request
11077                                 timeout. It can also be a pair (tuple) of
11078                                 (connection, read) timeouts.
11079        :type _request_timeout: int, tuple(int, int), optional
11080        :param _request_auth: set to override the auth_settings for an a single
11081                              request; this effectively ignores the
11082                              authentication in the spec for a single request.
11083        :type _request_auth: dict, optional
11084        :param _content_type: force content-type for the request.
11085        :type _content_type: str, Optional
11086        :param _headers: set to override the headers for a single
11087                         request; this effectively ignores the headers
11088                         in the spec for a single request.
11089        :type _headers: dict, optional
11090        :param _host_index: set to override the host_index for a single
11091                            request; this effectively ignores the host_index
11092                            in the spec for a single request.
11093        :type _host_index: int, optional
11094        :return: Returns the result object.
11095        """  # noqa: E501
11096
11097        _param = self._delete_card_item_serialize(
11098            board_id=board_id,
11099            item_id=item_id,
11100            _request_auth=_request_auth,
11101            _content_type=_content_type,
11102            _headers=_headers,
11103            _host_index=_host_index,
11104        )
11105
11106        _response_types_map: Dict[str, Optional[str]] = {
11107            "204": "object",
11108            "400": None,
11109            "404": None,
11110            "429": None,
11111        }
11112        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11113        response_data.read()
11114        return self.api_client.response_deserialize(
11115            response_data=response_data,
11116            response_types_map=_response_types_map,
11117        ).data

Delete card item

Deletes a card item from the board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_card_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.card_item.CardItem: View Source

11171    @validate_call
11172    def get_card_item(
11173        self,
11174        board_id: Annotated[
11175            StrictStr,
11176            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
11177        ],
11178        item_id: Annotated[
11179            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
11180        ],
11181        _request_timeout: Union[
11182            None,
11183            Annotated[StrictFloat, Field(gt=0)],
11184            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11185        ] = None,
11186        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11187        _content_type: Optional[StrictStr] = None,
11188        _headers: Optional[Dict[StrictStr, Any]] = None,
11189        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11190    ) -> CardItem:
11191        """Get card item
11192
11193        Retrieves information for a specific card item on a board<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
11194
11195        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
11196        :type board_id: str
11197        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
11198        :type item_id: str
11199        :param _request_timeout: timeout setting for this request. If one
11200                                 number provided, it will be total request
11201                                 timeout. It can also be a pair (tuple) of
11202                                 (connection, read) timeouts.
11203        :type _request_timeout: int, tuple(int, int), optional
11204        :param _request_auth: set to override the auth_settings for an a single
11205                              request; this effectively ignores the
11206                              authentication in the spec for a single request.
11207        :type _request_auth: dict, optional
11208        :param _content_type: force content-type for the request.
11209        :type _content_type: str, Optional
11210        :param _headers: set to override the headers for a single
11211                         request; this effectively ignores the headers
11212                         in the spec for a single request.
11213        :type _headers: dict, optional
11214        :param _host_index: set to override the host_index for a single
11215                            request; this effectively ignores the host_index
11216                            in the spec for a single request.
11217        :type _host_index: int, optional
11218        :return: Returns the result object.
11219        """  # noqa: E501
11220
11221        _param = self._get_card_item_serialize(
11222            board_id=board_id,
11223            item_id=item_id,
11224            _request_auth=_request_auth,
11225            _content_type=_content_type,
11226            _headers=_headers,
11227            _host_index=_host_index,
11228        )
11229
11230        _response_types_map: Dict[str, Optional[str]] = {
11231            "200": "CardItem",
11232            "400": None,
11233            "404": None,
11234            "429": None,
11235        }
11236        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11237        response_data.read()
11238        return self.api_client.response_deserialize(
11239            response_data=response_data,
11240            response_types_map=_response_types_map,
11241        ).data

Get card item

Retrieves information for a specific card item on a board

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_card_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], card_update_request: miro_api.models.card_update_request.CardUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.card_item.CardItem: View Source

11295    @validate_call
11296    def update_card_item(
11297        self,
11298        board_id: Annotated[
11299            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
11300        ],
11301        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
11302        card_update_request: CardUpdateRequest,
11303        _request_timeout: Union[
11304            None,
11305            Annotated[StrictFloat, Field(gt=0)],
11306            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11307        ] = None,
11308        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11309        _content_type: Optional[StrictStr] = None,
11310        _headers: Optional[Dict[StrictStr, Any]] = None,
11311        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11312    ) -> CardItem:
11313        """Update card item
11314
11315        Updates a card item on a board based on the data and style properties provided in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
11316
11317        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
11318        :type board_id: str
11319        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
11320        :type item_id: str
11321        :param card_update_request: (required)
11322        :type card_update_request: CardUpdateRequest
11323        :param _request_timeout: timeout setting for this request. If one
11324                                 number provided, it will be total request
11325                                 timeout. It can also be a pair (tuple) of
11326                                 (connection, read) timeouts.
11327        :type _request_timeout: int, tuple(int, int), optional
11328        :param _request_auth: set to override the auth_settings for an a single
11329                              request; this effectively ignores the
11330                              authentication in the spec for a single request.
11331        :type _request_auth: dict, optional
11332        :param _content_type: force content-type for the request.
11333        :type _content_type: str, Optional
11334        :param _headers: set to override the headers for a single
11335                         request; this effectively ignores the headers
11336                         in the spec for a single request.
11337        :type _headers: dict, optional
11338        :param _host_index: set to override the host_index for a single
11339                            request; this effectively ignores the host_index
11340                            in the spec for a single request.
11341        :type _host_index: int, optional
11342        :return: Returns the result object.
11343        """  # noqa: E501
11344
11345        _param = self._update_card_item_serialize(
11346            board_id=board_id,
11347            item_id=item_id,
11348            card_update_request=card_update_request,
11349            _request_auth=_request_auth,
11350            _content_type=_content_type,
11351            _headers=_headers,
11352            _host_index=_host_index,
11353        )
11354
11355        _response_types_map: Dict[str, Optional[str]] = {
11356            "200": "CardItem",
11357            "400": None,
11358            "404": None,
11359            "409": None,
11360            "429": None,
11361        }
11362        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11363        response_data.read()
11364        return self.api_client.response_deserialize(
11365            response_data=response_data,
11366            response_types_map=_response_types_map,
11367        ).data

Update card item

Updates a card item on a board based on the data and style properties provided in the request body.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param card_update_request: (required) :type card_update_request: CardUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_connector( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board for which you want to create the connector.')], connector_creation_data: miro_api.models.connector_creation_data.ConnectorCreationData, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.connector_with_links.ConnectorWithLinks: View Source

11432    @validate_call
11433    def create_connector(
11434        self,
11435        board_id: Annotated[
11436            StrictStr,
11437            Field(description="Unique identifier (ID) of the board for which you want to create the connector."),
11438        ],
11439        connector_creation_data: ConnectorCreationData,
11440        _request_timeout: Union[
11441            None,
11442            Annotated[StrictFloat, Field(gt=0)],
11443            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11444        ] = None,
11445        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11446        _content_type: Optional[StrictStr] = None,
11447        _headers: Optional[Dict[StrictStr, Any]] = None,
11448        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11449    ) -> ConnectorWithLinks:
11450        """Create connector
11451
11452        Adds a connector to a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
11453
11454        :param board_id: Unique identifier (ID) of the board for which you want to create the connector. (required)
11455        :type board_id: str
11456        :param connector_creation_data: (required)
11457        :type connector_creation_data: ConnectorCreationData
11458        :param _request_timeout: timeout setting for this request. If one
11459                                 number provided, it will be total request
11460                                 timeout. It can also be a pair (tuple) of
11461                                 (connection, read) timeouts.
11462        :type _request_timeout: int, tuple(int, int), optional
11463        :param _request_auth: set to override the auth_settings for an a single
11464                              request; this effectively ignores the
11465                              authentication in the spec for a single request.
11466        :type _request_auth: dict, optional
11467        :param _content_type: force content-type for the request.
11468        :type _content_type: str, Optional
11469        :param _headers: set to override the headers for a single
11470                         request; this effectively ignores the headers
11471                         in the spec for a single request.
11472        :type _headers: dict, optional
11473        :param _host_index: set to override the host_index for a single
11474                            request; this effectively ignores the host_index
11475                            in the spec for a single request.
11476        :type _host_index: int, optional
11477        :return: Returns the result object.
11478        """  # noqa: E501
11479
11480        _param = self._create_connector_serialize(
11481            board_id=board_id,
11482            connector_creation_data=connector_creation_data,
11483            _request_auth=_request_auth,
11484            _content_type=_content_type,
11485            _headers=_headers,
11486            _host_index=_host_index,
11487        )
11488
11489        _response_types_map: Dict[str, Optional[str]] = {
11490            "200": "ConnectorWithLinks",
11491            "400": None,
11492            "404": None,
11493            "429": None,
11494        }
11495        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11496        response_data.read()
11497        return self.api_client.response_deserialize(
11498            response_data=response_data,
11499            response_types_map=_response_types_map,
11500        ).data

Create connector

Adds a connector to a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board for which you want to create the connector. (required) :type board_id: str :param connector_creation_data: (required) :type connector_creation_data: ConnectorCreationData :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_connector( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the connector.')], connector_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the connector that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

11562    @validate_call
11563    def delete_connector(
11564        self,
11565        board_id: Annotated[
11566            StrictStr,
11567            Field(description="Unique identifier (ID) of the board from which you want to delete the connector."),
11568        ],
11569        connector_id: Annotated[
11570            StrictStr, Field(description="Unique identifier (ID) of the connector that you want to delete.")
11571        ],
11572        _request_timeout: Union[
11573            None,
11574            Annotated[StrictFloat, Field(gt=0)],
11575            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11576        ] = None,
11577        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11578        _content_type: Optional[StrictStr] = None,
11579        _headers: Optional[Dict[StrictStr, Any]] = None,
11580        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11581    ) -> object:
11582        """Delete connector
11583
11584        Deletes the specified connector from the board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
11585
11586        :param board_id: Unique identifier (ID) of the board from which you want to delete the connector. (required)
11587        :type board_id: str
11588        :param connector_id: Unique identifier (ID) of the connector that you want to delete. (required)
11589        :type connector_id: str
11590        :param _request_timeout: timeout setting for this request. If one
11591                                 number provided, it will be total request
11592                                 timeout. It can also be a pair (tuple) of
11593                                 (connection, read) timeouts.
11594        :type _request_timeout: int, tuple(int, int), optional
11595        :param _request_auth: set to override the auth_settings for an a single
11596                              request; this effectively ignores the
11597                              authentication in the spec for a single request.
11598        :type _request_auth: dict, optional
11599        :param _content_type: force content-type for the request.
11600        :type _content_type: str, Optional
11601        :param _headers: set to override the headers for a single
11602                         request; this effectively ignores the headers
11603                         in the spec for a single request.
11604        :type _headers: dict, optional
11605        :param _host_index: set to override the host_index for a single
11606                            request; this effectively ignores the host_index
11607                            in the spec for a single request.
11608        :type _host_index: int, optional
11609        :return: Returns the result object.
11610        """  # noqa: E501
11611
11612        _param = self._delete_connector_serialize(
11613            board_id=board_id,
11614            connector_id=connector_id,
11615            _request_auth=_request_auth,
11616            _content_type=_content_type,
11617            _headers=_headers,
11618            _host_index=_host_index,
11619        )
11620
11621        _response_types_map: Dict[str, Optional[str]] = {
11622            "204": "object",
11623            "400": None,
11624            "404": None,
11625            "429": None,
11626        }
11627        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11628        response_data.read()
11629        return self.api_client.response_deserialize(
11630            response_data=response_data,
11631            response_types_map=_response_types_map,
11632        ).data

Delete connector

Deletes the specified connector from the board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the connector. (required) :type board_id: str :param connector_id: Unique identifier (ID) of the connector that you want to delete. (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_connector( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific connector.')], connector_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the connector that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.connector_with_links.ConnectorWithLinks: View Source

11686    @validate_call
11687    def get_connector(
11688        self,
11689        board_id: Annotated[
11690            StrictStr,
11691            Field(
11692                description="Unique identifier (ID) of the board from which you want to retrieve a specific connector."
11693            ),
11694        ],
11695        connector_id: Annotated[
11696            StrictStr, Field(description="Unique identifier (ID) of the connector that you want to retrieve.")
11697        ],
11698        _request_timeout: Union[
11699            None,
11700            Annotated[StrictFloat, Field(gt=0)],
11701            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11702        ] = None,
11703        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11704        _content_type: Optional[StrictStr] = None,
11705        _headers: Optional[Dict[StrictStr, Any]] = None,
11706        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11707    ) -> ConnectorWithLinks:
11708        """Get specific connector
11709
11710        Retrieves information for a specific connector on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
11711
11712        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific connector. (required)
11713        :type board_id: str
11714        :param connector_id: Unique identifier (ID) of the connector that you want to retrieve. (required)
11715        :type connector_id: str
11716        :param _request_timeout: timeout setting for this request. If one
11717                                 number provided, it will be total request
11718                                 timeout. It can also be a pair (tuple) of
11719                                 (connection, read) timeouts.
11720        :type _request_timeout: int, tuple(int, int), optional
11721        :param _request_auth: set to override the auth_settings for an a single
11722                              request; this effectively ignores the
11723                              authentication in the spec for a single request.
11724        :type _request_auth: dict, optional
11725        :param _content_type: force content-type for the request.
11726        :type _content_type: str, Optional
11727        :param _headers: set to override the headers for a single
11728                         request; this effectively ignores the headers
11729                         in the spec for a single request.
11730        :type _headers: dict, optional
11731        :param _host_index: set to override the host_index for a single
11732                            request; this effectively ignores the host_index
11733                            in the spec for a single request.
11734        :type _host_index: int, optional
11735        :return: Returns the result object.
11736        """  # noqa: E501
11737
11738        _param = self._get_connector_serialize(
11739            board_id=board_id,
11740            connector_id=connector_id,
11741            _request_auth=_request_auth,
11742            _content_type=_content_type,
11743            _headers=_headers,
11744            _host_index=_host_index,
11745        )
11746
11747        _response_types_map: Dict[str, Optional[str]] = {
11748            "200": "ConnectorWithLinks",
11749            "400": None,
11750            "404": None,
11751            "429": None,
11752        }
11753        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11754        response_data.read()
11755        return self.api_client.response_deserialize(
11756            response_data=response_data,
11757            response_types_map=_response_types_map,
11758        ).data

Get specific connector

Retrieves information for a specific connector on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific connector. (required) :type board_id: str :param connector_id: Unique identifier (ID) of the connector that you want to retrieve. (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_connectors( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a list of connectors.')], limit: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] = None, cursor: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.connectors_cursor_paged.ConnectorsCursorPaged: View Source

11812    @validate_call
11813    def get_connectors(
11814        self,
11815        board_id: Annotated[
11816            StrictStr,
11817            Field(
11818                description="Unique identifier (ID) of the board from which you want to retrieve a list of connectors."
11819            ),
11820        ],
11821        limit: Optional[Annotated[str, Field(strict=True)]] = None,
11822        cursor: Optional[StrictStr] = None,
11823        _request_timeout: Union[
11824            None,
11825            Annotated[StrictFloat, Field(gt=0)],
11826            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11827        ] = None,
11828        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11829        _content_type: Optional[StrictStr] = None,
11830        _headers: Optional[Dict[StrictStr, Any]] = None,
11831        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11832    ) -> ConnectorsCursorPaged:
11833        """Get connectors
11834
11835        Retrieves a list of connectors for a specific board.  This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the `cursor` parameter equal to the `cursor` value you received in the response of the previous request. For example, if you set the `limit` query parameter to `10` and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is `foo`. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to `foo`.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
11836
11837        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a list of connectors. (required)
11838        :type board_id: str
11839        :param limit:
11840        :type limit: str
11841        :param cursor:
11842        :type cursor: str
11843        :param _request_timeout: timeout setting for this request. If one
11844                                 number provided, it will be total request
11845                                 timeout. It can also be a pair (tuple) of
11846                                 (connection, read) timeouts.
11847        :type _request_timeout: int, tuple(int, int), optional
11848        :param _request_auth: set to override the auth_settings for an a single
11849                              request; this effectively ignores the
11850                              authentication in the spec for a single request.
11851        :type _request_auth: dict, optional
11852        :param _content_type: force content-type for the request.
11853        :type _content_type: str, Optional
11854        :param _headers: set to override the headers for a single
11855                         request; this effectively ignores the headers
11856                         in the spec for a single request.
11857        :type _headers: dict, optional
11858        :param _host_index: set to override the host_index for a single
11859                            request; this effectively ignores the host_index
11860                            in the spec for a single request.
11861        :type _host_index: int, optional
11862        :return: Returns the result object.
11863        """  # noqa: E501
11864
11865        _param = self._get_connectors_serialize(
11866            board_id=board_id,
11867            limit=limit,
11868            cursor=cursor,
11869            _request_auth=_request_auth,
11870            _content_type=_content_type,
11871            _headers=_headers,
11872            _host_index=_host_index,
11873        )
11874
11875        _response_types_map: Dict[str, Optional[str]] = {
11876            "200": "ConnectorsCursorPaged",
11877            "400": None,
11878            "404": None,
11879            "429": None,
11880        }
11881        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11882        response_data.read()
11883        return self.api_client.response_deserialize(
11884            response_data=response_data,
11885            response_types_map=_response_types_map,
11886        ).data

Get connectors

Retrieves a list of connectors for a specific board. This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the cursor parameter equal to the cursor value you received in the response of the previous request. For example, if you set the limit query parameter to 10 and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is foo. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to foo.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a list of connectors. (required) :type board_id: str :param limit: :type limit: str :param cursor: :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_connector( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board for which you want to update the connector.')], connector_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the connector that you want to update.')], connector_changes_data: miro_api.models.connector_changes_data.ConnectorChangesData, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.connector_with_links.ConnectorWithLinks: View Source

11947    @validate_call
11948    def update_connector(
11949        self,
11950        board_id: Annotated[
11951            StrictStr,
11952            Field(description="Unique identifier (ID) of the board for which you want to update the connector."),
11953        ],
11954        connector_id: Annotated[
11955            StrictStr, Field(description="Unique identifier (ID) of the connector that you want to update.")
11956        ],
11957        connector_changes_data: ConnectorChangesData,
11958        _request_timeout: Union[
11959            None,
11960            Annotated[StrictFloat, Field(gt=0)],
11961            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11962        ] = None,
11963        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11964        _content_type: Optional[StrictStr] = None,
11965        _headers: Optional[Dict[StrictStr, Any]] = None,
11966        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11967    ) -> ConnectorWithLinks:
11968        """Update connector
11969
11970        Updates a connector on a board based on the data and style properties provided in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
11971
11972        :param board_id: Unique identifier (ID) of the board for which you want to update the connector. (required)
11973        :type board_id: str
11974        :param connector_id: Unique identifier (ID) of the connector that you want to update. (required)
11975        :type connector_id: str
11976        :param connector_changes_data: (required)
11977        :type connector_changes_data: ConnectorChangesData
11978        :param _request_timeout: timeout setting for this request. If one
11979                                 number provided, it will be total request
11980                                 timeout. It can also be a pair (tuple) of
11981                                 (connection, read) timeouts.
11982        :type _request_timeout: int, tuple(int, int), optional
11983        :param _request_auth: set to override the auth_settings for an a single
11984                              request; this effectively ignores the
11985                              authentication in the spec for a single request.
11986        :type _request_auth: dict, optional
11987        :param _content_type: force content-type for the request.
11988        :type _content_type: str, Optional
11989        :param _headers: set to override the headers for a single
11990                         request; this effectively ignores the headers
11991                         in the spec for a single request.
11992        :type _headers: dict, optional
11993        :param _host_index: set to override the host_index for a single
11994                            request; this effectively ignores the host_index
11995                            in the spec for a single request.
11996        :type _host_index: int, optional
11997        :return: Returns the result object.
11998        """  # noqa: E501
11999
12000        _param = self._update_connector_serialize(
12001            board_id=board_id,
12002            connector_id=connector_id,
12003            connector_changes_data=connector_changes_data,
12004            _request_auth=_request_auth,
12005            _content_type=_content_type,
12006            _headers=_headers,
12007            _host_index=_host_index,
12008        )
12009
12010        _response_types_map: Dict[str, Optional[str]] = {
12011            "200": "ConnectorWithLinks",
12012            "400": None,
12013            "404": None,
12014            "409": None,
12015            "429": None,
12016        }
12017        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12018        response_data.read()
12019        return self.api_client.response_deserialize(
12020            response_data=response_data,
12021            response_types_map=_response_types_map,
12022        ).data

Update connector

Updates a connector on a board based on the data and style properties provided in the request body.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board for which you want to update the connector. (required) :type board_id: str :param connector_id: Unique identifier (ID) of the connector that you want to update. (required) :type connector_id: str :param connector_changes_data: (required) :type connector_changes_data: ConnectorChangesData :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_document_item_using_file_from_device( self, board_id_platform_file_upload: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], resource: Annotated[Union[Annotated[bytes, Strict(strict=True)], Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Select a file to upload. Maximum file size is 6 MB.')], data: Optional[miro_api.models.create_document_item_using_file_from_device_request_data.CreateDocumentItemUsingFileFromDeviceRequestData] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.document_item.DocumentItem: View Source

12087    @validate_call
12088    def create_document_item_using_file_from_device(
12089        self,
12090        board_id_platform_file_upload: Annotated[
12091            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
12092        ],
12093        resource: Annotated[
12094            Union[StrictBytes, StrictStr], Field(description="Select a file to upload. Maximum file size is 6 MB.")
12095        ],
12096        data: Optional[CreateDocumentItemUsingFileFromDeviceRequestData] = None,
12097        _request_timeout: Union[
12098            None,
12099            Annotated[StrictFloat, Field(gt=0)],
12100            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12101        ] = None,
12102        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12103        _content_type: Optional[StrictStr] = None,
12104        _headers: Optional[Dict[StrictStr, Any]] = None,
12105        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12106    ) -> DocumentItem:
12107        """Create document item using file from device
12108
12109        Adds a document item to a board by selecting file from device.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
12110
12111        :param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to create the item. (required)
12112        :type board_id_platform_file_upload: str
12113        :param resource: Select a file to upload. Maximum file size is 6 MB. (required)
12114        :type resource: bytearray
12115        :param data:
12116        :type data: CreateDocumentItemUsingFileFromDeviceRequestData
12117        :param _request_timeout: timeout setting for this request. If one
12118                                 number provided, it will be total request
12119                                 timeout. It can also be a pair (tuple) of
12120                                 (connection, read) timeouts.
12121        :type _request_timeout: int, tuple(int, int), optional
12122        :param _request_auth: set to override the auth_settings for an a single
12123                              request; this effectively ignores the
12124                              authentication in the spec for a single request.
12125        :type _request_auth: dict, optional
12126        :param _content_type: force content-type for the request.
12127        :type _content_type: str, Optional
12128        :param _headers: set to override the headers for a single
12129                         request; this effectively ignores the headers
12130                         in the spec for a single request.
12131        :type _headers: dict, optional
12132        :param _host_index: set to override the host_index for a single
12133                            request; this effectively ignores the host_index
12134                            in the spec for a single request.
12135        :type _host_index: int, optional
12136        :return: Returns the result object.
12137        """  # noqa: E501
12138
12139        _param = self._create_document_item_using_file_from_device_serialize(
12140            board_id_platform_file_upload=board_id_platform_file_upload,
12141            resource=resource,
12142            data=data,
12143            _request_auth=_request_auth,
12144            _content_type=_content_type,
12145            _headers=_headers,
12146            _host_index=_host_index,
12147        )
12148
12149        _response_types_map: Dict[str, Optional[str]] = {
12150            "201": "DocumentItem",
12151        }
12152        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12153        response_data.read()
12154        return self.api_client.response_deserialize(
12155            response_data=response_data,
12156            response_types_map=_response_types_map,
12157        ).data

Create document item using file from device

Adds a document item to a board by selecting file from device.

Required scope

Rate limiting

:param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id_platform_file_upload: str :param resource: Select a file to upload. Maximum file size is 6 MB. (required) :type resource: bytearray :param data: :type data: CreateDocumentItemUsingFileFromDeviceRequestData :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_document_item_using_url( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], document_create_request: miro_api.models.document_create_request.DocumentCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.document_item.DocumentItem: View Source

12222    @validate_call
12223    def create_document_item_using_url(
12224        self,
12225        board_id: Annotated[
12226            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
12227        ],
12228        document_create_request: DocumentCreateRequest,
12229        _request_timeout: Union[
12230            None,
12231            Annotated[StrictFloat, Field(gt=0)],
12232            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12233        ] = None,
12234        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12235        _content_type: Optional[StrictStr] = None,
12236        _headers: Optional[Dict[StrictStr, Any]] = None,
12237        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12238    ) -> DocumentItem:
12239        """Create document item using URL
12240
12241        Adds a document item to a board by specifying the URL where the document is hosted.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
12242
12243        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
12244        :type board_id: str
12245        :param document_create_request: (required)
12246        :type document_create_request: DocumentCreateRequest
12247        :param _request_timeout: timeout setting for this request. If one
12248                                 number provided, it will be total request
12249                                 timeout. It can also be a pair (tuple) of
12250                                 (connection, read) timeouts.
12251        :type _request_timeout: int, tuple(int, int), optional
12252        :param _request_auth: set to override the auth_settings for an a single
12253                              request; this effectively ignores the
12254                              authentication in the spec for a single request.
12255        :type _request_auth: dict, optional
12256        :param _content_type: force content-type for the request.
12257        :type _content_type: str, Optional
12258        :param _headers: set to override the headers for a single
12259                         request; this effectively ignores the headers
12260                         in the spec for a single request.
12261        :type _headers: dict, optional
12262        :param _host_index: set to override the host_index for a single
12263                            request; this effectively ignores the host_index
12264                            in the spec for a single request.
12265        :type _host_index: int, optional
12266        :return: Returns the result object.
12267        """  # noqa: E501
12268
12269        _param = self._create_document_item_using_url_serialize(
12270            board_id=board_id,
12271            document_create_request=document_create_request,
12272            _request_auth=_request_auth,
12273            _content_type=_content_type,
12274            _headers=_headers,
12275            _host_index=_host_index,
12276        )
12277
12278        _response_types_map: Dict[str, Optional[str]] = {
12279            "201": "DocumentItem",
12280            "400": None,
12281            "404": None,
12282            "429": None,
12283        }
12284        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12285        response_data.read()
12286        return self.api_client.response_deserialize(
12287            response_data=response_data,
12288            response_types_map=_response_types_map,
12289        ).data

Create document item using URL

Adds a document item to a board by specifying the URL where the document is hosted.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param document_create_request: (required) :type document_create_request: DocumentCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_document_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

12351    @validate_call
12352    def delete_document_item(
12353        self,
12354        board_id: Annotated[
12355            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
12356        ],
12357        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
12358        _request_timeout: Union[
12359            None,
12360            Annotated[StrictFloat, Field(gt=0)],
12361            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12362        ] = None,
12363        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12364        _content_type: Optional[StrictStr] = None,
12365        _headers: Optional[Dict[StrictStr, Any]] = None,
12366        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12367    ) -> object:
12368        """Delete document item
12369
12370        Deletes a document item from the board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
12371
12372        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
12373        :type board_id: str
12374        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
12375        :type item_id: str
12376        :param _request_timeout: timeout setting for this request. If one
12377                                 number provided, it will be total request
12378                                 timeout. It can also be a pair (tuple) of
12379                                 (connection, read) timeouts.
12380        :type _request_timeout: int, tuple(int, int), optional
12381        :param _request_auth: set to override the auth_settings for an a single
12382                              request; this effectively ignores the
12383                              authentication in the spec for a single request.
12384        :type _request_auth: dict, optional
12385        :param _content_type: force content-type for the request.
12386        :type _content_type: str, Optional
12387        :param _headers: set to override the headers for a single
12388                         request; this effectively ignores the headers
12389                         in the spec for a single request.
12390        :type _headers: dict, optional
12391        :param _host_index: set to override the host_index for a single
12392                            request; this effectively ignores the host_index
12393                            in the spec for a single request.
12394        :type _host_index: int, optional
12395        :return: Returns the result object.
12396        """  # noqa: E501
12397
12398        _param = self._delete_document_item_serialize(
12399            board_id=board_id,
12400            item_id=item_id,
12401            _request_auth=_request_auth,
12402            _content_type=_content_type,
12403            _headers=_headers,
12404            _host_index=_host_index,
12405        )
12406
12407        _response_types_map: Dict[str, Optional[str]] = {
12408            "204": "object",
12409            "400": None,
12410            "404": None,
12411            "429": None,
12412        }
12413        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12414        response_data.read()
12415        return self.api_client.response_deserialize(
12416            response_data=response_data,
12417            response_types_map=_response_types_map,
12418        ).data

Delete document item

Deletes a document item from the board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_document_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.document_item.DocumentItem: View Source

12472    @validate_call
12473    def get_document_item(
12474        self,
12475        board_id: Annotated[
12476            StrictStr,
12477            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
12478        ],
12479        item_id: Annotated[
12480            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
12481        ],
12482        _request_timeout: Union[
12483            None,
12484            Annotated[StrictFloat, Field(gt=0)],
12485            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12486        ] = None,
12487        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12488        _content_type: Optional[StrictStr] = None,
12489        _headers: Optional[Dict[StrictStr, Any]] = None,
12490        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12491    ) -> DocumentItem:
12492        """Get document item
12493
12494        Retrieves information for a specific document item on a board<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
12495
12496        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
12497        :type board_id: str
12498        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
12499        :type item_id: str
12500        :param _request_timeout: timeout setting for this request. If one
12501                                 number provided, it will be total request
12502                                 timeout. It can also be a pair (tuple) of
12503                                 (connection, read) timeouts.
12504        :type _request_timeout: int, tuple(int, int), optional
12505        :param _request_auth: set to override the auth_settings for an a single
12506                              request; this effectively ignores the
12507                              authentication in the spec for a single request.
12508        :type _request_auth: dict, optional
12509        :param _content_type: force content-type for the request.
12510        :type _content_type: str, Optional
12511        :param _headers: set to override the headers for a single
12512                         request; this effectively ignores the headers
12513                         in the spec for a single request.
12514        :type _headers: dict, optional
12515        :param _host_index: set to override the host_index for a single
12516                            request; this effectively ignores the host_index
12517                            in the spec for a single request.
12518        :type _host_index: int, optional
12519        :return: Returns the result object.
12520        """  # noqa: E501
12521
12522        _param = self._get_document_item_serialize(
12523            board_id=board_id,
12524            item_id=item_id,
12525            _request_auth=_request_auth,
12526            _content_type=_content_type,
12527            _headers=_headers,
12528            _host_index=_host_index,
12529        )
12530
12531        _response_types_map: Dict[str, Optional[str]] = {
12532            "200": "DocumentItem",
12533            "400": None,
12534            "404": None,
12535            "429": None,
12536        }
12537        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12538        response_data.read()
12539        return self.api_client.response_deserialize(
12540            response_data=response_data,
12541            response_types_map=_response_types_map,
12542        ).data

Get document item

Retrieves information for a specific document item on a board

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_document_item_using_file_from_device( self, board_id_platform_file_upload: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], resource: Annotated[Union[Annotated[bytes, Strict(strict=True)], Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Select a file to upload. Maximum file size is 6 MB.')], data: Optional[miro_api.models.upload_file_from_device_data.UploadFileFromDeviceData] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.document_item.DocumentItem: View Source

12596    @validate_call
12597    def update_document_item_using_file_from_device(
12598        self,
12599        board_id_platform_file_upload: Annotated[
12600            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
12601        ],
12602        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
12603        resource: Annotated[
12604            Union[StrictBytes, StrictStr], Field(description="Select a file to upload. Maximum file size is 6 MB.")
12605        ],
12606        data: Optional[UploadFileFromDeviceData] = None,
12607        _request_timeout: Union[
12608            None,
12609            Annotated[StrictFloat, Field(gt=0)],
12610            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12611        ] = None,
12612        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12613        _content_type: Optional[StrictStr] = None,
12614        _headers: Optional[Dict[StrictStr, Any]] = None,
12615        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12616    ) -> DocumentItem:
12617        """Update document item using file from device
12618
12619        Updates a document item on a board by using file from a device.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
12620
12621        :param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to update the item. (required)
12622        :type board_id_platform_file_upload: str
12623        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
12624        :type item_id: str
12625        :param resource: Select a file to upload. Maximum file size is 6 MB. (required)
12626        :type resource: bytearray
12627        :param data:
12628        :type data: UploadFileFromDeviceData
12629        :param _request_timeout: timeout setting for this request. If one
12630                                 number provided, it will be total request
12631                                 timeout. It can also be a pair (tuple) of
12632                                 (connection, read) timeouts.
12633        :type _request_timeout: int, tuple(int, int), optional
12634        :param _request_auth: set to override the auth_settings for an a single
12635                              request; this effectively ignores the
12636                              authentication in the spec for a single request.
12637        :type _request_auth: dict, optional
12638        :param _content_type: force content-type for the request.
12639        :type _content_type: str, Optional
12640        :param _headers: set to override the headers for a single
12641                         request; this effectively ignores the headers
12642                         in the spec for a single request.
12643        :type _headers: dict, optional
12644        :param _host_index: set to override the host_index for a single
12645                            request; this effectively ignores the host_index
12646                            in the spec for a single request.
12647        :type _host_index: int, optional
12648        :return: Returns the result object.
12649        """  # noqa: E501
12650
12651        _param = self._update_document_item_using_file_from_device_serialize(
12652            board_id_platform_file_upload=board_id_platform_file_upload,
12653            item_id=item_id,
12654            resource=resource,
12655            data=data,
12656            _request_auth=_request_auth,
12657            _content_type=_content_type,
12658            _headers=_headers,
12659            _host_index=_host_index,
12660        )
12661
12662        _response_types_map: Dict[str, Optional[str]] = {
12663            "200": "DocumentItem",
12664        }
12665        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12666        response_data.read()
12667        return self.api_client.response_deserialize(
12668            response_data=response_data,
12669            response_types_map=_response_types_map,
12670        ).data

Update document item using file from device

Updates a document item on a board by using file from a device.

Required scope

Rate limiting

:param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id_platform_file_upload: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param resource: Select a file to upload. Maximum file size is 6 MB. (required) :type resource: bytearray :param data: :type data: UploadFileFromDeviceData :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_document_item_using_url( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], document_update_request: miro_api.models.document_update_request.DocumentUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.document_item.DocumentItem: View Source

12738    @validate_call
12739    def update_document_item_using_url(
12740        self,
12741        board_id: Annotated[
12742            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
12743        ],
12744        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
12745        document_update_request: DocumentUpdateRequest,
12746        _request_timeout: Union[
12747            None,
12748            Annotated[StrictFloat, Field(gt=0)],
12749            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12750        ] = None,
12751        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12752        _content_type: Optional[StrictStr] = None,
12753        _headers: Optional[Dict[StrictStr, Any]] = None,
12754        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12755    ) -> DocumentItem:
12756        """Update document item using URL
12757
12758        Updates a document item on a board<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
12759
12760        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
12761        :type board_id: str
12762        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
12763        :type item_id: str
12764        :param document_update_request: (required)
12765        :type document_update_request: DocumentUpdateRequest
12766        :param _request_timeout: timeout setting for this request. If one
12767                                 number provided, it will be total request
12768                                 timeout. It can also be a pair (tuple) of
12769                                 (connection, read) timeouts.
12770        :type _request_timeout: int, tuple(int, int), optional
12771        :param _request_auth: set to override the auth_settings for an a single
12772                              request; this effectively ignores the
12773                              authentication in the spec for a single request.
12774        :type _request_auth: dict, optional
12775        :param _content_type: force content-type for the request.
12776        :type _content_type: str, Optional
12777        :param _headers: set to override the headers for a single
12778                         request; this effectively ignores the headers
12779                         in the spec for a single request.
12780        :type _headers: dict, optional
12781        :param _host_index: set to override the host_index for a single
12782                            request; this effectively ignores the host_index
12783                            in the spec for a single request.
12784        :type _host_index: int, optional
12785        :return: Returns the result object.
12786        """  # noqa: E501
12787
12788        _param = self._update_document_item_using_url_serialize(
12789            board_id=board_id,
12790            item_id=item_id,
12791            document_update_request=document_update_request,
12792            _request_auth=_request_auth,
12793            _content_type=_content_type,
12794            _headers=_headers,
12795            _host_index=_host_index,
12796        )
12797
12798        _response_types_map: Dict[str, Optional[str]] = {
12799            "200": "DocumentItem",
12800            "400": None,
12801            "404": None,
12802            "409": None,
12803            "429": None,
12804        }
12805        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12806        response_data.read()
12807        return self.api_client.response_deserialize(
12808            response_data=response_data,
12809            response_types_map=_response_types_map,
12810        ).data

Update document item using URL

Updates a document item on a board

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param document_update_request: (required) :type document_update_request: DocumentUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_embed_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], embed_create_request: miro_api.models.embed_create_request.EmbedCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.embed_item.EmbedItem: View Source

12875    @validate_call
12876    def create_embed_item(
12877        self,
12878        board_id: Annotated[
12879            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
12880        ],
12881        embed_create_request: EmbedCreateRequest,
12882        _request_timeout: Union[
12883            None,
12884            Annotated[StrictFloat, Field(gt=0)],
12885            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12886        ] = None,
12887        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12888        _content_type: Optional[StrictStr] = None,
12889        _headers: Optional[Dict[StrictStr, Any]] = None,
12890        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12891    ) -> EmbedItem:
12892        """Create embed item
12893
12894        Adds an embed item containing external content to a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
12895
12896        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
12897        :type board_id: str
12898        :param embed_create_request: (required)
12899        :type embed_create_request: EmbedCreateRequest
12900        :param _request_timeout: timeout setting for this request. If one
12901                                 number provided, it will be total request
12902                                 timeout. It can also be a pair (tuple) of
12903                                 (connection, read) timeouts.
12904        :type _request_timeout: int, tuple(int, int), optional
12905        :param _request_auth: set to override the auth_settings for an a single
12906                              request; this effectively ignores the
12907                              authentication in the spec for a single request.
12908        :type _request_auth: dict, optional
12909        :param _content_type: force content-type for the request.
12910        :type _content_type: str, Optional
12911        :param _headers: set to override the headers for a single
12912                         request; this effectively ignores the headers
12913                         in the spec for a single request.
12914        :type _headers: dict, optional
12915        :param _host_index: set to override the host_index for a single
12916                            request; this effectively ignores the host_index
12917                            in the spec for a single request.
12918        :type _host_index: int, optional
12919        :return: Returns the result object.
12920        """  # noqa: E501
12921
12922        _param = self._create_embed_item_serialize(
12923            board_id=board_id,
12924            embed_create_request=embed_create_request,
12925            _request_auth=_request_auth,
12926            _content_type=_content_type,
12927            _headers=_headers,
12928            _host_index=_host_index,
12929        )
12930
12931        _response_types_map: Dict[str, Optional[str]] = {
12932            "201": "EmbedItem",
12933            "400": None,
12934            "404": None,
12935            "429": None,
12936        }
12937        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12938        response_data.read()
12939        return self.api_client.response_deserialize(
12940            response_data=response_data,
12941            response_types_map=_response_types_map,
12942        ).data

Create embed item

Adds an embed item containing external content to a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param embed_create_request: (required) :type embed_create_request: EmbedCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_embed_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

13004    @validate_call
13005    def delete_embed_item(
13006        self,
13007        board_id: Annotated[
13008            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
13009        ],
13010        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
13011        _request_timeout: Union[
13012            None,
13013            Annotated[StrictFloat, Field(gt=0)],
13014            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13015        ] = None,
13016        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13017        _content_type: Optional[StrictStr] = None,
13018        _headers: Optional[Dict[StrictStr, Any]] = None,
13019        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13020    ) -> object:
13021        """Delete embed item
13022
13023        Deletes an embed item from the board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
13024
13025        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
13026        :type board_id: str
13027        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
13028        :type item_id: str
13029        :param _request_timeout: timeout setting for this request. If one
13030                                 number provided, it will be total request
13031                                 timeout. It can also be a pair (tuple) of
13032                                 (connection, read) timeouts.
13033        :type _request_timeout: int, tuple(int, int), optional
13034        :param _request_auth: set to override the auth_settings for an a single
13035                              request; this effectively ignores the
13036                              authentication in the spec for a single request.
13037        :type _request_auth: dict, optional
13038        :param _content_type: force content-type for the request.
13039        :type _content_type: str, Optional
13040        :param _headers: set to override the headers for a single
13041                         request; this effectively ignores the headers
13042                         in the spec for a single request.
13043        :type _headers: dict, optional
13044        :param _host_index: set to override the host_index for a single
13045                            request; this effectively ignores the host_index
13046                            in the spec for a single request.
13047        :type _host_index: int, optional
13048        :return: Returns the result object.
13049        """  # noqa: E501
13050
13051        _param = self._delete_embed_item_serialize(
13052            board_id=board_id,
13053            item_id=item_id,
13054            _request_auth=_request_auth,
13055            _content_type=_content_type,
13056            _headers=_headers,
13057            _host_index=_host_index,
13058        )
13059
13060        _response_types_map: Dict[str, Optional[str]] = {
13061            "204": "object",
13062            "400": None,
13063            "404": None,
13064            "429": None,
13065        }
13066        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13067        response_data.read()
13068        return self.api_client.response_deserialize(
13069            response_data=response_data,
13070            response_types_map=_response_types_map,
13071        ).data

Delete embed item

Deletes an embed item from the board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_embed_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.embed_item.EmbedItem: View Source

13125    @validate_call
13126    def get_embed_item(
13127        self,
13128        board_id: Annotated[
13129            StrictStr,
13130            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
13131        ],
13132        item_id: Annotated[
13133            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
13134        ],
13135        _request_timeout: Union[
13136            None,
13137            Annotated[StrictFloat, Field(gt=0)],
13138            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13139        ] = None,
13140        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13141        _content_type: Optional[StrictStr] = None,
13142        _headers: Optional[Dict[StrictStr, Any]] = None,
13143        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13144    ) -> EmbedItem:
13145        """Get embed item
13146
13147        Retrieves information for a specific embed item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
13148
13149        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
13150        :type board_id: str
13151        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
13152        :type item_id: str
13153        :param _request_timeout: timeout setting for this request. If one
13154                                 number provided, it will be total request
13155                                 timeout. It can also be a pair (tuple) of
13156                                 (connection, read) timeouts.
13157        :type _request_timeout: int, tuple(int, int), optional
13158        :param _request_auth: set to override the auth_settings for an a single
13159                              request; this effectively ignores the
13160                              authentication in the spec for a single request.
13161        :type _request_auth: dict, optional
13162        :param _content_type: force content-type for the request.
13163        :type _content_type: str, Optional
13164        :param _headers: set to override the headers for a single
13165                         request; this effectively ignores the headers
13166                         in the spec for a single request.
13167        :type _headers: dict, optional
13168        :param _host_index: set to override the host_index for a single
13169                            request; this effectively ignores the host_index
13170                            in the spec for a single request.
13171        :type _host_index: int, optional
13172        :return: Returns the result object.
13173        """  # noqa: E501
13174
13175        _param = self._get_embed_item_serialize(
13176            board_id=board_id,
13177            item_id=item_id,
13178            _request_auth=_request_auth,
13179            _content_type=_content_type,
13180            _headers=_headers,
13181            _host_index=_host_index,
13182        )
13183
13184        _response_types_map: Dict[str, Optional[str]] = {
13185            "200": "EmbedItem",
13186            "400": None,
13187            "404": None,
13188            "429": None,
13189        }
13190        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13191        response_data.read()
13192        return self.api_client.response_deserialize(
13193            response_data=response_data,
13194            response_types_map=_response_types_map,
13195        ).data

Get embed item

Retrieves information for a specific embed item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_embed_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], embed_update_request: miro_api.models.embed_update_request.EmbedUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.embed_item.EmbedItem: View Source

13249    @validate_call
13250    def update_embed_item(
13251        self,
13252        board_id: Annotated[
13253            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
13254        ],
13255        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
13256        embed_update_request: EmbedUpdateRequest,
13257        _request_timeout: Union[
13258            None,
13259            Annotated[StrictFloat, Field(gt=0)],
13260            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13261        ] = None,
13262        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13263        _content_type: Optional[StrictStr] = None,
13264        _headers: Optional[Dict[StrictStr, Any]] = None,
13265        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13266    ) -> EmbedItem:
13267        """Update embed item
13268
13269        Updates an embed item on a board based on the data properties provided in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
13270
13271        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
13272        :type board_id: str
13273        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
13274        :type item_id: str
13275        :param embed_update_request: (required)
13276        :type embed_update_request: EmbedUpdateRequest
13277        :param _request_timeout: timeout setting for this request. If one
13278                                 number provided, it will be total request
13279                                 timeout. It can also be a pair (tuple) of
13280                                 (connection, read) timeouts.
13281        :type _request_timeout: int, tuple(int, int), optional
13282        :param _request_auth: set to override the auth_settings for an a single
13283                              request; this effectively ignores the
13284                              authentication in the spec for a single request.
13285        :type _request_auth: dict, optional
13286        :param _content_type: force content-type for the request.
13287        :type _content_type: str, Optional
13288        :param _headers: set to override the headers for a single
13289                         request; this effectively ignores the headers
13290                         in the spec for a single request.
13291        :type _headers: dict, optional
13292        :param _host_index: set to override the host_index for a single
13293                            request; this effectively ignores the host_index
13294                            in the spec for a single request.
13295        :type _host_index: int, optional
13296        :return: Returns the result object.
13297        """  # noqa: E501
13298
13299        _param = self._update_embed_item_serialize(
13300            board_id=board_id,
13301            item_id=item_id,
13302            embed_update_request=embed_update_request,
13303            _request_auth=_request_auth,
13304            _content_type=_content_type,
13305            _headers=_headers,
13306            _host_index=_host_index,
13307        )
13308
13309        _response_types_map: Dict[str, Optional[str]] = {
13310            "200": "EmbedItem",
13311            "400": None,
13312            "404": None,
13313            "409": None,
13314            "429": None,
13315        }
13316        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13317        response_data.read()
13318        return self.api_client.response_deserialize(
13319            response_data=response_data,
13320            response_types_map=_response_types_map,
13321        ).data

Update embed item

Updates an embed item on a board based on the data properties provided in the request body.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param embed_update_request: (required) :type embed_update_request: EmbedUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_frame_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create a frame.')], frame_create_request: miro_api.models.frame_create_request.FrameCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.frame_item.FrameItem: View Source

13386    @validate_call
13387    def create_frame_item(
13388        self,
13389        board_id: Annotated[
13390            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create a frame.")
13391        ],
13392        frame_create_request: FrameCreateRequest,
13393        _request_timeout: Union[
13394            None,
13395            Annotated[StrictFloat, Field(gt=0)],
13396            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13397        ] = None,
13398        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13399        _content_type: Optional[StrictStr] = None,
13400        _headers: Optional[Dict[StrictStr, Any]] = None,
13401        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13402    ) -> FrameItem:
13403        """Create frame
13404
13405        Adds a frame to a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
13406
13407        :param board_id: Unique identifier (ID) of the board where you want to create a frame. (required)
13408        :type board_id: str
13409        :param frame_create_request: (required)
13410        :type frame_create_request: FrameCreateRequest
13411        :param _request_timeout: timeout setting for this request. If one
13412                                 number provided, it will be total request
13413                                 timeout. It can also be a pair (tuple) of
13414                                 (connection, read) timeouts.
13415        :type _request_timeout: int, tuple(int, int), optional
13416        :param _request_auth: set to override the auth_settings for an a single
13417                              request; this effectively ignores the
13418                              authentication in the spec for a single request.
13419        :type _request_auth: dict, optional
13420        :param _content_type: force content-type for the request.
13421        :type _content_type: str, Optional
13422        :param _headers: set to override the headers for a single
13423                         request; this effectively ignores the headers
13424                         in the spec for a single request.
13425        :type _headers: dict, optional
13426        :param _host_index: set to override the host_index for a single
13427                            request; this effectively ignores the host_index
13428                            in the spec for a single request.
13429        :type _host_index: int, optional
13430        :return: Returns the result object.
13431        """  # noqa: E501
13432
13433        _param = self._create_frame_item_serialize(
13434            board_id=board_id,
13435            frame_create_request=frame_create_request,
13436            _request_auth=_request_auth,
13437            _content_type=_content_type,
13438            _headers=_headers,
13439            _host_index=_host_index,
13440        )
13441
13442        _response_types_map: Dict[str, Optional[str]] = {
13443            "201": "FrameItem",
13444            "400": "CreateFrameItem400Response",
13445            "404": "CreateFrameItem400Response",
13446            "429": "CreateFrameItem400Response",
13447        }
13448        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13449        response_data.read()
13450        return self.api_client.response_deserialize(
13451            response_data=response_data,
13452            response_types_map=_response_types_map,
13453        ).data

Create frame

Adds a frame to a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create a frame. (required) :type board_id: str :param frame_create_request: (required) :type frame_create_request: FrameCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_frame_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the frame.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the frame that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

13515    @validate_call
13516    def delete_frame_item(
13517        self,
13518        board_id: Annotated[
13519            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the frame.")
13520        ],
13521        item_id: Annotated[
13522            StrictStr, Field(description="Unique identifier (ID) of the frame that you want to delete.")
13523        ],
13524        _request_timeout: Union[
13525            None,
13526            Annotated[StrictFloat, Field(gt=0)],
13527            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13528        ] = None,
13529        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13530        _content_type: Optional[StrictStr] = None,
13531        _headers: Optional[Dict[StrictStr, Any]] = None,
13532        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13533    ) -> object:
13534        """Delete frame
13535
13536        Deletes a frame from a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
13537
13538        :param board_id: Unique identifier (ID) of the board from which you want to delete the frame. (required)
13539        :type board_id: str
13540        :param item_id: Unique identifier (ID) of the frame that you want to delete. (required)
13541        :type item_id: str
13542        :param _request_timeout: timeout setting for this request. If one
13543                                 number provided, it will be total request
13544                                 timeout. It can also be a pair (tuple) of
13545                                 (connection, read) timeouts.
13546        :type _request_timeout: int, tuple(int, int), optional
13547        :param _request_auth: set to override the auth_settings for an a single
13548                              request; this effectively ignores the
13549                              authentication in the spec for a single request.
13550        :type _request_auth: dict, optional
13551        :param _content_type: force content-type for the request.
13552        :type _content_type: str, Optional
13553        :param _headers: set to override the headers for a single
13554                         request; this effectively ignores the headers
13555                         in the spec for a single request.
13556        :type _headers: dict, optional
13557        :param _host_index: set to override the host_index for a single
13558                            request; this effectively ignores the host_index
13559                            in the spec for a single request.
13560        :type _host_index: int, optional
13561        :return: Returns the result object.
13562        """  # noqa: E501
13563
13564        _param = self._delete_frame_item_serialize(
13565            board_id=board_id,
13566            item_id=item_id,
13567            _request_auth=_request_auth,
13568            _content_type=_content_type,
13569            _headers=_headers,
13570            _host_index=_host_index,
13571        )
13572
13573        _response_types_map: Dict[str, Optional[str]] = {
13574            "204": "object",
13575            "400": "CreateFrameItem400Response",
13576            "404": "CreateFrameItem400Response",
13577            "429": "CreateFrameItem400Response",
13578        }
13579        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13580        response_data.read()
13581        return self.api_client.response_deserialize(
13582            response_data=response_data,
13583            response_types_map=_response_types_map,
13584        ).data

Delete frame

Deletes a frame from a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the frame. (required) :type board_id: str :param item_id: Unique identifier (ID) of the frame that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_frame_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board that contains the frame that you want to retrieve')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the frame that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.frame_item.FrameItem: View Source

13638    @validate_call
13639    def get_frame_item(
13640        self,
13641        board_id: Annotated[
13642            StrictStr,
13643            Field(description="Unique identifier (ID) of the board that contains the frame that you want to retrieve"),
13644        ],
13645        item_id: Annotated[
13646            StrictStr, Field(description="Unique identifier (ID) of the frame that you want to retrieve.")
13647        ],
13648        _request_timeout: Union[
13649            None,
13650            Annotated[StrictFloat, Field(gt=0)],
13651            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13652        ] = None,
13653        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13654        _content_type: Optional[StrictStr] = None,
13655        _headers: Optional[Dict[StrictStr, Any]] = None,
13656        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13657    ) -> FrameItem:
13658        """Get frame
13659
13660        Retrieves information for a specific frame on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
13661
13662        :param board_id: Unique identifier (ID) of the board that contains the frame that you want to retrieve (required)
13663        :type board_id: str
13664        :param item_id: Unique identifier (ID) of the frame that you want to retrieve. (required)
13665        :type item_id: str
13666        :param _request_timeout: timeout setting for this request. If one
13667                                 number provided, it will be total request
13668                                 timeout. It can also be a pair (tuple) of
13669                                 (connection, read) timeouts.
13670        :type _request_timeout: int, tuple(int, int), optional
13671        :param _request_auth: set to override the auth_settings for an a single
13672                              request; this effectively ignores the
13673                              authentication in the spec for a single request.
13674        :type _request_auth: dict, optional
13675        :param _content_type: force content-type for the request.
13676        :type _content_type: str, Optional
13677        :param _headers: set to override the headers for a single
13678                         request; this effectively ignores the headers
13679                         in the spec for a single request.
13680        :type _headers: dict, optional
13681        :param _host_index: set to override the host_index for a single
13682                            request; this effectively ignores the host_index
13683                            in the spec for a single request.
13684        :type _host_index: int, optional
13685        :return: Returns the result object.
13686        """  # noqa: E501
13687
13688        _param = self._get_frame_item_serialize(
13689            board_id=board_id,
13690            item_id=item_id,
13691            _request_auth=_request_auth,
13692            _content_type=_content_type,
13693            _headers=_headers,
13694            _host_index=_host_index,
13695        )
13696
13697        _response_types_map: Dict[str, Optional[str]] = {
13698            "200": "FrameItem",
13699            "400": "CreateFrameItem400Response",
13700            "404": "CreateFrameItem400Response",
13701            "429": "CreateFrameItem400Response",
13702        }
13703        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13704        response_data.read()
13705        return self.api_client.response_deserialize(
13706            response_data=response_data,
13707            response_types_map=_response_types_map,
13708        ).data

Get frame

Retrieves information for a specific frame on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board that contains the frame that you want to retrieve (required) :type board_id: str :param item_id: Unique identifier (ID) of the frame that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_frame_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the frame.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the frame that you want to update.')], frame_update_request: miro_api.models.frame_update_request.FrameUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.frame_item.FrameItem: View Source

13762    @validate_call
13763    def update_frame_item(
13764        self,
13765        board_id: Annotated[
13766            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the frame.")
13767        ],
13768        item_id: Annotated[
13769            StrictStr, Field(description="Unique identifier (ID) of the frame that you want to update.")
13770        ],
13771        frame_update_request: FrameUpdateRequest,
13772        _request_timeout: Union[
13773            None,
13774            Annotated[StrictFloat, Field(gt=0)],
13775            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13776        ] = None,
13777        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13778        _content_type: Optional[StrictStr] = None,
13779        _headers: Optional[Dict[StrictStr, Any]] = None,
13780        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13781    ) -> FrameItem:
13782        """Update frame
13783
13784        Updates a frame on a board based on the data, style, or geometry properties provided in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
13785
13786        :param board_id: Unique identifier (ID) of the board where you want to update the frame. (required)
13787        :type board_id: str
13788        :param item_id: Unique identifier (ID) of the frame that you want to update. (required)
13789        :type item_id: str
13790        :param frame_update_request: (required)
13791        :type frame_update_request: FrameUpdateRequest
13792        :param _request_timeout: timeout setting for this request. If one
13793                                 number provided, it will be total request
13794                                 timeout. It can also be a pair (tuple) of
13795                                 (connection, read) timeouts.
13796        :type _request_timeout: int, tuple(int, int), optional
13797        :param _request_auth: set to override the auth_settings for an a single
13798                              request; this effectively ignores the
13799                              authentication in the spec for a single request.
13800        :type _request_auth: dict, optional
13801        :param _content_type: force content-type for the request.
13802        :type _content_type: str, Optional
13803        :param _headers: set to override the headers for a single
13804                         request; this effectively ignores the headers
13805                         in the spec for a single request.
13806        :type _headers: dict, optional
13807        :param _host_index: set to override the host_index for a single
13808                            request; this effectively ignores the host_index
13809                            in the spec for a single request.
13810        :type _host_index: int, optional
13811        :return: Returns the result object.
13812        """  # noqa: E501
13813
13814        _param = self._update_frame_item_serialize(
13815            board_id=board_id,
13816            item_id=item_id,
13817            frame_update_request=frame_update_request,
13818            _request_auth=_request_auth,
13819            _content_type=_content_type,
13820            _headers=_headers,
13821            _host_index=_host_index,
13822        )
13823
13824        _response_types_map: Dict[str, Optional[str]] = {
13825            "200": "FrameItem",
13826            "400": "CreateFrameItem400Response",
13827            "404": "CreateFrameItem400Response",
13828            "409": "UpdateFrameItem409Response",
13829            "429": "CreateFrameItem400Response",
13830        }
13831        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13832        response_data.read()
13833        return self.api_client.response_deserialize(
13834            response_data=response_data,
13835            response_types_map=_response_types_map,
13836        ).data

Update frame

Updates a frame on a board based on the data, style, or geometry properties provided in the request body.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the frame. (required) :type board_id: str :param item_id: Unique identifier (ID) of the frame that you want to update. (required) :type item_id: str :param frame_update_request: (required) :type frame_update_request: FrameUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_group( self, board_id: typing.Annotated[str, Strict(strict=True)], group: miro_api.models.group.Group, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.group_response_short.GroupResponseShort: View Source

13901    @validate_call
13902    def create_group(
13903        self,
13904        board_id: StrictStr,
13905        group: Group,
13906        _request_timeout: Union[
13907            None,
13908            Annotated[StrictFloat, Field(gt=0)],
13909            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13910        ] = None,
13911        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13912        _content_type: Optional[StrictStr] = None,
13913        _headers: Optional[Dict[StrictStr, Any]] = None,
13914        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13915    ) -> GroupResponseShort:
13916        """Create group
13917
13918        Creates a group of items on a board. The group is created with the items that are passed in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
13919
13920        :param board_id: (required)
13921        :type board_id: str
13922        :param group: (required)
13923        :type group: Group
13924        :param _request_timeout: timeout setting for this request. If one
13925                                 number provided, it will be total request
13926                                 timeout. It can also be a pair (tuple) of
13927                                 (connection, read) timeouts.
13928        :type _request_timeout: int, tuple(int, int), optional
13929        :param _request_auth: set to override the auth_settings for an a single
13930                              request; this effectively ignores the
13931                              authentication in the spec for a single request.
13932        :type _request_auth: dict, optional
13933        :param _content_type: force content-type for the request.
13934        :type _content_type: str, Optional
13935        :param _headers: set to override the headers for a single
13936                         request; this effectively ignores the headers
13937                         in the spec for a single request.
13938        :type _headers: dict, optional
13939        :param _host_index: set to override the host_index for a single
13940                            request; this effectively ignores the host_index
13941                            in the spec for a single request.
13942        :type _host_index: int, optional
13943        :return: Returns the result object.
13944        """  # noqa: E501
13945
13946        _param = self._create_group_serialize(
13947            board_id=board_id,
13948            group=group,
13949            _request_auth=_request_auth,
13950            _content_type=_content_type,
13951            _headers=_headers,
13952            _host_index=_host_index,
13953        )
13954
13955        _response_types_map: Dict[str, Optional[str]] = {
13956            "201": "GroupResponseShort",
13957            "400": "GetAllGroups400Response",
13958            "404": "GetAllGroups404Response",
13959            "429": "GetAllGroups429Response",
13960        }
13961        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13962        response_data.read()
13963        return self.api_client.response_deserialize(
13964            response_data=response_data,
13965            response_types_map=_response_types_map,
13966        ).data

Create group

Creates a group of items on a board. The group is created with the items that are passed in the request body.

Required scope

Rate limiting

:param board_id: (required) :type board_id: str :param group: (required) :type group: Group :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_group( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the group.')], delete_items: typing.Annotated[bool, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Indicates whether the items should be removed. Set to `true` to delete items in the group.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

14028    @validate_call
14029    def delete_group(
14030        self,
14031        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
14032        group_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the group.")],
14033        delete_items: Annotated[
14034            StrictBool,
14035            Field(
14036                description="Indicates whether the items should be removed. Set to `true` to delete items in the group."
14037            ),
14038        ],
14039        _request_timeout: Union[
14040            None,
14041            Annotated[StrictFloat, Field(gt=0)],
14042            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14043        ] = None,
14044        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14045        _content_type: Optional[StrictStr] = None,
14046        _headers: Optional[Dict[StrictStr, Any]] = None,
14047        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14048    ) -> object:
14049        """Deletes the group
14050
14051        Deletes a group from a board. All the items in the groups are deleted along with the group.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
14052
14053        :param board_id: Unique identifier (ID) of the board. (required)
14054        :type board_id: str
14055        :param group_id: Unique identifier (ID) of the group. (required)
14056        :type group_id: str
14057        :param delete_items: Indicates whether the items should be removed. Set to `true` to delete items in the group. (required)
14058        :type delete_items: bool
14059        :param _request_timeout: timeout setting for this request. If one
14060                                 number provided, it will be total request
14061                                 timeout. It can also be a pair (tuple) of
14062                                 (connection, read) timeouts.
14063        :type _request_timeout: int, tuple(int, int), optional
14064        :param _request_auth: set to override the auth_settings for an a single
14065                              request; this effectively ignores the
14066                              authentication in the spec for a single request.
14067        :type _request_auth: dict, optional
14068        :param _content_type: force content-type for the request.
14069        :type _content_type: str, Optional
14070        :param _headers: set to override the headers for a single
14071                         request; this effectively ignores the headers
14072                         in the spec for a single request.
14073        :type _headers: dict, optional
14074        :param _host_index: set to override the host_index for a single
14075                            request; this effectively ignores the host_index
14076                            in the spec for a single request.
14077        :type _host_index: int, optional
14078        :return: Returns the result object.
14079        """  # noqa: E501
14080
14081        _param = self._delete_group_serialize(
14082            board_id=board_id,
14083            group_id=group_id,
14084            delete_items=delete_items,
14085            _request_auth=_request_auth,
14086            _content_type=_content_type,
14087            _headers=_headers,
14088            _host_index=_host_index,
14089        )
14090
14091        _response_types_map: Dict[str, Optional[str]] = {
14092            "204": "object",
14093            "400": "UnGroup400Response",
14094            "404": "UnGroup404Response",
14095            "429": "UnGroup429Response",
14096        }
14097        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14098        response_data.read()
14099        return self.api_client.response_deserialize(
14100            response_data=response_data,
14101            response_types_map=_response_types_map,
14102        ).data

Deletes the group

Deletes a group from a board. All the items in the groups are deleted along with the group.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board. (required) :type board_id: str :param group_id: Unique identifier (ID) of the group. (required) :type group_id: str :param delete_items: Indicates whether the items should be removed. Set to true to delete items in the group. (required) :type delete_items: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_all_groups( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board.')], limit: Annotated[Optional[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=10), Le(le=50)])]], FieldInfo(annotation=NoneType, required=True, description='The maximum number of items to return at one time, default is 10, maximum is 50.')] = None, cursor: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.get_all_groups200_response.GetAllGroups200Response: View Source

14161    @validate_call
14162    def get_all_groups(
14163        self,
14164        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
14165        limit: Annotated[
14166            Optional[Annotated[int, Field(le=50, strict=True, ge=10)]],
14167            Field(description="The maximum number of items to return at one time, default is 10, maximum is 50."),
14168        ] = None,
14169        cursor: Optional[StrictStr] = None,
14170        _request_timeout: Union[
14171            None,
14172            Annotated[StrictFloat, Field(gt=0)],
14173            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14174        ] = None,
14175        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14176        _content_type: Optional[StrictStr] = None,
14177        _headers: Optional[Dict[StrictStr, Any]] = None,
14178        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14179    ) -> GetAllGroups200Response:
14180        """Get all groups on a board
14181
14182        Returns all the groups and the items of the respective groups within a specific board.<br/> This method returns results using a cursor-based approach. A cursor-paginated  method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the `cursor` parameter equal to the `cursor` value you received in the response of the previous request.<br/> For example, if you set the `limit` query parameter to `10` and the board  contains 20 items that are a part of a group, the first call will return information about the first 10 items in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is `foo`. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to `foo`.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
14183
14184        :param board_id: Unique identifier (ID) of the board. (required)
14185        :type board_id: str
14186        :param limit: The maximum number of items to return at one time, default is 10, maximum is 50.
14187        :type limit: int
14188        :param cursor:
14189        :type cursor: str
14190        :param _request_timeout: timeout setting for this request. If one
14191                                 number provided, it will be total request
14192                                 timeout. It can also be a pair (tuple) of
14193                                 (connection, read) timeouts.
14194        :type _request_timeout: int, tuple(int, int), optional
14195        :param _request_auth: set to override the auth_settings for an a single
14196                              request; this effectively ignores the
14197                              authentication in the spec for a single request.
14198        :type _request_auth: dict, optional
14199        :param _content_type: force content-type for the request.
14200        :type _content_type: str, Optional
14201        :param _headers: set to override the headers for a single
14202                         request; this effectively ignores the headers
14203                         in the spec for a single request.
14204        :type _headers: dict, optional
14205        :param _host_index: set to override the host_index for a single
14206                            request; this effectively ignores the host_index
14207                            in the spec for a single request.
14208        :type _host_index: int, optional
14209        :return: Returns the result object.
14210        """  # noqa: E501
14211
14212        _param = self._get_all_groups_serialize(
14213            board_id=board_id,
14214            limit=limit,
14215            cursor=cursor,
14216            _request_auth=_request_auth,
14217            _content_type=_content_type,
14218            _headers=_headers,
14219            _host_index=_host_index,
14220        )
14221
14222        _response_types_map: Dict[str, Optional[str]] = {
14223            "200": "GetAllGroups200Response",
14224            "400": "GetAllGroups400Response",
14225            "404": "GetAllGroups404Response",
14226            "429": "GetAllGroups429Response",
14227        }
14228        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14229        response_data.read()
14230        return self.api_client.response_deserialize(
14231            response_data=response_data,
14232            response_types_map=_response_types_map,
14233        ).data

Get all groups on a board

Returns all the groups and the items of the respective groups within a specific board.
This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the cursor parameter equal to the cursor value you received in the response of the previous request.
For example, if you set the limit query parameter to 10 and the board contains 20 items that are a part of a group, the first call will return information about the first 10 items in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is foo. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to foo.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board. (required) :type board_id: str :param limit: The maximum number of items to return at one time, default is 10, maximum is 50. :type limit: int :param cursor: :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_group_by_id( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the group.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.group_response_short.GroupResponseShort: View Source

14294    @validate_call
14295    def get_group_by_id(
14296        self,
14297        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
14298        group_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the group.")],
14299        _request_timeout: Union[
14300            None,
14301            Annotated[StrictFloat, Field(gt=0)],
14302            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14303        ] = None,
14304        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14305        _content_type: Optional[StrictStr] = None,
14306        _headers: Optional[Dict[StrictStr, Any]] = None,
14307        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14308    ) -> GroupResponseShort:
14309        """Get a group by its ID
14310
14311        Returns a list of items in a specific group. <br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a> per item ID
14312
14313        :param board_id: Unique identifier (ID) of the board. (required)
14314        :type board_id: str
14315        :param group_id: Unique identifier (ID) of the group. (required)
14316        :type group_id: str
14317        :param _request_timeout: timeout setting for this request. If one
14318                                 number provided, it will be total request
14319                                 timeout. It can also be a pair (tuple) of
14320                                 (connection, read) timeouts.
14321        :type _request_timeout: int, tuple(int, int), optional
14322        :param _request_auth: set to override the auth_settings for an a single
14323                              request; this effectively ignores the
14324                              authentication in the spec for a single request.
14325        :type _request_auth: dict, optional
14326        :param _content_type: force content-type for the request.
14327        :type _content_type: str, Optional
14328        :param _headers: set to override the headers for a single
14329                         request; this effectively ignores the headers
14330                         in the spec for a single request.
14331        :type _headers: dict, optional
14332        :param _host_index: set to override the host_index for a single
14333                            request; this effectively ignores the host_index
14334                            in the spec for a single request.
14335        :type _host_index: int, optional
14336        :return: Returns the result object.
14337        """  # noqa: E501
14338
14339        _param = self._get_group_by_id_serialize(
14340            board_id=board_id,
14341            group_id=group_id,
14342            _request_auth=_request_auth,
14343            _content_type=_content_type,
14344            _headers=_headers,
14345            _host_index=_host_index,
14346        )
14347
14348        _response_types_map: Dict[str, Optional[str]] = {
14349            "200": "GroupResponseShort",
14350            "400": "GetAllGroups400Response",
14351            "404": "GetAllGroups404Response",
14352            "429": "GetAllGroups429Response",
14353        }
14354        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14355        response_data.read()
14356        return self.api_client.response_deserialize(
14357            response_data=response_data,
14358            response_types_map=_response_types_map,
14359        ).data

Get a group by its ID

Returns a list of items in a specific group.

Required scope

Rate limiting

Level 2 per item ID

:param board_id: Unique identifier (ID) of the board. (required) :type board_id: str :param group_id: Unique identifier (ID) of the group. (required) :type group_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_items_by_group_id( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board.')], group_item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the group item to retrieve.')], limit: Annotated[Optional[Annotated[int, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), Ge(ge=10), Le(le=50)])]], FieldInfo(annotation=NoneType, required=True, description='The maximum number of items to return at one time, default is 10, maximum is 50.')] = None, cursor: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.get_items_by_group_id200_response.GetItemsByGroupId200Response: View Source

14413    @validate_call
14414    def get_items_by_group_id(
14415        self,
14416        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
14417        group_item_id: Annotated[StrictStr, Field(description="The ID of the group item to retrieve.")],
14418        limit: Annotated[
14419            Optional[Annotated[int, Field(le=50, strict=True, ge=10)]],
14420            Field(description="The maximum number of items to return at one time, default is 10, maximum is 50."),
14421        ] = None,
14422        cursor: Optional[StrictStr] = None,
14423        _request_timeout: Union[
14424            None,
14425            Annotated[StrictFloat, Field(gt=0)],
14426            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14427        ] = None,
14428        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14429        _content_type: Optional[StrictStr] = None,
14430        _headers: Optional[Dict[StrictStr, Any]] = None,
14431        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14432    ) -> GetItemsByGroupId200Response:
14433        """Get items of a group by ID
14434
14435        Returns a list of items that are a part of any group, within a specific board.<br/> This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the `cursor` parameter equal to the `cursor` value you received in the response of the previous request.<br/> For example, if you set the `limit` query parameter to `10` and the board  contains 20 items that are a part of a group, the first call will return information about the first 10 items (not 10 groups) in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is `foo`. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to `foo`.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
14436
14437        :param board_id: Unique identifier (ID) of the board. (required)
14438        :type board_id: str
14439        :param group_item_id: The ID of the group item to retrieve. (required)
14440        :type group_item_id: str
14441        :param limit: The maximum number of items to return at one time, default is 10, maximum is 50.
14442        :type limit: int
14443        :param cursor:
14444        :type cursor: str
14445        :param _request_timeout: timeout setting for this request. If one
14446                                 number provided, it will be total request
14447                                 timeout. It can also be a pair (tuple) of
14448                                 (connection, read) timeouts.
14449        :type _request_timeout: int, tuple(int, int), optional
14450        :param _request_auth: set to override the auth_settings for an a single
14451                              request; this effectively ignores the
14452                              authentication in the spec for a single request.
14453        :type _request_auth: dict, optional
14454        :param _content_type: force content-type for the request.
14455        :type _content_type: str, Optional
14456        :param _headers: set to override the headers for a single
14457                         request; this effectively ignores the headers
14458                         in the spec for a single request.
14459        :type _headers: dict, optional
14460        :param _host_index: set to override the host_index for a single
14461                            request; this effectively ignores the host_index
14462                            in the spec for a single request.
14463        :type _host_index: int, optional
14464        :return: Returns the result object.
14465        """  # noqa: E501
14466
14467        _param = self._get_items_by_group_id_serialize(
14468            board_id=board_id,
14469            group_item_id=group_item_id,
14470            limit=limit,
14471            cursor=cursor,
14472            _request_auth=_request_auth,
14473            _content_type=_content_type,
14474            _headers=_headers,
14475            _host_index=_host_index,
14476        )
14477
14478        _response_types_map: Dict[str, Optional[str]] = {
14479            "200": "GetItemsByGroupId200Response",
14480            "400": "GetAllGroups400Response",
14481            "404": "GetAllGroups404Response",
14482            "429": "GetAllGroups429Response",
14483        }
14484        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14485        response_data.read()
14486        return self.api_client.response_deserialize(
14487            response_data=response_data,
14488            response_types_map=_response_types_map,
14489        ).data

Get items of a group by ID

Returns a list of items that are a part of any group, within a specific board.
This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the cursor parameter equal to the cursor value you received in the response of the previous request.
For example, if you set the limit query parameter to 10 and the board contains 20 items that are a part of a group, the first call will return information about the first 10 items (not 10 groups) in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is foo. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to foo.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board. (required) :type board_id: str :param group_item_id: The ID of the group item to retrieve. (required) :type group_item_id: str :param limit: The maximum number of items to return at one time, default is 10, maximum is 50. :type limit: int :param cursor: :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def un_group( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the group.')], delete_items: Annotated[Optional[Annotated[bool, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Indicates whether the items should be removed. By default, false.')] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

14555    @validate_call
14556    def un_group(
14557        self,
14558        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
14559        group_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the group.")],
14560        delete_items: Annotated[
14561            Optional[StrictBool], Field(description="Indicates whether the items should be removed. By default, false.")
14562        ] = None,
14563        _request_timeout: Union[
14564            None,
14565            Annotated[StrictFloat, Field(gt=0)],
14566            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14567        ] = None,
14568        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14569        _content_type: Optional[StrictStr] = None,
14570        _headers: Optional[Dict[StrictStr, Any]] = None,
14571        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14572    ) -> object:
14573        """Ungroup items
14574
14575        Ungroups items from a group.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
14576
14577        :param board_id: Unique identifier (ID) of the board. (required)
14578        :type board_id: str
14579        :param group_id: Unique identifier (ID) of the group. (required)
14580        :type group_id: str
14581        :param delete_items: Indicates whether the items should be removed. By default, false.
14582        :type delete_items: bool
14583        :param _request_timeout: timeout setting for this request. If one
14584                                 number provided, it will be total request
14585                                 timeout. It can also be a pair (tuple) of
14586                                 (connection, read) timeouts.
14587        :type _request_timeout: int, tuple(int, int), optional
14588        :param _request_auth: set to override the auth_settings for an a single
14589                              request; this effectively ignores the
14590                              authentication in the spec for a single request.
14591        :type _request_auth: dict, optional
14592        :param _content_type: force content-type for the request.
14593        :type _content_type: str, Optional
14594        :param _headers: set to override the headers for a single
14595                         request; this effectively ignores the headers
14596                         in the spec for a single request.
14597        :type _headers: dict, optional
14598        :param _host_index: set to override the host_index for a single
14599                            request; this effectively ignores the host_index
14600                            in the spec for a single request.
14601        :type _host_index: int, optional
14602        :return: Returns the result object.
14603        """  # noqa: E501
14604
14605        _param = self._un_group_serialize(
14606            board_id=board_id,
14607            group_id=group_id,
14608            delete_items=delete_items,
14609            _request_auth=_request_auth,
14610            _content_type=_content_type,
14611            _headers=_headers,
14612            _host_index=_host_index,
14613        )
14614
14615        _response_types_map: Dict[str, Optional[str]] = {
14616            "204": "object",
14617            "400": "UnGroup400Response",
14618            "404": "UnGroup404Response",
14619            "429": "UnGroup429Response",
14620        }
14621        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14622        response_data.read()
14623        return self.api_client.response_deserialize(
14624            response_data=response_data,
14625            response_types_map=_response_types_map,
14626        ).data

Ungroup items

Ungroups items from a group.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board. (required) :type board_id: str :param group_id: Unique identifier (ID) of the group. (required) :type group_id: str :param delete_items: Indicates whether the items should be removed. By default, false. :type delete_items: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_group( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the group.')], group: miro_api.models.group.Group, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.group_response_short.GroupResponseShort: View Source

14685    @validate_call
14686    def update_group(
14687        self,
14688        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
14689        group_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the group.")],
14690        group: Group,
14691        _request_timeout: Union[
14692            None,
14693            Annotated[StrictFloat, Field(gt=0)],
14694            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14695        ] = None,
14696        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14697        _content_type: Optional[StrictStr] = None,
14698        _headers: Optional[Dict[StrictStr, Any]] = None,
14699        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14700    ) -> GroupResponseShort:
14701        """Updates a group with new items
14702
14703        This endpoint updates an existing group by replacing it entirely with a new group.  When the update is made, the original group is completely replaced, and a new group ID is assigned. <br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
14704
14705        :param board_id: Unique identifier (ID) of the board. (required)
14706        :type board_id: str
14707        :param group_id: Unique identifier (ID) of the group. (required)
14708        :type group_id: str
14709        :param group: (required)
14710        :type group: Group
14711        :param _request_timeout: timeout setting for this request. If one
14712                                 number provided, it will be total request
14713                                 timeout. It can also be a pair (tuple) of
14714                                 (connection, read) timeouts.
14715        :type _request_timeout: int, tuple(int, int), optional
14716        :param _request_auth: set to override the auth_settings for an a single
14717                              request; this effectively ignores the
14718                              authentication in the spec for a single request.
14719        :type _request_auth: dict, optional
14720        :param _content_type: force content-type for the request.
14721        :type _content_type: str, Optional
14722        :param _headers: set to override the headers for a single
14723                         request; this effectively ignores the headers
14724                         in the spec for a single request.
14725        :type _headers: dict, optional
14726        :param _host_index: set to override the host_index for a single
14727                            request; this effectively ignores the host_index
14728                            in the spec for a single request.
14729        :type _host_index: int, optional
14730        :return: Returns the result object.
14731        """  # noqa: E501
14732
14733        _param = self._update_group_serialize(
14734            board_id=board_id,
14735            group_id=group_id,
14736            group=group,
14737            _request_auth=_request_auth,
14738            _content_type=_content_type,
14739            _headers=_headers,
14740            _host_index=_host_index,
14741        )
14742
14743        _response_types_map: Dict[str, Optional[str]] = {
14744            "200": "GroupResponseShort",
14745            "400": "GetAllGroups400Response",
14746            "404": "GetAllGroups404Response",
14747            "429": "GetAllGroups429Response",
14748        }
14749        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14750        response_data.read()
14751        return self.api_client.response_deserialize(
14752            response_data=response_data,
14753            response_types_map=_response_types_map,
14754        ).data

Updates a group with new items

This endpoint updates an existing group by replacing it entirely with a new group. When the update is made, the original group is completely replaced, and a new group ID is assigned.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board. (required) :type board_id: str :param group_id: Unique identifier (ID) of the group. (required) :type group_id: str :param group: (required) :type group: Group :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_image_item_using_local_file( self, board_id_platform_file_upload: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], resource: Annotated[Union[Annotated[bytes, Strict(strict=True)], Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Select a file to upload. Maximum file size is 6 MB.')], data: Optional[miro_api.models.upload_file_from_device_data.UploadFileFromDeviceData] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.image_item.ImageItem: View Source

14819    @validate_call
14820    def create_image_item_using_local_file(
14821        self,
14822        board_id_platform_file_upload: Annotated[
14823            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
14824        ],
14825        resource: Annotated[
14826            Union[StrictBytes, StrictStr], Field(description="Select a file to upload. Maximum file size is 6 MB.")
14827        ],
14828        data: Optional[UploadFileFromDeviceData] = None,
14829        _request_timeout: Union[
14830            None,
14831            Annotated[StrictFloat, Field(gt=0)],
14832            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14833        ] = None,
14834        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14835        _content_type: Optional[StrictStr] = None,
14836        _headers: Optional[Dict[StrictStr, Any]] = None,
14837        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14838    ) -> ImageItem:
14839        """Create image item using file from device
14840
14841        Adds an image item to a board by specifying a file from device.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
14842
14843        :param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to create the item. (required)
14844        :type board_id_platform_file_upload: str
14845        :param resource: Select a file to upload. Maximum file size is 6 MB. (required)
14846        :type resource: bytearray
14847        :param data:
14848        :type data: UploadFileFromDeviceData
14849        :param _request_timeout: timeout setting for this request. If one
14850                                 number provided, it will be total request
14851                                 timeout. It can also be a pair (tuple) of
14852                                 (connection, read) timeouts.
14853        :type _request_timeout: int, tuple(int, int), optional
14854        :param _request_auth: set to override the auth_settings for an a single
14855                              request; this effectively ignores the
14856                              authentication in the spec for a single request.
14857        :type _request_auth: dict, optional
14858        :param _content_type: force content-type for the request.
14859        :type _content_type: str, Optional
14860        :param _headers: set to override the headers for a single
14861                         request; this effectively ignores the headers
14862                         in the spec for a single request.
14863        :type _headers: dict, optional
14864        :param _host_index: set to override the host_index for a single
14865                            request; this effectively ignores the host_index
14866                            in the spec for a single request.
14867        :type _host_index: int, optional
14868        :return: Returns the result object.
14869        """  # noqa: E501
14870
14871        _param = self._create_image_item_using_local_file_serialize(
14872            board_id_platform_file_upload=board_id_platform_file_upload,
14873            resource=resource,
14874            data=data,
14875            _request_auth=_request_auth,
14876            _content_type=_content_type,
14877            _headers=_headers,
14878            _host_index=_host_index,
14879        )
14880
14881        _response_types_map: Dict[str, Optional[str]] = {
14882            "201": "ImageItem",
14883        }
14884        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14885        response_data.read()
14886        return self.api_client.response_deserialize(
14887            response_data=response_data,
14888            response_types_map=_response_types_map,
14889        ).data

Create image item using file from device

Adds an image item to a board by specifying a file from device.

Required scope

Rate limiting

:param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id_platform_file_upload: str :param resource: Select a file to upload. Maximum file size is 6 MB. (required) :type resource: bytearray :param data: :type data: UploadFileFromDeviceData :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_image_item_using_url( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], image_create_request: miro_api.models.image_create_request.ImageCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.image_item.ImageItem: View Source

14954    @validate_call
14955    def create_image_item_using_url(
14956        self,
14957        board_id: Annotated[
14958            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
14959        ],
14960        image_create_request: ImageCreateRequest,
14961        _request_timeout: Union[
14962            None,
14963            Annotated[StrictFloat, Field(gt=0)],
14964            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14965        ] = None,
14966        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14967        _content_type: Optional[StrictStr] = None,
14968        _headers: Optional[Dict[StrictStr, Any]] = None,
14969        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14970    ) -> ImageItem:
14971        """Create image item using URL
14972
14973        Adds an image item to a board by specifying an image URL.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
14974
14975        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
14976        :type board_id: str
14977        :param image_create_request: (required)
14978        :type image_create_request: ImageCreateRequest
14979        :param _request_timeout: timeout setting for this request. If one
14980                                 number provided, it will be total request
14981                                 timeout. It can also be a pair (tuple) of
14982                                 (connection, read) timeouts.
14983        :type _request_timeout: int, tuple(int, int), optional
14984        :param _request_auth: set to override the auth_settings for an a single
14985                              request; this effectively ignores the
14986                              authentication in the spec for a single request.
14987        :type _request_auth: dict, optional
14988        :param _content_type: force content-type for the request.
14989        :type _content_type: str, Optional
14990        :param _headers: set to override the headers for a single
14991                         request; this effectively ignores the headers
14992                         in the spec for a single request.
14993        :type _headers: dict, optional
14994        :param _host_index: set to override the host_index for a single
14995                            request; this effectively ignores the host_index
14996                            in the spec for a single request.
14997        :type _host_index: int, optional
14998        :return: Returns the result object.
14999        """  # noqa: E501
15000
15001        _param = self._create_image_item_using_url_serialize(
15002            board_id=board_id,
15003            image_create_request=image_create_request,
15004            _request_auth=_request_auth,
15005            _content_type=_content_type,
15006            _headers=_headers,
15007            _host_index=_host_index,
15008        )
15009
15010        _response_types_map: Dict[str, Optional[str]] = {
15011            "201": "ImageItem",
15012            "400": None,
15013            "404": None,
15014            "429": None,
15015        }
15016        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15017        response_data.read()
15018        return self.api_client.response_deserialize(
15019            response_data=response_data,
15020            response_types_map=_response_types_map,
15021        ).data

Create image item using URL

Adds an image item to a board by specifying an image URL.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param image_create_request: (required) :type image_create_request: ImageCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_image_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

15083    @validate_call
15084    def delete_image_item(
15085        self,
15086        board_id: Annotated[
15087            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
15088        ],
15089        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
15090        _request_timeout: Union[
15091            None,
15092            Annotated[StrictFloat, Field(gt=0)],
15093            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15094        ] = None,
15095        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15096        _content_type: Optional[StrictStr] = None,
15097        _headers: Optional[Dict[StrictStr, Any]] = None,
15098        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15099    ) -> object:
15100        """Delete image item
15101
15102        Deletes an image item from the board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
15103
15104        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
15105        :type board_id: str
15106        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
15107        :type item_id: str
15108        :param _request_timeout: timeout setting for this request. If one
15109                                 number provided, it will be total request
15110                                 timeout. It can also be a pair (tuple) of
15111                                 (connection, read) timeouts.
15112        :type _request_timeout: int, tuple(int, int), optional
15113        :param _request_auth: set to override the auth_settings for an a single
15114                              request; this effectively ignores the
15115                              authentication in the spec for a single request.
15116        :type _request_auth: dict, optional
15117        :param _content_type: force content-type for the request.
15118        :type _content_type: str, Optional
15119        :param _headers: set to override the headers for a single
15120                         request; this effectively ignores the headers
15121                         in the spec for a single request.
15122        :type _headers: dict, optional
15123        :param _host_index: set to override the host_index for a single
15124                            request; this effectively ignores the host_index
15125                            in the spec for a single request.
15126        :type _host_index: int, optional
15127        :return: Returns the result object.
15128        """  # noqa: E501
15129
15130        _param = self._delete_image_item_serialize(
15131            board_id=board_id,
15132            item_id=item_id,
15133            _request_auth=_request_auth,
15134            _content_type=_content_type,
15135            _headers=_headers,
15136            _host_index=_host_index,
15137        )
15138
15139        _response_types_map: Dict[str, Optional[str]] = {
15140            "204": "object",
15141            "400": None,
15142            "404": None,
15143            "429": None,
15144        }
15145        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15146        response_data.read()
15147        return self.api_client.response_deserialize(
15148            response_data=response_data,
15149            response_types_map=_response_types_map,
15150        ).data

Delete image item

Deletes an image item from the board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_image_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.image_item.ImageItem: View Source

15204    @validate_call
15205    def get_image_item(
15206        self,
15207        board_id: Annotated[
15208            StrictStr,
15209            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
15210        ],
15211        item_id: Annotated[
15212            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
15213        ],
15214        _request_timeout: Union[
15215            None,
15216            Annotated[StrictFloat, Field(gt=0)],
15217            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15218        ] = None,
15219        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15220        _content_type: Optional[StrictStr] = None,
15221        _headers: Optional[Dict[StrictStr, Any]] = None,
15222        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15223    ) -> ImageItem:
15224        """Get image item
15225
15226        Retrieves information for a specific image item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
15227
15228        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
15229        :type board_id: str
15230        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
15231        :type item_id: str
15232        :param _request_timeout: timeout setting for this request. If one
15233                                 number provided, it will be total request
15234                                 timeout. It can also be a pair (tuple) of
15235                                 (connection, read) timeouts.
15236        :type _request_timeout: int, tuple(int, int), optional
15237        :param _request_auth: set to override the auth_settings for an a single
15238                              request; this effectively ignores the
15239                              authentication in the spec for a single request.
15240        :type _request_auth: dict, optional
15241        :param _content_type: force content-type for the request.
15242        :type _content_type: str, Optional
15243        :param _headers: set to override the headers for a single
15244                         request; this effectively ignores the headers
15245                         in the spec for a single request.
15246        :type _headers: dict, optional
15247        :param _host_index: set to override the host_index for a single
15248                            request; this effectively ignores the host_index
15249                            in the spec for a single request.
15250        :type _host_index: int, optional
15251        :return: Returns the result object.
15252        """  # noqa: E501
15253
15254        _param = self._get_image_item_serialize(
15255            board_id=board_id,
15256            item_id=item_id,
15257            _request_auth=_request_auth,
15258            _content_type=_content_type,
15259            _headers=_headers,
15260            _host_index=_host_index,
15261        )
15262
15263        _response_types_map: Dict[str, Optional[str]] = {
15264            "200": "ImageItem",
15265            "400": None,
15266            "404": None,
15267            "429": None,
15268        }
15269        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15270        response_data.read()
15271        return self.api_client.response_deserialize(
15272            response_data=response_data,
15273            response_types_map=_response_types_map,
15274        ).data

Get image item

Retrieves information for a specific image item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_image_item_using_file_from_device( self, board_id_platform_file_upload: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], resource: Annotated[Union[Annotated[bytes, Strict(strict=True)], Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Select a file to upload. Maximum file size is 6 MB.')], data: Optional[miro_api.models.upload_file_from_device_data.UploadFileFromDeviceData] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.image_item.ImageItem: View Source

15328    @validate_call
15329    def update_image_item_using_file_from_device(
15330        self,
15331        board_id_platform_file_upload: Annotated[
15332            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
15333        ],
15334        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
15335        resource: Annotated[
15336            Union[StrictBytes, StrictStr], Field(description="Select a file to upload. Maximum file size is 6 MB.")
15337        ],
15338        data: Optional[UploadFileFromDeviceData] = None,
15339        _request_timeout: Union[
15340            None,
15341            Annotated[StrictFloat, Field(gt=0)],
15342            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15343        ] = None,
15344        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15345        _content_type: Optional[StrictStr] = None,
15346        _headers: Optional[Dict[StrictStr, Any]] = None,
15347        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15348    ) -> ImageItem:
15349        """Update image item using file from device
15350
15351        Updates an image item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
15352
15353        :param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to update the item. (required)
15354        :type board_id_platform_file_upload: str
15355        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
15356        :type item_id: str
15357        :param resource: Select a file to upload. Maximum file size is 6 MB. (required)
15358        :type resource: bytearray
15359        :param data:
15360        :type data: UploadFileFromDeviceData
15361        :param _request_timeout: timeout setting for this request. If one
15362                                 number provided, it will be total request
15363                                 timeout. It can also be a pair (tuple) of
15364                                 (connection, read) timeouts.
15365        :type _request_timeout: int, tuple(int, int), optional
15366        :param _request_auth: set to override the auth_settings for an a single
15367                              request; this effectively ignores the
15368                              authentication in the spec for a single request.
15369        :type _request_auth: dict, optional
15370        :param _content_type: force content-type for the request.
15371        :type _content_type: str, Optional
15372        :param _headers: set to override the headers for a single
15373                         request; this effectively ignores the headers
15374                         in the spec for a single request.
15375        :type _headers: dict, optional
15376        :param _host_index: set to override the host_index for a single
15377                            request; this effectively ignores the host_index
15378                            in the spec for a single request.
15379        :type _host_index: int, optional
15380        :return: Returns the result object.
15381        """  # noqa: E501
15382
15383        _param = self._update_image_item_using_file_from_device_serialize(
15384            board_id_platform_file_upload=board_id_platform_file_upload,
15385            item_id=item_id,
15386            resource=resource,
15387            data=data,
15388            _request_auth=_request_auth,
15389            _content_type=_content_type,
15390            _headers=_headers,
15391            _host_index=_host_index,
15392        )
15393
15394        _response_types_map: Dict[str, Optional[str]] = {
15395            "200": "ImageItem",
15396        }
15397        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15398        response_data.read()
15399        return self.api_client.response_deserialize(
15400            response_data=response_data,
15401            response_types_map=_response_types_map,
15402        ).data

Update image item using file from device

Updates an image item on a board.

Required scope

Rate limiting

:param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id_platform_file_upload: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param resource: Select a file to upload. Maximum file size is 6 MB. (required) :type resource: bytearray :param data: :type data: UploadFileFromDeviceData :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_image_item_using_url( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], image_update_request: miro_api.models.image_update_request.ImageUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.image_item.ImageItem: View Source

15470    @validate_call
15471    def update_image_item_using_url(
15472        self,
15473        board_id: Annotated[
15474            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
15475        ],
15476        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
15477        image_update_request: ImageUpdateRequest,
15478        _request_timeout: Union[
15479            None,
15480            Annotated[StrictFloat, Field(gt=0)],
15481            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15482        ] = None,
15483        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15484        _content_type: Optional[StrictStr] = None,
15485        _headers: Optional[Dict[StrictStr, Any]] = None,
15486        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15487    ) -> ImageItem:
15488        """Update image item using URL
15489
15490        Updates an image item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
15491
15492        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
15493        :type board_id: str
15494        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
15495        :type item_id: str
15496        :param image_update_request: (required)
15497        :type image_update_request: ImageUpdateRequest
15498        :param _request_timeout: timeout setting for this request. If one
15499                                 number provided, it will be total request
15500                                 timeout. It can also be a pair (tuple) of
15501                                 (connection, read) timeouts.
15502        :type _request_timeout: int, tuple(int, int), optional
15503        :param _request_auth: set to override the auth_settings for an a single
15504                              request; this effectively ignores the
15505                              authentication in the spec for a single request.
15506        :type _request_auth: dict, optional
15507        :param _content_type: force content-type for the request.
15508        :type _content_type: str, Optional
15509        :param _headers: set to override the headers for a single
15510                         request; this effectively ignores the headers
15511                         in the spec for a single request.
15512        :type _headers: dict, optional
15513        :param _host_index: set to override the host_index for a single
15514                            request; this effectively ignores the host_index
15515                            in the spec for a single request.
15516        :type _host_index: int, optional
15517        :return: Returns the result object.
15518        """  # noqa: E501
15519
15520        _param = self._update_image_item_using_url_serialize(
15521            board_id=board_id,
15522            item_id=item_id,
15523            image_update_request=image_update_request,
15524            _request_auth=_request_auth,
15525            _content_type=_content_type,
15526            _headers=_headers,
15527            _host_index=_host_index,
15528        )
15529
15530        _response_types_map: Dict[str, Optional[str]] = {
15531            "200": "ImageItem",
15532            "400": None,
15533            "404": None,
15534            "409": None,
15535            "429": None,
15536        }
15537        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15538        response_data.read()
15539        return self.api_client.response_deserialize(
15540            response_data=response_data,
15541            response_types_map=_response_types_map,
15542        ).data

Update image item using URL

Updates an image item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param image_update_request: (required) :type image_update_request: ImageUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

15607    @validate_call
15608    def delete_item(
15609        self,
15610        board_id: Annotated[
15611            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
15612        ],
15613        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
15614        _request_timeout: Union[
15615            None,
15616            Annotated[StrictFloat, Field(gt=0)],
15617            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15618        ] = None,
15619        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15620        _content_type: Optional[StrictStr] = None,
15621        _headers: Optional[Dict[StrictStr, Any]] = None,
15622        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15623    ) -> object:
15624        """Delete item
15625
15626        Deletes an item from a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
15627
15628        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
15629        :type board_id: str
15630        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
15631        :type item_id: str
15632        :param _request_timeout: timeout setting for this request. If one
15633                                 number provided, it will be total request
15634                                 timeout. It can also be a pair (tuple) of
15635                                 (connection, read) timeouts.
15636        :type _request_timeout: int, tuple(int, int), optional
15637        :param _request_auth: set to override the auth_settings for an a single
15638                              request; this effectively ignores the
15639                              authentication in the spec for a single request.
15640        :type _request_auth: dict, optional
15641        :param _content_type: force content-type for the request.
15642        :type _content_type: str, Optional
15643        :param _headers: set to override the headers for a single
15644                         request; this effectively ignores the headers
15645                         in the spec for a single request.
15646        :type _headers: dict, optional
15647        :param _host_index: set to override the host_index for a single
15648                            request; this effectively ignores the host_index
15649                            in the spec for a single request.
15650        :type _host_index: int, optional
15651        :return: Returns the result object.
15652        """  # noqa: E501
15653
15654        _param = self._delete_item_serialize(
15655            board_id=board_id,
15656            item_id=item_id,
15657            _request_auth=_request_auth,
15658            _content_type=_content_type,
15659            _headers=_headers,
15660            _host_index=_host_index,
15661        )
15662
15663        _response_types_map: Dict[str, Optional[str]] = {
15664            "204": "object",
15665            "400": None,
15666            "404": None,
15667            "429": None,
15668        }
15669        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15670        response_data.read()
15671        return self.api_client.response_deserialize(
15672            response_data=response_data,
15673            response_types_map=_response_types_map,
15674        ).data

Delete item

Deletes an item from a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_item_experimental( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

15728    @validate_call
15729    def delete_item_experimental(
15730        self,
15731        board_id: Annotated[
15732            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
15733        ],
15734        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
15735        _request_timeout: Union[
15736            None,
15737            Annotated[StrictFloat, Field(gt=0)],
15738            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15739        ] = None,
15740        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15741        _content_type: Optional[StrictStr] = None,
15742        _headers: Optional[Dict[StrictStr, Any]] = None,
15743        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15744    ) -> object:
15745        """Delete item
15746
15747        Deletes an item from a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
15748
15749        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
15750        :type board_id: str
15751        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
15752        :type item_id: str
15753        :param _request_timeout: timeout setting for this request. If one
15754                                 number provided, it will be total request
15755                                 timeout. It can also be a pair (tuple) of
15756                                 (connection, read) timeouts.
15757        :type _request_timeout: int, tuple(int, int), optional
15758        :param _request_auth: set to override the auth_settings for an a single
15759                              request; this effectively ignores the
15760                              authentication in the spec for a single request.
15761        :type _request_auth: dict, optional
15762        :param _content_type: force content-type for the request.
15763        :type _content_type: str, Optional
15764        :param _headers: set to override the headers for a single
15765                         request; this effectively ignores the headers
15766                         in the spec for a single request.
15767        :type _headers: dict, optional
15768        :param _host_index: set to override the host_index for a single
15769                            request; this effectively ignores the host_index
15770                            in the spec for a single request.
15771        :type _host_index: int, optional
15772        :return: Returns the result object.
15773        """  # noqa: E501
15774
15775        _param = self._delete_item_experimental_serialize(
15776            board_id=board_id,
15777            item_id=item_id,
15778            _request_auth=_request_auth,
15779            _content_type=_content_type,
15780            _headers=_headers,
15781            _host_index=_host_index,
15782        )
15783
15784        _response_types_map: Dict[str, Optional[str]] = {
15785            "204": "object",
15786            "400": "CreateFrameItem400Response",
15787            "404": "CreateFrameItem400Response",
15788            "429": "CreateFrameItem400Response",
15789        }
15790        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15791        response_data.read()
15792        return self.api_client.response_deserialize(
15793            response_data=response_data,
15794            response_types_map=_response_types_map,
15795        ).data

Delete item

Deletes an item from a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_items( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board for which you want to retrieve the list of available items.')], limit: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] = None, type: Optional[Annotated[str, Strict(strict=True)]] = None, cursor: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.generic_item_cursor_paged.GenericItemCursorPaged: View Source

15849    @validate_call
15850    def get_items(
15851        self,
15852        board_id: Annotated[
15853            StrictStr,
15854            Field(
15855                description="Unique identifier (ID) of the board for which you want to retrieve the list of available items."
15856            ),
15857        ],
15858        limit: Optional[Annotated[str, Field(strict=True)]] = None,
15859        type: Optional[StrictStr] = None,
15860        cursor: Optional[StrictStr] = None,
15861        _request_timeout: Union[
15862            None,
15863            Annotated[StrictFloat, Field(gt=0)],
15864            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15865        ] = None,
15866        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15867        _content_type: Optional[StrictStr] = None,
15868        _headers: Optional[Dict[StrictStr, Any]] = None,
15869        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15870    ) -> GenericItemCursorPaged:
15871        """Get items on board
15872
15873        Retrieves a list of items for a specific board. You can retrieve all items on the board, a list of child items inside a parent item, or a list of specific types of items by specifying URL query parameter values.  This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the `cursor` parameter equal to the `cursor` value you received in the response of the previous request. For example, if you set the `limit` query parameter to `10` and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is `foo`. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to `foo`.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
15874
15875        :param board_id: Unique identifier (ID) of the board for which you want to retrieve the list of available items. (required)
15876        :type board_id: str
15877        :param limit:
15878        :type limit: str
15879        :param type:
15880        :type type: str
15881        :param cursor:
15882        :type cursor: str
15883        :param _request_timeout: timeout setting for this request. If one
15884                                 number provided, it will be total request
15885                                 timeout. It can also be a pair (tuple) of
15886                                 (connection, read) timeouts.
15887        :type _request_timeout: int, tuple(int, int), optional
15888        :param _request_auth: set to override the auth_settings for an a single
15889                              request; this effectively ignores the
15890                              authentication in the spec for a single request.
15891        :type _request_auth: dict, optional
15892        :param _content_type: force content-type for the request.
15893        :type _content_type: str, Optional
15894        :param _headers: set to override the headers for a single
15895                         request; this effectively ignores the headers
15896                         in the spec for a single request.
15897        :type _headers: dict, optional
15898        :param _host_index: set to override the host_index for a single
15899                            request; this effectively ignores the host_index
15900                            in the spec for a single request.
15901        :type _host_index: int, optional
15902        :return: Returns the result object.
15903        """  # noqa: E501
15904
15905        _param = self._get_items_serialize(
15906            board_id=board_id,
15907            limit=limit,
15908            type=type,
15909            cursor=cursor,
15910            _request_auth=_request_auth,
15911            _content_type=_content_type,
15912            _headers=_headers,
15913            _host_index=_host_index,
15914        )
15915
15916        _response_types_map: Dict[str, Optional[str]] = {
15917            "200": "GenericItemCursorPaged",
15918            "400": None,
15919            "404": None,
15920            "429": None,
15921        }
15922        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15923        response_data.read()
15924        return self.api_client.response_deserialize(
15925            response_data=response_data,
15926            response_types_map=_response_types_map,
15927        ).data

Get items on board

Retrieves a list of items for a specific board. You can retrieve all items on the board, a list of child items inside a parent item, or a list of specific types of items by specifying URL query parameter values. This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the cursor parameter equal to the cursor value you received in the response of the previous request. For example, if you set the limit query parameter to 10 and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is foo. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to foo.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board for which you want to retrieve the list of available items. (required) :type board_id: str :param limit: :type limit: str :param type: :type type: str :param cursor: :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_items_within_frame( self, board_id_platform_containers: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board that contains the frame for which you want to retrieve the list of available items.')], parent_item_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='ID of the frame for which you want to retrieve the list of available items.', metadata=[Strict(strict=True)])], limit: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] = None, type: Optional[Annotated[str, Strict(strict=True)]] = None, cursor: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.generic_item_cursor_paged.GenericItemCursorPaged: View Source

15993    @validate_call
15994    def get_items_within_frame(
15995        self,
15996        board_id_platform_containers: Annotated[
15997            StrictStr,
15998            Field(
15999                description="Unique identifier (ID) of the board that contains the frame for which you want to retrieve the list of available items."
16000            ),
16001        ],
16002        parent_item_id: Annotated[
16003            str,
16004            Field(
16005                strict=True, description="ID of the frame for which you want to retrieve the list of available items."
16006            ),
16007        ],
16008        limit: Optional[Annotated[str, Field(strict=True)]] = None,
16009        type: Optional[StrictStr] = None,
16010        cursor: Optional[StrictStr] = None,
16011        _request_timeout: Union[
16012            None,
16013            Annotated[StrictFloat, Field(gt=0)],
16014            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16015        ] = None,
16016        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16017        _content_type: Optional[StrictStr] = None,
16018        _headers: Optional[Dict[StrictStr, Any]] = None,
16019        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16020    ) -> GenericItemCursorPaged:
16021        """Get items within frame
16022
16023        Retrieves a list of items within a specific frame. A frame is a parent item and all items within a frame are child items. This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the `cursor` parameter equal to the `cursor` value you received in the response of the previous request. For example, if you set the `limit` query parameter to `10` and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is `foo`. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to `foo`.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
16024
16025        :param board_id_platform_containers: Unique identifier (ID) of the board that contains the frame for which you want to retrieve the list of available items. (required)
16026        :type board_id_platform_containers: str
16027        :param parent_item_id: ID of the frame for which you want to retrieve the list of available items. (required)
16028        :type parent_item_id: str
16029        :param limit:
16030        :type limit: str
16031        :param type:
16032        :type type: str
16033        :param cursor:
16034        :type cursor: str
16035        :param _request_timeout: timeout setting for this request. If one
16036                                 number provided, it will be total request
16037                                 timeout. It can also be a pair (tuple) of
16038                                 (connection, read) timeouts.
16039        :type _request_timeout: int, tuple(int, int), optional
16040        :param _request_auth: set to override the auth_settings for an a single
16041                              request; this effectively ignores the
16042                              authentication in the spec for a single request.
16043        :type _request_auth: dict, optional
16044        :param _content_type: force content-type for the request.
16045        :type _content_type: str, Optional
16046        :param _headers: set to override the headers for a single
16047                         request; this effectively ignores the headers
16048                         in the spec for a single request.
16049        :type _headers: dict, optional
16050        :param _host_index: set to override the host_index for a single
16051                            request; this effectively ignores the host_index
16052                            in the spec for a single request.
16053        :type _host_index: int, optional
16054        :return: Returns the result object.
16055        """  # noqa: E501
16056
16057        _param = self._get_items_within_frame_serialize(
16058            board_id_platform_containers=board_id_platform_containers,
16059            parent_item_id=parent_item_id,
16060            limit=limit,
16061            type=type,
16062            cursor=cursor,
16063            _request_auth=_request_auth,
16064            _content_type=_content_type,
16065            _headers=_headers,
16066            _host_index=_host_index,
16067        )
16068
16069        _response_types_map: Dict[str, Optional[str]] = {
16070            "200": "GenericItemCursorPaged",
16071            "400": "CreateFrameItem400Response",
16072            "404": "CreateFrameItem400Response",
16073            "429": "CreateFrameItem400Response",
16074        }
16075        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16076        response_data.read()
16077        return self.api_client.response_deserialize(
16078            response_data=response_data,
16079            response_types_map=_response_types_map,
16080        ).data

Get items within frame

Retrieves a list of items within a specific frame. A frame is a parent item and all items within a frame are child items. This method returns results using a cursor-based approach. A cursor-paginated method returns a portion of the total set of results based on the limit specified and a cursor that points to the next portion of the results. To retrieve the next portion of the collection, on your next call to the same method, set the cursor parameter equal to the cursor value you received in the response of the previous request. For example, if you set the limit query parameter to 10 and the board contains 20 objects, the first call will return information about the first 10 objects in the response along with a cursor parameter and value. In this example, let's say the cursor parameter value returned in the response is foo. If you want to retrieve the next set of objects, on your next call to the same method, set the cursor parameter value to foo.

Required scope

Rate limiting

:param board_id_platform_containers: Unique identifier (ID) of the board that contains the frame for which you want to retrieve the list of available items. (required) :type board_id_platform_containers: str :param parent_item_id: ID of the frame for which you want to retrieve the list of available items. (required) :type parent_item_id: str :param limit: :type limit: str :param type: :type type: str :param cursor: :type cursor: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_specific_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.generic_item.GenericItem: View Source

16151    @validate_call
16152    def get_specific_item(
16153        self,
16154        board_id: Annotated[
16155            StrictStr,
16156            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
16157        ],
16158        item_id: Annotated[
16159            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
16160        ],
16161        _request_timeout: Union[
16162            None,
16163            Annotated[StrictFloat, Field(gt=0)],
16164            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16165        ] = None,
16166        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16167        _content_type: Optional[StrictStr] = None,
16168        _headers: Optional[Dict[StrictStr, Any]] = None,
16169        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16170    ) -> GenericItem:
16171        """Get specific item on board
16172
16173        Retrieves information for a specific item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
16174
16175        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
16176        :type board_id: str
16177        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
16178        :type item_id: str
16179        :param _request_timeout: timeout setting for this request. If one
16180                                 number provided, it will be total request
16181                                 timeout. It can also be a pair (tuple) of
16182                                 (connection, read) timeouts.
16183        :type _request_timeout: int, tuple(int, int), optional
16184        :param _request_auth: set to override the auth_settings for an a single
16185                              request; this effectively ignores the
16186                              authentication in the spec for a single request.
16187        :type _request_auth: dict, optional
16188        :param _content_type: force content-type for the request.
16189        :type _content_type: str, Optional
16190        :param _headers: set to override the headers for a single
16191                         request; this effectively ignores the headers
16192                         in the spec for a single request.
16193        :type _headers: dict, optional
16194        :param _host_index: set to override the host_index for a single
16195                            request; this effectively ignores the host_index
16196                            in the spec for a single request.
16197        :type _host_index: int, optional
16198        :return: Returns the result object.
16199        """  # noqa: E501
16200
16201        _param = self._get_specific_item_serialize(
16202            board_id=board_id,
16203            item_id=item_id,
16204            _request_auth=_request_auth,
16205            _content_type=_content_type,
16206            _headers=_headers,
16207            _host_index=_host_index,
16208        )
16209
16210        _response_types_map: Dict[str, Optional[str]] = {
16211            "200": "GenericItem",
16212            "400": None,
16213            "404": None,
16214            "429": None,
16215        }
16216        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16217        response_data.read()
16218        return self.api_client.response_deserialize(
16219            response_data=response_data,
16220            response_types_map=_response_types_map,
16221        ).data

Get specific item on board

Retrieves information for a specific item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_item_position_or_parent( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], generic_item_update: miro_api.models.generic_item_update.GenericItemUpdate, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.generic_item.GenericItem: View Source

16275    @validate_call
16276    def update_item_position_or_parent(
16277        self,
16278        board_id: Annotated[
16279            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
16280        ],
16281        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
16282        generic_item_update: GenericItemUpdate,
16283        _request_timeout: Union[
16284            None,
16285            Annotated[StrictFloat, Field(gt=0)],
16286            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16287        ] = None,
16288        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16289        _content_type: Optional[StrictStr] = None,
16290        _headers: Optional[Dict[StrictStr, Any]] = None,
16291        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16292    ) -> GenericItem:
16293        """Update item position or parent
16294
16295        Updates the position or the parent of an item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
16296
16297        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
16298        :type board_id: str
16299        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
16300        :type item_id: str
16301        :param generic_item_update: (required)
16302        :type generic_item_update: GenericItemUpdate
16303        :param _request_timeout: timeout setting for this request. If one
16304                                 number provided, it will be total request
16305                                 timeout. It can also be a pair (tuple) of
16306                                 (connection, read) timeouts.
16307        :type _request_timeout: int, tuple(int, int), optional
16308        :param _request_auth: set to override the auth_settings for an a single
16309                              request; this effectively ignores the
16310                              authentication in the spec for a single request.
16311        :type _request_auth: dict, optional
16312        :param _content_type: force content-type for the request.
16313        :type _content_type: str, Optional
16314        :param _headers: set to override the headers for a single
16315                         request; this effectively ignores the headers
16316                         in the spec for a single request.
16317        :type _headers: dict, optional
16318        :param _host_index: set to override the host_index for a single
16319                            request; this effectively ignores the host_index
16320                            in the spec for a single request.
16321        :type _host_index: int, optional
16322        :return: Returns the result object.
16323        """  # noqa: E501
16324
16325        _param = self._update_item_position_or_parent_serialize(
16326            board_id=board_id,
16327            item_id=item_id,
16328            generic_item_update=generic_item_update,
16329            _request_auth=_request_auth,
16330            _content_type=_content_type,
16331            _headers=_headers,
16332            _host_index=_host_index,
16333        )
16334
16335        _response_types_map: Dict[str, Optional[str]] = {
16336            "200": "GenericItem",
16337            "400": None,
16338            "404": None,
16339            "429": None,
16340        }
16341        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16342        response_data.read()
16343        return self.api_client.response_deserialize(
16344            response_data=response_data,
16345            response_types_map=_response_types_map,
16346        ).data

Update item position or parent

Updates the position or the parent of an item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param generic_item_update: (required) :type generic_item_update: GenericItemUpdate :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_shape_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], shape_create_request: miro_api.models.shape_create_request.ShapeCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.shape_item.ShapeItem: View Source

16411    @validate_call
16412    def create_shape_item(
16413        self,
16414        board_id: Annotated[
16415            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
16416        ],
16417        shape_create_request: ShapeCreateRequest,
16418        _request_timeout: Union[
16419            None,
16420            Annotated[StrictFloat, Field(gt=0)],
16421            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16422        ] = None,
16423        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16424        _content_type: Optional[StrictStr] = None,
16425        _headers: Optional[Dict[StrictStr, Any]] = None,
16426        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16427    ) -> ShapeItem:
16428        """Create shape item
16429
16430        Adds a shape item to a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
16431
16432        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
16433        :type board_id: str
16434        :param shape_create_request: (required)
16435        :type shape_create_request: ShapeCreateRequest
16436        :param _request_timeout: timeout setting for this request. If one
16437                                 number provided, it will be total request
16438                                 timeout. It can also be a pair (tuple) of
16439                                 (connection, read) timeouts.
16440        :type _request_timeout: int, tuple(int, int), optional
16441        :param _request_auth: set to override the auth_settings for an a single
16442                              request; this effectively ignores the
16443                              authentication in the spec for a single request.
16444        :type _request_auth: dict, optional
16445        :param _content_type: force content-type for the request.
16446        :type _content_type: str, Optional
16447        :param _headers: set to override the headers for a single
16448                         request; this effectively ignores the headers
16449                         in the spec for a single request.
16450        :type _headers: dict, optional
16451        :param _host_index: set to override the host_index for a single
16452                            request; this effectively ignores the host_index
16453                            in the spec for a single request.
16454        :type _host_index: int, optional
16455        :return: Returns the result object.
16456        """  # noqa: E501
16457
16458        _param = self._create_shape_item_serialize(
16459            board_id=board_id,
16460            shape_create_request=shape_create_request,
16461            _request_auth=_request_auth,
16462            _content_type=_content_type,
16463            _headers=_headers,
16464            _host_index=_host_index,
16465        )
16466
16467        _response_types_map: Dict[str, Optional[str]] = {
16468            "201": "ShapeItem",
16469            "400": None,
16470            "404": None,
16471            "429": None,
16472        }
16473        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16474        response_data.read()
16475        return self.api_client.response_deserialize(
16476            response_data=response_data,
16477            response_types_map=_response_types_map,
16478        ).data

Create shape item

Adds a shape item to a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param shape_create_request: (required) :type shape_create_request: ShapeCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_shape_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

16540    @validate_call
16541    def delete_shape_item(
16542        self,
16543        board_id: Annotated[
16544            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
16545        ],
16546        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
16547        _request_timeout: Union[
16548            None,
16549            Annotated[StrictFloat, Field(gt=0)],
16550            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16551        ] = None,
16552        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16553        _content_type: Optional[StrictStr] = None,
16554        _headers: Optional[Dict[StrictStr, Any]] = None,
16555        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16556    ) -> object:
16557        """Delete shape item
16558
16559        Deletes a shape item from the board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
16560
16561        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
16562        :type board_id: str
16563        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
16564        :type item_id: str
16565        :param _request_timeout: timeout setting for this request. If one
16566                                 number provided, it will be total request
16567                                 timeout. It can also be a pair (tuple) of
16568                                 (connection, read) timeouts.
16569        :type _request_timeout: int, tuple(int, int), optional
16570        :param _request_auth: set to override the auth_settings for an a single
16571                              request; this effectively ignores the
16572                              authentication in the spec for a single request.
16573        :type _request_auth: dict, optional
16574        :param _content_type: force content-type for the request.
16575        :type _content_type: str, Optional
16576        :param _headers: set to override the headers for a single
16577                         request; this effectively ignores the headers
16578                         in the spec for a single request.
16579        :type _headers: dict, optional
16580        :param _host_index: set to override the host_index for a single
16581                            request; this effectively ignores the host_index
16582                            in the spec for a single request.
16583        :type _host_index: int, optional
16584        :return: Returns the result object.
16585        """  # noqa: E501
16586
16587        _param = self._delete_shape_item_serialize(
16588            board_id=board_id,
16589            item_id=item_id,
16590            _request_auth=_request_auth,
16591            _content_type=_content_type,
16592            _headers=_headers,
16593            _host_index=_host_index,
16594        )
16595
16596        _response_types_map: Dict[str, Optional[str]] = {
16597            "204": "object",
16598            "400": None,
16599            "404": None,
16600            "429": None,
16601        }
16602        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16603        response_data.read()
16604        return self.api_client.response_deserialize(
16605            response_data=response_data,
16606            response_types_map=_response_types_map,
16607        ).data

Delete shape item

Deletes a shape item from the board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_shape_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.shape_item.ShapeItem: View Source

16661    @validate_call
16662    def get_shape_item(
16663        self,
16664        board_id: Annotated[
16665            StrictStr,
16666            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
16667        ],
16668        item_id: Annotated[
16669            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
16670        ],
16671        _request_timeout: Union[
16672            None,
16673            Annotated[StrictFloat, Field(gt=0)],
16674            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16675        ] = None,
16676        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16677        _content_type: Optional[StrictStr] = None,
16678        _headers: Optional[Dict[StrictStr, Any]] = None,
16679        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16680    ) -> ShapeItem:
16681        """Get shape item
16682
16683        Retrieves information for a specific shape item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
16684
16685        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
16686        :type board_id: str
16687        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
16688        :type item_id: str
16689        :param _request_timeout: timeout setting for this request. If one
16690                                 number provided, it will be total request
16691                                 timeout. It can also be a pair (tuple) of
16692                                 (connection, read) timeouts.
16693        :type _request_timeout: int, tuple(int, int), optional
16694        :param _request_auth: set to override the auth_settings for an a single
16695                              request; this effectively ignores the
16696                              authentication in the spec for a single request.
16697        :type _request_auth: dict, optional
16698        :param _content_type: force content-type for the request.
16699        :type _content_type: str, Optional
16700        :param _headers: set to override the headers for a single
16701                         request; this effectively ignores the headers
16702                         in the spec for a single request.
16703        :type _headers: dict, optional
16704        :param _host_index: set to override the host_index for a single
16705                            request; this effectively ignores the host_index
16706                            in the spec for a single request.
16707        :type _host_index: int, optional
16708        :return: Returns the result object.
16709        """  # noqa: E501
16710
16711        _param = self._get_shape_item_serialize(
16712            board_id=board_id,
16713            item_id=item_id,
16714            _request_auth=_request_auth,
16715            _content_type=_content_type,
16716            _headers=_headers,
16717            _host_index=_host_index,
16718        )
16719
16720        _response_types_map: Dict[str, Optional[str]] = {
16721            "200": "ShapeItem",
16722            "400": None,
16723            "404": None,
16724            "429": None,
16725        }
16726        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16727        response_data.read()
16728        return self.api_client.response_deserialize(
16729            response_data=response_data,
16730            response_types_map=_response_types_map,
16731        ).data

Get shape item

Retrieves information for a specific shape item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_shape_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], shape_update_request: miro_api.models.shape_update_request.ShapeUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.shape_item.ShapeItem: View Source

16785    @validate_call
16786    def update_shape_item(
16787        self,
16788        board_id: Annotated[
16789            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
16790        ],
16791        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
16792        shape_update_request: ShapeUpdateRequest,
16793        _request_timeout: Union[
16794            None,
16795            Annotated[StrictFloat, Field(gt=0)],
16796            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16797        ] = None,
16798        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16799        _content_type: Optional[StrictStr] = None,
16800        _headers: Optional[Dict[StrictStr, Any]] = None,
16801        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16802    ) -> ShapeItem:
16803        """Update shape item
16804
16805        Updates a shape item on a board based on the data and style properties provided in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
16806
16807        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
16808        :type board_id: str
16809        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
16810        :type item_id: str
16811        :param shape_update_request: (required)
16812        :type shape_update_request: ShapeUpdateRequest
16813        :param _request_timeout: timeout setting for this request. If one
16814                                 number provided, it will be total request
16815                                 timeout. It can also be a pair (tuple) of
16816                                 (connection, read) timeouts.
16817        :type _request_timeout: int, tuple(int, int), optional
16818        :param _request_auth: set to override the auth_settings for an a single
16819                              request; this effectively ignores the
16820                              authentication in the spec for a single request.
16821        :type _request_auth: dict, optional
16822        :param _content_type: force content-type for the request.
16823        :type _content_type: str, Optional
16824        :param _headers: set to override the headers for a single
16825                         request; this effectively ignores the headers
16826                         in the spec for a single request.
16827        :type _headers: dict, optional
16828        :param _host_index: set to override the host_index for a single
16829                            request; this effectively ignores the host_index
16830                            in the spec for a single request.
16831        :type _host_index: int, optional
16832        :return: Returns the result object.
16833        """  # noqa: E501
16834
16835        _param = self._update_shape_item_serialize(
16836            board_id=board_id,
16837            item_id=item_id,
16838            shape_update_request=shape_update_request,
16839            _request_auth=_request_auth,
16840            _content_type=_content_type,
16841            _headers=_headers,
16842            _host_index=_host_index,
16843        )
16844
16845        _response_types_map: Dict[str, Optional[str]] = {
16846            "200": "ShapeItem",
16847            "400": None,
16848            "404": None,
16849            "409": None,
16850            "429": None,
16851        }
16852        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16853        response_data.read()
16854        return self.api_client.response_deserialize(
16855            response_data=response_data,
16856            response_types_map=_response_types_map,
16857        ).data

Update shape item

Updates a shape item on a board based on the data and style properties provided in the request body.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param shape_update_request: (required) :type shape_update_request: ShapeUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_sticky_note_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], sticky_note_create_request: miro_api.models.sticky_note_create_request.StickyNoteCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.sticky_note_item.StickyNoteItem: View Source

16922    @validate_call
16923    def create_sticky_note_item(
16924        self,
16925        board_id: Annotated[
16926            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
16927        ],
16928        sticky_note_create_request: StickyNoteCreateRequest,
16929        _request_timeout: Union[
16930            None,
16931            Annotated[StrictFloat, Field(gt=0)],
16932            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16933        ] = None,
16934        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16935        _content_type: Optional[StrictStr] = None,
16936        _headers: Optional[Dict[StrictStr, Any]] = None,
16937        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16938    ) -> StickyNoteItem:
16939        """Create sticky note item
16940
16941        Adds a sticky note item to a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
16942
16943        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
16944        :type board_id: str
16945        :param sticky_note_create_request: (required)
16946        :type sticky_note_create_request: StickyNoteCreateRequest
16947        :param _request_timeout: timeout setting for this request. If one
16948                                 number provided, it will be total request
16949                                 timeout. It can also be a pair (tuple) of
16950                                 (connection, read) timeouts.
16951        :type _request_timeout: int, tuple(int, int), optional
16952        :param _request_auth: set to override the auth_settings for an a single
16953                              request; this effectively ignores the
16954                              authentication in the spec for a single request.
16955        :type _request_auth: dict, optional
16956        :param _content_type: force content-type for the request.
16957        :type _content_type: str, Optional
16958        :param _headers: set to override the headers for a single
16959                         request; this effectively ignores the headers
16960                         in the spec for a single request.
16961        :type _headers: dict, optional
16962        :param _host_index: set to override the host_index for a single
16963                            request; this effectively ignores the host_index
16964                            in the spec for a single request.
16965        :type _host_index: int, optional
16966        :return: Returns the result object.
16967        """  # noqa: E501
16968
16969        _param = self._create_sticky_note_item_serialize(
16970            board_id=board_id,
16971            sticky_note_create_request=sticky_note_create_request,
16972            _request_auth=_request_auth,
16973            _content_type=_content_type,
16974            _headers=_headers,
16975            _host_index=_host_index,
16976        )
16977
16978        _response_types_map: Dict[str, Optional[str]] = {
16979            "201": "StickyNoteItem",
16980            "400": None,
16981            "404": None,
16982            "429": None,
16983        }
16984        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16985        response_data.read()
16986        return self.api_client.response_deserialize(
16987            response_data=response_data,
16988            response_types_map=_response_types_map,
16989        ).data

Create sticky note item

Adds a sticky note item to a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param sticky_note_create_request: (required) :type sticky_note_create_request: StickyNoteCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_sticky_note_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

17051    @validate_call
17052    def delete_sticky_note_item(
17053        self,
17054        board_id: Annotated[
17055            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
17056        ],
17057        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
17058        _request_timeout: Union[
17059            None,
17060            Annotated[StrictFloat, Field(gt=0)],
17061            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17062        ] = None,
17063        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17064        _content_type: Optional[StrictStr] = None,
17065        _headers: Optional[Dict[StrictStr, Any]] = None,
17066        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17067    ) -> object:
17068        """Delete sticky note item
17069
17070        Deletes a sticky note item from the board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
17071
17072        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
17073        :type board_id: str
17074        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
17075        :type item_id: str
17076        :param _request_timeout: timeout setting for this request. If one
17077                                 number provided, it will be total request
17078                                 timeout. It can also be a pair (tuple) of
17079                                 (connection, read) timeouts.
17080        :type _request_timeout: int, tuple(int, int), optional
17081        :param _request_auth: set to override the auth_settings for an a single
17082                              request; this effectively ignores the
17083                              authentication in the spec for a single request.
17084        :type _request_auth: dict, optional
17085        :param _content_type: force content-type for the request.
17086        :type _content_type: str, Optional
17087        :param _headers: set to override the headers for a single
17088                         request; this effectively ignores the headers
17089                         in the spec for a single request.
17090        :type _headers: dict, optional
17091        :param _host_index: set to override the host_index for a single
17092                            request; this effectively ignores the host_index
17093                            in the spec for a single request.
17094        :type _host_index: int, optional
17095        :return: Returns the result object.
17096        """  # noqa: E501
17097
17098        _param = self._delete_sticky_note_item_serialize(
17099            board_id=board_id,
17100            item_id=item_id,
17101            _request_auth=_request_auth,
17102            _content_type=_content_type,
17103            _headers=_headers,
17104            _host_index=_host_index,
17105        )
17106
17107        _response_types_map: Dict[str, Optional[str]] = {
17108            "204": "object",
17109            "400": None,
17110            "404": None,
17111            "429": None,
17112        }
17113        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17114        response_data.read()
17115        return self.api_client.response_deserialize(
17116            response_data=response_data,
17117            response_types_map=_response_types_map,
17118        ).data

Delete sticky note item

Deletes a sticky note item from the board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_sticky_note_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.sticky_note_item.StickyNoteItem: View Source

17172    @validate_call
17173    def get_sticky_note_item(
17174        self,
17175        board_id: Annotated[
17176            StrictStr,
17177            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
17178        ],
17179        item_id: Annotated[
17180            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
17181        ],
17182        _request_timeout: Union[
17183            None,
17184            Annotated[StrictFloat, Field(gt=0)],
17185            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17186        ] = None,
17187        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17188        _content_type: Optional[StrictStr] = None,
17189        _headers: Optional[Dict[StrictStr, Any]] = None,
17190        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17191    ) -> StickyNoteItem:
17192        """Get sticky note item
17193
17194        Retrieves information for a specific sticky note item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
17195
17196        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
17197        :type board_id: str
17198        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
17199        :type item_id: str
17200        :param _request_timeout: timeout setting for this request. If one
17201                                 number provided, it will be total request
17202                                 timeout. It can also be a pair (tuple) of
17203                                 (connection, read) timeouts.
17204        :type _request_timeout: int, tuple(int, int), optional
17205        :param _request_auth: set to override the auth_settings for an a single
17206                              request; this effectively ignores the
17207                              authentication in the spec for a single request.
17208        :type _request_auth: dict, optional
17209        :param _content_type: force content-type for the request.
17210        :type _content_type: str, Optional
17211        :param _headers: set to override the headers for a single
17212                         request; this effectively ignores the headers
17213                         in the spec for a single request.
17214        :type _headers: dict, optional
17215        :param _host_index: set to override the host_index for a single
17216                            request; this effectively ignores the host_index
17217                            in the spec for a single request.
17218        :type _host_index: int, optional
17219        :return: Returns the result object.
17220        """  # noqa: E501
17221
17222        _param = self._get_sticky_note_item_serialize(
17223            board_id=board_id,
17224            item_id=item_id,
17225            _request_auth=_request_auth,
17226            _content_type=_content_type,
17227            _headers=_headers,
17228            _host_index=_host_index,
17229        )
17230
17231        _response_types_map: Dict[str, Optional[str]] = {
17232            "200": "StickyNoteItem",
17233            "400": None,
17234            "404": None,
17235            "429": None,
17236        }
17237        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17238        response_data.read()
17239        return self.api_client.response_deserialize(
17240            response_data=response_data,
17241            response_types_map=_response_types_map,
17242        ).data

Get sticky note item

Retrieves information for a specific sticky note item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_sticky_note_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], sticky_note_update_request: miro_api.models.sticky_note_update_request.StickyNoteUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.sticky_note_item.StickyNoteItem: View Source

17296    @validate_call
17297    def update_sticky_note_item(
17298        self,
17299        board_id: Annotated[
17300            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
17301        ],
17302        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
17303        sticky_note_update_request: StickyNoteUpdateRequest,
17304        _request_timeout: Union[
17305            None,
17306            Annotated[StrictFloat, Field(gt=0)],
17307            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17308        ] = None,
17309        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17310        _content_type: Optional[StrictStr] = None,
17311        _headers: Optional[Dict[StrictStr, Any]] = None,
17312        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17313    ) -> StickyNoteItem:
17314        """Update sticky note item
17315
17316        Updates a sticky note item on a board based on the data and style properties provided in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
17317
17318        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
17319        :type board_id: str
17320        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
17321        :type item_id: str
17322        :param sticky_note_update_request: (required)
17323        :type sticky_note_update_request: StickyNoteUpdateRequest
17324        :param _request_timeout: timeout setting for this request. If one
17325                                 number provided, it will be total request
17326                                 timeout. It can also be a pair (tuple) of
17327                                 (connection, read) timeouts.
17328        :type _request_timeout: int, tuple(int, int), optional
17329        :param _request_auth: set to override the auth_settings for an a single
17330                              request; this effectively ignores the
17331                              authentication in the spec for a single request.
17332        :type _request_auth: dict, optional
17333        :param _content_type: force content-type for the request.
17334        :type _content_type: str, Optional
17335        :param _headers: set to override the headers for a single
17336                         request; this effectively ignores the headers
17337                         in the spec for a single request.
17338        :type _headers: dict, optional
17339        :param _host_index: set to override the host_index for a single
17340                            request; this effectively ignores the host_index
17341                            in the spec for a single request.
17342        :type _host_index: int, optional
17343        :return: Returns the result object.
17344        """  # noqa: E501
17345
17346        _param = self._update_sticky_note_item_serialize(
17347            board_id=board_id,
17348            item_id=item_id,
17349            sticky_note_update_request=sticky_note_update_request,
17350            _request_auth=_request_auth,
17351            _content_type=_content_type,
17352            _headers=_headers,
17353            _host_index=_host_index,
17354        )
17355
17356        _response_types_map: Dict[str, Optional[str]] = {
17357            "200": "StickyNoteItem",
17358            "400": None,
17359            "404": None,
17360            "409": None,
17361            "429": None,
17362        }
17363        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17364        response_data.read()
17365        return self.api_client.response_deserialize(
17366            response_data=response_data,
17367            response_types_map=_response_types_map,
17368        ).data

Update sticky note item

Updates a sticky note item on a board based on the data and style properties provided in the request body.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to update. (required) :type item_id: str :param sticky_note_update_request: (required) :type sticky_note_update_request: StickyNoteUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def attach_tag_to_item( self, board_id_platform_tags: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board with the item that you want to add a tag to.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item to which you want to add a tag.')], tag_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the tag you want to add to the item.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

17433    @validate_call
17434    def attach_tag_to_item(
17435        self,
17436        board_id_platform_tags: Annotated[
17437            StrictStr,
17438            Field(description="Unique identifier (ID) of the board with the item that you want to add a tag to."),
17439        ],
17440        item_id: Annotated[
17441            StrictStr, Field(description="Unique identifier (ID) of the item to which you want to add a tag.")
17442        ],
17443        tag_id: Annotated[
17444            StrictStr, Field(description="Unique identifier (ID) of the tag you want to add to the item.")
17445        ],
17446        _request_timeout: Union[
17447            None,
17448            Annotated[StrictFloat, Field(gt=0)],
17449            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17450        ] = None,
17451        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17452        _content_type: Optional[StrictStr] = None,
17453        _headers: Optional[Dict[StrictStr, Any]] = None,
17454        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17455    ) -> object:
17456        """Attach tag to item
17457
17458        Attach an existing tag to the specified item. Card and sticky note items can have up to 8 tags. <br><blockquote><strong>Note:</strong> Updates to tags made via the REST API  will not be reflected on the board in realtime. To see REST API updates to tags on a board,  you need to refresh the board. This applies to the following endpoints:   [Remove tag from item](https://developers.miro.com/reference/remove-tag-from-item),  [Update tag](https://developers.miro.com/reference/update-tag),  [Delete tag](https://developers.miro.com/reference/delete-tag).</blockquote><br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
17459
17460        :param board_id_platform_tags: Unique identifier (ID) of the board with the item that you want to add a tag to. (required)
17461        :type board_id_platform_tags: str
17462        :param item_id: Unique identifier (ID) of the item to which you want to add a tag. (required)
17463        :type item_id: str
17464        :param tag_id: Unique identifier (ID) of the tag you want to add to the item. (required)
17465        :type tag_id: str
17466        :param _request_timeout: timeout setting for this request. If one
17467                                 number provided, it will be total request
17468                                 timeout. It can also be a pair (tuple) of
17469                                 (connection, read) timeouts.
17470        :type _request_timeout: int, tuple(int, int), optional
17471        :param _request_auth: set to override the auth_settings for an a single
17472                              request; this effectively ignores the
17473                              authentication in the spec for a single request.
17474        :type _request_auth: dict, optional
17475        :param _content_type: force content-type for the request.
17476        :type _content_type: str, Optional
17477        :param _headers: set to override the headers for a single
17478                         request; this effectively ignores the headers
17479                         in the spec for a single request.
17480        :type _headers: dict, optional
17481        :param _host_index: set to override the host_index for a single
17482                            request; this effectively ignores the host_index
17483                            in the spec for a single request.
17484        :type _host_index: int, optional
17485        :return: Returns the result object.
17486        """  # noqa: E501
17487
17488        _param = self._attach_tag_to_item_serialize(
17489            board_id_platform_tags=board_id_platform_tags,
17490            item_id=item_id,
17491            tag_id=tag_id,
17492            _request_auth=_request_auth,
17493            _content_type=_content_type,
17494            _headers=_headers,
17495            _host_index=_host_index,
17496        )
17497
17498        _response_types_map: Dict[str, Optional[str]] = {
17499            "204": "object",
17500            "400": "GetTagsFromItem400Response",
17501            "404": "GetTagsFromItem400Response",
17502            "429": "GetTagsFromItem400Response",
17503        }
17504        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17505        response_data.read()
17506        return self.api_client.response_deserialize(
17507            response_data=response_data,
17508            response_types_map=_response_types_map,
17509        ).data

Attach tag to item

Attach an existing tag to the specified item. Card and sticky note items can have up to 8 tags.

Note: Updates to tags made via the REST API will not be reflected on the board in realtime. To see REST API updates to tags on a board, you need to refresh the board. This applies to the following endpoints: Remove tag from item, Update tag, Delete tag.

Required scope

Rate limiting

:param board_id_platform_tags: Unique identifier (ID) of the board with the item that you want to add a tag to. (required) :type board_id_platform_tags: str :param item_id: Unique identifier (ID) of the item to which you want to add a tag. (required) :type item_id: str :param tag_id: Unique identifier (ID) of the tag you want to add to the item. (required) :type tag_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_tag( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the tag.')], tag_create_request: miro_api.models.tag_create_request.TagCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.tag_with_links.TagWithLinks: View Source

17568    @validate_call
17569    def create_tag(
17570        self,
17571        board_id: Annotated[
17572            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the tag.")
17573        ],
17574        tag_create_request: TagCreateRequest,
17575        _request_timeout: Union[
17576            None,
17577            Annotated[StrictFloat, Field(gt=0)],
17578            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17579        ] = None,
17580        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17581        _content_type: Optional[StrictStr] = None,
17582        _headers: Optional[Dict[StrictStr, Any]] = None,
17583        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17584    ) -> TagWithLinks:
17585        """Create tag
17586
17587        Creates a tag on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
17588
17589        :param board_id: Unique identifier (ID) of the board where you want to create the tag. (required)
17590        :type board_id: str
17591        :param tag_create_request: (required)
17592        :type tag_create_request: TagCreateRequest
17593        :param _request_timeout: timeout setting for this request. If one
17594                                 number provided, it will be total request
17595                                 timeout. It can also be a pair (tuple) of
17596                                 (connection, read) timeouts.
17597        :type _request_timeout: int, tuple(int, int), optional
17598        :param _request_auth: set to override the auth_settings for an a single
17599                              request; this effectively ignores the
17600                              authentication in the spec for a single request.
17601        :type _request_auth: dict, optional
17602        :param _content_type: force content-type for the request.
17603        :type _content_type: str, Optional
17604        :param _headers: set to override the headers for a single
17605                         request; this effectively ignores the headers
17606                         in the spec for a single request.
17607        :type _headers: dict, optional
17608        :param _host_index: set to override the host_index for a single
17609                            request; this effectively ignores the host_index
17610                            in the spec for a single request.
17611        :type _host_index: int, optional
17612        :return: Returns the result object.
17613        """  # noqa: E501
17614
17615        _param = self._create_tag_serialize(
17616            board_id=board_id,
17617            tag_create_request=tag_create_request,
17618            _request_auth=_request_auth,
17619            _content_type=_content_type,
17620            _headers=_headers,
17621            _host_index=_host_index,
17622        )
17623
17624        _response_types_map: Dict[str, Optional[str]] = {
17625            "201": "TagWithLinks",
17626            "400": "GetTagsFromItem400Response",
17627            "404": "GetTagsFromItem400Response",
17628            "429": "GetTagsFromItem400Response",
17629        }
17630        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17631        response_data.read()
17632        return self.api_client.response_deserialize(
17633            response_data=response_data,
17634            response_types_map=_response_types_map,
17635        ).data

Create tag

Creates a tag on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the tag. (required) :type board_id: str :param tag_create_request: (required) :type tag_create_request: TagCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_tag( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to delete a specific tag.')], tag_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the tag that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

17697    @validate_call
17698    def delete_tag(
17699        self,
17700        board_id: Annotated[
17701            StrictStr, Field(description="Unique identifier (ID) of the board where you want to delete a specific tag.")
17702        ],
17703        tag_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the tag that you want to delete.")],
17704        _request_timeout: Union[
17705            None,
17706            Annotated[StrictFloat, Field(gt=0)],
17707            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17708        ] = None,
17709        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17710        _content_type: Optional[StrictStr] = None,
17711        _headers: Optional[Dict[StrictStr, Any]] = None,
17712        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17713    ) -> object:
17714        """Delete tag
17715
17716        Deletes the specified tag from the board. The tag is also removed from all cards and sticky notes on the board. <br><blockquote><strong>Note:</strong> Updates to tags made via the REST API  will not be reflected on the board in realtime. To see REST API updates to tags on a board,  you need to refresh the board. This applies to the following endpoints:  [Attach tag to item](https://developers.miro.com/reference/attach-tag-to-item),  [Remove tag from item](https://developers.miro.com/reference/remove-tag-from-item),  [Update tag](https://developers.miro.com/reference/update-tag).</blockquote><br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
17717
17718        :param board_id: Unique identifier (ID) of the board where you want to delete a specific tag. (required)
17719        :type board_id: str
17720        :param tag_id: Unique identifier (ID) of the tag that you want to delete. (required)
17721        :type tag_id: str
17722        :param _request_timeout: timeout setting for this request. If one
17723                                 number provided, it will be total request
17724                                 timeout. It can also be a pair (tuple) of
17725                                 (connection, read) timeouts.
17726        :type _request_timeout: int, tuple(int, int), optional
17727        :param _request_auth: set to override the auth_settings for an a single
17728                              request; this effectively ignores the
17729                              authentication in the spec for a single request.
17730        :type _request_auth: dict, optional
17731        :param _content_type: force content-type for the request.
17732        :type _content_type: str, Optional
17733        :param _headers: set to override the headers for a single
17734                         request; this effectively ignores the headers
17735                         in the spec for a single request.
17736        :type _headers: dict, optional
17737        :param _host_index: set to override the host_index for a single
17738                            request; this effectively ignores the host_index
17739                            in the spec for a single request.
17740        :type _host_index: int, optional
17741        :return: Returns the result object.
17742        """  # noqa: E501
17743
17744        _param = self._delete_tag_serialize(
17745            board_id=board_id,
17746            tag_id=tag_id,
17747            _request_auth=_request_auth,
17748            _content_type=_content_type,
17749            _headers=_headers,
17750            _host_index=_host_index,
17751        )
17752
17753        _response_types_map: Dict[str, Optional[str]] = {
17754            "204": "object",
17755            "400": "GetTagsFromItem400Response",
17756            "404": "GetTagsFromItem400Response",
17757            "429": "GetTagsFromItem400Response",
17758        }
17759        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17760        response_data.read()
17761        return self.api_client.response_deserialize(
17762            response_data=response_data,
17763            response_types_map=_response_types_map,
17764        ).data

Delete tag

Deletes the specified tag from the board. The tag is also removed from all cards and sticky notes on the board.

Note: Updates to tags made via the REST API will not be reflected on the board in realtime. To see REST API updates to tags on a board, you need to refresh the board. This applies to the following endpoints: Attach tag to item, Remove tag from item, Update tag.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to delete a specific tag. (required) :type board_id: str :param tag_id: Unique identifier (ID) of the tag that you want to delete. (required) :type tag_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_items_by_tag( self, board_id_platform_tags: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to retrieve a specific tag.')], tag_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the tag that you want to retrieve.')], limit: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] = None, offset: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.item_paged_response.ItemPagedResponse: View Source

17818    @validate_call
17819    def get_items_by_tag(
17820        self,
17821        board_id_platform_tags: Annotated[
17822            StrictStr,
17823            Field(description="Unique identifier (ID) of the board where you want to retrieve a specific tag."),
17824        ],
17825        tag_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the tag that you want to retrieve.")],
17826        limit: Optional[Annotated[str, Field(strict=True)]] = None,
17827        offset: Optional[StrictStr] = None,
17828        _request_timeout: Union[
17829            None,
17830            Annotated[StrictFloat, Field(gt=0)],
17831            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17832        ] = None,
17833        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17834        _content_type: Optional[StrictStr] = None,
17835        _headers: Optional[Dict[StrictStr, Any]] = None,
17836        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17837    ) -> ItemPagedResponse:
17838        """Get items by tag
17839
17840        Retrieves all the items that have the specified tag.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
17841
17842        :param board_id_platform_tags: Unique identifier (ID) of the board where you want to retrieve a specific tag. (required)
17843        :type board_id_platform_tags: str
17844        :param tag_id: Unique identifier (ID) of the tag that you want to retrieve. (required)
17845        :type tag_id: str
17846        :param limit:
17847        :type limit: str
17848        :param offset:
17849        :type offset: str
17850        :param _request_timeout: timeout setting for this request. If one
17851                                 number provided, it will be total request
17852                                 timeout. It can also be a pair (tuple) of
17853                                 (connection, read) timeouts.
17854        :type _request_timeout: int, tuple(int, int), optional
17855        :param _request_auth: set to override the auth_settings for an a single
17856                              request; this effectively ignores the
17857                              authentication in the spec for a single request.
17858        :type _request_auth: dict, optional
17859        :param _content_type: force content-type for the request.
17860        :type _content_type: str, Optional
17861        :param _headers: set to override the headers for a single
17862                         request; this effectively ignores the headers
17863                         in the spec for a single request.
17864        :type _headers: dict, optional
17865        :param _host_index: set to override the host_index for a single
17866                            request; this effectively ignores the host_index
17867                            in the spec for a single request.
17868        :type _host_index: int, optional
17869        :return: Returns the result object.
17870        """  # noqa: E501
17871
17872        _param = self._get_items_by_tag_serialize(
17873            board_id_platform_tags=board_id_platform_tags,
17874            tag_id=tag_id,
17875            limit=limit,
17876            offset=offset,
17877            _request_auth=_request_auth,
17878            _content_type=_content_type,
17879            _headers=_headers,
17880            _host_index=_host_index,
17881        )
17882
17883        _response_types_map: Dict[str, Optional[str]] = {
17884            "200": "ItemPagedResponse",
17885            "400": "GetTagsFromItem400Response",
17886            "404": "GetTagsFromItem400Response",
17887            "429": "GetTagsFromItem400Response",
17888        }
17889        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17890        response_data.read()
17891        return self.api_client.response_deserialize(
17892            response_data=response_data,
17893            response_types_map=_response_types_map,
17894        ).data

Get items by tag

Retrieves all the items that have the specified tag.

Required scope

Rate limiting

:param board_id_platform_tags: Unique identifier (ID) of the board where you want to retrieve a specific tag. (required) :type board_id_platform_tags: str :param tag_id: Unique identifier (ID) of the tag that you want to retrieve. (required) :type tag_id: str :param limit: :type limit: str :param offset: :type offset: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_tag( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to retrieve a specific tag.')], tag_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the tag that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.tag_with_links.TagWithLinks: View Source

17960    @validate_call
17961    def get_tag(
17962        self,
17963        board_id: Annotated[
17964            StrictStr,
17965            Field(description="Unique identifier (ID) of the board where you want to retrieve a specific tag."),
17966        ],
17967        tag_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the tag that you want to retrieve.")],
17968        _request_timeout: Union[
17969            None,
17970            Annotated[StrictFloat, Field(gt=0)],
17971            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17972        ] = None,
17973        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17974        _content_type: Optional[StrictStr] = None,
17975        _headers: Optional[Dict[StrictStr, Any]] = None,
17976        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17977    ) -> TagWithLinks:
17978        """Get tag
17979
17980        Retrieves information for a specific tag.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
17981
17982        :param board_id: Unique identifier (ID) of the board where you want to retrieve a specific tag. (required)
17983        :type board_id: str
17984        :param tag_id: Unique identifier (ID) of the tag that you want to retrieve. (required)
17985        :type tag_id: str
17986        :param _request_timeout: timeout setting for this request. If one
17987                                 number provided, it will be total request
17988                                 timeout. It can also be a pair (tuple) of
17989                                 (connection, read) timeouts.
17990        :type _request_timeout: int, tuple(int, int), optional
17991        :param _request_auth: set to override the auth_settings for an a single
17992                              request; this effectively ignores the
17993                              authentication in the spec for a single request.
17994        :type _request_auth: dict, optional
17995        :param _content_type: force content-type for the request.
17996        :type _content_type: str, Optional
17997        :param _headers: set to override the headers for a single
17998                         request; this effectively ignores the headers
17999                         in the spec for a single request.
18000        :type _headers: dict, optional
18001        :param _host_index: set to override the host_index for a single
18002                            request; this effectively ignores the host_index
18003                            in the spec for a single request.
18004        :type _host_index: int, optional
18005        :return: Returns the result object.
18006        """  # noqa: E501
18007
18008        _param = self._get_tag_serialize(
18009            board_id=board_id,
18010            tag_id=tag_id,
18011            _request_auth=_request_auth,
18012            _content_type=_content_type,
18013            _headers=_headers,
18014            _host_index=_host_index,
18015        )
18016
18017        _response_types_map: Dict[str, Optional[str]] = {
18018            "200": "TagWithLinks",
18019            "400": "GetTagsFromItem400Response",
18020            "404": "GetTagsFromItem400Response",
18021            "429": "GetTagsFromItem400Response",
18022        }
18023        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18024        response_data.read()
18025        return self.api_client.response_deserialize(
18026            response_data=response_data,
18027            response_types_map=_response_types_map,
18028        ).data

Get tag

Retrieves information for a specific tag.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to retrieve a specific tag. (required) :type board_id: str :param tag_id: Unique identifier (ID) of the tag that you want to retrieve. (required) :type tag_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_tags_from_board( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board whose tags you want to retrieve.')], limit: Optional[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True)])]] = None, offset: Optional[Annotated[str, Strict(strict=True)]] = None, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.tags_paged_response.TagsPagedResponse: View Source

18082    @validate_call
18083    def get_tags_from_board(
18084        self,
18085        board_id: Annotated[
18086            StrictStr, Field(description="Unique identifier (ID) of the board whose tags you want to retrieve.")
18087        ],
18088        limit: Optional[Annotated[str, Field(strict=True)]] = None,
18089        offset: Optional[StrictStr] = None,
18090        _request_timeout: Union[
18091            None,
18092            Annotated[StrictFloat, Field(gt=0)],
18093            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18094        ] = None,
18095        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18096        _content_type: Optional[StrictStr] = None,
18097        _headers: Optional[Dict[StrictStr, Any]] = None,
18098        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18099    ) -> TagsPagedResponse:
18100        """Get tags from board
18101
18102        Retrieves all the tags from the specified board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
18103
18104        :param board_id: Unique identifier (ID) of the board whose tags you want to retrieve. (required)
18105        :type board_id: str
18106        :param limit:
18107        :type limit: str
18108        :param offset:
18109        :type offset: str
18110        :param _request_timeout: timeout setting for this request. If one
18111                                 number provided, it will be total request
18112                                 timeout. It can also be a pair (tuple) of
18113                                 (connection, read) timeouts.
18114        :type _request_timeout: int, tuple(int, int), optional
18115        :param _request_auth: set to override the auth_settings for an a single
18116                              request; this effectively ignores the
18117                              authentication in the spec for a single request.
18118        :type _request_auth: dict, optional
18119        :param _content_type: force content-type for the request.
18120        :type _content_type: str, Optional
18121        :param _headers: set to override the headers for a single
18122                         request; this effectively ignores the headers
18123                         in the spec for a single request.
18124        :type _headers: dict, optional
18125        :param _host_index: set to override the host_index for a single
18126                            request; this effectively ignores the host_index
18127                            in the spec for a single request.
18128        :type _host_index: int, optional
18129        :return: Returns the result object.
18130        """  # noqa: E501
18131
18132        _param = self._get_tags_from_board_serialize(
18133            board_id=board_id,
18134            limit=limit,
18135            offset=offset,
18136            _request_auth=_request_auth,
18137            _content_type=_content_type,
18138            _headers=_headers,
18139            _host_index=_host_index,
18140        )
18141
18142        _response_types_map: Dict[str, Optional[str]] = {
18143            "200": "TagsPagedResponse",
18144            "400": "GetTagsFromItem400Response",
18145            "404": "GetTagsFromItem400Response",
18146            "429": "GetTagsFromItem400Response",
18147        }
18148        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18149        response_data.read()
18150        return self.api_client.response_deserialize(
18151            response_data=response_data,
18152            response_types_map=_response_types_map,
18153        ).data

Get tags from board

Retrieves all the tags from the specified board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board whose tags you want to retrieve. (required) :type board_id: str :param limit: :type limit: str :param offset: :type offset: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_tags_from_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board with the item whose tags you want to retrieve.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item whose tags you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.get_tags_response.GetTagsResponse: View Source

18214    @validate_call
18215    def get_tags_from_item(
18216        self,
18217        board_id: Annotated[
18218            StrictStr,
18219            Field(description="Unique identifier (ID) of the board with the item whose tags you want to retrieve."),
18220        ],
18221        item_id: Annotated[
18222            StrictStr, Field(description="Unique identifier (ID) of the item whose tags you want to retrieve.")
18223        ],
18224        _request_timeout: Union[
18225            None,
18226            Annotated[StrictFloat, Field(gt=0)],
18227            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18228        ] = None,
18229        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18230        _content_type: Optional[StrictStr] = None,
18231        _headers: Optional[Dict[StrictStr, Any]] = None,
18232        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18233    ) -> GetTagsResponse:
18234        """Get tags from item
18235
18236        Retrieves all the tags from the specified item.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
18237
18238        :param board_id: Unique identifier (ID) of the board with the item whose tags you want to retrieve. (required)
18239        :type board_id: str
18240        :param item_id: Unique identifier (ID) of the item whose tags you want to retrieve. (required)
18241        :type item_id: str
18242        :param _request_timeout: timeout setting for this request. If one
18243                                 number provided, it will be total request
18244                                 timeout. It can also be a pair (tuple) of
18245                                 (connection, read) timeouts.
18246        :type _request_timeout: int, tuple(int, int), optional
18247        :param _request_auth: set to override the auth_settings for an a single
18248                              request; this effectively ignores the
18249                              authentication in the spec for a single request.
18250        :type _request_auth: dict, optional
18251        :param _content_type: force content-type for the request.
18252        :type _content_type: str, Optional
18253        :param _headers: set to override the headers for a single
18254                         request; this effectively ignores the headers
18255                         in the spec for a single request.
18256        :type _headers: dict, optional
18257        :param _host_index: set to override the host_index for a single
18258                            request; this effectively ignores the host_index
18259                            in the spec for a single request.
18260        :type _host_index: int, optional
18261        :return: Returns the result object.
18262        """  # noqa: E501
18263
18264        _param = self._get_tags_from_item_serialize(
18265            board_id=board_id,
18266            item_id=item_id,
18267            _request_auth=_request_auth,
18268            _content_type=_content_type,
18269            _headers=_headers,
18270            _host_index=_host_index,
18271        )
18272
18273        _response_types_map: Dict[str, Optional[str]] = {
18274            "200": "GetTagsResponse",
18275            "400": "GetTagsFromItem400Response",
18276            "404": "GetTagsFromItem400Response",
18277            "429": "GetTagsFromItem400Response",
18278        }
18279        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18280        response_data.read()
18281        return self.api_client.response_deserialize(
18282            response_data=response_data,
18283            response_types_map=_response_types_map,
18284        ).data

Get tags from item

Retrieves all the tags from the specified item.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board with the item whose tags you want to retrieve. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item whose tags you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def remove_tag_from_item( self, board_id_platform_tags: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board with the item that you want to remove a tag from.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to remove the tag from.')], tag_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the tag that you want to remove from the item.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

18338    @validate_call
18339    def remove_tag_from_item(
18340        self,
18341        board_id_platform_tags: Annotated[
18342            StrictStr,
18343            Field(description="Unique identifier (ID) of the board with the item that you want to remove a tag from."),
18344        ],
18345        item_id: Annotated[
18346            StrictStr, Field(description="Unique identifier (ID) of the item that you want to remove the tag from.")
18347        ],
18348        tag_id: Annotated[
18349            StrictStr, Field(description="Unique identifier (ID) of the tag that you want to remove from the item.")
18350        ],
18351        _request_timeout: Union[
18352            None,
18353            Annotated[StrictFloat, Field(gt=0)],
18354            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18355        ] = None,
18356        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18357        _content_type: Optional[StrictStr] = None,
18358        _headers: Optional[Dict[StrictStr, Any]] = None,
18359        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18360    ) -> object:
18361        """Remove tag from item
18362
18363        Removes the specified tag from the specified item. The tag still exists on the board. <br><blockquote><strong>Note:</strong> Updates to tags made via the REST API  will not be reflected on the board in realtime. To see REST API updates to tags on a board,  you need to refresh the board. This applies to the following endpoints:  [Attach tag to item](https://developers.miro.com/reference/attach-tag-to-item),   [Update tag](https://developers.miro.com/reference/update-tag),  [Delete tag](https://developers.miro.com/reference/delete-tag).</blockquote><br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
18364
18365        :param board_id_platform_tags: Unique identifier (ID) of the board with the item that you want to remove a tag from. (required)
18366        :type board_id_platform_tags: str
18367        :param item_id: Unique identifier (ID) of the item that you want to remove the tag from. (required)
18368        :type item_id: str
18369        :param tag_id: Unique identifier (ID) of the tag that you want to remove from the item. (required)
18370        :type tag_id: str
18371        :param _request_timeout: timeout setting for this request. If one
18372                                 number provided, it will be total request
18373                                 timeout. It can also be a pair (tuple) of
18374                                 (connection, read) timeouts.
18375        :type _request_timeout: int, tuple(int, int), optional
18376        :param _request_auth: set to override the auth_settings for an a single
18377                              request; this effectively ignores the
18378                              authentication in the spec for a single request.
18379        :type _request_auth: dict, optional
18380        :param _content_type: force content-type for the request.
18381        :type _content_type: str, Optional
18382        :param _headers: set to override the headers for a single
18383                         request; this effectively ignores the headers
18384                         in the spec for a single request.
18385        :type _headers: dict, optional
18386        :param _host_index: set to override the host_index for a single
18387                            request; this effectively ignores the host_index
18388                            in the spec for a single request.
18389        :type _host_index: int, optional
18390        :return: Returns the result object.
18391        """  # noqa: E501
18392
18393        _param = self._remove_tag_from_item_serialize(
18394            board_id_platform_tags=board_id_platform_tags,
18395            item_id=item_id,
18396            tag_id=tag_id,
18397            _request_auth=_request_auth,
18398            _content_type=_content_type,
18399            _headers=_headers,
18400            _host_index=_host_index,
18401        )
18402
18403        _response_types_map: Dict[str, Optional[str]] = {
18404            "204": "object",
18405            "400": "GetTagsFromItem400Response",
18406            "404": "GetTagsFromItem400Response",
18407            "429": "GetTagsFromItem400Response",
18408        }
18409        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18410        response_data.read()
18411        return self.api_client.response_deserialize(
18412            response_data=response_data,
18413            response_types_map=_response_types_map,
18414        ).data

Remove tag from item

Removes the specified tag from the specified item. The tag still exists on the board.

Note: Updates to tags made via the REST API will not be reflected on the board in realtime. To see REST API updates to tags on a board, you need to refresh the board. This applies to the following endpoints: Attach tag to item, Update tag, Delete tag.

Required scope

Rate limiting

:param board_id_platform_tags: Unique identifier (ID) of the board with the item that you want to remove a tag from. (required) :type board_id_platform_tags: str :param item_id: Unique identifier (ID) of the item that you want to remove the tag from. (required) :type item_id: str :param tag_id: Unique identifier (ID) of the tag that you want to remove from the item. (required) :type tag_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_tag( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update a specific tag.')], tag_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the tag that you want to update.')], tag_update_request: miro_api.models.tag_update_request.TagUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.tag_with_links.TagWithLinks: View Source

18473    @validate_call
18474    def update_tag(
18475        self,
18476        board_id: Annotated[
18477            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update a specific tag.")
18478        ],
18479        tag_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the tag that you want to update.")],
18480        tag_update_request: TagUpdateRequest,
18481        _request_timeout: Union[
18482            None,
18483            Annotated[StrictFloat, Field(gt=0)],
18484            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18485        ] = None,
18486        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18487        _content_type: Optional[StrictStr] = None,
18488        _headers: Optional[Dict[StrictStr, Any]] = None,
18489        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18490    ) -> TagWithLinks:
18491        """Update tag
18492
18493        Updates a tag based on the data properties provided in the request body. <br><blockquote><strong>Note:</strong> Updates to tags made via the REST API  will not be reflected on the board in realtime. To see REST API updates to tags on a board,  you need to refresh the board. This applies to the following endpoints:  [Attach tag to item](https://developers.miro.com/reference/attach-tag-to-item),  [Remove tag from item](https://developers.miro.com/reference/remove-tag-from-item),   [Delete tag](https://developers.miro.com/reference/delete-tag).</blockquote><br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
18494
18495        :param board_id: Unique identifier (ID) of the board where you want to update a specific tag. (required)
18496        :type board_id: str
18497        :param tag_id: Unique identifier (ID) of the tag that you want to update. (required)
18498        :type tag_id: str
18499        :param tag_update_request: (required)
18500        :type tag_update_request: TagUpdateRequest
18501        :param _request_timeout: timeout setting for this request. If one
18502                                 number provided, it will be total request
18503                                 timeout. It can also be a pair (tuple) of
18504                                 (connection, read) timeouts.
18505        :type _request_timeout: int, tuple(int, int), optional
18506        :param _request_auth: set to override the auth_settings for an a single
18507                              request; this effectively ignores the
18508                              authentication in the spec for a single request.
18509        :type _request_auth: dict, optional
18510        :param _content_type: force content-type for the request.
18511        :type _content_type: str, Optional
18512        :param _headers: set to override the headers for a single
18513                         request; this effectively ignores the headers
18514                         in the spec for a single request.
18515        :type _headers: dict, optional
18516        :param _host_index: set to override the host_index for a single
18517                            request; this effectively ignores the host_index
18518                            in the spec for a single request.
18519        :type _host_index: int, optional
18520        :return: Returns the result object.
18521        """  # noqa: E501
18522
18523        _param = self._update_tag_serialize(
18524            board_id=board_id,
18525            tag_id=tag_id,
18526            tag_update_request=tag_update_request,
18527            _request_auth=_request_auth,
18528            _content_type=_content_type,
18529            _headers=_headers,
18530            _host_index=_host_index,
18531        )
18532
18533        _response_types_map: Dict[str, Optional[str]] = {
18534            "200": "TagWithLinks",
18535            "400": "GetTagsFromItem400Response",
18536            "404": "GetTagsFromItem400Response",
18537            "429": "GetTagsFromItem400Response",
18538        }
18539        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18540        response_data.read()
18541        return self.api_client.response_deserialize(
18542            response_data=response_data,
18543            response_types_map=_response_types_map,
18544        ).data

Update tag

Updates a tag based on the data properties provided in the request body.

Note: Updates to tags made via the REST API will not be reflected on the board in realtime. To see REST API updates to tags on a board, you need to refresh the board. This applies to the following endpoints: Attach tag to item, Remove tag from item, Delete tag.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to update a specific tag. (required) :type board_id: str :param tag_id: Unique identifier (ID) of the tag that you want to update. (required) :type tag_id: str :param tag_update_request: (required) :type tag_update_request: TagUpdateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def create_text_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to create the item.')], text_create_request: miro_api.models.text_create_request.TextCreateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.text_item.TextItem: View Source

18609    @validate_call
18610    def create_text_item(
18611        self,
18612        board_id: Annotated[
18613            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
18614        ],
18615        text_create_request: TextCreateRequest,
18616        _request_timeout: Union[
18617            None,
18618            Annotated[StrictFloat, Field(gt=0)],
18619            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18620        ] = None,
18621        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18622        _content_type: Optional[StrictStr] = None,
18623        _headers: Optional[Dict[StrictStr, Any]] = None,
18624        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18625    ) -> TextItem:
18626        """Create text item
18627
18628        Adds a text item to a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
18629
18630        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
18631        :type board_id: str
18632        :param text_create_request: (required)
18633        :type text_create_request: TextCreateRequest
18634        :param _request_timeout: timeout setting for this request. If one
18635                                 number provided, it will be total request
18636                                 timeout. It can also be a pair (tuple) of
18637                                 (connection, read) timeouts.
18638        :type _request_timeout: int, tuple(int, int), optional
18639        :param _request_auth: set to override the auth_settings for an a single
18640                              request; this effectively ignores the
18641                              authentication in the spec for a single request.
18642        :type _request_auth: dict, optional
18643        :param _content_type: force content-type for the request.
18644        :type _content_type: str, Optional
18645        :param _headers: set to override the headers for a single
18646                         request; this effectively ignores the headers
18647                         in the spec for a single request.
18648        :type _headers: dict, optional
18649        :param _host_index: set to override the host_index for a single
18650                            request; this effectively ignores the host_index
18651                            in the spec for a single request.
18652        :type _host_index: int, optional
18653        :return: Returns the result object.
18654        """  # noqa: E501
18655
18656        _param = self._create_text_item_serialize(
18657            board_id=board_id,
18658            text_create_request=text_create_request,
18659            _request_auth=_request_auth,
18660            _content_type=_content_type,
18661            _headers=_headers,
18662            _host_index=_host_index,
18663        )
18664
18665        _response_types_map: Dict[str, Optional[str]] = {
18666            "201": "TextItem",
18667            "400": None,
18668            "404": None,
18669            "429": None,
18670        }
18671        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18672        response_data.read()
18673        return self.api_client.response_deserialize(
18674            response_data=response_data,
18675            response_types_map=_response_types_map,
18676        ).data

Create text item

Adds a text item to a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board where you want to create the item. (required) :type board_id: str :param text_create_request: (required) :type text_create_request: TextCreateRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def delete_text_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to delete the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to delete.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> object: View Source

18738    @validate_call
18739    def delete_text_item(
18740        self,
18741        board_id: Annotated[
18742            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
18743        ],
18744        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
18745        _request_timeout: Union[
18746            None,
18747            Annotated[StrictFloat, Field(gt=0)],
18748            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18749        ] = None,
18750        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18751        _content_type: Optional[StrictStr] = None,
18752        _headers: Optional[Dict[StrictStr, Any]] = None,
18753        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18754    ) -> object:
18755        """Delete text item
18756
18757        Deletes a text item from the board<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 3</a><br/>
18758
18759        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
18760        :type board_id: str
18761        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
18762        :type item_id: str
18763        :param _request_timeout: timeout setting for this request. If one
18764                                 number provided, it will be total request
18765                                 timeout. It can also be a pair (tuple) of
18766                                 (connection, read) timeouts.
18767        :type _request_timeout: int, tuple(int, int), optional
18768        :param _request_auth: set to override the auth_settings for an a single
18769                              request; this effectively ignores the
18770                              authentication in the spec for a single request.
18771        :type _request_auth: dict, optional
18772        :param _content_type: force content-type for the request.
18773        :type _content_type: str, Optional
18774        :param _headers: set to override the headers for a single
18775                         request; this effectively ignores the headers
18776                         in the spec for a single request.
18777        :type _headers: dict, optional
18778        :param _host_index: set to override the host_index for a single
18779                            request; this effectively ignores the host_index
18780                            in the spec for a single request.
18781        :type _host_index: int, optional
18782        :return: Returns the result object.
18783        """  # noqa: E501
18784
18785        _param = self._delete_text_item_serialize(
18786            board_id=board_id,
18787            item_id=item_id,
18788            _request_auth=_request_auth,
18789            _content_type=_content_type,
18790            _headers=_headers,
18791            _host_index=_host_index,
18792        )
18793
18794        _response_types_map: Dict[str, Optional[str]] = {
18795            "204": "object",
18796            "400": None,
18797            "404": None,
18798            "429": None,
18799        }
18800        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18801        response_data.read()
18802        return self.api_client.response_deserialize(
18803            response_data=response_data,
18804            response_types_map=_response_types_map,
18805        ).data

Delete text item

Deletes a text item from the board

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to delete. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def get_text_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board from which you want to retrieve a specific item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to retrieve.')], _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.text_item.TextItem: View Source

18859    @validate_call
18860    def get_text_item(
18861        self,
18862        board_id: Annotated[
18863            StrictStr,
18864            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
18865        ],
18866        item_id: Annotated[
18867            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
18868        ],
18869        _request_timeout: Union[
18870            None,
18871            Annotated[StrictFloat, Field(gt=0)],
18872            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18873        ] = None,
18874        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18875        _content_type: Optional[StrictStr] = None,
18876        _headers: Optional[Dict[StrictStr, Any]] = None,
18877        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18878    ) -> TextItem:
18879        """Get text item
18880
18881        Retrieves information for a specific text item on a board.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 1</a><br/>
18882
18883        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
18884        :type board_id: str
18885        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
18886        :type item_id: str
18887        :param _request_timeout: timeout setting for this request. If one
18888                                 number provided, it will be total request
18889                                 timeout. It can also be a pair (tuple) of
18890                                 (connection, read) timeouts.
18891        :type _request_timeout: int, tuple(int, int), optional
18892        :param _request_auth: set to override the auth_settings for an a single
18893                              request; this effectively ignores the
18894                              authentication in the spec for a single request.
18895        :type _request_auth: dict, optional
18896        :param _content_type: force content-type for the request.
18897        :type _content_type: str, Optional
18898        :param _headers: set to override the headers for a single
18899                         request; this effectively ignores the headers
18900                         in the spec for a single request.
18901        :type _headers: dict, optional
18902        :param _host_index: set to override the host_index for a single
18903                            request; this effectively ignores the host_index
18904                            in the spec for a single request.
18905        :type _host_index: int, optional
18906        :return: Returns the result object.
18907        """  # noqa: E501
18908
18909        _param = self._get_text_item_serialize(
18910            board_id=board_id,
18911            item_id=item_id,
18912            _request_auth=_request_auth,
18913            _content_type=_content_type,
18914            _headers=_headers,
18915            _host_index=_host_index,
18916        )
18917
18918        _response_types_map: Dict[str, Optional[str]] = {
18919            "200": "TextItem",
18920            "400": None,
18921            "404": None,
18922            "429": None,
18923        }
18924        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18925        response_data.read()
18926        return self.api_client.response_deserialize(
18927            response_data=response_data,
18928            response_types_map=_response_types_map,
18929        ).data

Get text item

Retrieves information for a specific text item on a board.

Required scope

Rate limiting

:param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required) :type board_id: str :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

@validate_call

def update_text_item( self, board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the board where you want to update the item.')], item_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier (ID) of the item that you want to update.')], text_update_request: miro_api.models.text_update_request.TextUpdateRequest, _request_timeout: Union[NoneType, Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]]] = None, _request_auth: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _content_type: Optional[Annotated[str, Strict(strict=True)]] = None, _headers: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, _host_index: typing.Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) -> miro_api.models.text_item.TextItem: View Source

18983    @validate_call
18984    def update_text_item(
18985        self,
18986        board_id: Annotated[
18987            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
18988        ],
18989        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
18990        text_update_request: TextUpdateRequest,
18991        _request_timeout: Union[
18992            None,
18993            Annotated[StrictFloat, Field(gt=0)],
18994            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18995        ] = None,
18996        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18997        _content_type: Optional[StrictStr] = None,
18998        _headers: Optional[Dict[StrictStr, Any]] = None,
18999        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
19000    ) -> TextItem:
19001        """Update text item
19002
19003        Updates a text item on a board based on the data and style properties provided in the request body.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/docs/miro-rest-api-introduction#rate-limiting\">Level 2</a><br/>
19004
19005        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
19006        :type board_id: str
19007        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
19008        :type item_id: str
19009        :param text_update_request: (required)
19010        :type text_update_request: TextUpdateRequest
19011        :param _request_timeout: timeout setting for this request. If one
19012                                 number provided, it will be total request
19013                                 timeout. It can also be a pair (tuple) of
19014                                 (connection, read) timeouts.
19015        :type _request_timeout: int, tuple(int, int), optional
19016        :param _request_auth: set to override the auth_settings for an a single
19017                              request; this effectively ignores the
19018                              authentication in the spec for a single request.
19019        :type _request_auth: dict, optional
19020        :param _content_type: force content-type for the request.
19021        :type _content_type: str, Optional
19022        :param _headers: set to override the headers for a single
19023                         request; this effectively ignores the headers
19024                         in the spec for a single request.
19025        :type _headers: dict, optional
19026        :param _host_index: set to override the host_index for a single
19027                            request; this effectively ignores the host_index
19028                            in the spec for a single request.
19029        :type _host_index: int, optional
19030        :return: Returns the result object.
19031        """  # noqa: E501
19032
19033        _param = self._update_text_item_serialize(
19034            board_id=board_id,
19035            item_id=item_id,
19036            text_update_request=text_update_request,
19037            _request_auth=_request_auth,
19038            _content_type=_content_type,
19039            _headers=_headers,
19040            _host_index=_host_index,
19041        )
19042
19043        _response_types_map: Dict[str, Optional[str]] = {
19044            "200": "TextItem",
19045            "400": None,
19046            "404": None,
19047            "409": None,
19048            "429": None,
19049        }
19050        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
19051        response_data.read()
19052        return self.api_client.response_deserialize(
19053            response_data=response_data,
19054            response_types_map=_response_types_map,
19055        ).data

Update text item

Updates a text item on a board based on the data and style properties provided in the request body.

Required scope

Rate limiting