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

390    @validate_call
391    def get_metrics_total(
392        self,
393        app_id: Annotated[StrictStr, Field(description="ID of the app to get total metrics for.")],
394        _request_timeout: Union[
395            None,
396            Annotated[StrictFloat, Field(gt=0)],
397            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
398        ] = None,
399        _request_auth: Optional[Dict[StrictStr, Any]] = None,
400        _content_type: Optional[StrictStr] = None,
401        _headers: Optional[Dict[StrictStr, Any]] = None,
402        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
403    ) -> GetMetricsTotal200Response:
404        """Get total app metrics
405
406        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
407
408        :param app_id: ID of the app to get total metrics for. (required)
409        :type app_id: str
410        :param _request_timeout: timeout setting for this request. If one
411                                 number provided, it will be total request
412                                 timeout. It can also be a pair (tuple) of
413                                 (connection, read) timeouts.
414        :type _request_timeout: int, tuple(int, int), optional
415        :param _request_auth: set to override the auth_settings for an a single
416                              request; this effectively ignores the
417                              authentication in the spec for a single request.
418        :type _request_auth: dict, optional
419        :param _content_type: force content-type for the request.
420        :type _content_type: str, Optional
421        :param _headers: set to override the headers for a single
422                         request; this effectively ignores the headers
423                         in the spec for a single request.
424        :type _headers: dict, optional
425        :param _host_index: set to override the host_index for a single
426                            request; this effectively ignores the host_index
427                            in the spec for a single request.
428        :type _host_index: int, optional
429        :return: Returns the result object.
430        """  # noqa: E501
431
432        _param = self._get_metrics_total_serialize(
433            app_id=app_id,
434            _request_auth=_request_auth,
435            _content_type=_content_type,
436            _headers=_headers,
437            _host_index=_host_index,
438        )
439
440        _response_types_map: Dict[str, Optional[str]] = {
441            "200": "GetMetricsTotal200Response",
442            "404": "GetMetricsTotal404Response",
443        }
444        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
445        response_data.read()
446        return self.api_client.response_deserialize(
447            response_data=response_data,
448            response_types_map=_response_types_map,
449        ).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. 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. 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. 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). 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

500    @validate_call
501    def enterprise_get_audit_logs(
502        self,
503        created_after: Annotated[
504            StrictStr,
505            Field(
506                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))." '
507            ),
508        ],
509        created_before: Annotated[
510            StrictStr,
511            Field(
512                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)). "
513            ),
514        ],
515        cursor: Annotated[
516            Optional[StrictStr],
517            Field(
518                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."
519            ),
520        ] = None,
521        limit: Annotated[
522            Optional[StrictInt],
523            Field(
524                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` "
525            ),
526        ] = None,
527        sorting: Annotated[
528            Optional[StrictStr],
529            Field(
530                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` "
531            ),
532        ] = None,
533        _request_timeout: Union[
534            None,
535            Annotated[StrictFloat, Field(gt=0)],
536            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
537        ] = None,
538        _request_auth: Optional[Dict[StrictStr, Any]] = None,
539        _content_type: Optional[StrictStr] = None,
540        _headers: Optional[Dict[StrictStr, Any]] = None,
541        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
542    ) -> AuditPage:
543        """Get audit logs
544
545        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a>
546
547        :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)
548        :type created_after: str
549        :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)
550        :type created_before: str
551        :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.
552        :type cursor: str
553        :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`
554        :type limit: int
555        :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`
556        :type sorting: str
557        :param _request_timeout: timeout setting for this request. If one
558                                 number provided, it will be total request
559                                 timeout. It can also be a pair (tuple) of
560                                 (connection, read) timeouts.
561        :type _request_timeout: int, tuple(int, int), optional
562        :param _request_auth: set to override the auth_settings for an a single
563                              request; this effectively ignores the
564                              authentication in the spec for a single request.
565        :type _request_auth: dict, optional
566        :param _content_type: force content-type for the request.
567        :type _content_type: str, Optional
568        :param _headers: set to override the headers for a single
569                         request; this effectively ignores the headers
570                         in the spec for a single request.
571        :type _headers: dict, optional
572        :param _host_index: set to override the host_index for a single
573                            request; this effectively ignores the host_index
574                            in the spec for a single request.
575        :type _host_index: int, optional
576        :return: Returns the result object.
577        """  # noqa: E501
578
579        _param = self._enterprise_get_audit_logs_serialize(
580            created_after=created_after,
581            created_before=created_before,
582            cursor=cursor,
583            limit=limit,
584            sorting=sorting,
585            _request_auth=_request_auth,
586            _content_type=_content_type,
587            _headers=_headers,
588            _host_index=_host_index,
589        )
590
591        _response_types_map: Dict[str, Optional[str]] = {
592            "200": "AuditPage",
593            "400": None,
594            "401": None,
595            "403": None,
596            "404": None,
597            "409": None,
598            "429": None,
599        }
600        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
601        response_data.read()
602        return self.api_client.response_deserialize(
603            response_data=response_data,
604            response_types_map=_response_types_map,
605        ).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

678    @validate_call
679    def enterprise_board_content_item_logs_fetch(
680        self,
681        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
682        var_from: Annotated[
683            datetime,
684            Field(
685                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)). "
686            ),
687        ],
688        to: Annotated[
689            datetime,
690            Field(
691                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)). "
692            ),
693        ],
694        board_ids: Annotated[
695            Optional[Annotated[List[StrictStr], Field(max_length=15)]],
696            Field(description="List of board IDs for which you want to retrieve the content logs."),
697        ] = None,
698        emails: Annotated[
699            Optional[Annotated[List[StrictStr], Field(max_length=15)]],
700            Field(
701                description="Filter content logs based on the list of emails of users who created, modified, or deleted the board item."
702            ),
703        ] = None,
704        cursor: Annotated[
705            Optional[StrictStr],
706            Field(
707                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. "
708            ),
709        ] = None,
710        limit: Annotated[
711            Optional[Annotated[int, Field(le=1000, strict=True, ge=1)]],
712            Field(
713                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. "
714            ),
715        ] = None,
716        sorting: Annotated[
717            Optional[StrictStr],
718            Field(
719                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`. "
720            ),
721        ] = None,
722        _request_timeout: Union[
723            None,
724            Annotated[StrictFloat, Field(gt=0)],
725            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
726        ] = None,
727        _request_auth: Optional[Dict[StrictStr, Any]] = None,
728        _content_type: Optional[StrictStr] = None,
729        _headers: Optional[Dict[StrictStr, Any]] = None,
730        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
731    ) -> GetBoardItemContentLogsResponse:
732        """Retrieve content change logs of board items
733
734        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
735
736        :param org_id: Unique identifier of the organization. (required)
737        :type org_id: str
738        :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)
739        :type var_from: datetime
740        :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)
741        :type to: datetime
742        :param board_ids: List of board IDs for which you want to retrieve the content logs.
743        :type board_ids: List[str]
744        :param emails: Filter content logs based on the list of emails of users who created, modified, or deleted the board item.
745        :type emails: List[str]
746        :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.
747        :type cursor: str
748        :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.
749        :type limit: int
750        :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`.
751        :type sorting: str
752        :param _request_timeout: timeout setting for this request. If one
753                                 number provided, it will be total request
754                                 timeout. It can also be a pair (tuple) of
755                                 (connection, read) timeouts.
756        :type _request_timeout: int, tuple(int, int), optional
757        :param _request_auth: set to override the auth_settings for an a single
758                              request; this effectively ignores the
759                              authentication in the spec for a single request.
760        :type _request_auth: dict, optional
761        :param _content_type: force content-type for the request.
762        :type _content_type: str, Optional
763        :param _headers: set to override the headers for a single
764                         request; this effectively ignores the headers
765                         in the spec for a single request.
766        :type _headers: dict, optional
767        :param _host_index: set to override the host_index for a single
768                            request; this effectively ignores the host_index
769                            in the spec for a single request.
770        :type _host_index: int, optional
771        :return: Returns the result object.
772        """  # noqa: E501
773
774        _param = self._enterprise_board_content_item_logs_fetch_serialize(
775            org_id=org_id,
776            var_from=var_from,
777            to=to,
778            board_ids=board_ids,
779            emails=emails,
780            cursor=cursor,
781            limit=limit,
782            sorting=sorting,
783            _request_auth=_request_auth,
784            _content_type=_content_type,
785            _headers=_headers,
786            _host_index=_host_index,
787        )
788
789        _response_types_map: Dict[str, Optional[str]] = {
790            "200": "GetBoardItemContentLogsResponse",
791            "400": None,
792            "401": None,
793            "403": None,
794            "404": None,
795            "429": None,
796        }
797        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
798        response_data.read()
799        return self.api_client.response_deserialize(
800            response_data=response_data,
801            response_types_map=_response_types_map,
802        ).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

895    @validate_call
896    def enterprise_board_export_job_results(
897        self,
898        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
899        job_id: Annotated[StrictStr, Field(description="Unique identifier of the job.")],
900        _request_timeout: Union[
901            None,
902            Annotated[StrictFloat, Field(gt=0)],
903            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
904        ] = None,
905        _request_auth: Optional[Dict[StrictStr, Any]] = None,
906        _content_type: Optional[StrictStr] = None,
907        _headers: Optional[Dict[StrictStr, Any]] = None,
908        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
909    ) -> BoardExportResult:
910        """Get results for board export job
911
912        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
913
914        :param org_id: Unique identifier of the organization. (required)
915        :type org_id: str
916        :param job_id: Unique identifier of the job. (required)
917        :type job_id: str
918        :param _request_timeout: timeout setting for this request. If one
919                                 number provided, it will be total request
920                                 timeout. It can also be a pair (tuple) of
921                                 (connection, read) timeouts.
922        :type _request_timeout: int, tuple(int, int), optional
923        :param _request_auth: set to override the auth_settings for an a single
924                              request; this effectively ignores the
925                              authentication in the spec for a single request.
926        :type _request_auth: dict, optional
927        :param _content_type: force content-type for the request.
928        :type _content_type: str, Optional
929        :param _headers: set to override the headers for a single
930                         request; this effectively ignores the headers
931                         in the spec for a single request.
932        :type _headers: dict, optional
933        :param _host_index: set to override the host_index for a single
934                            request; this effectively ignores the host_index
935                            in the spec for a single request.
936        :type _host_index: int, optional
937        :return: Returns the result object.
938        """  # noqa: E501
939
940        _param = self._enterprise_board_export_job_results_serialize(
941            org_id=org_id,
942            job_id=job_id,
943            _request_auth=_request_auth,
944            _content_type=_content_type,
945            _headers=_headers,
946            _host_index=_host_index,
947        )
948
949        _response_types_map: Dict[str, Optional[str]] = {
950            "200": "BoardExportResult",
951            "400": None,
952            "401": None,
953            "403": None,
954            "404": None,
955            "429": None,
956        }
957        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
958        response_data.read()
959        return self.api_client.response_deserialize(
960            response_data=response_data,
961            response_types_map=_response_types_map,
962        ).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

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

1016    @validate_call
1017    def enterprise_board_export_job_status(
1018        self,
1019        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
1020        job_id: Annotated[StrictStr, Field(description="Unique identifier of the board export job.")],
1021        _request_timeout: Union[
1022            None,
1023            Annotated[StrictFloat, Field(gt=0)],
1024            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1025        ] = None,
1026        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1027        _content_type: Optional[StrictStr] = None,
1028        _headers: Optional[Dict[StrictStr, Any]] = None,
1029        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1030    ) -> BoardExportJobStatus:
1031        """Get board export job status
1032
1033        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
1034
1035        :param org_id: Unique identifier of the organization. (required)
1036        :type org_id: str
1037        :param job_id: Unique identifier of the board export job. (required)
1038        :type job_id: str
1039        :param _request_timeout: timeout setting for this request. If one
1040                                 number provided, it will be total request
1041                                 timeout. It can also be a pair (tuple) of
1042                                 (connection, read) timeouts.
1043        :type _request_timeout: int, tuple(int, int), optional
1044        :param _request_auth: set to override the auth_settings for an a single
1045                              request; this effectively ignores the
1046                              authentication in the spec for a single request.
1047        :type _request_auth: dict, optional
1048        :param _content_type: force content-type for the request.
1049        :type _content_type: str, Optional
1050        :param _headers: set to override the headers for a single
1051                         request; this effectively ignores the headers
1052                         in the spec for a single request.
1053        :type _headers: dict, optional
1054        :param _host_index: set to override the host_index for a single
1055                            request; this effectively ignores the host_index
1056                            in the spec for a single request.
1057        :type _host_index: int, optional
1058        :return: Returns the result object.
1059        """  # noqa: E501
1060
1061        _param = self._enterprise_board_export_job_status_serialize(
1062            org_id=org_id,
1063            job_id=job_id,
1064            _request_auth=_request_auth,
1065            _content_type=_content_type,
1066            _headers=_headers,
1067            _host_index=_host_index,
1068        )
1069
1070        _response_types_map: Dict[str, Optional[str]] = {
1071            "200": "BoardExportJobStatus",
1072            "400": None,
1073            "401": None,
1074            "403": None,
1075            "404": None,
1076            "429": None,
1077        }
1078        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1079        response_data.read()
1080        return self.api_client.response_deserialize(
1081            response_data=response_data,
1082            response_types_map=_response_types_map,
1083        ).data

Get board export job status

Retrieves the status of the board export job.

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 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_board_export_job_tasks( 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.')], status: Annotated[Optional[List[Annotated[str, Strict(strict=True)]]], FieldInfo(annotation=NoneType, required=True, description='Filters the list of board export tasks by their status. Accepts an array of statuses such as TASK_STATUS_CREATED, TASK_STATUS_CANCELLED, TASK_STATUS_SCHEDULED, TASK_STATUS_SUCCESS or TASK_STATUS_ERROR.')] = 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=500)])]], FieldInfo(annotation=NoneType, required=True, description='The maximum number of results to return per call. If the number of tasks in the response is greater than the limit specified, the response returns the cursor parameter with a value. ')] = 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_export_job_tasks_list.BoardExportJobTasksList: View Source

1137    @validate_call
1138    def enterprise_board_export_job_tasks(
1139        self,
1140        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
1141        job_id: Annotated[StrictStr, Field(description="Unique identifier of the board export job.")],
1142        status: Annotated[
1143            Optional[List[StrictStr]],
1144            Field(
1145                description="Filters the list of board export tasks by their status. Accepts an array of statuses such as TASK_STATUS_CREATED, TASK_STATUS_CANCELLED, TASK_STATUS_SCHEDULED, TASK_STATUS_SUCCESS or TASK_STATUS_ERROR."
1146            ),
1147        ] = None,
1148        cursor: Annotated[
1149            Optional[StrictStr],
1150            Field(
1151                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. "
1152            ),
1153        ] = None,
1154        limit: Annotated[
1155            Optional[Annotated[int, Field(le=500, strict=True, ge=1)]],
1156            Field(
1157                description="The maximum number of results to return per call. If the number of tasks in the response is greater than the limit specified, the response returns the cursor parameter with a value. "
1158            ),
1159        ] = None,
1160        _request_timeout: Union[
1161            None,
1162            Annotated[StrictFloat, Field(gt=0)],
1163            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1164        ] = None,
1165        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1166        _content_type: Optional[StrictStr] = None,
1167        _headers: Optional[Dict[StrictStr, Any]] = None,
1168        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1169    ) -> BoardExportJobTasksList:
1170        """Get board export job tasks list
1171
1172        Retrieves the list of tasks for 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=\"/reference/rate-limiting#rate-limit-tiers\">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>
1173
1174        :param org_id: Unique identifier of the organization. (required)
1175        :type org_id: str
1176        :param job_id: Unique identifier of the board export job. (required)
1177        :type job_id: str
1178        :param status: Filters the list of board export tasks by their status. Accepts an array of statuses such as TASK_STATUS_CREATED, TASK_STATUS_CANCELLED, TASK_STATUS_SCHEDULED, TASK_STATUS_SUCCESS or TASK_STATUS_ERROR.
1179        :type status: List[str]
1180        :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.
1181        :type cursor: str
1182        :param limit: The maximum number of results to return per call. If the number of tasks in the response is greater than the limit specified, the response returns the cursor parameter with a value.
1183        :type limit: int
1184        :param _request_timeout: timeout setting for this request. If one
1185                                 number provided, it will be total request
1186                                 timeout. It can also be a pair (tuple) of
1187                                 (connection, read) timeouts.
1188        :type _request_timeout: int, tuple(int, int), optional
1189        :param _request_auth: set to override the auth_settings for an a single
1190                              request; this effectively ignores the
1191                              authentication in the spec for a single request.
1192        :type _request_auth: dict, optional
1193        :param _content_type: force content-type for the request.
1194        :type _content_type: str, Optional
1195        :param _headers: set to override the headers for a single
1196                         request; this effectively ignores the headers
1197                         in the spec for a single request.
1198        :type _headers: dict, optional
1199        :param _host_index: set to override the host_index for a single
1200                            request; this effectively ignores the host_index
1201                            in the spec for a single request.
1202        :type _host_index: int, optional
1203        :return: Returns the result object.
1204        """  # noqa: E501
1205
1206        _param = self._enterprise_board_export_job_tasks_serialize(
1207            org_id=org_id,
1208            job_id=job_id,
1209            status=status,
1210            cursor=cursor,
1211            limit=limit,
1212            _request_auth=_request_auth,
1213            _content_type=_content_type,
1214            _headers=_headers,
1215            _host_index=_host_index,
1216        )
1217
1218        _response_types_map: Dict[str, Optional[str]] = {
1219            "200": "BoardExportJobTasksList",
1220            "400": None,
1221            "401": None,
1222            "403": None,
1223            "404": None,
1224            "429": None,
1225        }
1226        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1227        response_data.read()
1228        return self.api_client.response_deserialize(
1229            response_data=response_data,
1230            response_types_map=_response_types_map,
1231        ).data

Get board export job tasks list

Retrieves the list of tasks for the board export job.

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 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 status: Filters the list of board export tasks by their status. Accepts an array of statuses such as TASK_STATUS_CREATED, TASK_STATUS_CANCELLED, TASK_STATUS_SCHEDULED, TASK_STATUS_SUCCESS or TASK_STATUS_ERROR. :type status: 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 tasks in the response is greater than the limit specified, the response returns the cursor parameter with a value. :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_board_export_jobs( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the organization.')], status: Annotated[Optional[List[Annotated[str, Strict(strict=True)]]], FieldInfo(annotation=NoneType, required=True, description='Status of the board export jobs that you want to retrieve, such as JOB_STATUS_CREATED, JOB_STATUS_IN_PROGRESS, JOB_STATUS_CANCELLED or JOB_STATUS_FINISHED.')] = None, creator_id: Annotated[Optional[List[Annotated[int, Strict(strict=True)]]], FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the board export job creator.')] = 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=500)])]], FieldInfo(annotation=NoneType, required=True, description='The maximum number of results to return per call. If the number of jobs in the response is greater than the limit specified, the response returns the cursor parameter with a value. ')] = 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_export_jobs_list.BoardExportJobsList: View Source

1302    @validate_call
1303    def enterprise_board_export_jobs(
1304        self,
1305        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
1306        status: Annotated[
1307            Optional[List[StrictStr]],
1308            Field(
1309                description="Status of the board export jobs that you want to retrieve, such as JOB_STATUS_CREATED, JOB_STATUS_IN_PROGRESS, JOB_STATUS_CANCELLED or JOB_STATUS_FINISHED."
1310            ),
1311        ] = None,
1312        creator_id: Annotated[
1313            Optional[List[StrictInt]], Field(description="Unique identifier of the board export job creator.")
1314        ] = None,
1315        cursor: Annotated[
1316            Optional[StrictStr],
1317            Field(
1318                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. "
1319            ),
1320        ] = None,
1321        limit: Annotated[
1322            Optional[Annotated[int, Field(le=500, strict=True, ge=1)]],
1323            Field(
1324                description="The maximum number of results to return per call. If the number of jobs in the response is greater than the limit specified, the response returns the cursor parameter with a value. "
1325            ),
1326        ] = None,
1327        _request_timeout: Union[
1328            None,
1329            Annotated[StrictFloat, Field(gt=0)],
1330            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1331        ] = None,
1332        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1333        _content_type: Optional[StrictStr] = None,
1334        _headers: Optional[Dict[StrictStr, Any]] = None,
1335        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1336    ) -> BoardExportJobsList:
1337        """Get board export jobs list
1338
1339        Retrieves the list of board export jobs based on the filters provided in the request.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
1340
1341        :param org_id: Unique identifier of the organization. (required)
1342        :type org_id: str
1343        :param status: Status of the board export jobs that you want to retrieve, such as JOB_STATUS_CREATED, JOB_STATUS_IN_PROGRESS, JOB_STATUS_CANCELLED or JOB_STATUS_FINISHED.
1344        :type status: List[str]
1345        :param creator_id: Unique identifier of the board export job creator.
1346        :type creator_id: List[int]
1347        :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.
1348        :type cursor: str
1349        :param limit: The maximum number of results to return per call. If the number of jobs in the response is greater than the limit specified, the response returns the cursor parameter with a value.
1350        :type limit: int
1351        :param _request_timeout: timeout setting for this request. If one
1352                                 number provided, it will be total request
1353                                 timeout. It can also be a pair (tuple) of
1354                                 (connection, read) timeouts.
1355        :type _request_timeout: int, tuple(int, int), optional
1356        :param _request_auth: set to override the auth_settings for an a single
1357                              request; this effectively ignores the
1358                              authentication in the spec for a single request.
1359        :type _request_auth: dict, optional
1360        :param _content_type: force content-type for the request.
1361        :type _content_type: str, Optional
1362        :param _headers: set to override the headers for a single
1363                         request; this effectively ignores the headers
1364                         in the spec for a single request.
1365        :type _headers: dict, optional
1366        :param _host_index: set to override the host_index for a single
1367                            request; this effectively ignores the host_index
1368                            in the spec for a single request.
1369        :type _host_index: int, optional
1370        :return: Returns the result object.
1371        """  # noqa: E501
1372
1373        _param = self._enterprise_board_export_jobs_serialize(
1374            org_id=org_id,
1375            status=status,
1376            creator_id=creator_id,
1377            cursor=cursor,
1378            limit=limit,
1379            _request_auth=_request_auth,
1380            _content_type=_content_type,
1381            _headers=_headers,
1382            _host_index=_host_index,
1383        )
1384
1385        _response_types_map: Dict[str, Optional[str]] = {
1386            "200": "BoardExportJobsList",
1387            "400": None,
1388            "401": None,
1389            "403": None,
1390            "404": None,
1391            "429": None,
1392        }
1393        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1394        response_data.read()
1395        return self.api_client.response_deserialize(
1396            response_data=response_data,
1397            response_types_map=_response_types_map,
1398        ).data

Get board export jobs list

Retrieves the list of board export jobs based on the filters 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 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 status: Status of the board export jobs that you want to retrieve, such as JOB_STATUS_CREATED, JOB_STATUS_IN_PROGRESS, JOB_STATUS_CANCELLED or JOB_STATUS_FINISHED. :type status: List[str] :param creator_id: Unique identifier of the board export job creator. :type creator_id: List[int] :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 jobs in the response is greater than the limit specified, the response returns the cursor parameter with a value. :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_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

1472    @validate_call
1473    def enterprise_create_board_export(
1474        self,
1475        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
1476        request_id: Annotated[StrictStr, Field(description="Unique identifier of the board export job.")],
1477        create_board_export_request: CreateBoardExportRequest,
1478        _request_timeout: Union[
1479            None,
1480            Annotated[StrictFloat, Field(gt=0)],
1481            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1482        ] = None,
1483        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1484        _content_type: Optional[StrictStr] = None,
1485        _headers: Optional[Dict[StrictStr, Any]] = None,
1486        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1487    ) -> BoardExportJobId:
1488        """Create board export job
1489
1490        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
1491
1492        :param org_id: Unique identifier of the organization. (required)
1493        :type org_id: str
1494        :param request_id: Unique identifier of the board export job. (required)
1495        :type request_id: str
1496        :param create_board_export_request: (required)
1497        :type create_board_export_request: CreateBoardExportRequest
1498        :param _request_timeout: timeout setting for this request. If one
1499                                 number provided, it will be total request
1500                                 timeout. It can also be a pair (tuple) of
1501                                 (connection, read) timeouts.
1502        :type _request_timeout: int, tuple(int, int), optional
1503        :param _request_auth: set to override the auth_settings for an a single
1504                              request; this effectively ignores the
1505                              authentication in the spec for a single request.
1506        :type _request_auth: dict, optional
1507        :param _content_type: force content-type for the request.
1508        :type _content_type: str, Optional
1509        :param _headers: set to override the headers for a single
1510                         request; this effectively ignores the headers
1511                         in the spec for a single request.
1512        :type _headers: dict, optional
1513        :param _host_index: set to override the host_index for a single
1514                            request; this effectively ignores the host_index
1515                            in the spec for a single request.
1516        :type _host_index: int, optional
1517        :return: Returns the result object.
1518        """  # noqa: E501
1519
1520        _param = self._enterprise_create_board_export_serialize(
1521            org_id=org_id,
1522            request_id=request_id,
1523            create_board_export_request=create_board_export_request,
1524            _request_auth=_request_auth,
1525            _content_type=_content_type,
1526            _headers=_headers,
1527            _host_index=_host_index,
1528        )
1529
1530        _response_types_map: Dict[str, Optional[str]] = {
1531            "200": "BoardExportJobId",
1532            "400": None,
1533            "401": None,
1534            "403": None,
1535            "404": None,
1536            "425": None,
1537            "429": None,
1538        }
1539        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1540        response_data.read()
1541        return self.api_client.response_deserialize(
1542            response_data=response_data,
1543            response_types_map=_response_types_map,
1544        ).data

Create board export job

Creates an export job for one or more boards.

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 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_create_board_export_task_export_link( 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.')], task_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Unique identifier of the board export task.')], _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_task_export_link.BoardExportTaskExportLink: View Source

1611    @validate_call
1612    def enterprise_create_board_export_task_export_link(
1613        self,
1614        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
1615        job_id: Annotated[StrictStr, Field(description="Unique identifier of the board export job.")],
1616        task_id: Annotated[StrictStr, Field(description="Unique identifier of the board export task.")],
1617        _request_timeout: Union[
1618            None,
1619            Annotated[StrictFloat, Field(gt=0)],
1620            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1621        ] = None,
1622        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1623        _content_type: Optional[StrictStr] = None,
1624        _headers: Optional[Dict[StrictStr, Any]] = None,
1625        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1626    ) -> BoardExportTaskExportLink:
1627        """Create task export link
1628
1629        Creates a link to download the results of a board export task.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
1630
1631        :param org_id: Unique identifier of the organization. (required)
1632        :type org_id: str
1633        :param job_id: Unique identifier of the board export job. (required)
1634        :type job_id: str
1635        :param task_id: Unique identifier of the board export task. (required)
1636        :type task_id: str
1637        :param _request_timeout: timeout setting for this request. If one
1638                                 number provided, it will be total request
1639                                 timeout. It can also be a pair (tuple) of
1640                                 (connection, read) timeouts.
1641        :type _request_timeout: int, tuple(int, int), optional
1642        :param _request_auth: set to override the auth_settings for an a single
1643                              request; this effectively ignores the
1644                              authentication in the spec for a single request.
1645        :type _request_auth: dict, optional
1646        :param _content_type: force content-type for the request.
1647        :type _content_type: str, Optional
1648        :param _headers: set to override the headers for a single
1649                         request; this effectively ignores the headers
1650                         in the spec for a single request.
1651        :type _headers: dict, optional
1652        :param _host_index: set to override the host_index for a single
1653                            request; this effectively ignores the host_index
1654                            in the spec for a single request.
1655        :type _host_index: int, optional
1656        :return: Returns the result object.
1657        """  # noqa: E501
1658
1659        _param = self._enterprise_create_board_export_task_export_link_serialize(
1660            org_id=org_id,
1661            job_id=job_id,
1662            task_id=task_id,
1663            _request_auth=_request_auth,
1664            _content_type=_content_type,
1665            _headers=_headers,
1666            _host_index=_host_index,
1667        )
1668
1669        _response_types_map: Dict[str, Optional[str]] = {
1670            "200": "BoardExportTaskExportLink",
1671            "400": None,
1672            "401": None,
1673            "403": None,
1674            "404": None,
1675            "425": None,
1676            "429": None,
1677        }
1678        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1679        response_data.read()
1680        return self.api_client.response_deserialize(
1681            response_data=response_data,
1682            response_types_map=_response_types_map,
1683        ).data

Create task export link

Creates a link to download the results of a board export task.

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 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 task_id: Unique identifier of the board export task. (required) :type task_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_board_export_job( 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.')], enterprise_update_board_export_job_request: Optional[miro_api.models.enterprise_update_board_export_job_request.EnterpriseUpdateBoardExportJobRequest] = 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_update_board_export_job200_response.EnterpriseUpdateBoardExportJob200Response: View Source

1740    @validate_call
1741    def enterprise_update_board_export_job(
1742        self,
1743        org_id: Annotated[StrictStr, Field(description="Unique identifier of the organization.")],
1744        job_id: Annotated[StrictStr, Field(description="Unique identifier of the board export job.")],
1745        enterprise_update_board_export_job_request: Optional[EnterpriseUpdateBoardExportJobRequest] = None,
1746        _request_timeout: Union[
1747            None,
1748            Annotated[StrictFloat, Field(gt=0)],
1749            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1750        ] = None,
1751        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1752        _content_type: Optional[StrictStr] = None,
1753        _headers: Optional[Dict[StrictStr, Any]] = None,
1754        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1755    ) -> EnterpriseUpdateBoardExportJob200Response:
1756        """Update board export job status
1757
1758        Updates the status of the board export job.<br/>Currently, only the cancellation of an ongoing export job is supported.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
1759
1760        :param org_id: Unique identifier of the organization. (required)
1761        :type org_id: str
1762        :param job_id: Unique identifier of the board export job. (required)
1763        :type job_id: str
1764        :param enterprise_update_board_export_job_request:
1765        :type enterprise_update_board_export_job_request: EnterpriseUpdateBoardExportJobRequest
1766        :param _request_timeout: timeout setting for this request. If one
1767                                 number provided, it will be total request
1768                                 timeout. It can also be a pair (tuple) of
1769                                 (connection, read) timeouts.
1770        :type _request_timeout: int, tuple(int, int), optional
1771        :param _request_auth: set to override the auth_settings for an a single
1772                              request; this effectively ignores the
1773                              authentication in the spec for a single request.
1774        :type _request_auth: dict, optional
1775        :param _content_type: force content-type for the request.
1776        :type _content_type: str, Optional
1777        :param _headers: set to override the headers for a single
1778                         request; this effectively ignores the headers
1779                         in the spec for a single request.
1780        :type _headers: dict, optional
1781        :param _host_index: set to override the host_index for a single
1782                            request; this effectively ignores the host_index
1783                            in the spec for a single request.
1784        :type _host_index: int, optional
1785        :return: Returns the result object.
1786        """  # noqa: E501
1787
1788        _param = self._enterprise_update_board_export_job_serialize(
1789            org_id=org_id,
1790            job_id=job_id,
1791            enterprise_update_board_export_job_request=enterprise_update_board_export_job_request,
1792            _request_auth=_request_auth,
1793            _content_type=_content_type,
1794            _headers=_headers,
1795            _host_index=_host_index,
1796        )
1797
1798        _response_types_map: Dict[str, Optional[str]] = {
1799            "200": "EnterpriseUpdateBoardExportJob200Response",
1800            "400": None,
1801            "401": None,
1802            "403": None,
1803            "404": None,
1804            "429": None,
1805        }
1806        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1807        response_data.read()
1808        return self.api_client.response_deserialize(
1809            response_data=response_data,
1810            response_types_map=_response_types_map,
1811        ).data

Update board export job status

Updates the status of the board export job.
Currently, only the cancellation of an ongoing export job is supported.

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 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 enterprise_update_board_export_job_request: :type enterprise_update_board_export_job_request: EnterpriseUpdateBoardExportJobRequest :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

1876    @validate_call
1877    def enterprise_dataclassification_board_get(
1878        self,
1879        org_id: Annotated[StrictStr, Field(description="id of the organization")],
1880        team_id: Annotated[StrictStr, Field(description="id of the team")],
1881        board_id: Annotated[StrictStr, Field(description="Unique identifier of the board that you want to retrieve.")],
1882        _request_timeout: Union[
1883            None,
1884            Annotated[StrictFloat, Field(gt=0)],
1885            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1886        ] = None,
1887        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1888        _content_type: Optional[StrictStr] = None,
1889        _headers: Optional[Dict[StrictStr, Any]] = None,
1890        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1891    ) -> BoardDataClassificationLabel:
1892        """Get board classification
1893
1894        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
1895
1896        :param org_id: id of the organization (required)
1897        :type org_id: str
1898        :param team_id: id of the team (required)
1899        :type team_id: str
1900        :param board_id: Unique identifier of the board that you want to retrieve. (required)
1901        :type board_id: str
1902        :param _request_timeout: timeout setting for this request. If one
1903                                 number provided, it will be total request
1904                                 timeout. It can also be a pair (tuple) of
1905                                 (connection, read) timeouts.
1906        :type _request_timeout: int, tuple(int, int), optional
1907        :param _request_auth: set to override the auth_settings for an a single
1908                              request; this effectively ignores the
1909                              authentication in the spec for a single request.
1910        :type _request_auth: dict, optional
1911        :param _content_type: force content-type for the request.
1912        :type _content_type: str, Optional
1913        :param _headers: set to override the headers for a single
1914                         request; this effectively ignores the headers
1915                         in the spec for a single request.
1916        :type _headers: dict, optional
1917        :param _host_index: set to override the host_index for a single
1918                            request; this effectively ignores the host_index
1919                            in the spec for a single request.
1920        :type _host_index: int, optional
1921        :return: Returns the result object.
1922        """  # noqa: E501
1923
1924        _param = self._enterprise_dataclassification_board_get_serialize(
1925            org_id=org_id,
1926            team_id=team_id,
1927            board_id=board_id,
1928            _request_auth=_request_auth,
1929            _content_type=_content_type,
1930            _headers=_headers,
1931            _host_index=_host_index,
1932        )
1933
1934        _response_types_map: Dict[str, Optional[str]] = {
1935            "200": "BoardDataClassificationLabel",
1936            "400": None,
1937            "401": None,
1938            "403": None,
1939            "404": None,
1940            "429": None,
1941        }
1942        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1943        response_data.read()
1944        return self.api_client.response_deserialize(
1945            response_data=response_data,
1946            response_types_map=_response_types_map,
1947        ).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

2004    @validate_call
2005    def enterprise_dataclassification_board_set(
2006        self,
2007        org_id: Annotated[StrictStr, Field(description="id of the organization")],
2008        team_id: Annotated[StrictStr, Field(description="id of the team")],
2009        board_id: Annotated[StrictStr, Field(description="Unique identifier of the board that you want to update.")],
2010        data_classification_label_id: DataClassificationLabelId,
2011        _request_timeout: Union[
2012            None,
2013            Annotated[StrictFloat, Field(gt=0)],
2014            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2015        ] = None,
2016        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2017        _content_type: Optional[StrictStr] = None,
2018        _headers: Optional[Dict[StrictStr, Any]] = None,
2019        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2020    ) -> BoardDataClassificationLabel:
2021        """Update board classification
2022
2023        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
2024
2025        :param org_id: id of the organization (required)
2026        :type org_id: str
2027        :param team_id: id of the team (required)
2028        :type team_id: str
2029        :param board_id: Unique identifier of the board that you want to update. (required)
2030        :type board_id: str
2031        :param data_classification_label_id: (required)
2032        :type data_classification_label_id: DataClassificationLabelId
2033        :param _request_timeout: timeout setting for this request. If one
2034                                 number provided, it will be total request
2035                                 timeout. It can also be a pair (tuple) of
2036                                 (connection, read) timeouts.
2037        :type _request_timeout: int, tuple(int, int), optional
2038        :param _request_auth: set to override the auth_settings for an a single
2039                              request; this effectively ignores the
2040                              authentication in the spec for a single request.
2041        :type _request_auth: dict, optional
2042        :param _content_type: force content-type for the request.
2043        :type _content_type: str, Optional
2044        :param _headers: set to override the headers for a single
2045                         request; this effectively ignores the headers
2046                         in the spec for a single request.
2047        :type _headers: dict, optional
2048        :param _host_index: set to override the host_index for a single
2049                            request; this effectively ignores the host_index
2050                            in the spec for a single request.
2051        :type _host_index: int, optional
2052        :return: Returns the result object.
2053        """  # noqa: E501
2054
2055        _param = self._enterprise_dataclassification_board_set_serialize(
2056            org_id=org_id,
2057            team_id=team_id,
2058            board_id=board_id,
2059            data_classification_label_id=data_classification_label_id,
2060            _request_auth=_request_auth,
2061            _content_type=_content_type,
2062            _headers=_headers,
2063            _host_index=_host_index,
2064        )
2065
2066        _response_types_map: Dict[str, Optional[str]] = {
2067            "200": "BoardDataClassificationLabel",
2068            "400": None,
2069            "401": None,
2070            "403": None,
2071            "404": None,
2072            "429": None,
2073        }
2074        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2075        response_data.read()
2076        return self.api_client.response_deserialize(
2077            response_data=response_data,
2078            response_types_map=_response_types_map,
2079        ).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

2147    @validate_call
2148    def enterprise_dataclassification_organization_settings_get(
2149        self,
2150        org_id: Annotated[StrictStr, Field(description="id of the organization")],
2151        _request_timeout: Union[
2152            None,
2153            Annotated[StrictFloat, Field(gt=0)],
2154            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2155        ] = None,
2156        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2157        _content_type: Optional[StrictStr] = None,
2158        _headers: Optional[Dict[StrictStr, Any]] = None,
2159        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2160    ) -> DataClassificationOrganizationSettings:
2161        """Get organization settings
2162
2163        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
2164
2165        :param org_id: id of the organization (required)
2166        :type org_id: str
2167        :param _request_timeout: timeout setting for this request. If one
2168                                 number provided, it will be total request
2169                                 timeout. It can also be a pair (tuple) of
2170                                 (connection, read) timeouts.
2171        :type _request_timeout: int, tuple(int, int), optional
2172        :param _request_auth: set to override the auth_settings for an a single
2173                              request; this effectively ignores the
2174                              authentication in the spec for a single request.
2175        :type _request_auth: dict, optional
2176        :param _content_type: force content-type for the request.
2177        :type _content_type: str, Optional
2178        :param _headers: set to override the headers for a single
2179                         request; this effectively ignores the headers
2180                         in the spec for a single request.
2181        :type _headers: dict, optional
2182        :param _host_index: set to override the host_index for a single
2183                            request; this effectively ignores the host_index
2184                            in the spec for a single request.
2185        :type _host_index: int, optional
2186        :return: Returns the result object.
2187        """  # noqa: E501
2188
2189        _param = self._enterprise_dataclassification_organization_settings_get_serialize(
2190            org_id=org_id,
2191            _request_auth=_request_auth,
2192            _content_type=_content_type,
2193            _headers=_headers,
2194            _host_index=_host_index,
2195        )
2196
2197        _response_types_map: Dict[str, Optional[str]] = {
2198            "200": "DataClassificationOrganizationSettings",
2199            "400": None,
2200            "401": None,
2201            "403": None,
2202            "404": None,
2203            "429": None,
2204        }
2205        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2206        response_data.read()
2207        return self.api_client.response_deserialize(
2208            response_data=response_data,
2209            response_types_map=_response_types_map,
2210        ).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

2261    @validate_call
2262    def enterprise_dataclassification_team_boards_bulk(
2263        self,
2264        org_id: Annotated[StrictStr, Field(description="id of the organization")],
2265        team_id: Annotated[StrictStr, Field(description="id of the team")],
2266        update_boards_data_classification_label_request: UpdateBoardsDataClassificationLabelRequest,
2267        _request_timeout: Union[
2268            None,
2269            Annotated[StrictFloat, Field(gt=0)],
2270            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2271        ] = None,
2272        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2273        _content_type: Optional[StrictStr] = None,
2274        _headers: Optional[Dict[StrictStr, Any]] = None,
2275        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2276    ) -> UpdateBoardsDataClassificationLabel:
2277        """Bulk update boards classification
2278
2279        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
2280
2281        :param org_id: id of the organization (required)
2282        :type org_id: str
2283        :param team_id: id of the team (required)
2284        :type team_id: str
2285        :param update_boards_data_classification_label_request: (required)
2286        :type update_boards_data_classification_label_request: UpdateBoardsDataClassificationLabelRequest
2287        :param _request_timeout: timeout setting for this request. If one
2288                                 number provided, it will be total request
2289                                 timeout. It can also be a pair (tuple) of
2290                                 (connection, read) timeouts.
2291        :type _request_timeout: int, tuple(int, int), optional
2292        :param _request_auth: set to override the auth_settings for an a single
2293                              request; this effectively ignores the
2294                              authentication in the spec for a single request.
2295        :type _request_auth: dict, optional
2296        :param _content_type: force content-type for the request.
2297        :type _content_type: str, Optional
2298        :param _headers: set to override the headers for a single
2299                         request; this effectively ignores the headers
2300                         in the spec for a single request.
2301        :type _headers: dict, optional
2302        :param _host_index: set to override the host_index for a single
2303                            request; this effectively ignores the host_index
2304                            in the spec for a single request.
2305        :type _host_index: int, optional
2306        :return: Returns the result object.
2307        """  # noqa: E501
2308
2309        _param = self._enterprise_dataclassification_team_boards_bulk_serialize(
2310            org_id=org_id,
2311            team_id=team_id,
2312            update_boards_data_classification_label_request=update_boards_data_classification_label_request,
2313            _request_auth=_request_auth,
2314            _content_type=_content_type,
2315            _headers=_headers,
2316            _host_index=_host_index,
2317        )
2318
2319        _response_types_map: Dict[str, Optional[str]] = {
2320            "200": "UpdateBoardsDataClassificationLabel",
2321            "400": None,
2322            "401": None,
2323            "403": None,
2324            "404": None,
2325            "429": None,
2326        }
2327        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2328        response_data.read()
2329        return self.api_client.response_deserialize(
2330            response_data=response_data,
2331            response_types_map=_response_types_map,
2332        ).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

2397    @validate_call
2398    def enterprise_dataclassification_team_settings_get(
2399        self,
2400        org_id: Annotated[StrictStr, Field(description="id of the organization")],
2401        team_id: Annotated[StrictStr, Field(description="id of the team")],
2402        _request_timeout: Union[
2403            None,
2404            Annotated[StrictFloat, Field(gt=0)],
2405            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2406        ] = None,
2407        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2408        _content_type: Optional[StrictStr] = None,
2409        _headers: Optional[Dict[StrictStr, Any]] = None,
2410        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2411    ) -> DataClassificationTeamSettings:
2412        """Get team settings
2413
2414        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
2415
2416        :param org_id: id of the organization (required)
2417        :type org_id: str
2418        :param team_id: id of the team (required)
2419        :type team_id: str
2420        :param _request_timeout: timeout setting for this request. If one
2421                                 number provided, it will be total request
2422                                 timeout. It can also be a pair (tuple) of
2423                                 (connection, read) timeouts.
2424        :type _request_timeout: int, tuple(int, int), optional
2425        :param _request_auth: set to override the auth_settings for an a single
2426                              request; this effectively ignores the
2427                              authentication in the spec for a single request.
2428        :type _request_auth: dict, optional
2429        :param _content_type: force content-type for the request.
2430        :type _content_type: str, Optional
2431        :param _headers: set to override the headers for a single
2432                         request; this effectively ignores the headers
2433                         in the spec for a single request.
2434        :type _headers: dict, optional
2435        :param _host_index: set to override the host_index for a single
2436                            request; this effectively ignores the host_index
2437                            in the spec for a single request.
2438        :type _host_index: int, optional
2439        :return: Returns the result object.
2440        """  # noqa: E501
2441
2442        _param = self._enterprise_dataclassification_team_settings_get_serialize(
2443            org_id=org_id,
2444            team_id=team_id,
2445            _request_auth=_request_auth,
2446            _content_type=_content_type,
2447            _headers=_headers,
2448            _host_index=_host_index,
2449        )
2450
2451        _response_types_map: Dict[str, Optional[str]] = {
2452            "200": "DataClassificationTeamSettings",
2453            "400": None,
2454            "401": None,
2455            "403": None,
2456            "404": None,
2457            "429": None,
2458        }
2459        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2460        response_data.read()
2461        return self.api_client.response_deserialize(
2462            response_data=response_data,
2463            response_types_map=_response_types_map,
2464        ).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

2518    @validate_call
2519    def enterprise_dataclassification_team_settings_set(
2520        self,
2521        org_id: Annotated[StrictStr, Field(description="id of the organization")],
2522        team_id: Annotated[StrictStr, Field(description="id of the team")],
2523        update_team_settings_request: UpdateTeamSettingsRequest,
2524        _request_timeout: Union[
2525            None,
2526            Annotated[StrictFloat, Field(gt=0)],
2527            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2528        ] = None,
2529        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2530        _content_type: Optional[StrictStr] = None,
2531        _headers: Optional[Dict[StrictStr, Any]] = None,
2532        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2533    ) -> DataClassificationTeamSettings:
2534        """Update team settings
2535
2536        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
2537
2538        :param org_id: id of the organization (required)
2539        :type org_id: str
2540        :param team_id: id of the team (required)
2541        :type team_id: str
2542        :param update_team_settings_request: (required)
2543        :type update_team_settings_request: UpdateTeamSettingsRequest
2544        :param _request_timeout: timeout setting for this request. If one
2545                                 number provided, it will be total request
2546                                 timeout. It can also be a pair (tuple) of
2547                                 (connection, read) timeouts.
2548        :type _request_timeout: int, tuple(int, int), optional
2549        :param _request_auth: set to override the auth_settings for an a single
2550                              request; this effectively ignores the
2551                              authentication in the spec for a single request.
2552        :type _request_auth: dict, optional
2553        :param _content_type: force content-type for the request.
2554        :type _content_type: str, Optional
2555        :param _headers: set to override the headers for a single
2556                         request; this effectively ignores the headers
2557                         in the spec for a single request.
2558        :type _headers: dict, optional
2559        :param _host_index: set to override the host_index for a single
2560                            request; this effectively ignores the host_index
2561                            in the spec for a single request.
2562        :type _host_index: int, optional
2563        :return: Returns the result object.
2564        """  # noqa: E501
2565
2566        _param = self._enterprise_dataclassification_team_settings_set_serialize(
2567            org_id=org_id,
2568            team_id=team_id,
2569            update_team_settings_request=update_team_settings_request,
2570            _request_auth=_request_auth,
2571            _content_type=_content_type,
2572            _headers=_headers,
2573            _host_index=_host_index,
2574        )
2575
2576        _response_types_map: Dict[str, Optional[str]] = {
2577            "200": "DataClassificationTeamSettings",
2578            "400": None,
2579            "401": None,
2580            "403": None,
2581            "404": None,
2582            "429": None,
2583        }
2584        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2585        response_data.read()
2586        return self.api_client.response_deserialize(
2587            response_data=response_data,
2588            response_types_map=_response_types_map,
2589        ).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

2654    @validate_call
2655    def create_items(
2656        self,
2657        board_id: Annotated[
2658            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
2659        ],
2660        item_create: Annotated[List[ItemCreate], Field(min_length=1, max_length=20)],
2661        _request_timeout: Union[
2662            None,
2663            Annotated[StrictFloat, Field(gt=0)],
2664            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2665        ] = None,
2666        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2667        _content_type: Optional[StrictStr] = None,
2668        _headers: Optional[Dict[StrictStr, Any]] = None,
2669        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2670    ) -> Items:
2671        """Create items in bulk
2672
2673        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=\"/reference/rate-limiting#rate-limit-tiers\">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.
2674
2675        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
2676        :type board_id: str
2677        :param item_create: (required)
2678        :type item_create: List[ItemCreate]
2679        :param _request_timeout: timeout setting for this request. If one
2680                                 number provided, it will be total request
2681                                 timeout. It can also be a pair (tuple) of
2682                                 (connection, read) timeouts.
2683        :type _request_timeout: int, tuple(int, int), optional
2684        :param _request_auth: set to override the auth_settings for an a single
2685                              request; this effectively ignores the
2686                              authentication in the spec for a single request.
2687        :type _request_auth: dict, optional
2688        :param _content_type: force content-type for the request.
2689        :type _content_type: str, Optional
2690        :param _headers: set to override the headers for a single
2691                         request; this effectively ignores the headers
2692                         in the spec for a single request.
2693        :type _headers: dict, optional
2694        :param _host_index: set to override the host_index for a single
2695                            request; this effectively ignores the host_index
2696                            in the spec for a single request.
2697        :type _host_index: int, optional
2698        :return: Returns the result object.
2699        """  # noqa: E501
2700
2701        _param = self._create_items_serialize(
2702            board_id=board_id,
2703            item_create=item_create,
2704            _request_auth=_request_auth,
2705            _content_type=_content_type,
2706            _headers=_headers,
2707            _host_index=_host_index,
2708        )
2709
2710        _response_types_map: Dict[str, Optional[str]] = {
2711            "201": "Items",
2712            "400": "BulkOperationError",
2713            "429": "Error",
2714        }
2715        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2716        response_data.read()
2717        return self.api_client.response_deserialize(
2718            response_data=response_data,
2719            response_types_map=_response_types_map,
2720        ).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

2784    @validate_call
2785    def create_items_in_bulk_using_file_from_device(
2786        self,
2787        board_id: Annotated[
2788            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
2789        ],
2790        data: Annotated[
2791            Union[StrictBytes, StrictStr],
2792            Field(
2793                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)."
2794            ),
2795        ],
2796        resources: Annotated[
2797            List[Union[StrictBytes, StrictStr]],
2798            Field(description="Array of items to create (PDFs, images, etc.). Maximum of 20 items."),
2799        ],
2800        _request_timeout: Union[
2801            None,
2802            Annotated[StrictFloat, Field(gt=0)],
2803            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2804        ] = None,
2805        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2806        _content_type: Optional[StrictStr] = None,
2807        _headers: Optional[Dict[StrictStr, Any]] = None,
2808        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2809    ) -> Items:
2810        """Create items in bulk using file from device
2811
2812        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a> per item<br/>
2813
2814        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
2815        :type board_id: str
2816        :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)
2817        :type data: bytearray
2818        :param resources: Array of items to create (PDFs, images, etc.). Maximum of 20 items. (required)
2819        :type resources: List[bytearray]
2820        :param _request_timeout: timeout setting for this request. If one
2821                                 number provided, it will be total request
2822                                 timeout. It can also be a pair (tuple) of
2823                                 (connection, read) timeouts.
2824        :type _request_timeout: int, tuple(int, int), optional
2825        :param _request_auth: set to override the auth_settings for an a single
2826                              request; this effectively ignores the
2827                              authentication in the spec for a single request.
2828        :type _request_auth: dict, optional
2829        :param _content_type: force content-type for the request.
2830        :type _content_type: str, Optional
2831        :param _headers: set to override the headers for a single
2832                         request; this effectively ignores the headers
2833                         in the spec for a single request.
2834        :type _headers: dict, optional
2835        :param _host_index: set to override the host_index for a single
2836                            request; this effectively ignores the host_index
2837                            in the spec for a single request.
2838        :type _host_index: int, optional
2839        :return: Returns the result object.
2840        """  # noqa: E501
2841
2842        _param = self._create_items_in_bulk_using_file_from_device_serialize(
2843            board_id=board_id,
2844            data=data,
2845            resources=resources,
2846            _request_auth=_request_auth,
2847            _content_type=_content_type,
2848            _headers=_headers,
2849            _host_index=_host_index,
2850        )
2851
2852        _response_types_map: Dict[str, Optional[str]] = {
2853            "201": "Items",
2854        }
2855        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2856        response_data.read()
2857        return self.api_client.response_deserialize(
2858            response_data=response_data,
2859            response_types_map=_response_types_map,
2860        ).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 get_resource_type( self, resource: typing.Annotated[str, 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.resource_type.ResourceType: View Source

2927    @validate_call
2928    def get_resource_type(
2929        self,
2930        resource: StrictStr,
2931        _request_timeout: Union[
2932            None,
2933            Annotated[StrictFloat, Field(gt=0)],
2934            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2935        ] = None,
2936        _request_auth: Optional[Dict[StrictStr, Any]] = None,
2937        _content_type: Optional[StrictStr] = None,
2938        _headers: Optional[Dict[StrictStr, Any]] = None,
2939        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
2940    ) -> ResourceType:
2941        """Get resource type
2942
2943        Retrieve metadata for the available resource types (User and Group) that are supported.
2944
2945        :param resource: (required)
2946        :type resource: str
2947        :param _request_timeout: timeout setting for this request. If one
2948                                 number provided, it will be total request
2949                                 timeout. It can also be a pair (tuple) of
2950                                 (connection, read) timeouts.
2951        :type _request_timeout: int, tuple(int, int), optional
2952        :param _request_auth: set to override the auth_settings for an a single
2953                              request; this effectively ignores the
2954                              authentication in the spec for a single request.
2955        :type _request_auth: dict, optional
2956        :param _content_type: force content-type for the request.
2957        :type _content_type: str, Optional
2958        :param _headers: set to override the headers for a single
2959                         request; this effectively ignores the headers
2960                         in the spec for a single request.
2961        :type _headers: dict, optional
2962        :param _host_index: set to override the host_index for a single
2963                            request; this effectively ignores the host_index
2964                            in the spec for a single request.
2965        :type _host_index: int, optional
2966        :return: Returns the result object.
2967        """  # noqa: E501
2968
2969        _param = self._get_resource_type_serialize(
2970            resource=resource,
2971            _request_auth=_request_auth,
2972            _content_type=_content_type,
2973            _headers=_headers,
2974            _host_index=_host_index,
2975        )
2976
2977        _response_types_map: Dict[str, Optional[str]] = {
2978            "200": "ResourceType",
2979            "400": None,
2980            "401": None,
2981            "403": None,
2982            "404": None,
2983            "500": None,
2984        }
2985        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2986        response_data.read()
2987        return self.api_client.response_deserialize(
2988            response_data=response_data,
2989            response_types_map=_response_types_map,
2990        ).data

Get resource type

Retrieve metadata for the available resource types (User and Group) that are supported.

:param resource: (required) :type resource: 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_schema( self, uri: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Schema URI of a particular resource type.')], _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.schema_resource.SchemaResource: View Source

3041    @validate_call
3042    def get_schema(
3043        self,
3044        uri: Annotated[StrictStr, Field(description="Schema URI of a particular resource type.")],
3045        _request_timeout: Union[
3046            None,
3047            Annotated[StrictFloat, Field(gt=0)],
3048            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3049        ] = None,
3050        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3051        _content_type: Optional[StrictStr] = None,
3052        _headers: Optional[Dict[StrictStr, Any]] = None,
3053        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3054    ) -> SchemaResource:
3055        """Get schema
3056
3057        Retrieve information about how users, groups, and enterprise-user attributes URIs that are formatted.
3058
3059        :param uri: Schema URI of a particular resource type. (required)
3060        :type uri: str
3061        :param _request_timeout: timeout setting for this request. If one
3062                                 number provided, it will be total request
3063                                 timeout. It can also be a pair (tuple) of
3064                                 (connection, read) timeouts.
3065        :type _request_timeout: int, tuple(int, int), optional
3066        :param _request_auth: set to override the auth_settings for an a single
3067                              request; this effectively ignores the
3068                              authentication in the spec for a single request.
3069        :type _request_auth: dict, optional
3070        :param _content_type: force content-type for the request.
3071        :type _content_type: str, Optional
3072        :param _headers: set to override the headers for a single
3073                         request; this effectively ignores the headers
3074                         in the spec for a single request.
3075        :type _headers: dict, optional
3076        :param _host_index: set to override the host_index for a single
3077                            request; this effectively ignores the host_index
3078                            in the spec for a single request.
3079        :type _host_index: int, optional
3080        :return: Returns the result object.
3081        """  # noqa: E501
3082
3083        _param = self._get_schema_serialize(
3084            uri=uri,
3085            _request_auth=_request_auth,
3086            _content_type=_content_type,
3087            _headers=_headers,
3088            _host_index=_host_index,
3089        )
3090
3091        _response_types_map: Dict[str, Optional[str]] = {
3092            "200": "SchemaResource",
3093            "400": None,
3094            "401": None,
3095            "403": None,
3096            "404": None,
3097            "500": None,
3098        }
3099        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3100        response_data.read()
3101        return self.api_client.response_deserialize(
3102            response_data=response_data,
3103            response_types_map=_response_types_map,
3104        ).data

Get schema

Retrieve information about how users, groups, and enterprise-user attributes URIs that are formatted.

:param uri: Schema URI of a particular resource type. (required) :type uri: 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 list_resource_types( self, _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.resource_type_list_response.ResourceTypeListResponse: View Source

3155    @validate_call
3156    def list_resource_types(
3157        self,
3158        _request_timeout: Union[
3159            None,
3160            Annotated[StrictFloat, Field(gt=0)],
3161            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3162        ] = None,
3163        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3164        _content_type: Optional[StrictStr] = None,
3165        _headers: Optional[Dict[StrictStr, Any]] = None,
3166        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3167    ) -> ResourceTypeListResponse:
3168        """List resource types
3169
3170        Retrieve information about which SCIM resources are supported. <br><br> Currently, Miro supports Users and Groups as Resource Types.
3171
3172        :param _request_timeout: timeout setting for this request. If one
3173                                 number provided, it will be total request
3174                                 timeout. It can also be a pair (tuple) of
3175                                 (connection, read) timeouts.
3176        :type _request_timeout: int, tuple(int, int), optional
3177        :param _request_auth: set to override the auth_settings for an a single
3178                              request; this effectively ignores the
3179                              authentication in the spec for a single request.
3180        :type _request_auth: dict, optional
3181        :param _content_type: force content-type for the request.
3182        :type _content_type: str, Optional
3183        :param _headers: set to override the headers for a single
3184                         request; this effectively ignores the headers
3185                         in the spec for a single request.
3186        :type _headers: dict, optional
3187        :param _host_index: set to override the host_index for a single
3188                            request; this effectively ignores the host_index
3189                            in the spec for a single request.
3190        :type _host_index: int, optional
3191        :return: Returns the result object.
3192        """  # noqa: E501
3193
3194        _param = self._list_resource_types_serialize(
3195            _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index
3196        )
3197
3198        _response_types_map: Dict[str, Optional[str]] = {
3199            "200": "ResourceTypeListResponse",
3200            "400": None,
3201            "401": None,
3202            "403": None,
3203            "404": None,
3204            "500": None,
3205        }
3206        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3207        response_data.read()
3208        return self.api_client.response_deserialize(
3209            response_data=response_data,
3210            response_types_map=_response_types_map,
3211        ).data

List resource types

Retrieve information about which SCIM resources are supported.

Currently, Miro supports Users and Groups as Resource Types.

: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 list_schemas( self, _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.schema_list_response.SchemaListResponse: View Source

3259    @validate_call
3260    def list_schemas(
3261        self,
3262        _request_timeout: Union[
3263            None,
3264            Annotated[StrictFloat, Field(gt=0)],
3265            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3266        ] = None,
3267        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3268        _content_type: Optional[StrictStr] = None,
3269        _headers: Optional[Dict[StrictStr, Any]] = None,
3270        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3271    ) -> SchemaListResponse:
3272        """List schemas
3273
3274        Retrieve metadata about Users, Groups, and extension attributes that are currently supported.
3275
3276        :param _request_timeout: timeout setting for this request. If one
3277                                 number provided, it will be total request
3278                                 timeout. It can also be a pair (tuple) of
3279                                 (connection, read) timeouts.
3280        :type _request_timeout: int, tuple(int, int), optional
3281        :param _request_auth: set to override the auth_settings for an a single
3282                              request; this effectively ignores the
3283                              authentication in the spec for a single request.
3284        :type _request_auth: dict, optional
3285        :param _content_type: force content-type for the request.
3286        :type _content_type: str, Optional
3287        :param _headers: set to override the headers for a single
3288                         request; this effectively ignores the headers
3289                         in the spec for a single request.
3290        :type _headers: dict, optional
3291        :param _host_index: set to override the host_index for a single
3292                            request; this effectively ignores the host_index
3293                            in the spec for a single request.
3294        :type _host_index: int, optional
3295        :return: Returns the result object.
3296        """  # noqa: E501
3297
3298        _param = self._list_schemas_serialize(
3299            _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index
3300        )
3301
3302        _response_types_map: Dict[str, Optional[str]] = {
3303            "200": "SchemaListResponse",
3304            "400": None,
3305            "401": None,
3306            "403": None,
3307            "404": None,
3308            "500": None,
3309        }
3310        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3311        response_data.read()
3312        return self.api_client.response_deserialize(
3313            response_data=response_data,
3314            response_types_map=_response_types_map,
3315        ).data

List schemas

Retrieve metadata about Users, Groups, and extension attributes that are currently supported.

: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 list_service_provider_configs( self, _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.service_provider_config_response.ServiceProviderConfigResponse: View Source

3363    @validate_call
3364    def list_service_provider_configs(
3365        self,
3366        _request_timeout: Union[
3367            None,
3368            Annotated[StrictFloat, Field(gt=0)],
3369            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3370        ] = None,
3371        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3372        _content_type: Optional[StrictStr] = None,
3373        _headers: Optional[Dict[StrictStr, Any]] = None,
3374        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3375    ) -> ServiceProviderConfigResponse:
3376        """Get Service Provider Config
3377
3378        Retrieve supported operations and SCIM API basic configuration.
3379
3380        :param _request_timeout: timeout setting for this request. If one
3381                                 number provided, it will be total request
3382                                 timeout. It can also be a pair (tuple) of
3383                                 (connection, read) timeouts.
3384        :type _request_timeout: int, tuple(int, int), optional
3385        :param _request_auth: set to override the auth_settings for an a single
3386                              request; this effectively ignores the
3387                              authentication in the spec for a single request.
3388        :type _request_auth: dict, optional
3389        :param _content_type: force content-type for the request.
3390        :type _content_type: str, Optional
3391        :param _headers: set to override the headers for a single
3392                         request; this effectively ignores the headers
3393                         in the spec for a single request.
3394        :type _headers: dict, optional
3395        :param _host_index: set to override the host_index for a single
3396                            request; this effectively ignores the host_index
3397                            in the spec for a single request.
3398        :type _host_index: int, optional
3399        :return: Returns the result object.
3400        """  # noqa: E501
3401
3402        _param = self._list_service_provider_configs_serialize(
3403            _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index
3404        )
3405
3406        _response_types_map: Dict[str, Optional[str]] = {
3407            "200": "ServiceProviderConfigResponse",
3408            "400": None,
3409            "401": None,
3410            "403": None,
3411            "404": None,
3412            "500": None,
3413        }
3414        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3415        response_data.read()
3416        return self.api_client.response_deserialize(
3417            response_data=response_data,
3418            response_types_map=_response_types_map,
3419        ).data

Get Service Provider Config

Retrieve supported operations and SCIM API basic configuration.

: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

3467    @validate_call
3468    def create_shape_item_flowchart(
3469        self,
3470        board_id: Annotated[
3471            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
3472        ],
3473        shape_create_request: ShapeCreateRequest,
3474        _request_timeout: Union[
3475            None,
3476            Annotated[StrictFloat, Field(gt=0)],
3477            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3478        ] = None,
3479        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3480        _content_type: Optional[StrictStr] = None,
3481        _headers: Optional[Dict[StrictStr, Any]] = None,
3482        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3483    ) -> ShapeItem:
3484        """Create shape item
3485
3486        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
3487
3488        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
3489        :type board_id: str
3490        :param shape_create_request: (required)
3491        :type shape_create_request: ShapeCreateRequest
3492        :param _request_timeout: timeout setting for this request. If one
3493                                 number provided, it will be total request
3494                                 timeout. It can also be a pair (tuple) of
3495                                 (connection, read) timeouts.
3496        :type _request_timeout: int, tuple(int, int), optional
3497        :param _request_auth: set to override the auth_settings for an a single
3498                              request; this effectively ignores the
3499                              authentication in the spec for a single request.
3500        :type _request_auth: dict, optional
3501        :param _content_type: force content-type for the request.
3502        :type _content_type: str, Optional
3503        :param _headers: set to override the headers for a single
3504                         request; this effectively ignores the headers
3505                         in the spec for a single request.
3506        :type _headers: dict, optional
3507        :param _host_index: set to override the host_index for a single
3508                            request; this effectively ignores the host_index
3509                            in the spec for a single request.
3510        :type _host_index: int, optional
3511        :return: Returns the result object.
3512        """  # noqa: E501
3513
3514        _param = self._create_shape_item_flowchart_serialize(
3515            board_id=board_id,
3516            shape_create_request=shape_create_request,
3517            _request_auth=_request_auth,
3518            _content_type=_content_type,
3519            _headers=_headers,
3520            _host_index=_host_index,
3521        )
3522
3523        _response_types_map: Dict[str, Optional[str]] = {
3524            "201": "ShapeItem",
3525            "400": "CreateFrameItem400Response",
3526            "404": "CreateFrameItem400Response",
3527            "429": "CreateFrameItem400Response",
3528        }
3529        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3530        response_data.read()
3531        return self.api_client.response_deserialize(
3532            response_data=response_data,
3533            response_types_map=_response_types_map,
3534        ).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

3596    @validate_call
3597    def delete_shape_item_flowchart(
3598        self,
3599        board_id: Annotated[
3600            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
3601        ],
3602        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
3603        _request_timeout: Union[
3604            None,
3605            Annotated[StrictFloat, Field(gt=0)],
3606            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3607        ] = None,
3608        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3609        _content_type: Optional[StrictStr] = None,
3610        _headers: Optional[Dict[StrictStr, Any]] = None,
3611        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3612    ) -> object:
3613        """Delete shape item
3614
3615        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
3616
3617        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
3618        :type board_id: str
3619        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
3620        :type item_id: str
3621        :param _request_timeout: timeout setting for this request. If one
3622                                 number provided, it will be total request
3623                                 timeout. It can also be a pair (tuple) of
3624                                 (connection, read) timeouts.
3625        :type _request_timeout: int, tuple(int, int), optional
3626        :param _request_auth: set to override the auth_settings for an a single
3627                              request; this effectively ignores the
3628                              authentication in the spec for a single request.
3629        :type _request_auth: dict, optional
3630        :param _content_type: force content-type for the request.
3631        :type _content_type: str, Optional
3632        :param _headers: set to override the headers for a single
3633                         request; this effectively ignores the headers
3634                         in the spec for a single request.
3635        :type _headers: dict, optional
3636        :param _host_index: set to override the host_index for a single
3637                            request; this effectively ignores the host_index
3638                            in the spec for a single request.
3639        :type _host_index: int, optional
3640        :return: Returns the result object.
3641        """  # noqa: E501
3642
3643        _param = self._delete_shape_item_flowchart_serialize(
3644            board_id=board_id,
3645            item_id=item_id,
3646            _request_auth=_request_auth,
3647            _content_type=_content_type,
3648            _headers=_headers,
3649            _host_index=_host_index,
3650        )
3651
3652        _response_types_map: Dict[str, Optional[str]] = {
3653            "204": "object",
3654            "400": "CreateFrameItem400Response",
3655            "404": "CreateFrameItem400Response",
3656            "429": "CreateFrameItem400Response",
3657        }
3658        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3659        response_data.read()
3660        return self.api_client.response_deserialize(
3661            response_data=response_data,
3662            response_types_map=_response_types_map,
3663        ).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

3717    @validate_call
3718    def get_items_experimental(
3719        self,
3720        board_id: Annotated[
3721            StrictStr,
3722            Field(
3723                description="Unique identifier (ID) of the board for which you want to retrieve the list of available items."
3724            ),
3725        ],
3726        limit: Optional[Annotated[str, Field(strict=True)]] = None,
3727        type: Optional[StrictStr] = None,
3728        cursor: Optional[StrictStr] = None,
3729        _request_timeout: Union[
3730            None,
3731            Annotated[StrictFloat, Field(gt=0)],
3732            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3733        ] = None,
3734        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3735        _content_type: Optional[StrictStr] = None,
3736        _headers: Optional[Dict[StrictStr, Any]] = None,
3737        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3738    ) -> GenericItemCursorPaged:
3739        """Get items on board
3740
3741        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
3742
3743        :param board_id: Unique identifier (ID) of the board for which you want to retrieve the list of available items. (required)
3744        :type board_id: str
3745        :param limit:
3746        :type limit: str
3747        :param type:
3748        :type type: str
3749        :param cursor:
3750        :type cursor: str
3751        :param _request_timeout: timeout setting for this request. If one
3752                                 number provided, it will be total request
3753                                 timeout. It can also be a pair (tuple) of
3754                                 (connection, read) timeouts.
3755        :type _request_timeout: int, tuple(int, int), optional
3756        :param _request_auth: set to override the auth_settings for an a single
3757                              request; this effectively ignores the
3758                              authentication in the spec for a single request.
3759        :type _request_auth: dict, optional
3760        :param _content_type: force content-type for the request.
3761        :type _content_type: str, Optional
3762        :param _headers: set to override the headers for a single
3763                         request; this effectively ignores the headers
3764                         in the spec for a single request.
3765        :type _headers: dict, optional
3766        :param _host_index: set to override the host_index for a single
3767                            request; this effectively ignores the host_index
3768                            in the spec for a single request.
3769        :type _host_index: int, optional
3770        :return: Returns the result object.
3771        """  # noqa: E501
3772
3773        _param = self._get_items_experimental_serialize(
3774            board_id=board_id,
3775            limit=limit,
3776            type=type,
3777            cursor=cursor,
3778            _request_auth=_request_auth,
3779            _content_type=_content_type,
3780            _headers=_headers,
3781            _host_index=_host_index,
3782        )
3783
3784        _response_types_map: Dict[str, Optional[str]] = {
3785            "200": "GenericItemCursorPaged",
3786            "400": "CreateFrameItem400Response",
3787            "404": "CreateFrameItem400Response",
3788            "429": "CreateFrameItem400Response",
3789        }
3790        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3791        response_data.read()
3792        return self.api_client.response_deserialize(
3793            response_data=response_data,
3794            response_types_map=_response_types_map,
3795        ).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

3861    @validate_call
3862    def get_shape_item_flowchart(
3863        self,
3864        board_id: Annotated[
3865            StrictStr,
3866            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
3867        ],
3868        item_id: Annotated[
3869            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
3870        ],
3871        _request_timeout: Union[
3872            None,
3873            Annotated[StrictFloat, Field(gt=0)],
3874            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3875        ] = None,
3876        _request_auth: Optional[Dict[StrictStr, Any]] = None,
3877        _content_type: Optional[StrictStr] = None,
3878        _headers: Optional[Dict[StrictStr, Any]] = None,
3879        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
3880    ) -> ShapeItem:
3881        """Get shape item
3882
3883        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
3884
3885        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
3886        :type board_id: str
3887        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
3888        :type item_id: str
3889        :param _request_timeout: timeout setting for this request. If one
3890                                 number provided, it will be total request
3891                                 timeout. It can also be a pair (tuple) of
3892                                 (connection, read) timeouts.
3893        :type _request_timeout: int, tuple(int, int), optional
3894        :param _request_auth: set to override the auth_settings for an a single
3895                              request; this effectively ignores the
3896                              authentication in the spec for a single request.
3897        :type _request_auth: dict, optional
3898        :param _content_type: force content-type for the request.
3899        :type _content_type: str, Optional
3900        :param _headers: set to override the headers for a single
3901                         request; this effectively ignores the headers
3902                         in the spec for a single request.
3903        :type _headers: dict, optional
3904        :param _host_index: set to override the host_index for a single
3905                            request; this effectively ignores the host_index
3906                            in the spec for a single request.
3907        :type _host_index: int, optional
3908        :return: Returns the result object.
3909        """  # noqa: E501
3910
3911        _param = self._get_shape_item_flowchart_serialize(
3912            board_id=board_id,
3913            item_id=item_id,
3914            _request_auth=_request_auth,
3915            _content_type=_content_type,
3916            _headers=_headers,
3917            _host_index=_host_index,
3918        )
3919
3920        _response_types_map: Dict[str, Optional[str]] = {
3921            "200": "ShapeItem",
3922            "400": "CreateFrameItem400Response",
3923            "404": "CreateFrameItem400Response",
3924            "429": "CreateFrameItem400Response",
3925        }
3926        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3927        response_data.read()
3928        return self.api_client.response_deserialize(
3929            response_data=response_data,
3930            response_types_map=_response_types_map,
3931        ).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

3985    @validate_call
3986    def get_specific_item_experimental(
3987        self,
3988        board_id: Annotated[
3989            StrictStr,
3990            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
3991        ],
3992        item_id: Annotated[
3993            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
3994        ],
3995        _request_timeout: Union[
3996            None,
3997            Annotated[StrictFloat, Field(gt=0)],
3998            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3999        ] = None,
4000        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4001        _content_type: Optional[StrictStr] = None,
4002        _headers: Optional[Dict[StrictStr, Any]] = None,
4003        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4004    ) -> GenericItem:
4005        """Get specific item on board
4006
4007        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
4008
4009        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
4010        :type board_id: str
4011        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
4012        :type item_id: str
4013        :param _request_timeout: timeout setting for this request. If one
4014                                 number provided, it will be total request
4015                                 timeout. It can also be a pair (tuple) of
4016                                 (connection, read) timeouts.
4017        :type _request_timeout: int, tuple(int, int), optional
4018        :param _request_auth: set to override the auth_settings for an a single
4019                              request; this effectively ignores the
4020                              authentication in the spec for a single request.
4021        :type _request_auth: dict, optional
4022        :param _content_type: force content-type for the request.
4023        :type _content_type: str, Optional
4024        :param _headers: set to override the headers for a single
4025                         request; this effectively ignores the headers
4026                         in the spec for a single request.
4027        :type _headers: dict, optional
4028        :param _host_index: set to override the host_index for a single
4029                            request; this effectively ignores the host_index
4030                            in the spec for a single request.
4031        :type _host_index: int, optional
4032        :return: Returns the result object.
4033        """  # noqa: E501
4034
4035        _param = self._get_specific_item_experimental_serialize(
4036            board_id=board_id,
4037            item_id=item_id,
4038            _request_auth=_request_auth,
4039            _content_type=_content_type,
4040            _headers=_headers,
4041            _host_index=_host_index,
4042        )
4043
4044        _response_types_map: Dict[str, Optional[str]] = {
4045            "200": "GenericItem",
4046            "400": "CreateFrameItem400Response",
4047            "404": "CreateFrameItem400Response",
4048            "429": "CreateFrameItem400Response",
4049        }
4050        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4051        response_data.read()
4052        return self.api_client.response_deserialize(
4053            response_data=response_data,
4054            response_types_map=_response_types_map,
4055        ).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

4109    @validate_call
4110    def update_shape_item_flowchart(
4111        self,
4112        board_id: Annotated[
4113            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
4114        ],
4115        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
4116        shape_update_request: ShapeUpdateRequest,
4117        _request_timeout: Union[
4118            None,
4119            Annotated[StrictFloat, Field(gt=0)],
4120            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4121        ] = None,
4122        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4123        _content_type: Optional[StrictStr] = None,
4124        _headers: Optional[Dict[StrictStr, Any]] = None,
4125        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4126    ) -> ShapeItem:
4127        """Update shape item
4128
4129        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
4130
4131        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
4132        :type board_id: str
4133        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
4134        :type item_id: str
4135        :param shape_update_request: (required)
4136        :type shape_update_request: ShapeUpdateRequest
4137        :param _request_timeout: timeout setting for this request. If one
4138                                 number provided, it will be total request
4139                                 timeout. It can also be a pair (tuple) of
4140                                 (connection, read) timeouts.
4141        :type _request_timeout: int, tuple(int, int), optional
4142        :param _request_auth: set to override the auth_settings for an a single
4143                              request; this effectively ignores the
4144                              authentication in the spec for a single request.
4145        :type _request_auth: dict, optional
4146        :param _content_type: force content-type for the request.
4147        :type _content_type: str, Optional
4148        :param _headers: set to override the headers for a single
4149                         request; this effectively ignores the headers
4150                         in the spec for a single request.
4151        :type _headers: dict, optional
4152        :param _host_index: set to override the host_index for a single
4153                            request; this effectively ignores the host_index
4154                            in the spec for a single request.
4155        :type _host_index: int, optional
4156        :return: Returns the result object.
4157        """  # noqa: E501
4158
4159        _param = self._update_shape_item_flowchart_serialize(
4160            board_id=board_id,
4161            item_id=item_id,
4162            shape_update_request=shape_update_request,
4163            _request_auth=_request_auth,
4164            _content_type=_content_type,
4165            _headers=_headers,
4166            _host_index=_host_index,
4167        )
4168
4169        _response_types_map: Dict[str, Optional[str]] = {
4170            "200": "ShapeItem",
4171            "400": "CreateFrameItem400Response",
4172            "404": "CreateFrameItem400Response",
4173            "429": "CreateFrameItem400Response",
4174        }
4175        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4176        response_data.read()
4177        return self.api_client.response_deserialize(
4178            response_data=response_data,
4179            response_types_map=_response_types_map,
4180        ).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_group( self, id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='A server-assigned, unique identifier for this Group (team).')], attributes: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A comma-separated list of attribute names to return in the response. Example attributes: id,displayName Note: It is also possible to retrieve attributes within complex attributes. For example: members.display')] = 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.group_resource.GroupResource: View Source

4245    @validate_call
4246    def get_group(
4247        self,
4248        id: Annotated[StrictStr, Field(description="A server-assigned, unique identifier for this Group (team).")],
4249        attributes: Annotated[
4250            Optional[StrictStr],
4251            Field(
4252                description="A comma-separated list of attribute names to return in the response. <br><br> Example attributes: id,displayName <br> Note</b>: It is also possible to retrieve attributes within complex attributes. For example: members.display"
4253            ),
4254        ] = None,
4255        _request_timeout: Union[
4256            None,
4257            Annotated[StrictFloat, Field(gt=0)],
4258            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4259        ] = None,
4260        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4261        _content_type: Optional[StrictStr] = None,
4262        _headers: Optional[Dict[StrictStr, Any]] = None,
4263        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4264    ) -> GroupResource:
4265        """Get group
4266
4267        Retrieves a single Group resource.<br><b> Note</b>: Along with groups (teams), the users that are part of those groups (teams) are also retrieved. Only users that have member role in the organization are fetched.
4268
4269        :param id: A server-assigned, unique identifier for this Group (team). (required)
4270        :type id: str
4271        :param attributes: A comma-separated list of attribute names to return in the response. <br><br> Example attributes: id,displayName <br> Note</b>: It is also possible to retrieve attributes within complex attributes. For example: members.display
4272        :type attributes: str
4273        :param _request_timeout: timeout setting for this request. If one
4274                                 number provided, it will be total request
4275                                 timeout. It can also be a pair (tuple) of
4276                                 (connection, read) timeouts.
4277        :type _request_timeout: int, tuple(int, int), optional
4278        :param _request_auth: set to override the auth_settings for an a single
4279                              request; this effectively ignores the
4280                              authentication in the spec for a single request.
4281        :type _request_auth: dict, optional
4282        :param _content_type: force content-type for the request.
4283        :type _content_type: str, Optional
4284        :param _headers: set to override the headers for a single
4285                         request; this effectively ignores the headers
4286                         in the spec for a single request.
4287        :type _headers: dict, optional
4288        :param _host_index: set to override the host_index for a single
4289                            request; this effectively ignores the host_index
4290                            in the spec for a single request.
4291        :type _host_index: int, optional
4292        :return: Returns the result object.
4293        """  # noqa: E501
4294
4295        _param = self._get_group_serialize(
4296            id=id,
4297            attributes=attributes,
4298            _request_auth=_request_auth,
4299            _content_type=_content_type,
4300            _headers=_headers,
4301            _host_index=_host_index,
4302        )
4303
4304        _response_types_map: Dict[str, Optional[str]] = {
4305            "200": "GroupResource",
4306            "400": None,
4307            "401": None,
4308            "403": None,
4309            "404": None,
4310            "409": None,
4311            "413": None,
4312            "429": None,
4313            "500": None,
4314        }
4315        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4316        response_data.read()
4317        return self.api_client.response_deserialize(
4318            response_data=response_data,
4319            response_types_map=_response_types_map,
4320        ).data

Get group

Retrieves a single Group resource.
Note: Along with groups (teams), the users that are part of those groups (teams) are also retrieved. Only users that have member role in the organization are fetched.

:param id: A server-assigned, unique identifier for this Group (team). (required) :type id: str :param attributes: A comma-separated list of attribute names to return in the response.

Example attributes: id,displayName
Note: It is also possible to retrieve attributes within complex attributes. For example: members.display :type attributes: 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 list_groups( self, attributes: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A comma-separated list of attribute names to return in the response. Example attributes: id,displayName Note: It is also possible to fetch attributes within complex attributes, for Example: members.display.')] = None, filter: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='You can request a subset of resources by specifying the filter query parameter containing a filter expression. Attribute names and attribute operators used in filters are not case sensitive. The filter parameter must contain at least one valid expression. Each expression must contain an attribute name followed by an attribute operator and an optional value. eq = equal ne = not equal co = contains sw = starts with ew = ends with pr = preset (has value) gt = greater than ge = greater than or equal to lt = less than le = less than or equal to and = Logical "and" or = Logical "or" not = "Not" function () = Precedence grouping The value must be passed within parenthesis. For Example: displayName eq "Product Team" will fetch information related to team matching the display name "Product Team". Note: Filtering on complex attributes is not supported')] = None, start_index: Annotated[Optional[Annotated[int, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Use startIndex in combination with count query parameters to receive paginated results. start index is 1-based. Example: startIndex=1')] = None, count: Annotated[Optional[Annotated[int, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Specifies the maximum number of query results per page. Use count in combination with startIndex query parameters to receive paginated results. The count query parameter is set to 100 by default and the maximum value allowed for this parameter is 1000. Example: count=12')] = None, sort_by: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Specifies the attribute whose value will be used to order the response. Example sortBy=displayName')] = None, sort_order: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description="Defines the order in which the 'sortBy' parameter is applied. Example: sortOrder=ascending")] = 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.group_list_response.GroupListResponse: View Source

4376    @validate_call
4377    def list_groups(
4378        self,
4379        attributes: Annotated[
4380            Optional[StrictStr],
4381            Field(
4382                description="A comma-separated list of attribute names to return in the response. <br><br> Example attributes: id,displayName <br> Note</b>: It is also possible to fetch attributes within complex attributes, for Example: members.display."
4383            ),
4384        ] = None,
4385        filter: Annotated[
4386            Optional[StrictStr],
4387            Field(
4388                description='You can request a subset of resources by specifying the filter query parameter containing a filter expression. Attribute names and attribute operators used in filters are not case sensitive. The filter parameter must contain at least one valid expression. Each expression must contain an attribute name followed by an attribute operator and an optional value. <br>eq = equal<br> ne = not equal<br> co = contains<br> sw = starts with<br> ew = ends with<br> pr = preset (has value)<br> gt = greater than<br> ge = greater than or equal to<br> lt = less than<br> le = less than or equal to<br> and = Logical "and"<br> or = Logical "or"<br> not = "Not" function<br> () = Precedence grouping <br>The value must be passed within parenthesis. <br><br>For Example: displayName eq "Product Team" will fetch information related to team matching the display name "Product Team". <br>Note</b>: Filtering on complex attributes is not supported'
4389            ),
4390        ] = None,
4391        start_index: Annotated[
4392            Optional[StrictInt],
4393            Field(
4394                description="Use startIndex in combination with count query parameters to receive paginated results. <br><br> start index is 1-based. <br><br> Example: startIndex=1"
4395            ),
4396        ] = None,
4397        count: Annotated[
4398            Optional[StrictInt],
4399            Field(
4400                description="Specifies the maximum number of query results per page. <br><br> Use count in combination with startIndex query parameters to receive paginated results. <br><br> The count query parameter is set to 100 by default and the maximum value allowed for this parameter is 1000. <br><br> Example: count=12"
4401            ),
4402        ] = None,
4403        sort_by: Annotated[
4404            Optional[StrictStr],
4405            Field(
4406                description="Specifies the attribute whose value will be used to order the response. Example sortBy=displayName"
4407            ),
4408        ] = None,
4409        sort_order: Annotated[
4410            Optional[StrictStr],
4411            Field(
4412                description="Defines the order in which the 'sortBy' parameter is applied. Example: sortOrder=ascending"
4413            ),
4414        ] = None,
4415        _request_timeout: Union[
4416            None,
4417            Annotated[StrictFloat, Field(gt=0)],
4418            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4419        ] = None,
4420        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4421        _content_type: Optional[StrictStr] = None,
4422        _headers: Optional[Dict[StrictStr, Any]] = None,
4423        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4424    ) -> GroupListResponse:
4425        """List groups
4426
4427        Retrieves the list of groups (teams) in the organization.<br><br> Note: Along with groups (teams), the users that are part of those groups (teams) are also retrieved. Only users that have member role in the organization are fetched.
4428
4429        :param attributes: A comma-separated list of attribute names to return in the response. <br><br> Example attributes: id,displayName <br> Note</b>: It is also possible to fetch attributes within complex attributes, for Example: members.display.
4430        :type attributes: str
4431        :param filter: You can request a subset of resources by specifying the filter query parameter containing a filter expression. Attribute names and attribute operators used in filters are not case sensitive. The filter parameter must contain at least one valid expression. Each expression must contain an attribute name followed by an attribute operator and an optional value. <br>eq = equal<br> ne = not equal<br> co = contains<br> sw = starts with<br> ew = ends with<br> pr = preset (has value)<br> gt = greater than<br> ge = greater than or equal to<br> lt = less than<br> le = less than or equal to<br> and = Logical \"and\"<br> or = Logical \"or\"<br> not = \"Not\" function<br> () = Precedence grouping <br>The value must be passed within parenthesis. <br><br>For Example: displayName eq \"Product Team\" will fetch information related to team matching the display name \"Product Team\". <br>Note</b>: Filtering on complex attributes is not supported
4432        :type filter: str
4433        :param start_index: Use startIndex in combination with count query parameters to receive paginated results. <br><br> start index is 1-based. <br><br> Example: startIndex=1
4434        :type start_index: int
4435        :param count: Specifies the maximum number of query results per page. <br><br> Use count in combination with startIndex query parameters to receive paginated results. <br><br> The count query parameter is set to 100 by default and the maximum value allowed for this parameter is 1000. <br><br> Example: count=12
4436        :type count: int
4437        :param sort_by: Specifies the attribute whose value will be used to order the response. Example sortBy=displayName
4438        :type sort_by: str
4439        :param sort_order: Defines the order in which the 'sortBy' parameter is applied. Example: sortOrder=ascending
4440        :type sort_order: str
4441        :param _request_timeout: timeout setting for this request. If one
4442                                 number provided, it will be total request
4443                                 timeout. It can also be a pair (tuple) of
4444                                 (connection, read) timeouts.
4445        :type _request_timeout: int, tuple(int, int), optional
4446        :param _request_auth: set to override the auth_settings for an a single
4447                              request; this effectively ignores the
4448                              authentication in the spec for a single request.
4449        :type _request_auth: dict, optional
4450        :param _content_type: force content-type for the request.
4451        :type _content_type: str, Optional
4452        :param _headers: set to override the headers for a single
4453                         request; this effectively ignores the headers
4454                         in the spec for a single request.
4455        :type _headers: dict, optional
4456        :param _host_index: set to override the host_index for a single
4457                            request; this effectively ignores the host_index
4458                            in the spec for a single request.
4459        :type _host_index: int, optional
4460        :return: Returns the result object.
4461        """  # noqa: E501
4462
4463        _param = self._list_groups_serialize(
4464            attributes=attributes,
4465            filter=filter,
4466            start_index=start_index,
4467            count=count,
4468            sort_by=sort_by,
4469            sort_order=sort_order,
4470            _request_auth=_request_auth,
4471            _content_type=_content_type,
4472            _headers=_headers,
4473            _host_index=_host_index,
4474        )
4475
4476        _response_types_map: Dict[str, Optional[str]] = {
4477            "200": "GroupListResponse",
4478            "400": None,
4479            "401": None,
4480            "403": None,
4481            "404": None,
4482            "429": None,
4483            "500": None,
4484        }
4485        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4486        response_data.read()
4487        return self.api_client.response_deserialize(
4488            response_data=response_data,
4489            response_types_map=_response_types_map,
4490        ).data

List groups

Retrieves the list of groups (teams) in the organization.

Note: Along with groups (teams), the users that are part of those groups (teams) are also retrieved. Only users that have member role in the organization are fetched.

:param attributes: A comma-separated list of attribute names to return in the response.

Example attributes: id,displayName
Note: It is also possible to fetch attributes within complex attributes, for Example: members.display. :type attributes: str :param filter: You can request a subset of resources by specifying the filter query parameter containing a filter expression. Attribute names and attribute operators used in filters are not case sensitive. The filter parameter must contain at least one valid expression. Each expression must contain an attribute name followed by an attribute operator and an optional value.
eq = equal
ne = not equal
co = contains
sw = starts with
ew = ends with
pr = preset (has value)
gt = greater than
ge = greater than or equal to
lt = less than
le = less than or equal to
and = Logical "and"
or = Logical "or"
not = "Not" function
() = Precedence grouping
The value must be passed within parenthesis.

For Example: displayName eq "Product Team" will fetch information related to team matching the display name "Product Team".
Note: Filtering on complex attributes is not supported :type filter: str :param start_index: Use startIndex in combination with count query parameters to receive paginated results.

start index is 1-based.

Example: startIndex=1 :type start_index: int :param count: Specifies the maximum number of query results per page.

Use count in combination with startIndex query parameters to receive paginated results.

The count query parameter is set to 100 by default and the maximum value allowed for this parameter is 1000.

Example: count=12 :type count: int :param sort_by: Specifies the attribute whose value will be used to order the response. Example sortBy=displayName :type sort_by: str :param sort_order: Defines the order in which the 'sortBy' parameter is applied. Example: sortOrder=ascending :type sort_order: 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 patch_group( self, id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='Group (Team) ID. A server-assigned, unique identifier for this Group (team).')], patch_group_resource: typing.Annotated[miro_api.models.patch_group_resource.PatchGroupResource, FieldInfo(annotation=NoneType, required=True, description='Payload to add, replace, remove members in the specified group (team). The body of a PATCH request must contain the attribute `Operations` and its value is an array of one or more PATCH operations. Each PATCH operation object must have exactly one `op` member. ')], attributes: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A comma-separated list of attribute names to return in the response. Example attributes: id,displayName It is also possible to fetch attributes within complex attributes, for Example: members.display')] = 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.group_resource.GroupResource: View Source

4568    @validate_call
4569    def patch_group(
4570        self,
4571        id: Annotated[
4572            StrictStr, Field(description="Group (Team) ID. A server-assigned, unique identifier for this Group (team).")
4573        ],
4574        patch_group_resource: Annotated[
4575            PatchGroupResource,
4576            Field(
4577                description="Payload to add, replace, remove members in the specified group (team). <br><br> The body of a PATCH request must contain the attribute `Operations` and its value is an array of one or more PATCH operations. Each PATCH operation object must have exactly one `op` member. "
4578            ),
4579        ],
4580        attributes: Annotated[
4581            Optional[StrictStr],
4582            Field(
4583                description="A comma-separated list of attribute names to return in the response. <br><br> Example attributes: id,displayName <br> It is also possible to fetch attributes within complex attributes, for Example: members.display"
4584            ),
4585        ] = None,
4586        _request_timeout: Union[
4587            None,
4588            Annotated[StrictFloat, Field(gt=0)],
4589            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4590        ] = None,
4591        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4592        _content_type: Optional[StrictStr] = None,
4593        _headers: Optional[Dict[StrictStr, Any]] = None,
4594        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4595    ) -> GroupResource:
4596        """Patch group
4597
4598        Updates an existing group resource, i.e. a team, overwriting values for specified attributes. Patch operation for group can be used to add, remove, or replace team members and to update the display name of the group (team). <br><br> To add a user to the group (team), use add operation. <br> To remove a user from a group (team), use remove operation. <br> To update a user resource, use the replace operation. <br> The last team admin cannot be removed from the team. <br><br> Note: Attributes that are not provided will remain unchanged. PATCH operation only updates the fields provided. <br><br> Team members removal specifics: <br> For remove or replace operations, the team member is removed from the team and from all team boards. The ownership of boards that belong to the removed team member is transferred to the oldest team member who currently has an admin role. After you remove a team member, adding the team member again to the team does not automatically restore their previous ownership of the boards. If the user is not registered fully in Miro and is not assigned to any other team, the user is also removed from the organization. <br><br> Add team members specifics: <br> All added team members are reactivated or recreated if they were deactivated or deleted earlier. <br><br> External users specifics: <br> When adding existing users with the role ORGANIZATION_EXTERNAL_USER or ORGANIZATION_TEAM_GUEST_USER to a team, we set FULL license and ORGANIZATION_INTERNAL_USER roles.
4599
4600        :param id: Group (Team) ID. A server-assigned, unique identifier for this Group (team). (required)
4601        :type id: str
4602        :param patch_group_resource: Payload to add, replace, remove members in the specified group (team). <br><br> The body of a PATCH request must contain the attribute `Operations` and its value is an array of one or more PATCH operations. Each PATCH operation object must have exactly one `op` member.  (required)
4603        :type patch_group_resource: PatchGroupResource
4604        :param attributes: A comma-separated list of attribute names to return in the response. <br><br> Example attributes: id,displayName <br> It is also possible to fetch attributes within complex attributes, for Example: members.display
4605        :type attributes: str
4606        :param _request_timeout: timeout setting for this request. If one
4607                                 number provided, it will be total request
4608                                 timeout. It can also be a pair (tuple) of
4609                                 (connection, read) timeouts.
4610        :type _request_timeout: int, tuple(int, int), optional
4611        :param _request_auth: set to override the auth_settings for an a single
4612                              request; this effectively ignores the
4613                              authentication in the spec for a single request.
4614        :type _request_auth: dict, optional
4615        :param _content_type: force content-type for the request.
4616        :type _content_type: str, Optional
4617        :param _headers: set to override the headers for a single
4618                         request; this effectively ignores the headers
4619                         in the spec for a single request.
4620        :type _headers: dict, optional
4621        :param _host_index: set to override the host_index for a single
4622                            request; this effectively ignores the host_index
4623                            in the spec for a single request.
4624        :type _host_index: int, optional
4625        :return: Returns the result object.
4626        """  # noqa: E501
4627
4628        _param = self._patch_group_serialize(
4629            id=id,
4630            patch_group_resource=patch_group_resource,
4631            attributes=attributes,
4632            _request_auth=_request_auth,
4633            _content_type=_content_type,
4634            _headers=_headers,
4635            _host_index=_host_index,
4636        )
4637
4638        _response_types_map: Dict[str, Optional[str]] = {
4639            "200": "GroupResource",
4640            "400": None,
4641            "401": None,
4642            "403": None,
4643            "404": None,
4644            "409": None,
4645            "413": None,
4646            "429": None,
4647            "500": None,
4648        }
4649        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4650        response_data.read()
4651        return self.api_client.response_deserialize(
4652            response_data=response_data,
4653            response_types_map=_response_types_map,
4654        ).data

Patch group

Updates an existing group resource, i.e. a team, overwriting values for specified attributes. Patch operation for group can be used to add, remove, or replace team members and to update the display name of the group (team).

To add a user to the group (team), use add operation.
To remove a user from a group (team), use remove operation.
To update a user resource, use the replace operation.
The last team admin cannot be removed from the team.

Note: Attributes that are not provided will remain unchanged. PATCH operation only updates the fields provided.

Team members removal specifics:
For remove or replace operations, the team member is removed from the team and from all team boards. The ownership of boards that belong to the removed team member is transferred to the oldest team member who currently has an admin role. After you remove a team member, adding the team member again to the team does not automatically restore their previous ownership of the boards. If the user is not registered fully in Miro and is not assigned to any other team, the user is also removed from the organization.

Add team members specifics:
All added team members are reactivated or recreated if they were deactivated or deleted earlier.

External users specifics:
When adding existing users with the role ORGANIZATION_EXTERNAL_USER or ORGANIZATION_TEAM_GUEST_USER to a team, we set FULL license and ORGANIZATION_INTERNAL_USER roles.

:param id: Group (Team) ID. A server-assigned, unique identifier for this Group (team). (required) :type id: str :param patch_group_resource: Payload to add, replace, remove members in the specified group (team).

The body of a PATCH request must contain the attribute Operations and its value is an array of one or more PATCH operations. Each PATCH operation object must have exactly one op member. (required) :type patch_group_resource: PatchGroupResource :param attributes: A comma-separated list of attribute names to return in the response.

Example attributes: id,displayName
It is also possible to fetch attributes within complex attributes, for Example: members.display :type attributes: 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_case( self, org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization in which you want to create a new case.', metadata=[Strict(strict=True)])], case_request: miro_api.models.case_request.CaseRequest, _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

4723    @validate_call
4724    def create_case(
4725        self,
4726        org_id: Annotated[
4727            str, Field(strict=True, description="The ID of the organization in which you want to create a new case.")
4728        ],
4729        case_request: CaseRequest,
4730        _request_timeout: Union[
4731            None,
4732            Annotated[StrictFloat, Field(gt=0)],
4733            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4734        ] = None,
4735        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4736        _content_type: Optional[StrictStr] = None,
4737        _headers: Optional[Dict[StrictStr, Any]] = None,
4738        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4739    ) -> CaseResponse:
4740        """Create case
4741
4742        Creating a case for legal hold is the first critical step in the eDiscovery process when litigation or an investigation is anticipated. One of the purposes of creating a case is that it acts as a container that allows admins to group multiple legal holds under one case. For more information, see our <a href=\"https://help.miro.com/hc/en-us/articles/22120022370962-Create-a-case\" target=_blank>Help Center page on creating a case</a>. <br><br>This API creates a new 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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
4743
4744        :param org_id: The ID of the organization in which you want to create a new case. (required)
4745        :type org_id: str
4746        :param case_request: (required)
4747        :type case_request: CaseRequest
4748        :param _request_timeout: timeout setting for this request. If one
4749                                 number provided, it will be total request
4750                                 timeout. It can also be a pair (tuple) of
4751                                 (connection, read) timeouts.
4752        :type _request_timeout: int, tuple(int, int), optional
4753        :param _request_auth: set to override the auth_settings for an a single
4754                              request; this effectively ignores the
4755                              authentication in the spec for a single request.
4756        :type _request_auth: dict, optional
4757        :param _content_type: force content-type for the request.
4758        :type _content_type: str, Optional
4759        :param _headers: set to override the headers for a single
4760                         request; this effectively ignores the headers
4761                         in the spec for a single request.
4762        :type _headers: dict, optional
4763        :param _host_index: set to override the host_index for a single
4764                            request; this effectively ignores the host_index
4765                            in the spec for a single request.
4766        :type _host_index: int, optional
4767        :return: Returns the result object.
4768        """  # noqa: E501
4769
4770        _param = self._create_case_serialize(
4771            org_id=org_id,
4772            case_request=case_request,
4773            _request_auth=_request_auth,
4774            _content_type=_content_type,
4775            _headers=_headers,
4776            _host_index=_host_index,
4777        )
4778
4779        _response_types_map: Dict[str, Optional[str]] = {
4780            "200": "CaseResponse",
4781            "400": None,
4782            "401": None,
4783            "403": None,
4784            "404": None,
4785            "429": None,
4786        }
4787        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4788        response_data.read()
4789        return self.api_client.response_deserialize(
4790            response_data=response_data,
4791            response_types_map=_response_types_map,
4792        ).data

Create case

Creating a case for legal hold is the first critical step in the eDiscovery process when litigation or an investigation is anticipated. One of the purposes of creating a case is that it acts as a container that allows admins to group multiple legal holds under one case. For more information, see our Help Center page on creating a case.

This API creates a new 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 in which you want to create a new case. (required) :type org_id: str :param case_request: (required) :type case_request: CaseRequest :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_legal_hold( self, org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization in which you want to create a new legal hold.', metadata=[Strict(strict=True)])], case_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the case in which you want to create a new legal hold.', metadata=[Strict(strict=True)])], legal_hold_request: miro_api.models.legal_hold_request.LegalHoldRequest, _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

4854    @validate_call
4855    def create_legal_hold(
4856        self,
4857        org_id: Annotated[
4858            str,
4859            Field(strict=True, description="The ID of the organization in which you want to create a new legal hold."),
4860        ],
4861        case_id: Annotated[
4862            str, Field(strict=True, description="The ID of the case in which you want to create a new legal hold.")
4863        ],
4864        legal_hold_request: LegalHoldRequest,
4865        _request_timeout: Union[
4866            None,
4867            Annotated[StrictFloat, Field(gt=0)],
4868            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
4869        ] = None,
4870        _request_auth: Optional[Dict[StrictStr, Any]] = None,
4871        _content_type: Optional[StrictStr] = None,
4872        _headers: Optional[Dict[StrictStr, Any]] = None,
4873        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4874    ) -> LegalHoldResponse:
4875        """Create legal hold
4876
4877        After creating a case it is possible to add one or multiple legal holds to the case. Creating a legal hold involves identifying the relevant users associated with a case and applying the hold to prevent permanent deletion of content that those users own, co-own, create, edit or access. For more information, see our <a href=\"https://help.miro.com/hc/en-us/articles/22120471564946-Add-a-legal-hold-to-a-case\" target=_blank>Help Center page on adding a legal hold to a case</a>. <br><br>This API creates a new legal hold in a case for an organization. Newly created legal holds could take up to 24 hours to be processed.<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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
4878
4879        :param org_id: The ID of the organization in which you want to create a new legal hold. (required)
4880        :type org_id: str
4881        :param case_id: The ID of the case in which you want to create a new legal hold. (required)
4882        :type case_id: str
4883        :param legal_hold_request: (required)
4884        :type legal_hold_request: LegalHoldRequest
4885        :param _request_timeout: timeout setting for this request. If one
4886                                 number provided, it will be total request
4887                                 timeout. It can also be a pair (tuple) of
4888                                 (connection, read) timeouts.
4889        :type _request_timeout: int, tuple(int, int), optional
4890        :param _request_auth: set to override the auth_settings for an a single
4891                              request; this effectively ignores the
4892                              authentication in the spec for a single request.
4893        :type _request_auth: dict, optional
4894        :param _content_type: force content-type for the request.
4895        :type _content_type: str, Optional
4896        :param _headers: set to override the headers for a single
4897                         request; this effectively ignores the headers
4898                         in the spec for a single request.
4899        :type _headers: dict, optional
4900        :param _host_index: set to override the host_index for a single
4901                            request; this effectively ignores the host_index
4902                            in the spec for a single request.
4903        :type _host_index: int, optional
4904        :return: Returns the result object.
4905        """  # noqa: E501
4906
4907        _param = self._create_legal_hold_serialize(
4908            org_id=org_id,
4909            case_id=case_id,
4910            legal_hold_request=legal_hold_request,
4911            _request_auth=_request_auth,
4912            _content_type=_content_type,
4913            _headers=_headers,
4914            _host_index=_host_index,
4915        )
4916
4917        _response_types_map: Dict[str, Optional[str]] = {
4918            "200": "LegalHoldResponse",
4919            "400": None,
4920            "401": None,
4921            "403": None,
4922            "404": None,
4923            "429": None,
4924        }
4925        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
4926        response_data.read()
4927        return self.api_client.response_deserialize(
4928            response_data=response_data,
4929            response_types_map=_response_types_map,
4930        ).data

Create legal hold

After creating a case it is possible to add one or multiple legal holds to the case. Creating a legal hold involves identifying the relevant users associated with a case and applying the hold to prevent permanent deletion of content that those users own, co-own, create, edit or access. For more information, see our Help Center page on adding a legal hold to a case.

This API creates a new legal hold in a case for an organization. Newly created legal holds could take up to 24 hours to be processed.

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 in which you want to create a new legal hold. (required) :type org_id: str :param case_id: The ID of the case in which you want to create a new legal hold. (required) :type case_id: str :param legal_hold_request: (required) :type legal_hold_request: LegalHoldRequest :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_case( self, org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization in which you want to close a case.', metadata=[Strict(strict=True)])], case_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the case you want to close.', 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) -> None: View Source

4995    @validate_call
4996    def delete_case(
4997        self,
4998        org_id: Annotated[
4999            str, Field(strict=True, description="The ID of the organization in which you want to close a case.")
5000        ],
5001        case_id: Annotated[str, Field(strict=True, description="The ID of the case you want to close.")],
5002        _request_timeout: Union[
5003            None,
5004            Annotated[StrictFloat, Field(gt=0)],
5005            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5006        ] = None,
5007        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5008        _content_type: Optional[StrictStr] = None,
5009        _headers: Optional[Dict[StrictStr, Any]] = None,
5010        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5011    ) -> None:
5012        """Close case
5013
5014        Closing a case is the final stage in the eDiscovery process, marking the conclusion of a legal matter or investigation. You must ensure that all associated legal holds within the case are closed before closing the case. Closing a case will permanently delete it. For more information, see our <a href=\"https://help.miro.com/hc/en-us/articles/22138936297746-Close-a-case\" target=_blank>Help Center page on closing a case</a>. <br><br>This API closes 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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
5015
5016        :param org_id: The ID of the organization in which you want to close a case. (required)
5017        :type org_id: str
5018        :param case_id: The ID of the case you want to close. (required)
5019        :type case_id: str
5020        :param _request_timeout: timeout setting for this request. If one
5021                                 number provided, it will be total request
5022                                 timeout. It can also be a pair (tuple) of
5023                                 (connection, read) timeouts.
5024        :type _request_timeout: int, tuple(int, int), optional
5025        :param _request_auth: set to override the auth_settings for an a single
5026                              request; this effectively ignores the
5027                              authentication in the spec for a single request.
5028        :type _request_auth: dict, optional
5029        :param _content_type: force content-type for the request.
5030        :type _content_type: str, Optional
5031        :param _headers: set to override the headers for a single
5032                         request; this effectively ignores the headers
5033                         in the spec for a single request.
5034        :type _headers: dict, optional
5035        :param _host_index: set to override the host_index for a single
5036                            request; this effectively ignores the host_index
5037                            in the spec for a single request.
5038        :type _host_index: int, optional
5039        :return: Returns the result object.
5040        """  # noqa: E501
5041
5042        _param = self._delete_case_serialize(
5043            org_id=org_id,
5044            case_id=case_id,
5045            _request_auth=_request_auth,
5046            _content_type=_content_type,
5047            _headers=_headers,
5048            _host_index=_host_index,
5049        )
5050
5051        _response_types_map: Dict[str, Optional[str]] = {
5052            "204": None,
5053            "400": None,
5054            "401": None,
5055            "403": None,
5056            "404": None,
5057            "429": None,
5058        }
5059        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5060        response_data.read()
5061        return self.api_client.response_deserialize(
5062            response_data=response_data,
5063            response_types_map=_response_types_map,
5064        ).data

Close case

Closing a case is the final stage in the eDiscovery process, marking the conclusion of a legal matter or investigation. You must ensure that all associated legal holds within the case are closed before closing the case. Closing a case will permanently delete it. For more information, see our Help Center page on closing a case.

This API closes 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 in which you want to close a case. (required) :type org_id: str :param case_id: The ID of the case you want to close. (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 delete_legal_hold( self, org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization in which you want to close a legal hold.', metadata=[Strict(strict=True)])], case_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the case in which you want to close a legal hold.', 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 close.', 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) -> None: View Source

5115    @validate_call
5116    def delete_legal_hold(
5117        self,
5118        org_id: Annotated[
5119            str, Field(strict=True, description="The ID of the organization in which you want to close a legal hold.")
5120        ],
5121        case_id: Annotated[
5122            str, Field(strict=True, description="The ID of the case in which you want to close a legal hold.")
5123        ],
5124        legal_hold_id: Annotated[str, Field(strict=True, description="The ID of the legal hold you want to close.")],
5125        _request_timeout: Union[
5126            None,
5127            Annotated[StrictFloat, Field(gt=0)],
5128            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5129        ] = None,
5130        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5131        _content_type: Optional[StrictStr] = None,
5132        _headers: Optional[Dict[StrictStr, Any]] = None,
5133        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5134    ) -> None:
5135        """Close legal hold
5136
5137        Closing a legal hold is one of the final steps in the eDiscovery process once the litigation or investigation has concluded. This process involves releasing the Miro boards and custodians that were under legal hold, allowing the preserved boards to return to normal operations. Closing a legal hold will permanently delete it. For more information, see our <a href=\"https://help.miro.com/hc/en-us/articles/21922521629330-Close-a-legal-hold\" target=_blank>Help Center page on closing a legal hold</a>. <br><br>This API closes a legal hold in a case for an organization. Once a legal hold is closed, it can take up to 24 hours to release the content items from the legal 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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
5138
5139        :param org_id: The ID of the organization in which you want to close a legal hold. (required)
5140        :type org_id: str
5141        :param case_id: The ID of the case in which you want to close a legal hold. (required)
5142        :type case_id: str
5143        :param legal_hold_id: The ID of the legal hold you want to close. (required)
5144        :type legal_hold_id: str
5145        :param _request_timeout: timeout setting for this request. If one
5146                                 number provided, it will be total request
5147                                 timeout. It can also be a pair (tuple) of
5148                                 (connection, read) timeouts.
5149        :type _request_timeout: int, tuple(int, int), optional
5150        :param _request_auth: set to override the auth_settings for an a single
5151                              request; this effectively ignores the
5152                              authentication in the spec for a single request.
5153        :type _request_auth: dict, optional
5154        :param _content_type: force content-type for the request.
5155        :type _content_type: str, Optional
5156        :param _headers: set to override the headers for a single
5157                         request; this effectively ignores the headers
5158                         in the spec for a single request.
5159        :type _headers: dict, optional
5160        :param _host_index: set to override the host_index for a single
5161                            request; this effectively ignores the host_index
5162                            in the spec for a single request.
5163        :type _host_index: int, optional
5164        :return: Returns the result object.
5165        """  # noqa: E501
5166
5167        _param = self._delete_legal_hold_serialize(
5168            org_id=org_id,
5169            case_id=case_id,
5170            legal_hold_id=legal_hold_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            "204": None,
5179            "400": None,
5180            "401": None,
5181            "403": None,
5182            "404": None,
5183            "429": None,
5184        }
5185        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5186        response_data.read()
5187        return self.api_client.response_deserialize(
5188            response_data=response_data,
5189            response_types_map=_response_types_map,
5190        ).data

Close legal hold

Closing a legal hold is one of the final steps in the eDiscovery process once the litigation or investigation has concluded. This process involves releasing the Miro boards and custodians that were under legal hold, allowing the preserved boards to return to normal operations. Closing a legal hold will permanently delete it. For more information, see our Help Center page on closing a legal hold.

This API closes a legal hold in a case for an organization. Once a legal hold is closed, it can take up to 24 hours to release the content items from the legal 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 in which you want to close a legal hold. (required) :type org_id: str :param case_id: The ID of the case in which you want to close a legal hold. (required) :type case_id: str :param legal_hold_id: The ID of the legal hold you want to close. (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 edit_case( self, org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization for which you want to edit 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 edit.', metadata=[Strict(strict=True)])], case_request: miro_api.models.case_request.CaseRequest, _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

5244    @validate_call
5245    def edit_case(
5246        self,
5247        org_id: Annotated[
5248            str,
5249            Field(
5250                strict=True, description="The ID of the organization for which you want to edit the case information."
5251            ),
5252        ],
5253        case_id: Annotated[str, Field(strict=True, description="The ID of the case you want to edit.")],
5254        case_request: CaseRequest,
5255        _request_timeout: Union[
5256            None,
5257            Annotated[StrictFloat, Field(gt=0)],
5258            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5259        ] = None,
5260        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5261        _content_type: Optional[StrictStr] = None,
5262        _headers: Optional[Dict[StrictStr, Any]] = None,
5263        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5264    ) -> CaseResponse:
5265        """Edit case
5266
5267        Editing a case allows eDiscovery Admins to keep case details accurate and aligned with the evolving scope of a legal matter. As investigations progress, it may be necessary to update the case name or description to reflect changes in focus, terminology, or internal documentation standards. Since a case serves as the central container for one or more legal holds, keeping its information up to date helps ensure clarity, consistency, and easier navigation for all stakeholders involved in the legal process.<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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
5268
5269        :param org_id: The ID of the organization for which you want to edit the case information. (required)
5270        :type org_id: str
5271        :param case_id: The ID of the case you want to edit. (required)
5272        :type case_id: str
5273        :param case_request: (required)
5274        :type case_request: CaseRequest
5275        :param _request_timeout: timeout setting for this request. If one
5276                                 number provided, it will be total request
5277                                 timeout. It can also be a pair (tuple) of
5278                                 (connection, read) timeouts.
5279        :type _request_timeout: int, tuple(int, int), optional
5280        :param _request_auth: set to override the auth_settings for an a single
5281                              request; this effectively ignores the
5282                              authentication in the spec for a single request.
5283        :type _request_auth: dict, optional
5284        :param _content_type: force content-type for the request.
5285        :type _content_type: str, Optional
5286        :param _headers: set to override the headers for a single
5287                         request; this effectively ignores the headers
5288                         in the spec for a single request.
5289        :type _headers: dict, optional
5290        :param _host_index: set to override the host_index for a single
5291                            request; this effectively ignores the host_index
5292                            in the spec for a single request.
5293        :type _host_index: int, optional
5294        :return: Returns the result object.
5295        """  # noqa: E501
5296
5297        _param = self._edit_case_serialize(
5298            org_id=org_id,
5299            case_id=case_id,
5300            case_request=case_request,
5301            _request_auth=_request_auth,
5302            _content_type=_content_type,
5303            _headers=_headers,
5304            _host_index=_host_index,
5305        )
5306
5307        _response_types_map: Dict[str, Optional[str]] = {
5308            "200": "CaseResponse",
5309            "400": None,
5310            "401": None,
5311            "403": None,
5312            "404": None,
5313            "429": None,
5314        }
5315        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5316        response_data.read()
5317        return self.api_client.response_deserialize(
5318            response_data=response_data,
5319            response_types_map=_response_types_map,
5320        ).data

Edit case

Editing a case allows eDiscovery Admins to keep case details accurate and aligned with the evolving scope of a legal matter. As investigations progress, it may be necessary to update the case name or description to reflect changes in focus, terminology, or internal documentation standards. Since a case serves as the central container for one or more legal holds, keeping its information up to date helps ensure clarity, consistency, and easier navigation for all stakeholders involved in the legal process.

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 edit the case information. (required) :type org_id: str :param case_id: The ID of the case you want to edit. (required) :type case_id: str :param case_request: (required) :type case_request: CaseRequest :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 edit_legal_hold( self, org_id: typing.Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The ID of the organization for which you want to edit 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 edit 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 edit.', metadata=[Strict(strict=True)])], legal_hold_request: miro_api.models.legal_hold_request.LegalHoldRequest, _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

5385    @validate_call
5386    def edit_legal_hold(
5387        self,
5388        org_id: Annotated[
5389            str,
5390            Field(
5391                strict=True,
5392                description="The ID of the organization for which you want to edit the legal hold information.",
5393            ),
5394        ],
5395        case_id: Annotated[
5396            str,
5397            Field(strict=True, description="The ID of the case for which you want to edit the legal hold information."),
5398        ],
5399        legal_hold_id: Annotated[str, Field(strict=True, description="The ID of the legal hold you want to edit.")],
5400        legal_hold_request: LegalHoldRequest,
5401        _request_timeout: Union[
5402            None,
5403            Annotated[StrictFloat, Field(gt=0)],
5404            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5405        ] = None,
5406        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5407        _content_type: Optional[StrictStr] = None,
5408        _headers: Optional[Dict[StrictStr, Any]] = None,
5409        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5410    ) -> LegalHoldResponse:
5411        """Edit legal hold
5412
5413        Editing a legal hold allows eDiscovery Admins to adjust and refine ongoing legal preservation efforts as case requirements evolve. Whether new custodians are identified, additional Miro boards become relevant, or existing boards or users are no longer in scope, editing a legal hold ensures that the correct data remains preserved and defensible throughout the legal process. Admins can update the legal hold’s name or description and add or remove users and boards as needed. This flexibility supports dynamic legal workflows and ensures that preservation stays precise, up to date, and aligned with the scope of the legal matter—maintaining compliance while avoiding unnecessary data retention.<br/><br/>When a legal hold is edited, boards newly added to the hold will begin having their versions preserved from that point forward, boards or users removed from the hold will stop being preserved, and their versions will no longer be preserved as part of that legal hold, boards that remain under hold will continue to have all versions preserved, including any deletions that occur after the hold was applied. This approach ensures organizations can respond to legal demands with accuracy and accountability as a case evolves.<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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
5414
5415        :param org_id: The ID of the organization for which you want to edit the legal hold information. (required)
5416        :type org_id: str
5417        :param case_id: The ID of the case for which you want to edit the legal hold information. (required)
5418        :type case_id: str
5419        :param legal_hold_id: The ID of the legal hold you want to edit. (required)
5420        :type legal_hold_id: str
5421        :param legal_hold_request: (required)
5422        :type legal_hold_request: LegalHoldRequest
5423        :param _request_timeout: timeout setting for this request. If one
5424                                 number provided, it will be total request
5425                                 timeout. It can also be a pair (tuple) of
5426                                 (connection, read) timeouts.
5427        :type _request_timeout: int, tuple(int, int), optional
5428        :param _request_auth: set to override the auth_settings for an a single
5429                              request; this effectively ignores the
5430                              authentication in the spec for a single request.
5431        :type _request_auth: dict, optional
5432        :param _content_type: force content-type for the request.
5433        :type _content_type: str, Optional
5434        :param _headers: set to override the headers for a single
5435                         request; this effectively ignores the headers
5436                         in the spec for a single request.
5437        :type _headers: dict, optional
5438        :param _host_index: set to override the host_index for a single
5439                            request; this effectively ignores the host_index
5440                            in the spec for a single request.
5441        :type _host_index: int, optional
5442        :return: Returns the result object.
5443        """  # noqa: E501
5444
5445        _param = self._edit_legal_hold_serialize(
5446            org_id=org_id,
5447            case_id=case_id,
5448            legal_hold_id=legal_hold_id,
5449            legal_hold_request=legal_hold_request,
5450            _request_auth=_request_auth,
5451            _content_type=_content_type,
5452            _headers=_headers,
5453            _host_index=_host_index,
5454        )
5455
5456        _response_types_map: Dict[str, Optional[str]] = {
5457            "200": "LegalHoldResponse",
5458            "400": None,
5459            "401": None,
5460            "403": None,
5461            "404": None,
5462            "429": None,
5463        }
5464        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5465        response_data.read()
5466        return self.api_client.response_deserialize(
5467            response_data=response_data,
5468            response_types_map=_response_types_map,
5469        ).data

Edit legal hold

Editing a legal hold allows eDiscovery Admins to adjust and refine ongoing legal preservation efforts as case requirements evolve. Whether new custodians are identified, additional Miro boards become relevant, or existing boards or users are no longer in scope, editing a legal hold ensures that the correct data remains preserved and defensible throughout the legal process. Admins can update the legal hold’s name or description and add or remove users and boards as needed. This flexibility supports dynamic legal workflows and ensures that preservation stays precise, up to date, and aligned with the scope of the legal matter—maintaining compliance while avoiding unnecessary data retention.

When a legal hold is edited, boards newly added to the hold will begin having their versions preserved from that point forward, boards or users removed from the hold will stop being preserved, and their versions will no longer be preserved as part of that legal hold, boards that remain under hold will continue to have all versions preserved, including any deletions that occur after the hold was applied. This approach ensures organizations can respond to legal demands with accuracy and accountability as a case evolves.

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 edit the legal hold information. (required) :type org_id: str :param case_id: The ID of the case for which you want to edit the legal hold information. (required) :type case_id: str :param legal_hold_id: The ID of the legal hold you want to edit. (required) :type legal_hold_id: str :param legal_hold_request: (required) :type legal_hold_request: LegalHoldRequest :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, 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)])], 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 items in the result list.')] = 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.paginated_case_response.PaginatedCaseResponse: View Source

5537    @validate_call
5538    def get_all_cases(
5539        self,
5540        org_id: Annotated[
5541            str,
5542            Field(
5543                strict=True, description="The ID of the organization for which you want to retrieve the list of cases."
5544            ),
5545        ],
5546        limit: Annotated[
5547            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
5548            Field(description="The maximum number of items in the result list."),
5549        ] = None,
5550        cursor: Annotated[
5551            Optional[StrictStr],
5552            Field(
5553                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. "
5554            ),
5555        ] = None,
5556        _request_timeout: Union[
5557            None,
5558            Annotated[StrictFloat, Field(gt=0)],
5559            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5560        ] = None,
5561        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5562        _content_type: Optional[StrictStr] = None,
5563        _headers: Optional[Dict[StrictStr, Any]] = None,
5564        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5565    ) -> PaginatedCaseResponse:
5566        """Get all cases
5567
5568        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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
5569
5570        :param org_id: The ID of the organization for which you want to retrieve the list of cases. (required)
5571        :type org_id: str
5572        :param limit: The maximum number of items in the result list.
5573        :type limit: int
5574        :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.
5575        :type cursor: str
5576        :param _request_timeout: timeout setting for this request. If one
5577                                 number provided, it will be total request
5578                                 timeout. It can also be a pair (tuple) of
5579                                 (connection, read) timeouts.
5580        :type _request_timeout: int, tuple(int, int), optional
5581        :param _request_auth: set to override the auth_settings for an a single
5582                              request; this effectively ignores the
5583                              authentication in the spec for a single request.
5584        :type _request_auth: dict, optional
5585        :param _content_type: force content-type for the request.
5586        :type _content_type: str, Optional
5587        :param _headers: set to override the headers for a single
5588                         request; this effectively ignores the headers
5589                         in the spec for a single request.
5590        :type _headers: dict, optional
5591        :param _host_index: set to override the host_index for a single
5592                            request; this effectively ignores the host_index
5593                            in the spec for a single request.
5594        :type _host_index: int, optional
5595        :return: Returns the result object.
5596        """  # noqa: E501
5597
5598        _param = self._get_all_cases_serialize(
5599            org_id=org_id,
5600            limit=limit,
5601            cursor=cursor,
5602            _request_auth=_request_auth,
5603            _content_type=_content_type,
5604            _headers=_headers,
5605            _host_index=_host_index,
5606        )
5607
5608        _response_types_map: Dict[str, Optional[str]] = {
5609            "200": "PaginatedCaseResponse",
5610            "400": None,
5611            "401": None,
5612            "403": None,
5613            "404": None,
5614            "429": None,
5615        }
5616        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5617        response_data.read()
5618        return self.api_client.response_deserialize(
5619            response_data=response_data,
5620            response_types_map=_response_types_map,
5621        ).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 org_id: The ID of the organization for which you want to retrieve the list of cases. (required) :type org_id: str :param limit: The maximum number of items in the result list. :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 get_all_legal_holds( 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 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)])], 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 items in the result list.')] = 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.paginated_legal_hold_response.PaginatedLegalHoldResponse: View Source

5682    @validate_call
5683    def get_all_legal_holds(
5684        self,
5685        org_id: Annotated[
5686            str,
5687            Field(
5688                strict=True,
5689                description="The ID of the organization for which you want to retrieve the list of legal holds within a case.",
5690            ),
5691        ],
5692        case_id: Annotated[
5693            str,
5694            Field(
5695                strict=True, description="The ID of the case for which you want to retrieve the list of legal holds."
5696            ),
5697        ],
5698        limit: Annotated[
5699            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
5700            Field(description="The maximum number of items in the result list."),
5701        ] = None,
5702        cursor: Annotated[
5703            Optional[StrictStr],
5704            Field(
5705                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. "
5706            ),
5707        ] = None,
5708        _request_timeout: Union[
5709            None,
5710            Annotated[StrictFloat, Field(gt=0)],
5711            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5712        ] = None,
5713        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5714        _content_type: Optional[StrictStr] = None,
5715        _headers: Optional[Dict[StrictStr, Any]] = None,
5716        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5717    ) -> PaginatedLegalHoldResponse:
5718        """Get all legal holds within a case
5719
5720        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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
5721
5722        :param org_id: The ID of the organization for which you want to retrieve the list of legal holds within a case. (required)
5723        :type org_id: str
5724        :param case_id: The ID of the case for which you want to retrieve the list of legal holds. (required)
5725        :type case_id: str
5726        :param limit: The maximum number of items in the result list.
5727        :type limit: int
5728        :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.
5729        :type cursor: str
5730        :param _request_timeout: timeout setting for this request. If one
5731                                 number provided, it will be total request
5732                                 timeout. It can also be a pair (tuple) of
5733                                 (connection, read) timeouts.
5734        :type _request_timeout: int, tuple(int, int), optional
5735        :param _request_auth: set to override the auth_settings for an a single
5736                              request; this effectively ignores the
5737                              authentication in the spec for a single request.
5738        :type _request_auth: dict, optional
5739        :param _content_type: force content-type for the request.
5740        :type _content_type: str, Optional
5741        :param _headers: set to override the headers for a single
5742                         request; this effectively ignores the headers
5743                         in the spec for a single request.
5744        :type _headers: dict, optional
5745        :param _host_index: set to override the host_index for a single
5746                            request; this effectively ignores the host_index
5747                            in the spec for a single request.
5748        :type _host_index: int, optional
5749        :return: Returns the result object.
5750        """  # noqa: E501
5751
5752        _param = self._get_all_legal_holds_serialize(
5753            org_id=org_id,
5754            case_id=case_id,
5755            limit=limit,
5756            cursor=cursor,
5757            _request_auth=_request_auth,
5758            _content_type=_content_type,
5759            _headers=_headers,
5760            _host_index=_host_index,
5761        )
5762
5763        _response_types_map: Dict[str, Optional[str]] = {
5764            "200": "PaginatedLegalHoldResponse",
5765            "400": None,
5766            "401": None,
5767            "403": None,
5768            "404": None,
5769            "429": None,
5770        }
5771        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
5772        response_data.read()
5773        return self.api_client.response_deserialize(
5774            response_data=response_data,
5775            response_types_map=_response_types_map,
5776        ).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 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 limit: The maximum number of items in the result list. :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 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

5840    @validate_call
5841    def get_case(
5842        self,
5843        org_id: Annotated[
5844            str,
5845            Field(
5846                strict=True,
5847                description="The ID of the organization for which you want to retrieve the case information.",
5848            ),
5849        ],
5850        case_id: Annotated[str, Field(strict=True, description="The ID of the case you want to retrieve.")],
5851        _request_timeout: Union[
5852            None,
5853            Annotated[StrictFloat, Field(gt=0)],
5854            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5855        ] = None,
5856        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5857        _content_type: Optional[StrictStr] = None,
5858        _headers: Optional[Dict[StrictStr, Any]] = None,
5859        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5860    ) -> CaseResponse:
5861        """Get case
5862
5863        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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
5864
5865        :param org_id: The ID of the organization for which you want to retrieve the case information. (required)
5866        :type org_id: str
5867        :param case_id: The ID of the case you want to retrieve. (required)
5868        :type case_id: str
5869        :param _request_timeout: timeout setting for this request. If one
5870                                 number provided, it will be total request
5871                                 timeout. It can also be a pair (tuple) of
5872                                 (connection, read) timeouts.
5873        :type _request_timeout: int, tuple(int, int), optional
5874        :param _request_auth: set to override the auth_settings for an a single
5875                              request; this effectively ignores the
5876                              authentication in the spec for a single request.
5877        :type _request_auth: dict, optional
5878        :param _content_type: force content-type for the request.
5879        :type _content_type: str, Optional
5880        :param _headers: set to override the headers for a single
5881                         request; this effectively ignores the headers
5882                         in the spec for a single request.
5883        :type _headers: dict, optional
5884        :param _host_index: set to override the host_index for a single
5885                            request; this effectively ignores the host_index
5886                            in the spec for a single request.
5887        :type _host_index: int, optional
5888        :return: Returns the result object.
5889        """  # noqa: E501
5890
5891        _param = self._get_case_serialize(
5892            org_id=org_id,
5893            case_id=case_id,
5894            _request_auth=_request_auth,
5895            _content_type=_content_type,
5896            _headers=_headers,
5897            _host_index=_host_index,
5898        )
5899
5900        _response_types_map: Dict[str, Optional[str]] = {
5901            "200": "CaseResponse",
5902            "400": None,
5903            "401": None,
5904            "403": None,
5905            "404": None,
5906            "429": None,
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

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

5967    @validate_call
5968    def get_legal_hold(
5969        self,
5970        org_id: Annotated[
5971            str,
5972            Field(
5973                strict=True,
5974                description="The ID of the organization for which you want to retrieve the legal hold information.",
5975            ),
5976        ],
5977        case_id: Annotated[
5978            str,
5979            Field(
5980                strict=True, description="The ID of the case for which you want to retrieve the legal hold information."
5981            ),
5982        ],
5983        legal_hold_id: Annotated[str, Field(strict=True, description="The ID of the legal hold you want to retrieve.")],
5984        _request_timeout: Union[
5985            None,
5986            Annotated[StrictFloat, Field(gt=0)],
5987            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
5988        ] = None,
5989        _request_auth: Optional[Dict[StrictStr, Any]] = None,
5990        _content_type: Optional[StrictStr] = None,
5991        _headers: Optional[Dict[StrictStr, Any]] = None,
5992        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5993    ) -> LegalHoldResponse:
5994        """Get legal hold information
5995
5996        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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
5997
5998        :param org_id: The ID of the organization for which you want to retrieve the legal hold information. (required)
5999        :type org_id: str
6000        :param case_id: The ID of the case for which you want to retrieve the legal hold information. (required)
6001        :type case_id: str
6002        :param legal_hold_id: The ID of the legal hold you want to retrieve. (required)
6003        :type legal_hold_id: str
6004        :param _request_timeout: timeout setting for this request. If one
6005                                 number provided, it will be total request
6006                                 timeout. It can also be a pair (tuple) of
6007                                 (connection, read) timeouts.
6008        :type _request_timeout: int, tuple(int, int), optional
6009        :param _request_auth: set to override the auth_settings for an a single
6010                              request; this effectively ignores the
6011                              authentication in the spec for a single request.
6012        :type _request_auth: dict, optional
6013        :param _content_type: force content-type for the request.
6014        :type _content_type: str, Optional
6015        :param _headers: set to override the headers for a single
6016                         request; this effectively ignores the headers
6017                         in the spec for a single request.
6018        :type _headers: dict, optional
6019        :param _host_index: set to override the host_index for a single
6020                            request; this effectively ignores the host_index
6021                            in the spec for a single request.
6022        :type _host_index: int, optional
6023        :return: Returns the result object.
6024        """  # noqa: E501
6025
6026        _param = self._get_legal_hold_serialize(
6027            org_id=org_id,
6028            case_id=case_id,
6029            legal_hold_id=legal_hold_id,
6030            _request_auth=_request_auth,
6031            _content_type=_content_type,
6032            _headers=_headers,
6033            _host_index=_host_index,
6034        )
6035
6036        _response_types_map: Dict[str, Optional[str]] = {
6037            "200": "LegalHoldResponse",
6038            "400": None,
6039            "401": None,
6040            "403": None,
6041            "404": None,
6042            "429": None,
6043        }
6044        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6045        response_data.read()
6046        return self.api_client.response_deserialize(
6047            response_data=response_data,
6048            response_types_map=_response_types_map,
6049        ).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: 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 items in the result list.')] = 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.paginated_legal_hold_content_items_response.PaginatedLegalHoldContentItemsResponse: View Source

6106    @validate_call
6107    def get_legal_hold_content_items(
6108        self,
6109        org_id: Annotated[
6110            str,
6111            Field(
6112                strict=True,
6113                description="The ID of the organization for which you want to retrieve the list of content items under hold.",
6114            ),
6115        ],
6116        case_id: Annotated[
6117            str,
6118            Field(
6119                strict=True,
6120                description="The ID of the case for which you want to retrieve the list of content items under hold.",
6121            ),
6122        ],
6123        legal_hold_id: Annotated[
6124            str,
6125            Field(
6126                strict=True,
6127                description="The ID of the legal hold for which you want to retrieve the list of content items under hold.",
6128            ),
6129        ],
6130        limit: Annotated[
6131            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
6132            Field(description="The maximum number of items in the result list."),
6133        ] = None,
6134        cursor: Annotated[
6135            Optional[StrictStr],
6136            Field(
6137                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. "
6138            ),
6139        ] = None,
6140        _request_timeout: Union[
6141            None,
6142            Annotated[StrictFloat, Field(gt=0)],
6143            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6144        ] = None,
6145        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6146        _content_type: Optional[StrictStr] = None,
6147        _headers: Optional[Dict[StrictStr, Any]] = None,
6148        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6149    ) -> PaginatedLegalHoldContentItemsResponse:
6150        """Get content items under legal hold
6151
6152        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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
6153
6154        :param org_id: The ID of the organization for which you want to retrieve the list of content items under hold. (required)
6155        :type org_id: str
6156        :param case_id: The ID of the case for which you want to retrieve the list of content items under hold. (required)
6157        :type case_id: str
6158        :param legal_hold_id: The ID of the legal hold for which you want to retrieve the list of content items under hold. (required)
6159        :type legal_hold_id: str
6160        :param limit: The maximum number of items in the result list.
6161        :type limit: int
6162        :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.
6163        :type cursor: str
6164        :param _request_timeout: timeout setting for this request. If one
6165                                 number provided, it will be total request
6166                                 timeout. It can also be a pair (tuple) of
6167                                 (connection, read) timeouts.
6168        :type _request_timeout: int, tuple(int, int), optional
6169        :param _request_auth: set to override the auth_settings for an a single
6170                              request; this effectively ignores the
6171                              authentication in the spec for a single request.
6172        :type _request_auth: dict, optional
6173        :param _content_type: force content-type for the request.
6174        :type _content_type: str, Optional
6175        :param _headers: set to override the headers for a single
6176                         request; this effectively ignores the headers
6177                         in the spec for a single request.
6178        :type _headers: dict, optional
6179        :param _host_index: set to override the host_index for a single
6180                            request; this effectively ignores the host_index
6181                            in the spec for a single request.
6182        :type _host_index: int, optional
6183        :return: Returns the result object.
6184        """  # noqa: E501
6185
6186        _param = self._get_legal_hold_content_items_serialize(
6187            org_id=org_id,
6188            case_id=case_id,
6189            legal_hold_id=legal_hold_id,
6190            limit=limit,
6191            cursor=cursor,
6192            _request_auth=_request_auth,
6193            _content_type=_content_type,
6194            _headers=_headers,
6195            _host_index=_host_index,
6196        )
6197
6198        _response_types_map: Dict[str, Optional[str]] = {
6199            "200": "PaginatedLegalHoldContentItemsResponse",
6200            "400": None,
6201            "401": None,
6202            "403": None,
6203            "404": None,
6204            "429": None,
6205        }
6206        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6207        response_data.read()
6208        return self.api_client.response_deserialize(
6209            response_data=response_data,
6210            response_types_map=_response_types_map,
6211        ).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. :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 get_legal_hold_export_jobs( 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 export jobs 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 export jobs.', metadata=[Strict(strict=True)])], 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 items in the result list.')] = 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.paginated_case_export_jobs_response.PaginatedCaseExportJobsResponse: View Source

6278    @validate_call
6279    def get_legal_hold_export_jobs(
6280        self,
6281        org_id: Annotated[
6282            str,
6283            Field(
6284                strict=True,
6285                description="The ID of the organization for which you want to retrieve the list of export jobs within a case.",
6286            ),
6287        ],
6288        case_id: Annotated[
6289            str,
6290            Field(
6291                strict=True, description="The ID of the case for which you want to retrieve the list of export jobs."
6292            ),
6293        ],
6294        limit: Annotated[
6295            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
6296            Field(description="The maximum number of items in the result list."),
6297        ] = None,
6298        cursor: Annotated[
6299            Optional[StrictStr],
6300            Field(
6301                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. "
6302            ),
6303        ] = None,
6304        _request_timeout: Union[
6305            None,
6306            Annotated[StrictFloat, Field(gt=0)],
6307            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6308        ] = None,
6309        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6310        _content_type: Optional[StrictStr] = None,
6311        _headers: Optional[Dict[StrictStr, Any]] = None,
6312        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6313    ) -> PaginatedCaseExportJobsResponse:
6314        """Get board export jobs of a case
6315
6316        Retrieves board export jobs for a case.<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=\"/reference/rate-limiting#rate-limit-tiers\">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#01JARF6KM8ATNT6YDMGD7GMYJN\">eDiscovery Admin</a> roles.
6317
6318        :param org_id: The ID of the organization for which you want to retrieve the list of export jobs within a case. (required)
6319        :type org_id: str
6320        :param case_id: The ID of the case for which you want to retrieve the list of export jobs. (required)
6321        :type case_id: str
6322        :param limit: The maximum number of items in the result list.
6323        :type limit: int
6324        :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.
6325        :type cursor: str
6326        :param _request_timeout: timeout setting for this request. If one
6327                                 number provided, it will be total request
6328                                 timeout. It can also be a pair (tuple) of
6329                                 (connection, read) timeouts.
6330        :type _request_timeout: int, tuple(int, int), optional
6331        :param _request_auth: set to override the auth_settings for an a single
6332                              request; this effectively ignores the
6333                              authentication in the spec for a single request.
6334        :type _request_auth: dict, optional
6335        :param _content_type: force content-type for the request.
6336        :type _content_type: str, Optional
6337        :param _headers: set to override the headers for a single
6338                         request; this effectively ignores the headers
6339                         in the spec for a single request.
6340        :type _headers: dict, optional
6341        :param _host_index: set to override the host_index for a single
6342                            request; this effectively ignores the host_index
6343                            in the spec for a single request.
6344        :type _host_index: int, optional
6345        :return: Returns the result object.
6346        """  # noqa: E501
6347
6348        _param = self._get_legal_hold_export_jobs_serialize(
6349            org_id=org_id,
6350            case_id=case_id,
6351            limit=limit,
6352            cursor=cursor,
6353            _request_auth=_request_auth,
6354            _content_type=_content_type,
6355            _headers=_headers,
6356            _host_index=_host_index,
6357        )
6358
6359        _response_types_map: Dict[str, Optional[str]] = {
6360            "200": "PaginatedCaseExportJobsResponse",
6361            "400": None,
6362            "401": None,
6363            "403": None,
6364            "404": None,
6365            "429": None,
6366        }
6367        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6368        response_data.read()
6369        return self.api_client.response_deserialize(
6370            response_data=response_data,
6371            response_types_map=_response_types_map,
6372        ).data

Get board export jobs of a case

Retrieves board export jobs for a case.

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 export jobs 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 export jobs. (required) :type case_id: str :param limit: The maximum number of items in the result list. :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

6436    @validate_call
6437    def create_mindmap_nodes_experimental(
6438        self,
6439        board_id: Annotated[
6440            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
6441        ],
6442        mindmap_create_request: MindmapCreateRequest,
6443        _request_timeout: Union[
6444            None,
6445            Annotated[StrictFloat, Field(gt=0)],
6446            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6447        ] = None,
6448        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6449        _content_type: Optional[StrictStr] = None,
6450        _headers: Optional[Dict[StrictStr, Any]] = None,
6451        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6452    ) -> MindmapItem:
6453        """Create mind map node
6454
6455        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=\"/reference/rate-limiting#rate-limit-tiers\">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.
6456
6457        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
6458        :type board_id: str
6459        :param mindmap_create_request: (required)
6460        :type mindmap_create_request: MindmapCreateRequest
6461        :param _request_timeout: timeout setting for this request. If one
6462                                 number provided, it will be total request
6463                                 timeout. It can also be a pair (tuple) of
6464                                 (connection, read) timeouts.
6465        :type _request_timeout: int, tuple(int, int), optional
6466        :param _request_auth: set to override the auth_settings for an a single
6467                              request; this effectively ignores the
6468                              authentication in the spec for a single request.
6469        :type _request_auth: dict, optional
6470        :param _content_type: force content-type for the request.
6471        :type _content_type: str, Optional
6472        :param _headers: set to override the headers for a single
6473                         request; this effectively ignores the headers
6474                         in the spec for a single request.
6475        :type _headers: dict, optional
6476        :param _host_index: set to override the host_index for a single
6477                            request; this effectively ignores the host_index
6478                            in the spec for a single request.
6479        :type _host_index: int, optional
6480        :return: Returns the result object.
6481        """  # noqa: E501
6482
6483        _param = self._create_mindmap_nodes_experimental_serialize(
6484            board_id=board_id,
6485            mindmap_create_request=mindmap_create_request,
6486            _request_auth=_request_auth,
6487            _content_type=_content_type,
6488            _headers=_headers,
6489            _host_index=_host_index,
6490        )
6491
6492        _response_types_map: Dict[str, Optional[str]] = {
6493            "201": "MindmapItem",
6494            "400": "CreateFrameItem400Response",
6495            "404": "CreateFrameItem400Response",
6496            "429": "CreateFrameItem400Response",
6497        }
6498        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6499        response_data.read()
6500        return self.api_client.response_deserialize(
6501            response_data=response_data,
6502            response_types_map=_response_types_map,
6503        ).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

6565    @validate_call
6566    def delete_mindmap_node_experimental(
6567        self,
6568        board_id: Annotated[
6569            StrictStr,
6570            Field(description="Unique identifier (ID) of the board from which you want to delete the mind map node."),
6571        ],
6572        item_id: Annotated[
6573            StrictStr, Field(description="Unique identifier (ID) of the mind map node that you want to delete.")
6574        ],
6575        _request_timeout: Union[
6576            None,
6577            Annotated[StrictFloat, Field(gt=0)],
6578            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6579        ] = None,
6580        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6581        _content_type: Optional[StrictStr] = None,
6582        _headers: Optional[Dict[StrictStr, Any]] = None,
6583        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6584    ) -> object:
6585        """Delete mind map node
6586
6587        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
6588
6589        :param board_id: Unique identifier (ID) of the board from which you want to delete the mind map node. (required)
6590        :type board_id: str
6591        :param item_id: Unique identifier (ID) of the mind map node that you want to delete. (required)
6592        :type item_id: str
6593        :param _request_timeout: timeout setting for this request. If one
6594                                 number provided, it will be total request
6595                                 timeout. It can also be a pair (tuple) of
6596                                 (connection, read) timeouts.
6597        :type _request_timeout: int, tuple(int, int), optional
6598        :param _request_auth: set to override the auth_settings for an a single
6599                              request; this effectively ignores the
6600                              authentication in the spec for a single request.
6601        :type _request_auth: dict, optional
6602        :param _content_type: force content-type for the request.
6603        :type _content_type: str, Optional
6604        :param _headers: set to override the headers for a single
6605                         request; this effectively ignores the headers
6606                         in the spec for a single request.
6607        :type _headers: dict, optional
6608        :param _host_index: set to override the host_index for a single
6609                            request; this effectively ignores the host_index
6610                            in the spec for a single request.
6611        :type _host_index: int, optional
6612        :return: Returns the result object.
6613        """  # noqa: E501
6614
6615        _param = self._delete_mindmap_node_experimental_serialize(
6616            board_id=board_id,
6617            item_id=item_id,
6618            _request_auth=_request_auth,
6619            _content_type=_content_type,
6620            _headers=_headers,
6621            _host_index=_host_index,
6622        )
6623
6624        _response_types_map: Dict[str, Optional[str]] = {
6625            "204": "object",
6626            "400": "CreateFrameItem400Response",
6627            "404": "CreateFrameItem400Response",
6628            "429": "CreateFrameItem400Response",
6629        }
6630        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6631        response_data.read()
6632        return self.api_client.response_deserialize(
6633            response_data=response_data,
6634            response_types_map=_response_types_map,
6635        ).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

6689    @validate_call
6690    def get_mindmap_node_experimental(
6691        self,
6692        board_id: Annotated[
6693            StrictStr,
6694            Field(description="Unique identifier (ID) of the board from which you want to retrieve a mind map node."),
6695        ],
6696        item_id: Annotated[
6697            StrictStr, Field(description="Unique identifier (ID) of the mind map node that you want to retrieve.")
6698        ],
6699        _request_timeout: Union[
6700            None,
6701            Annotated[StrictFloat, Field(gt=0)],
6702            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6703        ] = None,
6704        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6705        _content_type: Optional[StrictStr] = None,
6706        _headers: Optional[Dict[StrictStr, Any]] = None,
6707        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6708    ) -> MindmapItem:
6709        """Get specific mind map node
6710
6711        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
6712
6713        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a mind map node. (required)
6714        :type board_id: str
6715        :param item_id: Unique identifier (ID) of the mind map node that you want to retrieve. (required)
6716        :type item_id: str
6717        :param _request_timeout: timeout setting for this request. If one
6718                                 number provided, it will be total request
6719                                 timeout. It can also be a pair (tuple) of
6720                                 (connection, read) timeouts.
6721        :type _request_timeout: int, tuple(int, int), optional
6722        :param _request_auth: set to override the auth_settings for an a single
6723                              request; this effectively ignores the
6724                              authentication in the spec for a single request.
6725        :type _request_auth: dict, optional
6726        :param _content_type: force content-type for the request.
6727        :type _content_type: str, Optional
6728        :param _headers: set to override the headers for a single
6729                         request; this effectively ignores the headers
6730                         in the spec for a single request.
6731        :type _headers: dict, optional
6732        :param _host_index: set to override the host_index for a single
6733                            request; this effectively ignores the host_index
6734                            in the spec for a single request.
6735        :type _host_index: int, optional
6736        :return: Returns the result object.
6737        """  # noqa: E501
6738
6739        _param = self._get_mindmap_node_experimental_serialize(
6740            board_id=board_id,
6741            item_id=item_id,
6742            _request_auth=_request_auth,
6743            _content_type=_content_type,
6744            _headers=_headers,
6745            _host_index=_host_index,
6746        )
6747
6748        _response_types_map: Dict[str, Optional[str]] = {
6749            "200": "MindmapItem",
6750        }
6751        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6752        response_data.read()
6753        return self.api_client.response_deserialize(
6754            response_data=response_data,
6755            response_types_map=_response_types_map,
6756        ).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

6810    @validate_call
6811    def get_mindmap_nodes_experimental(
6812        self,
6813        board_id: Annotated[
6814            StrictStr,
6815            Field(description="Unique identifier (ID) of the board from which you want to retrieve mind map nodes."),
6816        ],
6817        limit: Annotated[Optional[StrictStr], Field(description="Maximum number of results returned")] = None,
6818        cursor: Annotated[
6819            Optional[StrictStr], Field(description="Points to the next portion of the results set")
6820        ] = None,
6821        _request_timeout: Union[
6822            None,
6823            Annotated[StrictFloat, Field(gt=0)],
6824            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6825        ] = None,
6826        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6827        _content_type: Optional[StrictStr] = None,
6828        _headers: Optional[Dict[StrictStr, Any]] = None,
6829        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6830    ) -> MindmapCursorPaged:
6831        """Get mind map nodes
6832
6833        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
6834
6835        :param board_id: Unique identifier (ID) of the board from which you want to retrieve mind map nodes. (required)
6836        :type board_id: str
6837        :param limit: Maximum number of results returned
6838        :type limit: str
6839        :param cursor: Points to the next portion of the results set
6840        :type cursor: str
6841        :param _request_timeout: timeout setting for this request. If one
6842                                 number provided, it will be total request
6843                                 timeout. It can also be a pair (tuple) of
6844                                 (connection, read) timeouts.
6845        :type _request_timeout: int, tuple(int, int), optional
6846        :param _request_auth: set to override the auth_settings for an a single
6847                              request; this effectively ignores the
6848                              authentication in the spec for a single request.
6849        :type _request_auth: dict, optional
6850        :param _content_type: force content-type for the request.
6851        :type _content_type: str, Optional
6852        :param _headers: set to override the headers for a single
6853                         request; this effectively ignores the headers
6854                         in the spec for a single request.
6855        :type _headers: dict, optional
6856        :param _host_index: set to override the host_index for a single
6857                            request; this effectively ignores the host_index
6858                            in the spec for a single request.
6859        :type _host_index: int, optional
6860        :return: Returns the result object.
6861        """  # noqa: E501
6862
6863        _param = self._get_mindmap_nodes_experimental_serialize(
6864            board_id=board_id,
6865            limit=limit,
6866            cursor=cursor,
6867            _request_auth=_request_auth,
6868            _content_type=_content_type,
6869            _headers=_headers,
6870            _host_index=_host_index,
6871        )
6872
6873        _response_types_map: Dict[str, Optional[str]] = {
6874            "200": "MindmapCursorPaged",
6875        }
6876        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6877        response_data.read()
6878        return self.api_client.response_deserialize(
6879            response_data=response_data,
6880            response_types_map=_response_types_map,
6881        ).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

6942    @validate_call
6943    def revoke_token_v2(
6944        self,
6945        revoke_token_request: RevokeTokenRequest,
6946        _request_timeout: Union[
6947            None,
6948            Annotated[StrictFloat, Field(gt=0)],
6949            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
6950        ] = None,
6951        _request_auth: Optional[Dict[StrictStr, Any]] = None,
6952        _content_type: Optional[StrictStr] = None,
6953        _headers: Optional[Dict[StrictStr, Any]] = None,
6954        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
6955    ) -> None:
6956        """Revoke token (v2)
6957
6958        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.
6959
6960        :param revoke_token_request: (required)
6961        :type revoke_token_request: RevokeTokenRequest
6962        :param _request_timeout: timeout setting for this request. If one
6963                                 number provided, it will be total request
6964                                 timeout. It can also be a pair (tuple) of
6965                                 (connection, read) timeouts.
6966        :type _request_timeout: int, tuple(int, int), optional
6967        :param _request_auth: set to override the auth_settings for an a single
6968                              request; this effectively ignores the
6969                              authentication in the spec for a single request.
6970        :type _request_auth: dict, optional
6971        :param _content_type: force content-type for the request.
6972        :type _content_type: str, Optional
6973        :param _headers: set to override the headers for a single
6974                         request; this effectively ignores the headers
6975                         in the spec for a single request.
6976        :type _headers: dict, optional
6977        :param _host_index: set to override the host_index for a single
6978                            request; this effectively ignores the host_index
6979                            in the spec for a single request.
6980        :type _host_index: int, optional
6981        :return: Returns the result object.
6982        """  # noqa: E501
6983
6984        _param = self._revoke_token_v2_serialize(
6985            revoke_token_request=revoke_token_request,
6986            _request_auth=_request_auth,
6987            _content_type=_content_type,
6988            _headers=_headers,
6989            _host_index=_host_index,
6990        )
6991
6992        _response_types_map: Dict[str, Optional[str]] = {
6993            "204": None,
6994            "404": "ErrorResponse",
6995        }
6996        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
6997        response_data.read()
6998        return self.api_client.response_deserialize(
6999            response_data=response_data,
7000            response_types_map=_response_types_map,
7001        ).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

7060    @validate_call
7061    def enterprise_get_organization_member(
7062        self,
7063        org_id: Annotated[StrictStr, Field(description="id of the organization")],
7064        member_id: Annotated[StrictStr, Field(description="id of the organization member")],
7065        _request_timeout: Union[
7066            None,
7067            Annotated[StrictFloat, Field(gt=0)],
7068            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7069        ] = None,
7070        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7071        _content_type: Optional[StrictStr] = None,
7072        _headers: Optional[Dict[StrictStr, Any]] = None,
7073        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7074    ) -> OrganizationMember:
7075        """Get organization member
7076
7077        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
7078
7079        :param org_id: id of the organization (required)
7080        :type org_id: str
7081        :param member_id: id of the organization member (required)
7082        :type member_id: str
7083        :param _request_timeout: timeout setting for this request. If one
7084                                 number provided, it will be total request
7085                                 timeout. It can also be a pair (tuple) of
7086                                 (connection, read) timeouts.
7087        :type _request_timeout: int, tuple(int, int), optional
7088        :param _request_auth: set to override the auth_settings for an a single
7089                              request; this effectively ignores the
7090                              authentication in the spec for a single request.
7091        :type _request_auth: dict, optional
7092        :param _content_type: force content-type for the request.
7093        :type _content_type: str, Optional
7094        :param _headers: set to override the headers for a single
7095                         request; this effectively ignores the headers
7096                         in the spec for a single request.
7097        :type _headers: dict, optional
7098        :param _host_index: set to override the host_index for a single
7099                            request; this effectively ignores the host_index
7100                            in the spec for a single request.
7101        :type _host_index: int, optional
7102        :return: Returns the result object.
7103        """  # noqa: E501
7104
7105        _param = self._enterprise_get_organization_member_serialize(
7106            org_id=org_id,
7107            member_id=member_id,
7108            _request_auth=_request_auth,
7109            _content_type=_content_type,
7110            _headers=_headers,
7111            _host_index=_host_index,
7112        )
7113
7114        _response_types_map: Dict[str, Optional[str]] = {
7115            "200": "OrganizationMember",
7116            "400": None,
7117            "401": None,
7118            "403": None,
7119            "404": None,
7120            "409": None,
7121            "429": None,
7122        }
7123        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7124        response_data.read()
7125        return self.api_client.response_deserialize(
7126            response_data=response_data,
7127            response_types_map=_response_types_map,
7128        ).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

7182    @validate_call
7183    def enterprise_get_organization_members(
7184        self,
7185        org_id: Annotated[StrictStr, Field(description="id of the organization")],
7186        emails: Optional[StrictStr] = None,
7187        role: Optional[StrictStr] = None,
7188        license: Optional[StrictStr] = None,
7189        active: Optional[StrictBool] = None,
7190        cursor: Optional[StrictStr] = None,
7191        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
7192        _request_timeout: Union[
7193            None,
7194            Annotated[StrictFloat, Field(gt=0)],
7195            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7196        ] = None,
7197        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7198        _content_type: Optional[StrictStr] = None,
7199        _headers: Optional[Dict[StrictStr, Any]] = None,
7200        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7201    ) -> EnterpriseGetOrganizationMembers200Response:
7202        """Get organization members
7203
7204        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
7205
7206        :param org_id: id of the organization (required)
7207        :type org_id: str
7208        :param emails:
7209        :type emails: str
7210        :param role:
7211        :type role: str
7212        :param license:
7213        :type license: str
7214        :param active:
7215        :type active: bool
7216        :param cursor:
7217        :type cursor: str
7218        :param limit:
7219        :type limit: int
7220        :param _request_timeout: timeout setting for this request. If one
7221                                 number provided, it will be total request
7222                                 timeout. It can also be a pair (tuple) of
7223                                 (connection, read) timeouts.
7224        :type _request_timeout: int, tuple(int, int), optional
7225        :param _request_auth: set to override the auth_settings for an a single
7226                              request; this effectively ignores the
7227                              authentication in the spec for a single request.
7228        :type _request_auth: dict, optional
7229        :param _content_type: force content-type for the request.
7230        :type _content_type: str, Optional
7231        :param _headers: set to override the headers for a single
7232                         request; this effectively ignores the headers
7233                         in the spec for a single request.
7234        :type _headers: dict, optional
7235        :param _host_index: set to override the host_index for a single
7236                            request; this effectively ignores the host_index
7237                            in the spec for a single request.
7238        :type _host_index: int, optional
7239        :return: Returns the result object.
7240        """  # noqa: E501
7241
7242        _param = self._enterprise_get_organization_members_serialize(
7243            org_id=org_id,
7244            emails=emails,
7245            role=role,
7246            license=license,
7247            active=active,
7248            cursor=cursor,
7249            limit=limit,
7250            _request_auth=_request_auth,
7251            _content_type=_content_type,
7252            _headers=_headers,
7253            _host_index=_host_index,
7254        )
7255
7256        _response_types_map: Dict[str, Optional[str]] = {
7257            "200": "EnterpriseGetOrganizationMembers200Response",
7258            "400": None,
7259            "401": None,
7260            "403": None,
7261            "404": None,
7262            "409": None,
7263            "429": None,
7264        }
7265        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7266        response_data.read()
7267        return self.api_client.response_deserialize(
7268            response_data=response_data,
7269            response_types_map=_response_types_map,
7270        ).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

7351    @validate_call
7352    def enterprise_get_organization(
7353        self,
7354        org_id: Annotated[StrictStr, Field(description="id of the organization")],
7355        _request_timeout: Union[
7356            None,
7357            Annotated[StrictFloat, Field(gt=0)],
7358            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7359        ] = None,
7360        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7361        _content_type: Optional[StrictStr] = None,
7362        _headers: Optional[Dict[StrictStr, Any]] = None,
7363        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7364    ) -> Organization:
7365        """Get organization info
7366
7367        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
7368
7369        :param org_id: id of the organization (required)
7370        :type org_id: str
7371        :param _request_timeout: timeout setting for this request. If one
7372                                 number provided, it will be total request
7373                                 timeout. It can also be a pair (tuple) of
7374                                 (connection, read) timeouts.
7375        :type _request_timeout: int, tuple(int, int), optional
7376        :param _request_auth: set to override the auth_settings for an a single
7377                              request; this effectively ignores the
7378                              authentication in the spec for a single request.
7379        :type _request_auth: dict, optional
7380        :param _content_type: force content-type for the request.
7381        :type _content_type: str, Optional
7382        :param _headers: set to override the headers for a single
7383                         request; this effectively ignores the headers
7384                         in the spec for a single request.
7385        :type _headers: dict, optional
7386        :param _host_index: set to override the host_index for a single
7387                            request; this effectively ignores the host_index
7388                            in the spec for a single request.
7389        :type _host_index: int, optional
7390        :return: Returns the result object.
7391        """  # noqa: E501
7392
7393        _param = self._enterprise_get_organization_serialize(
7394            org_id=org_id,
7395            _request_auth=_request_auth,
7396            _content_type=_content_type,
7397            _headers=_headers,
7398            _host_index=_host_index,
7399        )
7400
7401        _response_types_map: Dict[str, Optional[str]] = {
7402            "200": "Organization",
7403            "400": None,
7404            "401": None,
7405            "403": None,
7406            "404": None,
7407            "409": None,
7408            "429": None,
7409        }
7410        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7411        response_data.read()
7412        return self.api_client.response_deserialize(
7413            response_data=response_data,
7414            response_types_map=_response_types_map,
7415        ).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

7466    @validate_call
7467    def enterprise_add_project_member(
7468        self,
7469        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
7470        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
7471        project_id: Annotated[StrictStr, Field(description="The ID of the project to which you want to add a user.")],
7472        add_project_member_request: AddProjectMemberRequest,
7473        _request_timeout: Union[
7474            None,
7475            Annotated[StrictFloat, Field(gt=0)],
7476            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7477        ] = None,
7478        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7479        _content_type: Optional[StrictStr] = None,
7480        _headers: Optional[Dict[StrictStr, Any]] = None,
7481        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7482    ) -> ProjectMember:
7483        """Add member in a project
7484
7485        Add a Miro user to a project.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
7486
7487        :param org_id: The ID of the organization to which the project belongs. (required)
7488        :type org_id: str
7489        :param team_id: The ID of the team to which the project belongs. (required)
7490        :type team_id: str
7491        :param project_id: The ID of the project to which you want to add a user. (required)
7492        :type project_id: str
7493        :param add_project_member_request: (required)
7494        :type add_project_member_request: AddProjectMemberRequest
7495        :param _request_timeout: timeout setting for this request. If one
7496                                 number provided, it will be total request
7497                                 timeout. It can also be a pair (tuple) of
7498                                 (connection, read) timeouts.
7499        :type _request_timeout: int, tuple(int, int), optional
7500        :param _request_auth: set to override the auth_settings for an a single
7501                              request; this effectively ignores the
7502                              authentication in the spec for a single request.
7503        :type _request_auth: dict, optional
7504        :param _content_type: force content-type for the request.
7505        :type _content_type: str, Optional
7506        :param _headers: set to override the headers for a single
7507                         request; this effectively ignores the headers
7508                         in the spec for a single request.
7509        :type _headers: dict, optional
7510        :param _host_index: set to override the host_index for a single
7511                            request; this effectively ignores the host_index
7512                            in the spec for a single request.
7513        :type _host_index: int, optional
7514        :return: Returns the result object.
7515        """  # noqa: E501
7516
7517        _param = self._enterprise_add_project_member_serialize(
7518            org_id=org_id,
7519            team_id=team_id,
7520            project_id=project_id,
7521            add_project_member_request=add_project_member_request,
7522            _request_auth=_request_auth,
7523            _content_type=_content_type,
7524            _headers=_headers,
7525            _host_index=_host_index,
7526        )
7527
7528        _response_types_map: Dict[str, Optional[str]] = {
7529            "201": "ProjectMember",
7530            "400": "Error400",
7531            "401": "Error401",
7532            "403": "Error403",
7533            "404": "Error404",
7534            "409": "Error409",
7535            "429": "Error429",
7536        }
7537        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7538        response_data.read()
7539        return self.api_client.response_deserialize(
7540            response_data=response_data,
7541            response_types_map=_response_types_map,
7542        ).data

Add member in a project

Add a Miro user to a project.

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

7610    @validate_call
7611    def enterprise_delete_project_member(
7612        self,
7613        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
7614        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
7615        project_id: Annotated[
7616            StrictStr, Field(description="The ID of the project from which you want to remove a member.")
7617        ],
7618        member_id: Annotated[
7619            StrictStr, Field(description="The ID of the member that you want to remove from a project.")
7620        ],
7621        _request_timeout: Union[
7622            None,
7623            Annotated[StrictFloat, Field(gt=0)],
7624            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7625        ] = None,
7626        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7627        _content_type: Optional[StrictStr] = None,
7628        _headers: Optional[Dict[StrictStr, Any]] = None,
7629        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7630    ) -> None:
7631        """Remove project member
7632
7633        Remove a member from a project. The user remains in the team even after the member is removed from a project.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
7634
7635        :param org_id: The ID of the organization to which the project belongs. (required)
7636        :type org_id: str
7637        :param team_id: The ID of the team to which the project belongs. (required)
7638        :type team_id: str
7639        :param project_id: The ID of the project from which you want to remove a member. (required)
7640        :type project_id: str
7641        :param member_id: The ID of the member that you want to remove from a project. (required)
7642        :type member_id: str
7643        :param _request_timeout: timeout setting for this request. If one
7644                                 number provided, it will be total request
7645                                 timeout. It can also be a pair (tuple) of
7646                                 (connection, read) timeouts.
7647        :type _request_timeout: int, tuple(int, int), optional
7648        :param _request_auth: set to override the auth_settings for an a single
7649                              request; this effectively ignores the
7650                              authentication in the spec for a single request.
7651        :type _request_auth: dict, optional
7652        :param _content_type: force content-type for the request.
7653        :type _content_type: str, Optional
7654        :param _headers: set to override the headers for a single
7655                         request; this effectively ignores the headers
7656                         in the spec for a single request.
7657        :type _headers: dict, optional
7658        :param _host_index: set to override the host_index for a single
7659                            request; this effectively ignores the host_index
7660                            in the spec for a single request.
7661        :type _host_index: int, optional
7662        :return: Returns the result object.
7663        """  # noqa: E501
7664
7665        _param = self._enterprise_delete_project_member_serialize(
7666            org_id=org_id,
7667            team_id=team_id,
7668            project_id=project_id,
7669            member_id=member_id,
7670            _request_auth=_request_auth,
7671            _content_type=_content_type,
7672            _headers=_headers,
7673            _host_index=_host_index,
7674        )
7675
7676        _response_types_map: Dict[str, Optional[str]] = {
7677            "204": None,
7678            "400": "Error400",
7679            "401": "Error401",
7680            "403": "Error403",
7681            "404": "Error404",
7682            "409": "Error409",
7683            "429": "Error429",
7684        }
7685        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7686        response_data.read()
7687        return self.api_client.response_deserialize(
7688            response_data=response_data,
7689            response_types_map=_response_types_map,
7690        ).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.

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

7750    @validate_call
7751    def enterprise_get_project_member(
7752        self,
7753        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
7754        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
7755        project_id: Annotated[
7756            StrictStr,
7757            Field(description="The ID of the project from which you want to retrieve specific member information."),
7758        ],
7759        member_id: Annotated[
7760            StrictStr, Field(description="The ID of the member for which you want to retrieve information.")
7761        ],
7762        _request_timeout: Union[
7763            None,
7764            Annotated[StrictFloat, Field(gt=0)],
7765            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7766        ] = None,
7767        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7768        _content_type: Optional[StrictStr] = None,
7769        _headers: Optional[Dict[StrictStr, Any]] = None,
7770        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7771    ) -> ProjectMember:
7772        """Get project member
7773
7774        Retrieves information for a specific project member.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
7775
7776        :param org_id: The ID of the organization to which the project belongs. (required)
7777        :type org_id: str
7778        :param team_id: The ID of the team to which the project belongs. (required)
7779        :type team_id: str
7780        :param project_id: The ID of the project from which you want to retrieve specific member information. (required)
7781        :type project_id: str
7782        :param member_id: The ID of the member for which you want to retrieve information. (required)
7783        :type member_id: str
7784        :param _request_timeout: timeout setting for this request. If one
7785                                 number provided, it will be total request
7786                                 timeout. It can also be a pair (tuple) of
7787                                 (connection, read) timeouts.
7788        :type _request_timeout: int, tuple(int, int), optional
7789        :param _request_auth: set to override the auth_settings for an a single
7790                              request; this effectively ignores the
7791                              authentication in the spec for a single request.
7792        :type _request_auth: dict, optional
7793        :param _content_type: force content-type for the request.
7794        :type _content_type: str, Optional
7795        :param _headers: set to override the headers for a single
7796                         request; this effectively ignores the headers
7797                         in the spec for a single request.
7798        :type _headers: dict, optional
7799        :param _host_index: set to override the host_index for a single
7800                            request; this effectively ignores the host_index
7801                            in the spec for a single request.
7802        :type _host_index: int, optional
7803        :return: Returns the result object.
7804        """  # noqa: E501
7805
7806        _param = self._enterprise_get_project_member_serialize(
7807            org_id=org_id,
7808            team_id=team_id,
7809            project_id=project_id,
7810            member_id=member_id,
7811            _request_auth=_request_auth,
7812            _content_type=_content_type,
7813            _headers=_headers,
7814            _host_index=_host_index,
7815        )
7816
7817        _response_types_map: Dict[str, Optional[str]] = {
7818            "200": "ProjectMember",
7819            "400": "Error400",
7820            "401": "Error401",
7821            "403": "Error403",
7822            "404": "Error404",
7823            "409": "Error409",
7824            "429": "Error429",
7825        }
7826        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7827        response_data.read()
7828        return self.api_client.response_deserialize(
7829            response_data=response_data,
7830            response_types_map=_response_types_map,
7831        ).data

Get project member

Retrieves information for a specific project member.

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

7891    @validate_call
7892    def enterprise_get_project_members(
7893        self,
7894        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
7895        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
7896        project_id: Annotated[
7897            StrictStr, Field(description="The ID of the project for which you want to retrieve the list of members.")
7898        ],
7899        limit: Annotated[
7900            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
7901            Field(
7902                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."
7903            ),
7904        ] = None,
7905        cursor: Annotated[
7906            Optional[StrictStr],
7907            Field(
7908                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."
7909            ),
7910        ] = None,
7911        _request_timeout: Union[
7912            None,
7913            Annotated[StrictFloat, Field(gt=0)],
7914            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
7915        ] = None,
7916        _request_auth: Optional[Dict[StrictStr, Any]] = None,
7917        _content_type: Optional[StrictStr] = None,
7918        _headers: Optional[Dict[StrictStr, Any]] = None,
7919        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
7920    ) -> ProjectMemberPage:
7921        """List of project members
7922
7923        Retrieves the list of members for a specific project.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
7924
7925        :param org_id: The ID of the organization to which the project belongs. (required)
7926        :type org_id: str
7927        :param team_id: The ID of the team to which the project belongs. (required)
7928        :type team_id: str
7929        :param project_id: The ID of the project for which you want to retrieve the list of members. (required)
7930        :type project_id: str
7931        :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.
7932        :type limit: int
7933        :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.
7934        :type cursor: str
7935        :param _request_timeout: timeout setting for this request. If one
7936                                 number provided, it will be total request
7937                                 timeout. It can also be a pair (tuple) of
7938                                 (connection, read) timeouts.
7939        :type _request_timeout: int, tuple(int, int), optional
7940        :param _request_auth: set to override the auth_settings for an a single
7941                              request; this effectively ignores the
7942                              authentication in the spec for a single request.
7943        :type _request_auth: dict, optional
7944        :param _content_type: force content-type for the request.
7945        :type _content_type: str, Optional
7946        :param _headers: set to override the headers for a single
7947                         request; this effectively ignores the headers
7948                         in the spec for a single request.
7949        :type _headers: dict, optional
7950        :param _host_index: set to override the host_index for a single
7951                            request; this effectively ignores the host_index
7952                            in the spec for a single request.
7953        :type _host_index: int, optional
7954        :return: Returns the result object.
7955        """  # noqa: E501
7956
7957        _param = self._enterprise_get_project_members_serialize(
7958            org_id=org_id,
7959            team_id=team_id,
7960            project_id=project_id,
7961            limit=limit,
7962            cursor=cursor,
7963            _request_auth=_request_auth,
7964            _content_type=_content_type,
7965            _headers=_headers,
7966            _host_index=_host_index,
7967        )
7968
7969        _response_types_map: Dict[str, Optional[str]] = {
7970            "200": "ProjectMemberPage",
7971            "400": "Error400",
7972            "401": "Error401",
7973            "403": "Error403",
7974            "404": "Error404",
7975            "409": "Error409",
7976            "429": "Error429",
7977        }
7978        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
7979        response_data.read()
7980        return self.api_client.response_deserialize(
7981            response_data=response_data,
7982            response_types_map=_response_types_map,
7983        ).data

List of project members

Retrieves the list of members for a specific project.

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

8050    @validate_call
8051    def enterprise_update_project_member(
8052        self,
8053        org_id: Annotated[
8054            StrictStr, Field(description="The ID of the organization to which the project member belongs.")
8055        ],
8056        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project member belongs.")],
8057        project_id: Annotated[StrictStr, Field(description="The ID of a Project.")],
8058        member_id: Annotated[StrictStr, Field(description="The ID of the member whose details you want to update.")],
8059        update_project_member_request: UpdateProjectMemberRequest,
8060        _request_timeout: Union[
8061            None,
8062            Annotated[StrictFloat, Field(gt=0)],
8063            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8064        ] = None,
8065        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8066        _content_type: Optional[StrictStr] = None,
8067        _headers: Optional[Dict[StrictStr, Any]] = None,
8068        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8069    ) -> ProjectMember:
8070        """Update project member
8071
8072        Updates details of a project member, such as the member's role.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
8073
8074        :param org_id: The ID of the organization to which the project member belongs. (required)
8075        :type org_id: str
8076        :param team_id: The ID of the team to which the project member belongs. (required)
8077        :type team_id: str
8078        :param project_id: The ID of a Project. (required)
8079        :type project_id: str
8080        :param member_id: The ID of the member whose details you want to update. (required)
8081        :type member_id: str
8082        :param update_project_member_request: (required)
8083        :type update_project_member_request: UpdateProjectMemberRequest
8084        :param _request_timeout: timeout setting for this request. If one
8085                                 number provided, it will be total request
8086                                 timeout. It can also be a pair (tuple) of
8087                                 (connection, read) timeouts.
8088        :type _request_timeout: int, tuple(int, int), optional
8089        :param _request_auth: set to override the auth_settings for an a single
8090                              request; this effectively ignores the
8091                              authentication in the spec for a single request.
8092        :type _request_auth: dict, optional
8093        :param _content_type: force content-type for the request.
8094        :type _content_type: str, Optional
8095        :param _headers: set to override the headers for a single
8096                         request; this effectively ignores the headers
8097                         in the spec for a single request.
8098        :type _headers: dict, optional
8099        :param _host_index: set to override the host_index for a single
8100                            request; this effectively ignores the host_index
8101                            in the spec for a single request.
8102        :type _host_index: int, optional
8103        :return: Returns the result object.
8104        """  # noqa: E501
8105
8106        _param = self._enterprise_update_project_member_serialize(
8107            org_id=org_id,
8108            team_id=team_id,
8109            project_id=project_id,
8110            member_id=member_id,
8111            update_project_member_request=update_project_member_request,
8112            _request_auth=_request_auth,
8113            _content_type=_content_type,
8114            _headers=_headers,
8115            _host_index=_host_index,
8116        )
8117
8118        _response_types_map: Dict[str, Optional[str]] = {
8119            "200": "ProjectMember",
8120            "400": "Error400",
8121            "401": "Error401",
8122            "403": "Error403",
8123            "404": "Error404",
8124            "409": "Error409",
8125            "429": "Error429",
8126        }
8127        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8128        response_data.read()
8129        return self.api_client.response_deserialize(
8130            response_data=response_data,
8131            response_types_map=_response_types_map,
8132        ).data

Update project member

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

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

8203    @validate_call
8204    def enterprise_get_project_settings(
8205        self,
8206        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
8207        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
8208        project_id: Annotated[
8209            StrictStr, Field(description="The ID of the project for which you want to retrieve the project settings.")
8210        ],
8211        _request_timeout: Union[
8212            None,
8213            Annotated[StrictFloat, Field(gt=0)],
8214            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8215        ] = None,
8216        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8217        _content_type: Optional[StrictStr] = None,
8218        _headers: Optional[Dict[StrictStr, Any]] = None,
8219        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8220    ) -> ProjectSettings:
8221        """Get project settings
8222
8223        Retrieves the project settings.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
8224
8225        :param org_id: The ID of the organization to which the project belongs. (required)
8226        :type org_id: str
8227        :param team_id: The ID of the team to which the project belongs. (required)
8228        :type team_id: str
8229        :param project_id: The ID of the project for which you want to retrieve the project settings. (required)
8230        :type project_id: str
8231        :param _request_timeout: timeout setting for this request. If one
8232                                 number provided, it will be total request
8233                                 timeout. It can also be a pair (tuple) of
8234                                 (connection, read) timeouts.
8235        :type _request_timeout: int, tuple(int, int), optional
8236        :param _request_auth: set to override the auth_settings for an a single
8237                              request; this effectively ignores the
8238                              authentication in the spec for a single request.
8239        :type _request_auth: dict, optional
8240        :param _content_type: force content-type for the request.
8241        :type _content_type: str, Optional
8242        :param _headers: set to override the headers for a single
8243                         request; this effectively ignores the headers
8244                         in the spec for a single request.
8245        :type _headers: dict, optional
8246        :param _host_index: set to override the host_index for a single
8247                            request; this effectively ignores the host_index
8248                            in the spec for a single request.
8249        :type _host_index: int, optional
8250        :return: Returns the result object.
8251        """  # noqa: E501
8252
8253        _param = self._enterprise_get_project_settings_serialize(
8254            org_id=org_id,
8255            team_id=team_id,
8256            project_id=project_id,
8257            _request_auth=_request_auth,
8258            _content_type=_content_type,
8259            _headers=_headers,
8260            _host_index=_host_index,
8261        )
8262
8263        _response_types_map: Dict[str, Optional[str]] = {
8264            "200": "ProjectSettings",
8265            "400": "Error400",
8266            "401": "Error401",
8267            "403": "Error403",
8268            "404": "Error404",
8269            "429": "Error429",
8270        }
8271        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8272        response_data.read()
8273        return self.api_client.response_deserialize(
8274            response_data=response_data,
8275            response_types_map=_response_types_map,
8276        ).data

Get project settings

Retrieves the project settings.

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

8333    @validate_call
8334    def enterprise_update_project_settings(
8335        self,
8336        org_id: Annotated[StrictStr, Field(description="The ID of the organization to which the project belongs.")],
8337        team_id: Annotated[StrictStr, Field(description="The ID of the team to which the project belongs.")],
8338        project_id: Annotated[StrictStr, Field(description="The ID of the project whose settings you want to update.")],
8339        update_project_settings_request: UpdateProjectSettingsRequest,
8340        _request_timeout: Union[
8341            None,
8342            Annotated[StrictFloat, Field(gt=0)],
8343            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8344        ] = None,
8345        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8346        _content_type: Optional[StrictStr] = None,
8347        _headers: Optional[Dict[StrictStr, Any]] = None,
8348        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8349    ) -> ProjectSettings:
8350        """Update project settings
8351
8352        Updates the settings of a project.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
8353
8354        :param org_id: The ID of the organization to which the project belongs. (required)
8355        :type org_id: str
8356        :param team_id: The ID of the team to which the project belongs. (required)
8357        :type team_id: str
8358        :param project_id: The ID of the project whose settings you want to update. (required)
8359        :type project_id: str
8360        :param update_project_settings_request: (required)
8361        :type update_project_settings_request: UpdateProjectSettingsRequest
8362        :param _request_timeout: timeout setting for this request. If one
8363                                 number provided, it will be total request
8364                                 timeout. It can also be a pair (tuple) of
8365                                 (connection, read) timeouts.
8366        :type _request_timeout: int, tuple(int, int), optional
8367        :param _request_auth: set to override the auth_settings for an a single
8368                              request; this effectively ignores the
8369                              authentication in the spec for a single request.
8370        :type _request_auth: dict, optional
8371        :param _content_type: force content-type for the request.
8372        :type _content_type: str, Optional
8373        :param _headers: set to override the headers for a single
8374                         request; this effectively ignores the headers
8375                         in the spec for a single request.
8376        :type _headers: dict, optional
8377        :param _host_index: set to override the host_index for a single
8378                            request; this effectively ignores the host_index
8379                            in the spec for a single request.
8380        :type _host_index: int, optional
8381        :return: Returns the result object.
8382        """  # noqa: E501
8383
8384        _param = self._enterprise_update_project_settings_serialize(
8385            org_id=org_id,
8386            team_id=team_id,
8387            project_id=project_id,
8388            update_project_settings_request=update_project_settings_request,
8389            _request_auth=_request_auth,
8390            _content_type=_content_type,
8391            _headers=_headers,
8392            _host_index=_host_index,
8393        )
8394
8395        _response_types_map: Dict[str, Optional[str]] = {
8396            "200": "ProjectSettings",
8397            "400": "Error400",
8398            "401": "Error401",
8399            "403": "Error403",
8400            "404": "Error404",
8401            "409": "Error409",
8402            "429": "Error429",
8403        }
8404        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8405        response_data.read()
8406        return self.api_client.response_deserialize(
8407            response_data=response_data,
8408            response_types_map=_response_types_map,
8409        ).data

Update project settings

Updates the settings of a project.

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

8477    @validate_call
8478    def enterprise_create_project(
8479        self,
8480        org_id: Annotated[
8481            StrictStr, Field(description="The ID of the organization within which you you want to create a project.")
8482        ],
8483        team_id: Annotated[
8484            StrictStr, Field(description="The ID of the team within which you you want to create a project.")
8485        ],
8486        create_project_request: CreateProjectRequest,
8487        _request_timeout: Union[
8488            None,
8489            Annotated[StrictFloat, Field(gt=0)],
8490            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8491        ] = None,
8492        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8493        _content_type: Optional[StrictStr] = None,
8494        _headers: Optional[Dict[StrictStr, Any]] = None,
8495        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8496    ) -> Project:
8497        """Create project
8498
8499        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.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
8500
8501        :param org_id: The ID of the organization within which you you want to create a project. (required)
8502        :type org_id: str
8503        :param team_id: The ID of the team within which you you want to create a project. (required)
8504        :type team_id: str
8505        :param create_project_request: (required)
8506        :type create_project_request: CreateProjectRequest
8507        :param _request_timeout: timeout setting for this request. If one
8508                                 number provided, it will be total request
8509                                 timeout. It can also be a pair (tuple) of
8510                                 (connection, read) timeouts.
8511        :type _request_timeout: int, tuple(int, int), optional
8512        :param _request_auth: set to override the auth_settings for an a single
8513                              request; this effectively ignores the
8514                              authentication in the spec for a single request.
8515        :type _request_auth: dict, optional
8516        :param _content_type: force content-type for the request.
8517        :type _content_type: str, Optional
8518        :param _headers: set to override the headers for a single
8519                         request; this effectively ignores the headers
8520                         in the spec for a single request.
8521        :type _headers: dict, optional
8522        :param _host_index: set to override the host_index for a single
8523                            request; this effectively ignores the host_index
8524                            in the spec for a single request.
8525        :type _host_index: int, optional
8526        :return: Returns the result object.
8527        """  # noqa: E501
8528
8529        _param = self._enterprise_create_project_serialize(
8530            org_id=org_id,
8531            team_id=team_id,
8532            create_project_request=create_project_request,
8533            _request_auth=_request_auth,
8534            _content_type=_content_type,
8535            _headers=_headers,
8536            _host_index=_host_index,
8537        )
8538
8539        _response_types_map: Dict[str, Optional[str]] = {
8540            "201": "Project",
8541            "400": "Error400",
8542            "401": "Error401",
8543            "403": "Error403",
8544            "404": "Error404",
8545            "409": "Error409",
8546            "429": "Error429",
8547        }
8548        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8549        response_data.read()
8550        return self.api_client.response_deserialize(
8551            response_data=response_data,
8552            response_types_map=_response_types_map,
8553        ).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.

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

8618    @validate_call
8619    def enterprise_delete_project(
8620        self,
8621        org_id: Annotated[
8622            StrictStr, Field(description="The ID of the organization from which you want to delete a project.")
8623        ],
8624        team_id: Annotated[StrictStr, Field(description="The ID of the team from which you want to delete a project.")],
8625        project_id: Annotated[StrictStr, Field(description="The ID of the project that you want to delete.")],
8626        _request_timeout: Union[
8627            None,
8628            Annotated[StrictFloat, Field(gt=0)],
8629            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8630        ] = None,
8631        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8632        _content_type: Optional[StrictStr] = None,
8633        _headers: Optional[Dict[StrictStr, Any]] = None,
8634        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8635    ) -> None:
8636        """Delete project
8637
8638        Deletes a project. After a project is deleted, all boards and users that belong to the project remain in the team.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
8639
8640        :param org_id: The ID of the organization from which you want to delete a project. (required)
8641        :type org_id: str
8642        :param team_id: The ID of the team from which you want to delete a project. (required)
8643        :type team_id: str
8644        :param project_id: The ID of the project that you want to delete. (required)
8645        :type project_id: str
8646        :param _request_timeout: timeout setting for this request. If one
8647                                 number provided, it will be total request
8648                                 timeout. It can also be a pair (tuple) of
8649                                 (connection, read) timeouts.
8650        :type _request_timeout: int, tuple(int, int), optional
8651        :param _request_auth: set to override the auth_settings for an a single
8652                              request; this effectively ignores the
8653                              authentication in the spec for a single request.
8654        :type _request_auth: dict, optional
8655        :param _content_type: force content-type for the request.
8656        :type _content_type: str, Optional
8657        :param _headers: set to override the headers for a single
8658                         request; this effectively ignores the headers
8659                         in the spec for a single request.
8660        :type _headers: dict, optional
8661        :param _host_index: set to override the host_index for a single
8662                            request; this effectively ignores the host_index
8663                            in the spec for a single request.
8664        :type _host_index: int, optional
8665        :return: Returns the result object.
8666        """  # noqa: E501
8667
8668        _param = self._enterprise_delete_project_serialize(
8669            org_id=org_id,
8670            team_id=team_id,
8671            project_id=project_id,
8672            _request_auth=_request_auth,
8673            _content_type=_content_type,
8674            _headers=_headers,
8675            _host_index=_host_index,
8676        )
8677
8678        _response_types_map: Dict[str, Optional[str]] = {
8679            "204": None,
8680            "400": "Error400",
8681            "401": "Error401",
8682            "403": "Error403",
8683            "404": "Error404",
8684            "409": "Error409",
8685            "429": "Error429",
8686        }
8687        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8688        response_data.read()
8689        return self.api_client.response_deserialize(
8690            response_data=response_data,
8691            response_types_map=_response_types_map,
8692        ).data

Delete project

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

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

8749    @validate_call
8750    def enterprise_get_project(
8751        self,
8752        org_id: Annotated[
8753            StrictStr,
8754            Field(description="The ID of the organization from which you want to retrieve the project information."),
8755        ],
8756        team_id: Annotated[
8757            StrictStr, Field(description="The ID of the team from which you want to retrieve the project information.")
8758        ],
8759        project_id: Annotated[
8760            StrictStr, Field(description="The ID of the project for which you want to retrieve the information.")
8761        ],
8762        _request_timeout: Union[
8763            None,
8764            Annotated[StrictFloat, Field(gt=0)],
8765            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8766        ] = None,
8767        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8768        _content_type: Optional[StrictStr] = None,
8769        _headers: Optional[Dict[StrictStr, Any]] = None,
8770        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8771    ) -> Project:
8772        """Get project
8773
8774        Retrieves project information, such as a name for an existing project.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
8775
8776        :param org_id: The ID of the organization from which you want to retrieve the project information. (required)
8777        :type org_id: str
8778        :param team_id: The ID of the team from which you want to retrieve the project information. (required)
8779        :type team_id: str
8780        :param project_id: The ID of the project for which you want to retrieve the information. (required)
8781        :type project_id: str
8782        :param _request_timeout: timeout setting for this request. If one
8783                                 number provided, it will be total request
8784                                 timeout. It can also be a pair (tuple) of
8785                                 (connection, read) timeouts.
8786        :type _request_timeout: int, tuple(int, int), optional
8787        :param _request_auth: set to override the auth_settings for an a single
8788                              request; this effectively ignores the
8789                              authentication in the spec for a single request.
8790        :type _request_auth: dict, optional
8791        :param _content_type: force content-type for the request.
8792        :type _content_type: str, Optional
8793        :param _headers: set to override the headers for a single
8794                         request; this effectively ignores the headers
8795                         in the spec for a single request.
8796        :type _headers: dict, optional
8797        :param _host_index: set to override the host_index for a single
8798                            request; this effectively ignores the host_index
8799                            in the spec for a single request.
8800        :type _host_index: int, optional
8801        :return: Returns the result object.
8802        """  # noqa: E501
8803
8804        _param = self._enterprise_get_project_serialize(
8805            org_id=org_id,
8806            team_id=team_id,
8807            project_id=project_id,
8808            _request_auth=_request_auth,
8809            _content_type=_content_type,
8810            _headers=_headers,
8811            _host_index=_host_index,
8812        )
8813
8814        _response_types_map: Dict[str, Optional[str]] = {
8815            "200": "Project",
8816            "400": "Error400",
8817            "401": "Error401",
8818            "403": "Error403",
8819            "404": "Error404",
8820            "429": "Error429",
8821        }
8822        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8823        response_data.read()
8824        return self.api_client.response_deserialize(
8825            response_data=response_data,
8826            response_types_map=_response_types_map,
8827        ).data

Get project

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

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

8884    @validate_call
8885    def enterprise_get_projects(
8886        self,
8887        org_id: Annotated[
8888            StrictStr,
8889            Field(
8890                description="The ID of the organization from which you want to retrieve the list of available projects."
8891            ),
8892        ],
8893        team_id: Annotated[
8894            StrictStr,
8895            Field(description="The ID of the team from which you want to retrieve the list of available projects."),
8896        ],
8897        limit: Annotated[
8898            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
8899            Field(
8900                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."
8901            ),
8902        ] = None,
8903        cursor: Annotated[
8904            Optional[StrictStr],
8905            Field(
8906                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."
8907            ),
8908        ] = None,
8909        _request_timeout: Union[
8910            None,
8911            Annotated[StrictFloat, Field(gt=0)],
8912            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
8913        ] = None,
8914        _request_auth: Optional[Dict[StrictStr, Any]] = None,
8915        _content_type: Optional[StrictStr] = None,
8916        _headers: Optional[Dict[StrictStr, Any]] = None,
8917        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
8918    ) -> ProjectPage:
8919        """List of projects
8920
8921        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).<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
8922
8923        :param org_id: The ID of the organization from which you want to retrieve the list of available projects. (required)
8924        :type org_id: str
8925        :param team_id: The ID of the team from which you want to retrieve the list of available projects. (required)
8926        :type team_id: str
8927        :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.
8928        :type limit: int
8929        :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.
8930        :type cursor: str
8931        :param _request_timeout: timeout setting for this request. If one
8932                                 number provided, it will be total request
8933                                 timeout. It can also be a pair (tuple) of
8934                                 (connection, read) timeouts.
8935        :type _request_timeout: int, tuple(int, int), optional
8936        :param _request_auth: set to override the auth_settings for an a single
8937                              request; this effectively ignores the
8938                              authentication in the spec for a single request.
8939        :type _request_auth: dict, optional
8940        :param _content_type: force content-type for the request.
8941        :type _content_type: str, Optional
8942        :param _headers: set to override the headers for a single
8943                         request; this effectively ignores the headers
8944                         in the spec for a single request.
8945        :type _headers: dict, optional
8946        :param _host_index: set to override the host_index for a single
8947                            request; this effectively ignores the host_index
8948                            in the spec for a single request.
8949        :type _host_index: int, optional
8950        :return: Returns the result object.
8951        """  # noqa: E501
8952
8953        _param = self._enterprise_get_projects_serialize(
8954            org_id=org_id,
8955            team_id=team_id,
8956            limit=limit,
8957            cursor=cursor,
8958            _request_auth=_request_auth,
8959            _content_type=_content_type,
8960            _headers=_headers,
8961            _host_index=_host_index,
8962        )
8963
8964        _response_types_map: Dict[str, Optional[str]] = {
8965            "200": "ProjectPage",
8966            "400": "Error400",
8967            "401": "Error401",
8968            "403": "Error403",
8969            "404": "Error404",
8970            "429": "Error429",
8971        }
8972        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
8973        response_data.read()
8974        return self.api_client.response_deserialize(
8975            response_data=response_data,
8976            response_types_map=_response_types_map,
8977        ).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.

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

9041    @validate_call
9042    def enterprise_update_project(
9043        self,
9044        org_id: Annotated[StrictStr, Field(description="The ID of an Organization.")],
9045        team_id: Annotated[StrictStr, Field(description="The ID of a Team.")],
9046        project_id: Annotated[StrictStr, Field(description="The ID of a Project.")],
9047        update_project_request: UpdateProjectRequest,
9048        _request_timeout: Union[
9049            None,
9050            Annotated[StrictFloat, Field(gt=0)],
9051            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9052        ] = None,
9053        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9054        _content_type: Optional[StrictStr] = None,
9055        _headers: Optional[Dict[StrictStr, Any]] = None,
9056        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9057    ) -> Project:
9058        """Update project
9059
9060        Update information about a project, such as the project name.<h4>Note</h4> <em>Projects</em> have been renamed to <em>Spaces</em>, and the terms can be used interchangeably.<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=\"/reference/rate-limiting#rate-limit-tiers\">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>
9061
9062        :param org_id: The ID of an Organization. (required)
9063        :type org_id: str
9064        :param team_id: The ID of a Team. (required)
9065        :type team_id: str
9066        :param project_id: The ID of a Project. (required)
9067        :type project_id: str
9068        :param update_project_request: (required)
9069        :type update_project_request: UpdateProjectRequest
9070        :param _request_timeout: timeout setting for this request. If one
9071                                 number provided, it will be total request
9072                                 timeout. It can also be a pair (tuple) of
9073                                 (connection, read) timeouts.
9074        :type _request_timeout: int, tuple(int, int), optional
9075        :param _request_auth: set to override the auth_settings for an a single
9076                              request; this effectively ignores the
9077                              authentication in the spec for a single request.
9078        :type _request_auth: dict, optional
9079        :param _content_type: force content-type for the request.
9080        :type _content_type: str, Optional
9081        :param _headers: set to override the headers for a single
9082                         request; this effectively ignores the headers
9083                         in the spec for a single request.
9084        :type _headers: dict, optional
9085        :param _host_index: set to override the host_index for a single
9086                            request; this effectively ignores the host_index
9087                            in the spec for a single request.
9088        :type _host_index: int, optional
9089        :return: Returns the result object.
9090        """  # noqa: E501
9091
9092        _param = self._enterprise_update_project_serialize(
9093            org_id=org_id,
9094            team_id=team_id,
9095            project_id=project_id,
9096            update_project_request=update_project_request,
9097            _request_auth=_request_auth,
9098            _content_type=_content_type,
9099            _headers=_headers,
9100            _host_index=_host_index,
9101        )
9102
9103        _response_types_map: Dict[str, Optional[str]] = {
9104            "200": "Project",
9105            "400": "Error400",
9106            "401": "Error401",
9107            "403": "Error403",
9108            "404": "Error404",
9109            "409": "Error409",
9110            "429": "Error429",
9111        }
9112        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9113        response_data.read()
9114        return self.api_client.response_deserialize(
9115            response_data=response_data,
9116            response_types_map=_response_types_map,
9117        ).data

Update project

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

Note

Projects have been renamed to Spaces, and the terms can be used interchangeably.

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

9185    @validate_call
9186    def enterprise_post_user_sessions_reset(
9187        self,
9188        email: Annotated[
9189            StrictStr,
9190            Field(
9191                description="Email ID of the user whose sessions you want to reset. Note that this user will be signed out from all devices."
9192            ),
9193        ],
9194        _request_timeout: Union[
9195            None,
9196            Annotated[StrictFloat, Field(gt=0)],
9197            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9198        ] = None,
9199        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9200        _content_type: Optional[StrictStr] = None,
9201        _headers: Optional[Dict[StrictStr, Any]] = None,
9202        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9203    ) -> None:
9204        """Reset all sessions of a user
9205
9206        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
9207
9208        :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)
9209        :type email: str
9210        :param _request_timeout: timeout setting for this request. If one
9211                                 number provided, it will be total request
9212                                 timeout. It can also be a pair (tuple) of
9213                                 (connection, read) timeouts.
9214        :type _request_timeout: int, tuple(int, int), optional
9215        :param _request_auth: set to override the auth_settings for an a single
9216                              request; this effectively ignores the
9217                              authentication in the spec for a single request.
9218        :type _request_auth: dict, optional
9219        :param _content_type: force content-type for the request.
9220        :type _content_type: str, Optional
9221        :param _headers: set to override the headers for a single
9222                         request; this effectively ignores the headers
9223                         in the spec for a single request.
9224        :type _headers: dict, optional
9225        :param _host_index: set to override the host_index for a single
9226                            request; this effectively ignores the host_index
9227                            in the spec for a single request.
9228        :type _host_index: int, optional
9229        :return: Returns the result object.
9230        """  # noqa: E501
9231
9232        _param = self._enterprise_post_user_sessions_reset_serialize(
9233            email=email,
9234            _request_auth=_request_auth,
9235            _content_type=_content_type,
9236            _headers=_headers,
9237            _host_index=_host_index,
9238        )
9239
9240        _response_types_map: Dict[str, Optional[str]] = {
9241            "200": None,
9242            "400": None,
9243            "401": None,
9244            "403": None,
9245            "404": None,
9246            "429": None,
9247        }
9248        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9249        response_data.read()
9250        return self.api_client.response_deserialize(
9251            response_data=response_data,
9252            response_types_map=_response_types_map,
9253        ).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

organizations:groups:read
boards:write

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_boards_create_group( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the board.')], create_board_user_groups_request: miro_api.models.create_board_user_groups_request.CreateBoardUserGroupsRequest, _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_user_group.BoardUserGroup: View Source

9303    @validate_call
9304    def enterprise_boards_create_group(
9305        self,
9306        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
9307        board_id: Annotated[StrictStr, Field(description="The ID of the board.")],
9308        create_board_user_groups_request: CreateBoardUserGroupsRequest,
9309        _request_timeout: Union[
9310            None,
9311            Annotated[StrictFloat, Field(gt=0)],
9312            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9313        ] = None,
9314        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9315        _content_type: Optional[StrictStr] = None,
9316        _headers: Optional[Dict[StrictStr, Any]] = None,
9317        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9318    ) -> BoardUserGroup:
9319        """Create board user group assignments
9320
9321        Shares a board with user groups with a specified role. Updates the role if already shared.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a><br/> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
9322
9323        :param org_id: The ID of an organization. (required)
9324        :type org_id: str
9325        :param board_id: The ID of the board. (required)
9326        :type board_id: str
9327        :param create_board_user_groups_request: (required)
9328        :type create_board_user_groups_request: CreateBoardUserGroupsRequest
9329        :param _request_timeout: timeout setting for this request. If one
9330                                 number provided, it will be total request
9331                                 timeout. It can also be a pair (tuple) of
9332                                 (connection, read) timeouts.
9333        :type _request_timeout: int, tuple(int, int), optional
9334        :param _request_auth: set to override the auth_settings for an a single
9335                              request; this effectively ignores the
9336                              authentication in the spec for a single request.
9337        :type _request_auth: dict, optional
9338        :param _content_type: force content-type for the request.
9339        :type _content_type: str, Optional
9340        :param _headers: set to override the headers for a single
9341                         request; this effectively ignores the headers
9342                         in the spec for a single request.
9343        :type _headers: dict, optional
9344        :param _host_index: set to override the host_index for a single
9345                            request; this effectively ignores the host_index
9346                            in the spec for a single request.
9347        :type _host_index: int, optional
9348        :return: Returns the result object.
9349        """  # noqa: E501
9350
9351        _param = self._enterprise_boards_create_group_serialize(
9352            org_id=org_id,
9353            board_id=board_id,
9354            create_board_user_groups_request=create_board_user_groups_request,
9355            _request_auth=_request_auth,
9356            _content_type=_content_type,
9357            _headers=_headers,
9358            _host_index=_host_index,
9359        )
9360
9361        _response_types_map: Dict[str, Optional[str]] = {
9362            "200": "BoardUserGroup",
9363            "400": None,
9364            "401": None,
9365            "403": None,
9366            "409": None,
9367            "429": None,
9368        }
9369        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9370        response_data.read()
9371        return self.api_client.response_deserialize(
9372            response_data=response_data,
9373            response_types_map=_response_types_map,
9374        ).data

Create board user group assignments

Shares a board with user groups with a specified role. Updates the role if already shared.

Required scope

Rate limiting

organizations:groups:read
projects:write

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 board_id: The ID of the board. (required) :type board_id: str :param create_board_user_groups_request: (required) :type create_board_user_groups_request: CreateBoardUserGroupsRequest :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_boards_delete_groups( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the board.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user 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) -> None: View Source

9439    @validate_call
9440    def enterprise_boards_delete_groups(
9441        self,
9442        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
9443        board_id: Annotated[StrictStr, Field(description="The ID of the board.")],
9444        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
9445        _request_timeout: Union[
9446            None,
9447            Annotated[StrictFloat, Field(gt=0)],
9448            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9449        ] = None,
9450        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9451        _content_type: Optional[StrictStr] = None,
9452        _headers: Optional[Dict[StrictStr, Any]] = None,
9453        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9454    ) -> None:
9455        """Delete board user group assignment
9456
9457        Removes a user group from the specified board.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:write</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
9458
9459        :param org_id: The ID of an organization. (required)
9460        :type org_id: str
9461        :param board_id: The ID of the board. (required)
9462        :type board_id: str
9463        :param group_id: The ID of a user group. (required)
9464        :type group_id: str
9465        :param _request_timeout: timeout setting for this request. If one
9466                                 number provided, it will be total request
9467                                 timeout. It can also be a pair (tuple) of
9468                                 (connection, read) timeouts.
9469        :type _request_timeout: int, tuple(int, int), optional
9470        :param _request_auth: set to override the auth_settings for an a single
9471                              request; this effectively ignores the
9472                              authentication in the spec for a single request.
9473        :type _request_auth: dict, optional
9474        :param _content_type: force content-type for the request.
9475        :type _content_type: str, Optional
9476        :param _headers: set to override the headers for a single
9477                         request; this effectively ignores the headers
9478                         in the spec for a single request.
9479        :type _headers: dict, optional
9480        :param _host_index: set to override the host_index for a single
9481                            request; this effectively ignores the host_index
9482                            in the spec for a single request.
9483        :type _host_index: int, optional
9484        :return: Returns the result object.
9485        """  # noqa: E501
9486
9487        _param = self._enterprise_boards_delete_groups_serialize(
9488            org_id=org_id,
9489            board_id=board_id,
9490            group_id=group_id,
9491            _request_auth=_request_auth,
9492            _content_type=_content_type,
9493            _headers=_headers,
9494            _host_index=_host_index,
9495        )
9496
9497        _response_types_map: Dict[str, Optional[str]] = {
9498            "204": None,
9499            "400": None,
9500            "401": None,
9501            "403": None,
9502            "404": None,
9503            "409": None,
9504            "429": None,
9505        }
9506        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9507        response_data.read()
9508        return self.api_client.response_deserialize(
9509            response_data=response_data,
9510            response_types_map=_response_types_map,
9511        ).data

Delete board user group assignment

Removes a user group from the specified board.

Required scope

organizations:groups:read
boards:write

Rate limiting

Level 1

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 board_id: The ID of the board. (required) :type board_id: str :param group_id: The ID of a user 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 enterprise_boards_get_groups( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], board_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the board.')], 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 user groups in the result list.')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.')] = 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_user_groups_page.BoardUserGroupsPage: View Source

9565    @validate_call
9566    def enterprise_boards_get_groups(
9567        self,
9568        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
9569        board_id: Annotated[StrictStr, Field(description="The ID of the board.")],
9570        limit: Annotated[
9571            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
9572            Field(description="The maximum number of user groups in the result list."),
9573        ] = None,
9574        cursor: Annotated[
9575            Optional[StrictStr],
9576            Field(
9577                description="A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning."
9578            ),
9579        ] = None,
9580        _request_timeout: Union[
9581            None,
9582            Annotated[StrictFloat, Field(gt=0)],
9583            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9584        ] = None,
9585        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9586        _content_type: Optional[StrictStr] = None,
9587        _headers: Optional[Dict[StrictStr, Any]] = None,
9588        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9589    ) -> BoardUserGroupsPage:
9590        """Get board user group assignments
9591
9592        Retrieves information about user groups invited to the specified board.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/> <a target=_blank href=https://developers.miro.com/reference/scopes>boards:read</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
9593
9594        :param org_id: The ID of an organization. (required)
9595        :type org_id: str
9596        :param board_id: The ID of the board. (required)
9597        :type board_id: str
9598        :param limit: The maximum number of user groups in the result list.
9599        :type limit: int
9600        :param cursor: A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.
9601        :type cursor: str
9602        :param _request_timeout: timeout setting for this request. If one
9603                                 number provided, it will be total request
9604                                 timeout. It can also be a pair (tuple) of
9605                                 (connection, read) timeouts.
9606        :type _request_timeout: int, tuple(int, int), optional
9607        :param _request_auth: set to override the auth_settings for an a single
9608                              request; this effectively ignores the
9609                              authentication in the spec for a single request.
9610        :type _request_auth: dict, optional
9611        :param _content_type: force content-type for the request.
9612        :type _content_type: str, Optional
9613        :param _headers: set to override the headers for a single
9614                         request; this effectively ignores the headers
9615                         in the spec for a single request.
9616        :type _headers: dict, optional
9617        :param _host_index: set to override the host_index for a single
9618                            request; this effectively ignores the host_index
9619                            in the spec for a single request.
9620        :type _host_index: int, optional
9621        :return: Returns the result object.
9622        """  # noqa: E501
9623
9624        _param = self._enterprise_boards_get_groups_serialize(
9625            org_id=org_id,
9626            board_id=board_id,
9627            limit=limit,
9628            cursor=cursor,
9629            _request_auth=_request_auth,
9630            _content_type=_content_type,
9631            _headers=_headers,
9632            _host_index=_host_index,
9633        )
9634
9635        _response_types_map: Dict[str, Optional[str]] = {
9636            "200": "BoardUserGroupsPage",
9637            "400": None,
9638            "401": None,
9639            "403": None,
9640            "404": None,
9641            "429": None,
9642        }
9643        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9644        response_data.read()
9645        return self.api_client.response_deserialize(
9646            response_data=response_data,
9647            response_types_map=_response_types_map,
9648        ).data

Get board user group assignments

Retrieves information about user groups invited to the specified board.

Required scope

organizations:groups:read
boards:read

Rate limiting

Level 1

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 board_id: The ID of the board. (required) :type board_id: str :param limit: The maximum number of user groups in the result list. :type limit: int :param cursor: A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning. :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_project_create_group( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project.')], create_project_user_groups_request: miro_api.models.create_project_user_groups_request.CreateProjectUserGroupsRequest, _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_user_group.ProjectUserGroup: View Source

9712    @validate_call
9713    def enterprise_project_create_group(
9714        self,
9715        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
9716        project_id: Annotated[StrictStr, Field(description="The ID of the project.")],
9717        create_project_user_groups_request: CreateProjectUserGroupsRequest,
9718        _request_timeout: Union[
9719            None,
9720            Annotated[StrictFloat, Field(gt=0)],
9721            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9722        ] = None,
9723        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9724        _content_type: Optional[StrictStr] = None,
9725        _headers: Optional[Dict[StrictStr, Any]] = None,
9726        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9727    ) -> ProjectUserGroup:
9728        """Create project user group assignments
9729
9730        Shares a project with user groups with a specified role. Updates the role if already shared.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a><br/> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:write</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
9731
9732        :param org_id: The ID of an organization. (required)
9733        :type org_id: str
9734        :param project_id: The ID of the project. (required)
9735        :type project_id: str
9736        :param create_project_user_groups_request: (required)
9737        :type create_project_user_groups_request: CreateProjectUserGroupsRequest
9738        :param _request_timeout: timeout setting for this request. If one
9739                                 number provided, it will be total request
9740                                 timeout. It can also be a pair (tuple) of
9741                                 (connection, read) timeouts.
9742        :type _request_timeout: int, tuple(int, int), optional
9743        :param _request_auth: set to override the auth_settings for an a single
9744                              request; this effectively ignores the
9745                              authentication in the spec for a single request.
9746        :type _request_auth: dict, optional
9747        :param _content_type: force content-type for the request.
9748        :type _content_type: str, Optional
9749        :param _headers: set to override the headers for a single
9750                         request; this effectively ignores the headers
9751                         in the spec for a single request.
9752        :type _headers: dict, optional
9753        :param _host_index: set to override the host_index for a single
9754                            request; this effectively ignores the host_index
9755                            in the spec for a single request.
9756        :type _host_index: int, optional
9757        :return: Returns the result object.
9758        """  # noqa: E501
9759
9760        _param = self._enterprise_project_create_group_serialize(
9761            org_id=org_id,
9762            project_id=project_id,
9763            create_project_user_groups_request=create_project_user_groups_request,
9764            _request_auth=_request_auth,
9765            _content_type=_content_type,
9766            _headers=_headers,
9767            _host_index=_host_index,
9768        )
9769
9770        _response_types_map: Dict[str, Optional[str]] = {
9771            "200": "ProjectUserGroup",
9772            "400": None,
9773            "401": None,
9774            "403": None,
9775            "409": None,
9776            "429": None,
9777        }
9778        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9779        response_data.read()
9780        return self.api_client.response_deserialize(
9781            response_data=response_data,
9782            response_types_map=_response_types_map,
9783        ).data

Create project user group assignments

Shares a project with user groups with a specified role. Updates the role if already shared.

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 project_id: The ID of the project. (required) :type project_id: str :param create_project_user_groups_request: (required) :type create_project_user_groups_request: CreateProjectUserGroupsRequest :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_project_delete_groups( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user 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) -> None: View Source

9848    @validate_call
9849    def enterprise_project_delete_groups(
9850        self,
9851        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
9852        project_id: Annotated[StrictStr, Field(description="The ID of the project.")],
9853        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
9854        _request_timeout: Union[
9855            None,
9856            Annotated[StrictFloat, Field(gt=0)],
9857            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
9858        ] = None,
9859        _request_auth: Optional[Dict[StrictStr, Any]] = None,
9860        _content_type: Optional[StrictStr] = None,
9861        _headers: Optional[Dict[StrictStr, Any]] = None,
9862        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
9863    ) -> None:
9864        """Delete project user group assignment
9865
9866        Removes a user group from the specified project.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:write</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
9867
9868        :param org_id: The ID of an organization. (required)
9869        :type org_id: str
9870        :param project_id: The ID of the project. (required)
9871        :type project_id: str
9872        :param group_id: The ID of a user group. (required)
9873        :type group_id: str
9874        :param _request_timeout: timeout setting for this request. If one
9875                                 number provided, it will be total request
9876                                 timeout. It can also be a pair (tuple) of
9877                                 (connection, read) timeouts.
9878        :type _request_timeout: int, tuple(int, int), optional
9879        :param _request_auth: set to override the auth_settings for an a single
9880                              request; this effectively ignores the
9881                              authentication in the spec for a single request.
9882        :type _request_auth: dict, optional
9883        :param _content_type: force content-type for the request.
9884        :type _content_type: str, Optional
9885        :param _headers: set to override the headers for a single
9886                         request; this effectively ignores the headers
9887                         in the spec for a single request.
9888        :type _headers: dict, optional
9889        :param _host_index: set to override the host_index for a single
9890                            request; this effectively ignores the host_index
9891                            in the spec for a single request.
9892        :type _host_index: int, optional
9893        :return: Returns the result object.
9894        """  # noqa: E501
9895
9896        _param = self._enterprise_project_delete_groups_serialize(
9897            org_id=org_id,
9898            project_id=project_id,
9899            group_id=group_id,
9900            _request_auth=_request_auth,
9901            _content_type=_content_type,
9902            _headers=_headers,
9903            _host_index=_host_index,
9904        )
9905
9906        _response_types_map: Dict[str, Optional[str]] = {
9907            "204": None,
9908            "400": None,
9909            "401": None,
9910            "403": None,
9911            "404": None,
9912            "409": None,
9913            "429": None,
9914        }
9915        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
9916        response_data.read()
9917        return self.api_client.response_deserialize(
9918            response_data=response_data,
9919            response_types_map=_response_types_map,
9920        ).data

Delete project user group assignment

Removes a user group from the specified project.

Required scope

organizations:groups:read
projects:write

Rate limiting

Level 1

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 project_id: The ID of the project. (required) :type project_id: str :param group_id: The ID of a user 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 enterprise_projects_get_groups( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], project_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project.')], 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 user groups in the result list.')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.')] = 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_user_groups_page.ProjectUserGroupsPage: View Source

 9974    @validate_call
 9975    def enterprise_projects_get_groups(
 9976        self,
 9977        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
 9978        project_id: Annotated[StrictStr, Field(description="The ID of the project.")],
 9979        limit: Annotated[
 9980            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
 9981            Field(description="The maximum number of user groups in the result list."),
 9982        ] = None,
 9983        cursor: Annotated[
 9984            Optional[StrictStr],
 9985            Field(
 9986                description="A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning."
 9987            ),
 9988        ] = None,
 9989        _request_timeout: Union[
 9990            None,
 9991            Annotated[StrictFloat, Field(gt=0)],
 9992            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
 9993        ] = None,
 9994        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 9995        _content_type: Optional[StrictStr] = None,
 9996        _headers: Optional[Dict[StrictStr, Any]] = None,
 9997        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 9998    ) -> ProjectUserGroupsPage:
 9999        """Get project user group assignments
10000
10001        Retrieves information about user groups invited to the specified project.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/> <a target=_blank href=https://developers.miro.com/reference/scopes>projects:read</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
10002
10003        :param org_id: The ID of an organization. (required)
10004        :type org_id: str
10005        :param project_id: The ID of the project. (required)
10006        :type project_id: str
10007        :param limit: The maximum number of user groups in the result list.
10008        :type limit: int
10009        :param cursor: A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.
10010        :type cursor: str
10011        :param _request_timeout: timeout setting for this request. If one
10012                                 number provided, it will be total request
10013                                 timeout. It can also be a pair (tuple) of
10014                                 (connection, read) timeouts.
10015        :type _request_timeout: int, tuple(int, int), optional
10016        :param _request_auth: set to override the auth_settings for an a single
10017                              request; this effectively ignores the
10018                              authentication in the spec for a single request.
10019        :type _request_auth: dict, optional
10020        :param _content_type: force content-type for the request.
10021        :type _content_type: str, Optional
10022        :param _headers: set to override the headers for a single
10023                         request; this effectively ignores the headers
10024                         in the spec for a single request.
10025        :type _headers: dict, optional
10026        :param _host_index: set to override the host_index for a single
10027                            request; this effectively ignores the host_index
10028                            in the spec for a single request.
10029        :type _host_index: int, optional
10030        :return: Returns the result object.
10031        """  # noqa: E501
10032
10033        _param = self._enterprise_projects_get_groups_serialize(
10034            org_id=org_id,
10035            project_id=project_id,
10036            limit=limit,
10037            cursor=cursor,
10038            _request_auth=_request_auth,
10039            _content_type=_content_type,
10040            _headers=_headers,
10041            _host_index=_host_index,
10042        )
10043
10044        _response_types_map: Dict[str, Optional[str]] = {
10045            "200": "ProjectUserGroupsPage",
10046            "400": None,
10047            "401": None,
10048            "403": None,
10049            "404": None,
10050            "429": None,
10051        }
10052        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10053        response_data.read()
10054        return self.api_client.response_deserialize(
10055            response_data=response_data,
10056            response_types_map=_response_types_map,
10057        ).data

Get project user group assignments

Retrieves information about user groups invited to the specified project.

Required scope

organizations:groups:read
projects:read

Rate limiting

Level 1

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 project_id: The ID of the project. (required) :type project_id: str :param limit: The maximum number of user groups in the result list. :type limit: int :param cursor: A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning. :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_delete_team_member( 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.')], 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

10121    @validate_call
10122    def enterprise_delete_team_member(
10123        self,
10124        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
10125        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
10126        member_id: Annotated[StrictStr, Field(description="The id of the Team Member")],
10127        _request_timeout: Union[
10128            None,
10129            Annotated[StrictFloat, Field(gt=0)],
10130            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10131        ] = None,
10132        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10133        _content_type: Optional[StrictStr] = None,
10134        _headers: Optional[Dict[StrictStr, Any]] = None,
10135        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10136    ) -> None:
10137        """Delete team member from team
10138
10139        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
10140
10141        :param org_id: The ID of an organization. (required)
10142        :type org_id: str
10143        :param team_id: The ID of a team. (required)
10144        :type team_id: str
10145        :param member_id: The id of the Team Member (required)
10146        :type member_id: str
10147        :param _request_timeout: timeout setting for this request. If one
10148                                 number provided, it will be total request
10149                                 timeout. It can also be a pair (tuple) of
10150                                 (connection, read) timeouts.
10151        :type _request_timeout: int, tuple(int, int), optional
10152        :param _request_auth: set to override the auth_settings for an a single
10153                              request; this effectively ignores the
10154                              authentication in the spec for a single request.
10155        :type _request_auth: dict, optional
10156        :param _content_type: force content-type for the request.
10157        :type _content_type: str, Optional
10158        :param _headers: set to override the headers for a single
10159                         request; this effectively ignores the headers
10160                         in the spec for a single request.
10161        :type _headers: dict, optional
10162        :param _host_index: set to override the host_index for a single
10163                            request; this effectively ignores the host_index
10164                            in the spec for a single request.
10165        :type _host_index: int, optional
10166        :return: Returns the result object.
10167        """  # noqa: E501
10168
10169        _param = self._enterprise_delete_team_member_serialize(
10170            org_id=org_id,
10171            team_id=team_id,
10172            member_id=member_id,
10173            _request_auth=_request_auth,
10174            _content_type=_content_type,
10175            _headers=_headers,
10176            _host_index=_host_index,
10177        )
10178
10179        _response_types_map: Dict[str, Optional[str]] = {
10180            "204": None,
10181            "400": None,
10182            "401": None,
10183            "403": None,
10184            "404": None,
10185            "409": None,
10186            "429": None,
10187        }
10188        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10189        response_data.read()
10190        return self.api_client.response_deserialize(
10191            response_data=response_data,
10192            response_types_map=_response_types_map,
10193        ).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 an organization. (required) :type org_id: str :param team_id: The ID of a 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 an organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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

10247    @validate_call
10248    def enterprise_get_team_member(
10249        self,
10250        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
10251        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
10252        member_id: Annotated[StrictStr, Field(description="The id of the Team Member")],
10253        _request_timeout: Union[
10254            None,
10255            Annotated[StrictFloat, Field(gt=0)],
10256            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10257        ] = None,
10258        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10259        _content_type: Optional[StrictStr] = None,
10260        _headers: Optional[Dict[StrictStr, Any]] = None,
10261        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10262    ) -> TeamMember:
10263        """Get team member
10264
10265        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
10266
10267        :param org_id: The ID of an organization. (required)
10268        :type org_id: str
10269        :param team_id: The ID of a team. (required)
10270        :type team_id: str
10271        :param member_id: The id of the Team Member (required)
10272        :type member_id: str
10273        :param _request_timeout: timeout setting for this request. If one
10274                                 number provided, it will be total request
10275                                 timeout. It can also be a pair (tuple) of
10276                                 (connection, read) timeouts.
10277        :type _request_timeout: int, tuple(int, int), optional
10278        :param _request_auth: set to override the auth_settings for an a single
10279                              request; this effectively ignores the
10280                              authentication in the spec for a single request.
10281        :type _request_auth: dict, optional
10282        :param _content_type: force content-type for the request.
10283        :type _content_type: str, Optional
10284        :param _headers: set to override the headers for a single
10285                         request; this effectively ignores the headers
10286                         in the spec for a single request.
10287        :type _headers: dict, optional
10288        :param _host_index: set to override the host_index for a single
10289                            request; this effectively ignores the host_index
10290                            in the spec for a single request.
10291        :type _host_index: int, optional
10292        :return: Returns the result object.
10293        """  # noqa: E501
10294
10295        _param = self._enterprise_get_team_member_serialize(
10296            org_id=org_id,
10297            team_id=team_id,
10298            member_id=member_id,
10299            _request_auth=_request_auth,
10300            _content_type=_content_type,
10301            _headers=_headers,
10302            _host_index=_host_index,
10303        )
10304
10305        _response_types_map: Dict[str, Optional[str]] = {
10306            "200": "TeamMember",
10307            "400": None,
10308            "401": None,
10309            "403": None,
10310            "404": None,
10311            "429": None,
10312        }
10313        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10314        response_data.read()
10315        return self.api_client.response_deserialize(
10316            response_data=response_data,
10317            response_types_map=_response_types_map,
10318        ).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 an organization. (required) :type org_id: str :param team_id: The ID of a 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 an organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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": (Deprecated) 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

10375    @validate_call
10376    def enterprise_get_team_members(
10377        self,
10378        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
10379        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
10380        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
10381        cursor: Annotated[
10382            Optional[StrictStr],
10383            Field(
10384                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."
10385            ),
10386        ] = None,
10387        role: Annotated[
10388            Optional[StrictStr],
10389            Field(
10390                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": (Deprecated) Team-guest user, user with access only to a team without access to organization. '
10391            ),
10392        ] = None,
10393        _request_timeout: Union[
10394            None,
10395            Annotated[StrictFloat, Field(gt=0)],
10396            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10397        ] = None,
10398        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10399        _content_type: Optional[StrictStr] = None,
10400        _headers: Optional[Dict[StrictStr, Any]] = None,
10401        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10402    ) -> TeamMembersPage:
10403        """List team members
10404
10405        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
10406
10407        :param org_id: The ID of an organization. (required)
10408        :type org_id: str
10409        :param team_id: The ID of a team. (required)
10410        :type team_id: str
10411        :param limit:
10412        :type limit: int
10413        :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.
10414        :type cursor: str
10415        :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\": (Deprecated) Team-guest user, user with access only to a team without access to organization.
10416        :type role: str
10417        :param _request_timeout: timeout setting for this request. If one
10418                                 number provided, it will be total request
10419                                 timeout. It can also be a pair (tuple) of
10420                                 (connection, read) timeouts.
10421        :type _request_timeout: int, tuple(int, int), optional
10422        :param _request_auth: set to override the auth_settings for an a single
10423                              request; this effectively ignores the
10424                              authentication in the spec for a single request.
10425        :type _request_auth: dict, optional
10426        :param _content_type: force content-type for the request.
10427        :type _content_type: str, Optional
10428        :param _headers: set to override the headers for a single
10429                         request; this effectively ignores the headers
10430                         in the spec for a single request.
10431        :type _headers: dict, optional
10432        :param _host_index: set to override the host_index for a single
10433                            request; this effectively ignores the host_index
10434                            in the spec for a single request.
10435        :type _host_index: int, optional
10436        :return: Returns the result object.
10437        """  # noqa: E501
10438
10439        _param = self._enterprise_get_team_members_serialize(
10440            org_id=org_id,
10441            team_id=team_id,
10442            limit=limit,
10443            cursor=cursor,
10444            role=role,
10445            _request_auth=_request_auth,
10446            _content_type=_content_type,
10447            _headers=_headers,
10448            _host_index=_host_index,
10449        )
10450
10451        _response_types_map: Dict[str, Optional[str]] = {
10452            "200": "TeamMembersPage",
10453            "400": None,
10454            "401": None,
10455            "403": None,
10456            "404": None,
10457            "429": None,
10458        }
10459        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10460        response_data.read()
10461        return self.api_client.response_deserialize(
10462            response_data=response_data,
10463            response_types_map=_response_types_map,
10464        ).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 an organization. (required) :type org_id: str :param team_id: The ID of a 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": (Deprecated) 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 an organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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

10533    @validate_call
10534    def enterprise_invite_team_member(
10535        self,
10536        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
10537        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
10538        team_member_invite: TeamMemberInvite,
10539        _request_timeout: Union[
10540            None,
10541            Annotated[StrictFloat, Field(gt=0)],
10542            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10543        ] = None,
10544        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10545        _content_type: Optional[StrictStr] = None,
10546        _headers: Optional[Dict[StrictStr, Any]] = None,
10547        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10548    ) -> TeamMember:
10549        """Invite team members
10550
10551        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
10552
10553        :param org_id: The ID of an organization. (required)
10554        :type org_id: str
10555        :param team_id: The ID of a team. (required)
10556        :type team_id: str
10557        :param team_member_invite: (required)
10558        :type team_member_invite: TeamMemberInvite
10559        :param _request_timeout: timeout setting for this request. If one
10560                                 number provided, it will be total request
10561                                 timeout. It can also be a pair (tuple) of
10562                                 (connection, read) timeouts.
10563        :type _request_timeout: int, tuple(int, int), optional
10564        :param _request_auth: set to override the auth_settings for an a single
10565                              request; this effectively ignores the
10566                              authentication in the spec for a single request.
10567        :type _request_auth: dict, optional
10568        :param _content_type: force content-type for the request.
10569        :type _content_type: str, Optional
10570        :param _headers: set to override the headers for a single
10571                         request; this effectively ignores the headers
10572                         in the spec for a single request.
10573        :type _headers: dict, optional
10574        :param _host_index: set to override the host_index for a single
10575                            request; this effectively ignores the host_index
10576                            in the spec for a single request.
10577        :type _host_index: int, optional
10578        :return: Returns the result object.
10579        """  # noqa: E501
10580
10581        _param = self._enterprise_invite_team_member_serialize(
10582            org_id=org_id,
10583            team_id=team_id,
10584            team_member_invite=team_member_invite,
10585            _request_auth=_request_auth,
10586            _content_type=_content_type,
10587            _headers=_headers,
10588            _host_index=_host_index,
10589        )
10590
10591        _response_types_map: Dict[str, Optional[str]] = {
10592            "201": "TeamMember",
10593            "400": None,
10594            "401": None,
10595            "403": None,
10596            "404": None,
10597            "409": None,
10598            "429": None,
10599        }
10600        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10601        response_data.read()
10602        return self.api_client.response_deserialize(
10603            response_data=response_data,
10604            response_types_map=_response_types_map,
10605        ).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 an organization. (required) :type org_id: str :param team_id: The ID of a 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 an organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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

10670    @validate_call
10671    def enterprise_update_team_member(
10672        self,
10673        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
10674        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
10675        member_id: Annotated[StrictStr, Field(description="The id of the Team Member")],
10676        team_member_changes: TeamMemberChanges,
10677        _request_timeout: Union[
10678            None,
10679            Annotated[StrictFloat, Field(gt=0)],
10680            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10681        ] = None,
10682        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10683        _content_type: Optional[StrictStr] = None,
10684        _headers: Optional[Dict[StrictStr, Any]] = None,
10685        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10686    ) -> TeamMember:
10687        """Update team member
10688
10689        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
10690
10691        :param org_id: The ID of an organization. (required)
10692        :type org_id: str
10693        :param team_id: The ID of a team. (required)
10694        :type team_id: str
10695        :param member_id: The id of the Team Member (required)
10696        :type member_id: str
10697        :param team_member_changes: (required)
10698        :type team_member_changes: TeamMemberChanges
10699        :param _request_timeout: timeout setting for this request. If one
10700                                 number provided, it will be total request
10701                                 timeout. It can also be a pair (tuple) of
10702                                 (connection, read) timeouts.
10703        :type _request_timeout: int, tuple(int, int), optional
10704        :param _request_auth: set to override the auth_settings for an a single
10705                              request; this effectively ignores the
10706                              authentication in the spec for a single request.
10707        :type _request_auth: dict, optional
10708        :param _content_type: force content-type for the request.
10709        :type _content_type: str, Optional
10710        :param _headers: set to override the headers for a single
10711                         request; this effectively ignores the headers
10712                         in the spec for a single request.
10713        :type _headers: dict, optional
10714        :param _host_index: set to override the host_index for a single
10715                            request; this effectively ignores the host_index
10716                            in the spec for a single request.
10717        :type _host_index: int, optional
10718        :return: Returns the result object.
10719        """  # noqa: E501
10720
10721        _param = self._enterprise_update_team_member_serialize(
10722            org_id=org_id,
10723            team_id=team_id,
10724            member_id=member_id,
10725            team_member_changes=team_member_changes,
10726            _request_auth=_request_auth,
10727            _content_type=_content_type,
10728            _headers=_headers,
10729            _host_index=_host_index,
10730        )
10731
10732        _response_types_map: Dict[str, Optional[str]] = {
10733            "200": "TeamMember",
10734            "400": None,
10735            "401": None,
10736            "403": None,
10737            "404": None,
10738            "409": None,
10739            "429": None,
10740        }
10741        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10742        response_data.read()
10743        return self.api_client.response_deserialize(
10744            response_data=response_data,
10745            response_types_map=_response_types_map,
10746        ).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 an organization. (required) :type org_id: str :param team_id: The ID of a 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

10814    @validate_call
10815    def enterprise_get_default_team_settings(
10816        self,
10817        org_id: Annotated[StrictStr, Field(description="The id of an Organization.")],
10818        _request_timeout: Union[
10819            None,
10820            Annotated[StrictFloat, Field(gt=0)],
10821            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10822        ] = None,
10823        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10824        _content_type: Optional[StrictStr] = None,
10825        _headers: Optional[Dict[StrictStr, Any]] = None,
10826        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10827    ) -> TeamSettings:
10828        """Get default team settings
10829
10830        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
10831
10832        :param org_id: The id of an Organization. (required)
10833        :type org_id: str
10834        :param _request_timeout: timeout setting for this request. If one
10835                                 number provided, it will be total request
10836                                 timeout. It can also be a pair (tuple) of
10837                                 (connection, read) timeouts.
10838        :type _request_timeout: int, tuple(int, int), optional
10839        :param _request_auth: set to override the auth_settings for an a single
10840                              request; this effectively ignores the
10841                              authentication in the spec for a single request.
10842        :type _request_auth: dict, optional
10843        :param _content_type: force content-type for the request.
10844        :type _content_type: str, Optional
10845        :param _headers: set to override the headers for a single
10846                         request; this effectively ignores the headers
10847                         in the spec for a single request.
10848        :type _headers: dict, optional
10849        :param _host_index: set to override the host_index for a single
10850                            request; this effectively ignores the host_index
10851                            in the spec for a single request.
10852        :type _host_index: int, optional
10853        :return: Returns the result object.
10854        """  # noqa: E501
10855
10856        _param = self._enterprise_get_default_team_settings_serialize(
10857            org_id=org_id,
10858            _request_auth=_request_auth,
10859            _content_type=_content_type,
10860            _headers=_headers,
10861            _host_index=_host_index,
10862        )
10863
10864        _response_types_map: Dict[str, Optional[str]] = {
10865            "200": "TeamSettings",
10866            "400": None,
10867            "401": None,
10868            "403": None,
10869            "404": None,
10870            "429": None,
10871        }
10872        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10873        response_data.read()
10874        return self.api_client.response_deserialize(
10875            response_data=response_data,
10876            response_types_map=_response_types_map,
10877        ).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 an organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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

10928    @validate_call
10929    def enterprise_get_team_settings(
10930        self,
10931        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
10932        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
10933        _request_timeout: Union[
10934            None,
10935            Annotated[StrictFloat, Field(gt=0)],
10936            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
10937        ] = None,
10938        _request_auth: Optional[Dict[StrictStr, Any]] = None,
10939        _content_type: Optional[StrictStr] = None,
10940        _headers: Optional[Dict[StrictStr, Any]] = None,
10941        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
10942    ) -> TeamSettings:
10943        """Get team settings
10944
10945        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
10946
10947        :param org_id: The ID of an organization. (required)
10948        :type org_id: str
10949        :param team_id: The ID of a team. (required)
10950        :type team_id: str
10951        :param _request_timeout: timeout setting for this request. If one
10952                                 number provided, it will be total request
10953                                 timeout. It can also be a pair (tuple) of
10954                                 (connection, read) timeouts.
10955        :type _request_timeout: int, tuple(int, int), optional
10956        :param _request_auth: set to override the auth_settings for an a single
10957                              request; this effectively ignores the
10958                              authentication in the spec for a single request.
10959        :type _request_auth: dict, optional
10960        :param _content_type: force content-type for the request.
10961        :type _content_type: str, Optional
10962        :param _headers: set to override the headers for a single
10963                         request; this effectively ignores the headers
10964                         in the spec for a single request.
10965        :type _headers: dict, optional
10966        :param _host_index: set to override the host_index for a single
10967                            request; this effectively ignores the host_index
10968                            in the spec for a single request.
10969        :type _host_index: int, optional
10970        :return: Returns the result object.
10971        """  # noqa: E501
10972
10973        _param = self._enterprise_get_team_settings_serialize(
10974            org_id=org_id,
10975            team_id=team_id,
10976            _request_auth=_request_auth,
10977            _content_type=_content_type,
10978            _headers=_headers,
10979            _host_index=_host_index,
10980        )
10981
10982        _response_types_map: Dict[str, Optional[str]] = {
10983            "200": "TeamSettings",
10984            "400": None,
10985            "401": None,
10986            "403": None,
10987            "404": None,
10988            "429": None,
10989        }
10990        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
10991        response_data.read()
10992        return self.api_client.response_deserialize(
10993            response_data=response_data,
10994            response_types_map=_response_types_map,
10995        ).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 an organization. (required) :type org_id: str :param team_id: The ID of a 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 an organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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

11049    @validate_call
11050    def enterprise_update_team_settings(
11051        self,
11052        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
11053        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
11054        team_settings_changes: TeamSettingsChanges,
11055        _request_timeout: Union[
11056            None,
11057            Annotated[StrictFloat, Field(gt=0)],
11058            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11059        ] = None,
11060        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11061        _content_type: Optional[StrictStr] = None,
11062        _headers: Optional[Dict[StrictStr, Any]] = None,
11063        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11064    ) -> TeamSettings:
11065        """Update team settings
11066
11067        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
11068
11069        :param org_id: The ID of an organization. (required)
11070        :type org_id: str
11071        :param team_id: The ID of a team. (required)
11072        :type team_id: str
11073        :param team_settings_changes: (required)
11074        :type team_settings_changes: TeamSettingsChanges
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._enterprise_update_team_settings_serialize(
11098            org_id=org_id,
11099            team_id=team_id,
11100            team_settings_changes=team_settings_changes,
11101            _request_auth=_request_auth,
11102            _content_type=_content_type,
11103            _headers=_headers,
11104            _host_index=_host_index,
11105        )
11106
11107        _response_types_map: Dict[str, Optional[str]] = {
11108            "200": "TeamSettings",
11109            "400": None,
11110            "401": None,
11111            "403": None,
11112            "404": None,
11113            "409": None,
11114            "429": None,
11115        }
11116        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11117        response_data.read()
11118        return self.api_client.response_deserialize(
11119            response_data=response_data,
11120            response_types_map=_response_types_map,
11121        ).data

Update team settings

Updates team settings of an existing team.

Required scope

Rate limiting

organizations:groups:read
organizations:teams:write

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 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_teams_create_group( 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.')], create_team_group_request: miro_api.models.create_team_group_request.CreateTeamGroupRequest, _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_group.TeamGroup: View Source

11186    @validate_call
11187    def enterprise_teams_create_group(
11188        self,
11189        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
11190        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
11191        create_team_group_request: CreateTeamGroupRequest,
11192        _request_timeout: Union[
11193            None,
11194            Annotated[StrictFloat, Field(gt=0)],
11195            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11196        ] = None,
11197        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11198        _content_type: Optional[StrictStr] = None,
11199        _headers: Optional[Dict[StrictStr, Any]] = None,
11200        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11201    ) -> TeamGroup:
11202        """Create user group to team connection
11203
11204        Adds a user group to a team in an organization.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a><br/> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>'
11205
11206        :param org_id: The ID of an organization. (required)
11207        :type org_id: str
11208        :param team_id: The ID of a team. (required)
11209        :type team_id: str
11210        :param create_team_group_request: (required)
11211        :type create_team_group_request: CreateTeamGroupRequest
11212        :param _request_timeout: timeout setting for this request. If one
11213                                 number provided, it will be total request
11214                                 timeout. It can also be a pair (tuple) of
11215                                 (connection, read) timeouts.
11216        :type _request_timeout: int, tuple(int, int), optional
11217        :param _request_auth: set to override the auth_settings for an a single
11218                              request; this effectively ignores the
11219                              authentication in the spec for a single request.
11220        :type _request_auth: dict, optional
11221        :param _content_type: force content-type for the request.
11222        :type _content_type: str, Optional
11223        :param _headers: set to override the headers for a single
11224                         request; this effectively ignores the headers
11225                         in the spec for a single request.
11226        :type _headers: dict, optional
11227        :param _host_index: set to override the host_index for a single
11228                            request; this effectively ignores the host_index
11229                            in the spec for a single request.
11230        :type _host_index: int, optional
11231        :return: Returns the result object.
11232        """  # noqa: E501
11233
11234        _param = self._enterprise_teams_create_group_serialize(
11235            org_id=org_id,
11236            team_id=team_id,
11237            create_team_group_request=create_team_group_request,
11238            _request_auth=_request_auth,
11239            _content_type=_content_type,
11240            _headers=_headers,
11241            _host_index=_host_index,
11242        )
11243
11244        _response_types_map: Dict[str, Optional[str]] = {
11245            "201": "TeamGroup",
11246            "400": None,
11247            "401": None,
11248            "403": None,
11249            "409": None,
11250            "429": None,
11251        }
11252        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11253        response_data.read()
11254        return self.api_client.response_deserialize(
11255            response_data=response_data,
11256            response_types_map=_response_types_map,
11257        ).data

Create user group to team connection

Adds a user group to a team in an organization.

Required scope

Rate limiting

organizations:groups:read
organizations:teams:write

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 create_team_group_request: (required) :type create_team_group_request: CreateTeamGroupRequest :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_teams_delete_group( 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.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user 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) -> None: View Source

11322    @validate_call
11323    def enterprise_teams_delete_group(
11324        self,
11325        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
11326        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
11327        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
11328        _request_timeout: Union[
11329            None,
11330            Annotated[StrictFloat, Field(gt=0)],
11331            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11332        ] = None,
11333        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11334        _content_type: Optional[StrictStr] = None,
11335        _headers: Optional[Dict[StrictStr, Any]] = None,
11336        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11337    ) -> None:
11338        """Delete user group to team connection
11339
11340        Removes a user group from a team in an existing organization.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:write</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
11341
11342        :param org_id: The ID of an organization. (required)
11343        :type org_id: str
11344        :param team_id: The ID of a team. (required)
11345        :type team_id: str
11346        :param group_id: The ID of a user group. (required)
11347        :type group_id: str
11348        :param _request_timeout: timeout setting for this request. If one
11349                                 number provided, it will be total request
11350                                 timeout. It can also be a pair (tuple) of
11351                                 (connection, read) timeouts.
11352        :type _request_timeout: int, tuple(int, int), optional
11353        :param _request_auth: set to override the auth_settings for an a single
11354                              request; this effectively ignores the
11355                              authentication in the spec for a single request.
11356        :type _request_auth: dict, optional
11357        :param _content_type: force content-type for the request.
11358        :type _content_type: str, Optional
11359        :param _headers: set to override the headers for a single
11360                         request; this effectively ignores the headers
11361                         in the spec for a single request.
11362        :type _headers: dict, optional
11363        :param _host_index: set to override the host_index for a single
11364                            request; this effectively ignores the host_index
11365                            in the spec for a single request.
11366        :type _host_index: int, optional
11367        :return: Returns the result object.
11368        """  # noqa: E501
11369
11370        _param = self._enterprise_teams_delete_group_serialize(
11371            org_id=org_id,
11372            team_id=team_id,
11373            group_id=group_id,
11374            _request_auth=_request_auth,
11375            _content_type=_content_type,
11376            _headers=_headers,
11377            _host_index=_host_index,
11378        )
11379
11380        _response_types_map: Dict[str, Optional[str]] = {
11381            "204": None,
11382            "400": None,
11383            "401": None,
11384            "403": None,
11385            "404": None,
11386            "409": None,
11387            "429": None,
11388        }
11389        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11390        response_data.read()
11391        return self.api_client.response_deserialize(
11392            response_data=response_data,
11393            response_types_map=_response_types_map,
11394        ).data

Delete user group to team connection

Removes a user group from a team in an existing organization.

Required scope

Rate limiting

Level 1

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 group_id: The ID of a user 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 enterprise_teams_get_group( 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.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user 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.team_group.TeamGroup: View Source

11448    @validate_call
11449    def enterprise_teams_get_group(
11450        self,
11451        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
11452        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
11453        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
11454        _request_timeout: Union[
11455            None,
11456            Annotated[StrictFloat, Field(gt=0)],
11457            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11458        ] = None,
11459        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11460        _content_type: Optional[StrictStr] = None,
11461        _headers: Optional[Dict[StrictStr, Any]] = None,
11462        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11463    ) -> TeamGroup:
11464        """Get user group of a team
11465
11466        Retrieves information about a specific user group of a team.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
11467
11468        :param org_id: The ID of an organization. (required)
11469        :type org_id: str
11470        :param team_id: The ID of a team. (required)
11471        :type team_id: str
11472        :param group_id: The ID of a user group. (required)
11473        :type group_id: str
11474        :param _request_timeout: timeout setting for this request. If one
11475                                 number provided, it will be total request
11476                                 timeout. It can also be a pair (tuple) of
11477                                 (connection, read) timeouts.
11478        :type _request_timeout: int, tuple(int, int), optional
11479        :param _request_auth: set to override the auth_settings for an a single
11480                              request; this effectively ignores the
11481                              authentication in the spec for a single request.
11482        :type _request_auth: dict, optional
11483        :param _content_type: force content-type for the request.
11484        :type _content_type: str, Optional
11485        :param _headers: set to override the headers for a single
11486                         request; this effectively ignores the headers
11487                         in the spec for a single request.
11488        :type _headers: dict, optional
11489        :param _host_index: set to override the host_index for a single
11490                            request; this effectively ignores the host_index
11491                            in the spec for a single request.
11492        :type _host_index: int, optional
11493        :return: Returns the result object.
11494        """  # noqa: E501
11495
11496        _param = self._enterprise_teams_get_group_serialize(
11497            org_id=org_id,
11498            team_id=team_id,
11499            group_id=group_id,
11500            _request_auth=_request_auth,
11501            _content_type=_content_type,
11502            _headers=_headers,
11503            _host_index=_host_index,
11504        )
11505
11506        _response_types_map: Dict[str, Optional[str]] = {
11507            "200": "TeamGroup",
11508            "400": None,
11509            "401": None,
11510            "403": None,
11511            "404": None,
11512            "429": None,
11513        }
11514        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11515        response_data.read()
11516        return self.api_client.response_deserialize(
11517            response_data=response_data,
11518            response_types_map=_response_types_map,
11519        ).data

Get user group of a team

Retrieves information about a specific user group of a team.

Required scope

Rate limiting

Level 1

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 group_id: The ID of a user 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 enterprise_teams_get_groups( 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.')], 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 user groups in the result list.')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.')] = 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_groups_page.TeamGroupsPage: View Source

11576    @validate_call
11577    def enterprise_teams_get_groups(
11578        self,
11579        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
11580        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
11581        limit: Annotated[
11582            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
11583            Field(description="The maximum number of user groups in the result list."),
11584        ] = None,
11585        cursor: Annotated[
11586            Optional[StrictStr],
11587            Field(
11588                description="A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning."
11589            ),
11590        ] = None,
11591        _request_timeout: Union[
11592            None,
11593            Annotated[StrictFloat, Field(gt=0)],
11594            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11595        ] = None,
11596        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11597        _content_type: Optional[StrictStr] = None,
11598        _headers: Optional[Dict[StrictStr, Any]] = None,
11599        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11600    ) -> TeamGroupsPage:
11601        """List of user group to team connections
11602
11603        Retrieves the list of user groups that are part of a team in an organization.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
11604
11605        :param org_id: The ID of an organization. (required)
11606        :type org_id: str
11607        :param team_id: The ID of a team. (required)
11608        :type team_id: str
11609        :param limit: The maximum number of user groups in the result list.
11610        :type limit: int
11611        :param cursor: A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.
11612        :type cursor: str
11613        :param _request_timeout: timeout setting for this request. If one
11614                                 number provided, it will be total request
11615                                 timeout. It can also be a pair (tuple) of
11616                                 (connection, read) timeouts.
11617        :type _request_timeout: int, tuple(int, int), optional
11618        :param _request_auth: set to override the auth_settings for an a single
11619                              request; this effectively ignores the
11620                              authentication in the spec for a single request.
11621        :type _request_auth: dict, optional
11622        :param _content_type: force content-type for the request.
11623        :type _content_type: str, Optional
11624        :param _headers: set to override the headers for a single
11625                         request; this effectively ignores the headers
11626                         in the spec for a single request.
11627        :type _headers: dict, optional
11628        :param _host_index: set to override the host_index for a single
11629                            request; this effectively ignores the host_index
11630                            in the spec for a single request.
11631        :type _host_index: int, optional
11632        :return: Returns the result object.
11633        """  # noqa: E501
11634
11635        _param = self._enterprise_teams_get_groups_serialize(
11636            org_id=org_id,
11637            team_id=team_id,
11638            limit=limit,
11639            cursor=cursor,
11640            _request_auth=_request_auth,
11641            _content_type=_content_type,
11642            _headers=_headers,
11643            _host_index=_host_index,
11644        )
11645
11646        _response_types_map: Dict[str, Optional[str]] = {
11647            "200": "TeamGroupsPage",
11648            "400": None,
11649            "401": None,
11650            "403": None,
11651            "429": None,
11652        }
11653        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11654        response_data.read()
11655        return self.api_client.response_deserialize(
11656            response_data=response_data,
11657            response_types_map=_response_types_map,
11658        ).data

List of user group to team connections

Retrieves the list of user groups that are part of a team in an organization.

Required scope

Rate limiting

Level 1

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 limit: The maximum number of user groups in the result list. :type limit: int :param cursor: A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning. :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_create_team( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an 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

11722    @validate_call
11723    def enterprise_create_team(
11724        self,
11725        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
11726        create_team_request: CreateTeamRequest,
11727        _request_timeout: Union[
11728            None,
11729            Annotated[StrictFloat, Field(gt=0)],
11730            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11731        ] = None,
11732        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11733        _content_type: Optional[StrictStr] = None,
11734        _headers: Optional[Dict[StrictStr, Any]] = None,
11735        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11736    ) -> Team:
11737        """Create team
11738
11739        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
11740
11741        :param org_id: The ID of an organization. (required)
11742        :type org_id: str
11743        :param create_team_request: (required)
11744        :type create_team_request: CreateTeamRequest
11745        :param _request_timeout: timeout setting for this request. If one
11746                                 number provided, it will be total request
11747                                 timeout. It can also be a pair (tuple) of
11748                                 (connection, read) timeouts.
11749        :type _request_timeout: int, tuple(int, int), optional
11750        :param _request_auth: set to override the auth_settings for an a single
11751                              request; this effectively ignores the
11752                              authentication in the spec for a single request.
11753        :type _request_auth: dict, optional
11754        :param _content_type: force content-type for the request.
11755        :type _content_type: str, Optional
11756        :param _headers: set to override the headers for a single
11757                         request; this effectively ignores the headers
11758                         in the spec for a single request.
11759        :type _headers: dict, optional
11760        :param _host_index: set to override the host_index for a single
11761                            request; this effectively ignores the host_index
11762                            in the spec for a single request.
11763        :type _host_index: int, optional
11764        :return: Returns the result object.
11765        """  # noqa: E501
11766
11767        _param = self._enterprise_create_team_serialize(
11768            org_id=org_id,
11769            create_team_request=create_team_request,
11770            _request_auth=_request_auth,
11771            _content_type=_content_type,
11772            _headers=_headers,
11773            _host_index=_host_index,
11774        )
11775
11776        _response_types_map: Dict[str, Optional[str]] = {
11777            "201": "Team",
11778            "400": None,
11779            "401": None,
11780            "403": None,
11781            "404": None,
11782            "429": None,
11783        }
11784        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11785        response_data.read()
11786        return self.api_client.response_deserialize(
11787            response_data=response_data,
11788            response_types_map=_response_types_map,
11789        ).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 an 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 an organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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

11851    @validate_call
11852    def enterprise_delete_team(
11853        self,
11854        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
11855        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
11856        _request_timeout: Union[
11857            None,
11858            Annotated[StrictFloat, Field(gt=0)],
11859            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11860        ] = None,
11861        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11862        _content_type: Optional[StrictStr] = None,
11863        _headers: Optional[Dict[StrictStr, Any]] = None,
11864        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11865    ) -> None:
11866        """Delete team
11867
11868        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
11869
11870        :param org_id: The ID of an organization. (required)
11871        :type org_id: str
11872        :param team_id: The ID of a team. (required)
11873        :type team_id: str
11874        :param _request_timeout: timeout setting for this request. If one
11875                                 number provided, it will be total request
11876                                 timeout. It can also be a pair (tuple) of
11877                                 (connection, read) timeouts.
11878        :type _request_timeout: int, tuple(int, int), optional
11879        :param _request_auth: set to override the auth_settings for an a single
11880                              request; this effectively ignores the
11881                              authentication in the spec for a single request.
11882        :type _request_auth: dict, optional
11883        :param _content_type: force content-type for the request.
11884        :type _content_type: str, Optional
11885        :param _headers: set to override the headers for a single
11886                         request; this effectively ignores the headers
11887                         in the spec for a single request.
11888        :type _headers: dict, optional
11889        :param _host_index: set to override the host_index for a single
11890                            request; this effectively ignores the host_index
11891                            in the spec for a single request.
11892        :type _host_index: int, optional
11893        :return: Returns the result object.
11894        """  # noqa: E501
11895
11896        _param = self._enterprise_delete_team_serialize(
11897            org_id=org_id,
11898            team_id=team_id,
11899            _request_auth=_request_auth,
11900            _content_type=_content_type,
11901            _headers=_headers,
11902            _host_index=_host_index,
11903        )
11904
11905        _response_types_map: Dict[str, Optional[str]] = {
11906            "204": None,
11907            "400": None,
11908            "401": None,
11909            "403": None,
11910            "404": None,
11911            "429": None,
11912        }
11913        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
11914        response_data.read()
11915        return self.api_client.response_deserialize(
11916            response_data=response_data,
11917            response_types_map=_response_types_map,
11918        ).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 an organization. (required) :type org_id: str :param team_id: The ID of a 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 an organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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

11969    @validate_call
11970    def enterprise_get_team(
11971        self,
11972        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
11973        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
11974        _request_timeout: Union[
11975            None,
11976            Annotated[StrictFloat, Field(gt=0)],
11977            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
11978        ] = None,
11979        _request_auth: Optional[Dict[StrictStr, Any]] = None,
11980        _content_type: Optional[StrictStr] = None,
11981        _headers: Optional[Dict[StrictStr, Any]] = None,
11982        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
11983    ) -> Team:
11984        """Get team
11985
11986        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
11987
11988        :param org_id: The ID of an organization. (required)
11989        :type org_id: str
11990        :param team_id: The ID of a team. (required)
11991        :type team_id: str
11992        :param _request_timeout: timeout setting for this request. If one
11993                                 number provided, it will be total request
11994                                 timeout. It can also be a pair (tuple) of
11995                                 (connection, read) timeouts.
11996        :type _request_timeout: int, tuple(int, int), optional
11997        :param _request_auth: set to override the auth_settings for an a single
11998                              request; this effectively ignores the
11999                              authentication in the spec for a single request.
12000        :type _request_auth: dict, optional
12001        :param _content_type: force content-type for the request.
12002        :type _content_type: str, Optional
12003        :param _headers: set to override the headers for a single
12004                         request; this effectively ignores the headers
12005                         in the spec for a single request.
12006        :type _headers: dict, optional
12007        :param _host_index: set to override the host_index for a single
12008                            request; this effectively ignores the host_index
12009                            in the spec for a single request.
12010        :type _host_index: int, optional
12011        :return: Returns the result object.
12012        """  # noqa: E501
12013
12014        _param = self._enterprise_get_team_serialize(
12015            org_id=org_id,
12016            team_id=team_id,
12017            _request_auth=_request_auth,
12018            _content_type=_content_type,
12019            _headers=_headers,
12020            _host_index=_host_index,
12021        )
12022
12023        _response_types_map: Dict[str, Optional[str]] = {
12024            "200": "Team",
12025            "400": None,
12026            "401": None,
12027            "403": None,
12028            "404": None,
12029            "429": None,
12030        }
12031        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12032        response_data.read()
12033        return self.api_client.response_deserialize(
12034            response_data=response_data,
12035            response_types_map=_response_types_map,
12036        ).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 an organization. (required) :type org_id: str :param team_id: The ID of a 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 an 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

12090    @validate_call
12091    def enterprise_get_teams(
12092        self,
12093        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
12094        limit: Optional[Annotated[int, Field(le=100, strict=True, ge=1)]] = None,
12095        cursor: Annotated[
12096            Optional[StrictStr],
12097            Field(
12098                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."
12099            ),
12100        ] = None,
12101        name: Annotated[
12102            Optional[StrictStr],
12103            Field(
12104                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".'
12105            ),
12106        ] = None,
12107        _request_timeout: Union[
12108            None,
12109            Annotated[StrictFloat, Field(gt=0)],
12110            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12111        ] = None,
12112        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12113        _content_type: Optional[StrictStr] = None,
12114        _headers: Optional[Dict[StrictStr, Any]] = None,
12115        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12116    ) -> TeamsPage:
12117        """List teams
12118
12119        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
12120
12121        :param org_id: The ID of an organization. (required)
12122        :type org_id: str
12123        :param limit:
12124        :type limit: int
12125        :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.
12126        :type cursor: str
12127        :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\".
12128        :type name: str
12129        :param _request_timeout: timeout setting for this request. If one
12130                                 number provided, it will be total request
12131                                 timeout. It can also be a pair (tuple) of
12132                                 (connection, read) timeouts.
12133        :type _request_timeout: int, tuple(int, int), optional
12134        :param _request_auth: set to override the auth_settings for an a single
12135                              request; this effectively ignores the
12136                              authentication in the spec for a single request.
12137        :type _request_auth: dict, optional
12138        :param _content_type: force content-type for the request.
12139        :type _content_type: str, Optional
12140        :param _headers: set to override the headers for a single
12141                         request; this effectively ignores the headers
12142                         in the spec for a single request.
12143        :type _headers: dict, optional
12144        :param _host_index: set to override the host_index for a single
12145                            request; this effectively ignores the host_index
12146                            in the spec for a single request.
12147        :type _host_index: int, optional
12148        :return: Returns the result object.
12149        """  # noqa: E501
12150
12151        _param = self._enterprise_get_teams_serialize(
12152            org_id=org_id,
12153            limit=limit,
12154            cursor=cursor,
12155            name=name,
12156            _request_auth=_request_auth,
12157            _content_type=_content_type,
12158            _headers=_headers,
12159            _host_index=_host_index,
12160        )
12161
12162        _response_types_map: Dict[str, Optional[str]] = {
12163            "200": "TeamsPage",
12164            "400": None,
12165            "401": None,
12166            "403": None,
12167            "404": None,
12168            "429": None,
12169        }
12170        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12171        response_data.read()
12172        return self.api_client.response_deserialize(
12173            response_data=response_data,
12174            response_types_map=_response_types_map,
12175        ).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 an 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 an organization.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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

12241    @validate_call
12242    def enterprise_update_team(
12243        self,
12244        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
12245        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
12246        team_changes: TeamChanges,
12247        _request_timeout: Union[
12248            None,
12249            Annotated[StrictFloat, Field(gt=0)],
12250            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12251        ] = None,
12252        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12253        _content_type: Optional[StrictStr] = None,
12254        _headers: Optional[Dict[StrictStr, Any]] = None,
12255        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12256    ) -> Team:
12257        """Update team
12258
12259        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=\"/reference/rate-limiting#rate-limit-tiers\">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>
12260
12261        :param org_id: The ID of an organization. (required)
12262        :type org_id: str
12263        :param team_id: The ID of a team. (required)
12264        :type team_id: str
12265        :param team_changes: (required)
12266        :type team_changes: TeamChanges
12267        :param _request_timeout: timeout setting for this request. If one
12268                                 number provided, it will be total request
12269                                 timeout. It can also be a pair (tuple) of
12270                                 (connection, read) timeouts.
12271        :type _request_timeout: int, tuple(int, int), optional
12272        :param _request_auth: set to override the auth_settings for an a single
12273                              request; this effectively ignores the
12274                              authentication in the spec for a single request.
12275        :type _request_auth: dict, optional
12276        :param _content_type: force content-type for the request.
12277        :type _content_type: str, Optional
12278        :param _headers: set to override the headers for a single
12279                         request; this effectively ignores the headers
12280                         in the spec for a single request.
12281        :type _headers: dict, optional
12282        :param _host_index: set to override the host_index for a single
12283                            request; this effectively ignores the host_index
12284                            in the spec for a single request.
12285        :type _host_index: int, optional
12286        :return: Returns the result object.
12287        """  # noqa: E501
12288
12289        _param = self._enterprise_update_team_serialize(
12290            org_id=org_id,
12291            team_id=team_id,
12292            team_changes=team_changes,
12293            _request_auth=_request_auth,
12294            _content_type=_content_type,
12295            _headers=_headers,
12296            _host_index=_host_index,
12297        )
12298
12299        _response_types_map: Dict[str, Optional[str]] = {
12300            "200": "Team",
12301            "400": None,
12302            "401": None,
12303            "403": None,
12304            "404": None,
12305            "429": None,
12306        }
12307        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12308        response_data.read()
12309        return self.api_client.response_deserialize(
12310            response_data=response_data,
12311            response_types_map=_response_types_map,
12312        ).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 an organization. (required) :type org_id: str :param team_id: The ID of a 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_user( self, create_user_resource: miro_api.models.create_user_resource.CreateUserResource, _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.user_resource.UserResource: View Source

12377    @validate_call
12378    def create_user(
12379        self,
12380        create_user_resource: CreateUserResource,
12381        _request_timeout: Union[
12382            None,
12383            Annotated[StrictFloat, Field(gt=0)],
12384            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12385        ] = None,
12386        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12387        _content_type: Optional[StrictStr] = None,
12388        _headers: Optional[Dict[StrictStr, Any]] = None,
12389        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12390    ) -> UserResource:
12391        """Create user
12392
12393        Creates a new user in the organization. <br><br> <br>Note</b>: All newly provisioned users are added to the default team.
12394
12395        :param create_user_resource: (required)
12396        :type create_user_resource: CreateUserResource
12397        :param _request_timeout: timeout setting for this request. If one
12398                                 number provided, it will be total request
12399                                 timeout. It can also be a pair (tuple) of
12400                                 (connection, read) timeouts.
12401        :type _request_timeout: int, tuple(int, int), optional
12402        :param _request_auth: set to override the auth_settings for an a single
12403                              request; this effectively ignores the
12404                              authentication in the spec for a single request.
12405        :type _request_auth: dict, optional
12406        :param _content_type: force content-type for the request.
12407        :type _content_type: str, Optional
12408        :param _headers: set to override the headers for a single
12409                         request; this effectively ignores the headers
12410                         in the spec for a single request.
12411        :type _headers: dict, optional
12412        :param _host_index: set to override the host_index for a single
12413                            request; this effectively ignores the host_index
12414                            in the spec for a single request.
12415        :type _host_index: int, optional
12416        :return: Returns the result object.
12417        """  # noqa: E501
12418
12419        _param = self._create_user_serialize(
12420            create_user_resource=create_user_resource,
12421            _request_auth=_request_auth,
12422            _content_type=_content_type,
12423            _headers=_headers,
12424            _host_index=_host_index,
12425        )
12426
12427        _response_types_map: Dict[str, Optional[str]] = {
12428            "201": "UserResource",
12429            "400": None,
12430            "401": None,
12431            "403": None,
12432            "404": None,
12433            "409": None,
12434            "413": None,
12435            "429": None,
12436            "500": None,
12437        }
12438        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12439        response_data.read()
12440        return self.api_client.response_deserialize(
12441            response_data=response_data,
12442            response_types_map=_response_types_map,
12443        ).data

Create user

Creates a new user in the organization.

Note: All newly provisioned users are added to the default team.

:param create_user_resource: (required) :type create_user_resource: CreateUserResource :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_user( self, id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='User ID. A server-assigned, unique identifier for this user.')], _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

12504    @validate_call
12505    def delete_user(
12506        self,
12507        id: Annotated[StrictStr, Field(description="User ID. A server-assigned, unique identifier for this user.")],
12508        _request_timeout: Union[
12509            None,
12510            Annotated[StrictFloat, Field(gt=0)],
12511            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12512        ] = None,
12513        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12514        _content_type: Optional[StrictStr] = None,
12515        _headers: Optional[Dict[StrictStr, Any]] = None,
12516        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12517    ) -> None:
12518        """Delete user
12519
12520        Deletes a single user from the organization.<br><br> Note: A user who is the last admin in the team or the last admin in the organization cannot be deleted. User must be a member in the organization to be deleted. Users that have guest role in the organization cannot be deleted. <br><br> After a user is deleted, the ownership of all the boards that belong to the deleted user is transferred to the oldest team member who currently has an admin role.
12521
12522        :param id: User ID. A server-assigned, unique identifier for this user. (required)
12523        :type id: str
12524        :param _request_timeout: timeout setting for this request. If one
12525                                 number provided, it will be total request
12526                                 timeout. It can also be a pair (tuple) of
12527                                 (connection, read) timeouts.
12528        :type _request_timeout: int, tuple(int, int), optional
12529        :param _request_auth: set to override the auth_settings for an a single
12530                              request; this effectively ignores the
12531                              authentication in the spec for a single request.
12532        :type _request_auth: dict, optional
12533        :param _content_type: force content-type for the request.
12534        :type _content_type: str, Optional
12535        :param _headers: set to override the headers for a single
12536                         request; this effectively ignores the headers
12537                         in the spec for a single request.
12538        :type _headers: dict, optional
12539        :param _host_index: set to override the host_index for a single
12540                            request; this effectively ignores the host_index
12541                            in the spec for a single request.
12542        :type _host_index: int, optional
12543        :return: Returns the result object.
12544        """  # noqa: E501
12545
12546        _param = self._delete_user_serialize(
12547            id=id, _request_auth=_request_auth, _content_type=_content_type, _headers=_headers, _host_index=_host_index
12548        )
12549
12550        _response_types_map: Dict[str, Optional[str]] = {
12551            "204": None,
12552            "400": None,
12553            "401": None,
12554            "403": None,
12555            "404": None,
12556            "409": None,
12557            "429": None,
12558            "500": None,
12559        }
12560        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12561        response_data.read()
12562        return self.api_client.response_deserialize(
12563            response_data=response_data,
12564            response_types_map=_response_types_map,
12565        ).data

Delete user

Deletes a single user from the organization.

Note: A user who is the last admin in the team or the last admin in the organization cannot be deleted. User must be a member in the organization to be deleted. Users that have guest role in the organization cannot be deleted.

After a user is deleted, the ownership of all the boards that belong to the deleted user is transferred to the oldest team member who currently has an admin role.

:param id: User ID. A server-assigned, unique identifier for this user. (required) :type 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( self, id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='User ID of the user to be retrieved')], attributes: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A comma-separated list of attribute names to return in the response. Example attributes - id, userName, displayName, name, userType, active, emails, photos, groups, roles. Note: It is also possible to fetch attributes within complex attributes, for Example: emails.value')] = 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.user_resource.UserResource: View Source

12613    @validate_call
12614    def get_user(
12615        self,
12616        id: Annotated[StrictStr, Field(description="User ID of the user to be retrieved")],
12617        attributes: Annotated[
12618            Optional[StrictStr],
12619            Field(
12620                description="A comma-separated list of attribute names to return in the response. <br><br> <br>Example attributes</b> - id, userName, displayName, name, userType, active, emails, photos, groups, roles. <br><br> <br>Note</b>: It is also possible to fetch attributes within complex attributes, for Example: emails.value"
12621            ),
12622        ] = None,
12623        _request_timeout: Union[
12624            None,
12625            Annotated[StrictFloat, Field(gt=0)],
12626            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12627        ] = None,
12628        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12629        _content_type: Optional[StrictStr] = None,
12630        _headers: Optional[Dict[StrictStr, Any]] = None,
12631        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12632    ) -> UserResource:
12633        """Get user
12634
12635        Retrieves a single user resource. <br><b> <br>Note</b>: Returns only users that are members in the organization. It does not return users that are added in the organization as guests.
12636
12637        :param id: User ID of the user to be retrieved (required)
12638        :type id: str
12639        :param attributes: A comma-separated list of attribute names to return in the response. <br><br> <br>Example attributes</b> - id, userName, displayName, name, userType, active, emails, photos, groups, roles. <br><br> <br>Note</b>: It is also possible to fetch attributes within complex attributes, for Example: emails.value
12640        :type attributes: str
12641        :param _request_timeout: timeout setting for this request. If one
12642                                 number provided, it will be total request
12643                                 timeout. It can also be a pair (tuple) of
12644                                 (connection, read) timeouts.
12645        :type _request_timeout: int, tuple(int, int), optional
12646        :param _request_auth: set to override the auth_settings for an a single
12647                              request; this effectively ignores the
12648                              authentication in the spec for a single request.
12649        :type _request_auth: dict, optional
12650        :param _content_type: force content-type for the request.
12651        :type _content_type: str, Optional
12652        :param _headers: set to override the headers for a single
12653                         request; this effectively ignores the headers
12654                         in the spec for a single request.
12655        :type _headers: dict, optional
12656        :param _host_index: set to override the host_index for a single
12657                            request; this effectively ignores the host_index
12658                            in the spec for a single request.
12659        :type _host_index: int, optional
12660        :return: Returns the result object.
12661        """  # noqa: E501
12662
12663        _param = self._get_user_serialize(
12664            id=id,
12665            attributes=attributes,
12666            _request_auth=_request_auth,
12667            _content_type=_content_type,
12668            _headers=_headers,
12669            _host_index=_host_index,
12670        )
12671
12672        _response_types_map: Dict[str, Optional[str]] = {
12673            "200": "UserResource",
12674            "400": None,
12675            "401": None,
12676            "403": None,
12677            "404": None,
12678            "429": None,
12679            "500": None,
12680        }
12681        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12682        response_data.read()
12683        return self.api_client.response_deserialize(
12684            response_data=response_data,
12685            response_types_map=_response_types_map,
12686        ).data

Get user

Retrieves a single user resource.

Note: Returns only users that are members in the organization. It does not return users that are added in the organization as guests.

:param id: User ID of the user to be retrieved (required) :type id: str :param attributes: A comma-separated list of attribute names to return in the response.

Example attributes - id, userName, displayName, name, userType, active, emails, photos, groups, roles.

Note: It is also possible to fetch attributes within complex attributes, for Example: emails.value :type attributes: 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 list_users( self, attributes: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A comma-separated list of attribute names to return in the response. Example attributes: id, userName, displayName, name, userType, active, emails, photos, groups, roles. You can also retrieve attributes within complex attributes, for Example: emails.value. The API also supports sorting and the filter parameter.')] = None, filter: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='You can request a subset of resources by specifying the filter query parameter containing a filter expression. Attribute names and attribute operators used in filters are not case sensitive. The filter parameter must contain at least one valid expression. Each expression must contain an attribute name followed by an attribute operator and an optional value. eq = equal ne = not equal co = contains sw = starts with ew = ends with pr = preset (has value) gt = greater than ge = greater than or equal to lt = less than le = less than or equal to and = Logical "and" or = Logical "or" not = "Not" function () = Precedence grouping The value must be passed within parenthesis. Example filters: For fetching users with user name as user@miro.com: userName eq "user@miro.com" For fetching all active users in the organization: active eq true For fetching users with "user" in their displayName: displayName co "user" For fetching users that are member of a specific group (team): groups.value eq "3458764577585056871" For fetching users that are not of userType Full: userType ne "Full"')] = None, start_index: Annotated[Optional[Annotated[int, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Use startIndex in combination with count query parameters to receive paginated results. start index is 1-based. Example: startIndex=1')] = None, count: Annotated[Optional[Annotated[int, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Specifies the maximum number of query results per page. Use count in combination with startIndex query parameters to receive paginated results. The count query parameter is set to 100 by default and the maximum value allowed for this parameter is 1000. Example: count=12')] = None, sort_by: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Specifies the attribute whose value will be used to order the response. Example: sortBy=userName, sortBy=emails.value')] = None, sort_order: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='Defines the order in which the sortBy parameter is applied. Example: sortOrder=ascending')] = 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.user_list_response.UserListResponse: View Source

12742    @validate_call
12743    def list_users(
12744        self,
12745        attributes: Annotated[
12746            Optional[StrictStr],
12747            Field(
12748                description="A comma-separated list of attribute names to return in the response. <br><br> Example attributes: id, userName, displayName, name, userType, active, emails, photos, groups, roles. You can also retrieve attributes within complex attributes, for Example: emails.value. The API also supports sorting and the filter parameter."
12749            ),
12750        ] = None,
12751        filter: Annotated[
12752            Optional[StrictStr],
12753            Field(
12754                description='You can request a subset of resources by specifying the filter query parameter containing a filter expression. Attribute names and attribute operators used in filters are not case sensitive. The filter parameter must contain at least one valid expression. Each expression must contain an attribute name followed by an attribute operator and an optional value. <br>eq = equal<br> ne = not equal<br> co = contains<br> sw = starts with<br> ew = ends with<br> pr = preset (has value)<br> gt = greater than<br> ge = greater than or equal to<br> lt = less than<br> le = less than or equal to<br> and = Logical "and"<br> or = Logical "or"<br> not = "Not" function<br> () = Precedence grouping <br>The value must be passed within parenthesis. <br><br> <u>Example filters</u>:<br><br> For fetching  users with user name as user@miro.com: userName eq "user@miro.com" <br><br> For fetching all active users in the organization: active eq true <br><br> For fetching users with "user" in their displayName: displayName co "user" <br><br> For fetching users that are member of a specific group (team): groups.value eq "3458764577585056871" <br><br> For fetching users that are not of userType Full: userType ne "Full"'
12755            ),
12756        ] = None,
12757        start_index: Annotated[
12758            Optional[StrictInt],
12759            Field(
12760                description="Use startIndex in combination with count query parameters to receive paginated results. <br><br> start index is 1-based. <br><br> Example: startIndex=1"
12761            ),
12762        ] = None,
12763        count: Annotated[
12764            Optional[StrictInt],
12765            Field(
12766                description="Specifies the maximum number of query results per page. <br><br> Use count in combination with startIndex query parameters to receive paginated results. <br><br> The count query parameter is set to 100 by default and the maximum value allowed for this parameter is 1000. <br><br> Example: count=12"
12767            ),
12768        ] = None,
12769        sort_by: Annotated[
12770            Optional[StrictStr],
12771            Field(
12772                description="Specifies the attribute whose value will be used to order the response. <br><br> Example: sortBy=userName, sortBy=emails.value"
12773            ),
12774        ] = None,
12775        sort_order: Annotated[
12776            Optional[StrictStr],
12777            Field(
12778                description="Defines the order in which the sortBy parameter is applied. <br><br> Example: sortOrder=ascending"
12779            ),
12780        ] = None,
12781        _request_timeout: Union[
12782            None,
12783            Annotated[StrictFloat, Field(gt=0)],
12784            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12785        ] = None,
12786        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12787        _content_type: Optional[StrictStr] = None,
12788        _headers: Optional[Dict[StrictStr, Any]] = None,
12789        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12790    ) -> UserListResponse:
12791        """List users
12792
12793        Retrieves the list of users in your organization. <br><b> <br>Note</b>: The API returns users that are members in the organization, it does not return users that are added in the organization as guests.
12794
12795        :param attributes: A comma-separated list of attribute names to return in the response. <br><br> Example attributes: id, userName, displayName, name, userType, active, emails, photos, groups, roles. You can also retrieve attributes within complex attributes, for Example: emails.value. The API also supports sorting and the filter parameter.
12796        :type attributes: str
12797        :param filter: You can request a subset of resources by specifying the filter query parameter containing a filter expression. Attribute names and attribute operators used in filters are not case sensitive. The filter parameter must contain at least one valid expression. Each expression must contain an attribute name followed by an attribute operator and an optional value. <br>eq = equal<br> ne = not equal<br> co = contains<br> sw = starts with<br> ew = ends with<br> pr = preset (has value)<br> gt = greater than<br> ge = greater than or equal to<br> lt = less than<br> le = less than or equal to<br> and = Logical \"and\"<br> or = Logical \"or\"<br> not = \"Not\" function<br> () = Precedence grouping <br>The value must be passed within parenthesis. <br><br> <u>Example filters</u>:<br><br> For fetching  users with user name as user@miro.com: userName eq \"user@miro.com\" <br><br> For fetching all active users in the organization: active eq true <br><br> For fetching users with \"user\" in their displayName: displayName co \"user\" <br><br> For fetching users that are member of a specific group (team): groups.value eq \"3458764577585056871\" <br><br> For fetching users that are not of userType Full: userType ne \"Full\"
12798        :type filter: str
12799        :param start_index: Use startIndex in combination with count query parameters to receive paginated results. <br><br> start index is 1-based. <br><br> Example: startIndex=1
12800        :type start_index: int
12801        :param count: Specifies the maximum number of query results per page. <br><br> Use count in combination with startIndex query parameters to receive paginated results. <br><br> The count query parameter is set to 100 by default and the maximum value allowed for this parameter is 1000. <br><br> Example: count=12
12802        :type count: int
12803        :param sort_by: Specifies the attribute whose value will be used to order the response. <br><br> Example: sortBy=userName, sortBy=emails.value
12804        :type sort_by: str
12805        :param sort_order: Defines the order in which the sortBy parameter is applied. <br><br> Example: sortOrder=ascending
12806        :type sort_order: str
12807        :param _request_timeout: timeout setting for this request. If one
12808                                 number provided, it will be total request
12809                                 timeout. It can also be a pair (tuple) of
12810                                 (connection, read) timeouts.
12811        :type _request_timeout: int, tuple(int, int), optional
12812        :param _request_auth: set to override the auth_settings for an a single
12813                              request; this effectively ignores the
12814                              authentication in the spec for a single request.
12815        :type _request_auth: dict, optional
12816        :param _content_type: force content-type for the request.
12817        :type _content_type: str, Optional
12818        :param _headers: set to override the headers for a single
12819                         request; this effectively ignores the headers
12820                         in the spec for a single request.
12821        :type _headers: dict, optional
12822        :param _host_index: set to override the host_index for a single
12823                            request; this effectively ignores the host_index
12824                            in the spec for a single request.
12825        :type _host_index: int, optional
12826        :return: Returns the result object.
12827        """  # noqa: E501
12828
12829        _param = self._list_users_serialize(
12830            attributes=attributes,
12831            filter=filter,
12832            start_index=start_index,
12833            count=count,
12834            sort_by=sort_by,
12835            sort_order=sort_order,
12836            _request_auth=_request_auth,
12837            _content_type=_content_type,
12838            _headers=_headers,
12839            _host_index=_host_index,
12840        )
12841
12842        _response_types_map: Dict[str, Optional[str]] = {
12843            "200": "UserListResponse",
12844            "400": None,
12845            "401": None,
12846            "403": None,
12847            "404": None,
12848            "429": None,
12849            "500": None,
12850        }
12851        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
12852        response_data.read()
12853        return self.api_client.response_deserialize(
12854            response_data=response_data,
12855            response_types_map=_response_types_map,
12856        ).data

List users

Retrieves the list of users in your organization.

Note: The API returns users that are members in the organization, it does not return users that are added in the organization as guests.

:param attributes: A comma-separated list of attribute names to return in the response.

Example attributes: id, userName, displayName, name, userType, active, emails, photos, groups, roles. You can also retrieve attributes within complex attributes, for Example: emails.value. The API also supports sorting and the filter parameter. :type attributes: str :param filter: You can request a subset of resources by specifying the filter query parameter containing a filter expression. Attribute names and attribute operators used in filters are not case sensitive. The filter parameter must contain at least one valid expression. Each expression must contain an attribute name followed by an attribute operator and an optional value.
eq = equal
ne = not equal
co = contains
sw = starts with
ew = ends with
pr = preset (has value)
gt = greater than
ge = greater than or equal to
lt = less than
le = less than or equal to
and = Logical "and"
or = Logical "or"
not = "Not" function
() = Precedence grouping
The value must be passed within parenthesis.

Example filters:

For fetching users with user name as user@miro.com: userName eq "user@miro.com"

For fetching all active users in the organization: active eq true

For fetching users with "user" in their displayName: displayName co "user"

For fetching users that are member of a specific group (team): groups.value eq "3458764577585056871"

For fetching users that are not of userType Full: userType ne "Full" :type filter: str :param start_index: Use startIndex in combination with count query parameters to receive paginated results.

start index is 1-based.

Example: startIndex=1 :type start_index: int :param count: Specifies the maximum number of query results per page.

Use count in combination with startIndex query parameters to receive paginated results.

The count query parameter is set to 100 by default and the maximum value allowed for this parameter is 1000.

Example: count=12 :type count: int :param sort_by: Specifies the attribute whose value will be used to order the response.

Example: sortBy=userName, sortBy=emails.value :type sort_by: str :param sort_order: Defines the order in which the sortBy parameter is applied.

Example: sortOrder=ascending :type sort_order: 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 patch_user( self, id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='User ID. A server-assigned, unique identifier for this user.')], patch_user_resource: typing.Annotated[miro_api.models.patch_user_resource.PatchUserResource, FieldInfo(annotation=NoneType, required=True, description='Payload to update user information. The body of a PATCH request must contain the attribute `Operations`, and its value is an array of one or more PATCH operations. Each PATCH operation object must have exactly one "op" 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.user_resource.UserResource: View Source

12934    @validate_call
12935    def patch_user(
12936        self,
12937        id: Annotated[StrictStr, Field(description="User ID. A server-assigned, unique identifier for this user.")],
12938        patch_user_resource: Annotated[
12939            PatchUserResource,
12940            Field(
12941                description='Payload to update user information. <br><br> The body of a PATCH request must contain the attribute `Operations`, and its value is an array of one or more PATCH operations. Each PATCH operation object must have exactly one "op" member.'
12942            ),
12943        ],
12944        _request_timeout: Union[
12945            None,
12946            Annotated[StrictFloat, Field(gt=0)],
12947            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
12948        ] = None,
12949        _request_auth: Optional[Dict[StrictStr, Any]] = None,
12950        _content_type: Optional[StrictStr] = None,
12951        _headers: Optional[Dict[StrictStr, Any]] = None,
12952        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
12953    ) -> UserResource:
12954        """Patch user
12955
12956        Updates an existing user resource, overwriting values for specified attributes. Attributes that are not provided will remain unchanged. PATCH operation only updates the fields provided. <br><br> Note: If  the user is not a member in the organization, they cannot be updated. Additionally, users with guest role in the organization cannot be updated.
12957
12958        :param id: User ID. A server-assigned, unique identifier for this user. (required)
12959        :type id: str
12960        :param patch_user_resource: Payload to update user information. <br><br> The body of a PATCH request must contain the attribute `Operations`, and its value is an array of one or more PATCH operations. Each PATCH operation object must have exactly one \"op\" member. (required)
12961        :type patch_user_resource: PatchUserResource
12962        :param _request_timeout: timeout setting for this request. If one
12963                                 number provided, it will be total request
12964                                 timeout. It can also be a pair (tuple) of
12965                                 (connection, read) timeouts.
12966        :type _request_timeout: int, tuple(int, int), optional
12967        :param _request_auth: set to override the auth_settings for an a single
12968                              request; this effectively ignores the
12969                              authentication in the spec for a single request.
12970        :type _request_auth: dict, optional
12971        :param _content_type: force content-type for the request.
12972        :type _content_type: str, Optional
12973        :param _headers: set to override the headers for a single
12974                         request; this effectively ignores the headers
12975                         in the spec for a single request.
12976        :type _headers: dict, optional
12977        :param _host_index: set to override the host_index for a single
12978                            request; this effectively ignores the host_index
12979                            in the spec for a single request.
12980        :type _host_index: int, optional
12981        :return: Returns the result object.
12982        """  # noqa: E501
12983
12984        _param = self._patch_user_serialize(
12985            id=id,
12986            patch_user_resource=patch_user_resource,
12987            _request_auth=_request_auth,
12988            _content_type=_content_type,
12989            _headers=_headers,
12990            _host_index=_host_index,
12991        )
12992
12993        _response_types_map: Dict[str, Optional[str]] = {
12994            "200": "UserResource",
12995            "400": None,
12996            "401": None,
12997            "403": None,
12998            "404": None,
12999            "409": None,
13000            "429": None,
13001            "500": None,
13002        }
13003        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13004        response_data.read()
13005        return self.api_client.response_deserialize(
13006            response_data=response_data,
13007            response_types_map=_response_types_map,
13008        ).data

Patch user

Updates an existing user resource, overwriting values for specified attributes. Attributes that are not provided will remain unchanged. PATCH operation only updates the fields provided.

Note: If the user is not a member in the organization, they cannot be updated. Additionally, users with guest role in the organization cannot be updated.

:param id: User ID. A server-assigned, unique identifier for this user. (required) :type id: str :param patch_user_resource: Payload to update user information.

The body of a PATCH request must contain the attribute Operations, and its value is an array of one or more PATCH operations. Each PATCH operation object must have exactly one "op" member. (required) :type patch_user_resource: PatchUserResource :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 replace_user( self, id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='User ID. A server-assigned, unique identifier for this user.')], user_resource: typing.Annotated[miro_api.models.user_resource.UserResource, FieldInfo(annotation=NoneType, required=True, description='Payload to update user 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.user_resource.UserResource: View Source

13072    @validate_call
13073    def replace_user(
13074        self,
13075        id: Annotated[StrictStr, Field(description="User ID. A server-assigned, unique identifier for this user.")],
13076        user_resource: Annotated[UserResource, Field(description="Payload to update user information.")],
13077        _request_timeout: Union[
13078            None,
13079            Annotated[StrictFloat, Field(gt=0)],
13080            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13081        ] = None,
13082        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13083        _content_type: Optional[StrictStr] = None,
13084        _headers: Optional[Dict[StrictStr, Any]] = None,
13085        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13086    ) -> UserResource:
13087        """Replace user
13088
13089        Updates an existing user resource. This is the easiest way to replace user information. <br><br> If the user is deactivated, <br> userName, userType, and roles.value cannot be updated. <br> emails.value, emails.display, emails.primary get ignored and do not return any error. <br><br> Note: If the user is not a member in the organization, they cannot be updated. Additionally, users with guest role in the organization cannot be updated.
13090
13091        :param id: User ID. A server-assigned, unique identifier for this user. (required)
13092        :type id: str
13093        :param user_resource: Payload to update user information. (required)
13094        :type user_resource: UserResource
13095        :param _request_timeout: timeout setting for this request. If one
13096                                 number provided, it will be total request
13097                                 timeout. It can also be a pair (tuple) of
13098                                 (connection, read) timeouts.
13099        :type _request_timeout: int, tuple(int, int), optional
13100        :param _request_auth: set to override the auth_settings for an a single
13101                              request; this effectively ignores the
13102                              authentication in the spec for a single request.
13103        :type _request_auth: dict, optional
13104        :param _content_type: force content-type for the request.
13105        :type _content_type: str, Optional
13106        :param _headers: set to override the headers for a single
13107                         request; this effectively ignores the headers
13108                         in the spec for a single request.
13109        :type _headers: dict, optional
13110        :param _host_index: set to override the host_index for a single
13111                            request; this effectively ignores the host_index
13112                            in the spec for a single request.
13113        :type _host_index: int, optional
13114        :return: Returns the result object.
13115        """  # noqa: E501
13116
13117        _param = self._replace_user_serialize(
13118            id=id,
13119            user_resource=user_resource,
13120            _request_auth=_request_auth,
13121            _content_type=_content_type,
13122            _headers=_headers,
13123            _host_index=_host_index,
13124        )
13125
13126        _response_types_map: Dict[str, Optional[str]] = {
13127            "200": "UserResource",
13128            "400": None,
13129            "401": None,
13130            "403": None,
13131            "404": None,
13132            "409": None,
13133            "429": None,
13134            "500": None,
13135        }
13136        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13137        response_data.read()
13138        return self.api_client.response_deserialize(
13139            response_data=response_data,
13140            response_types_map=_response_types_map,
13141        ).data

Replace user

Updates an existing user resource. This is the easiest way to replace user information.

If the user is deactivated,
userName, userType, and roles.value cannot be updated.
emails.value, emails.display, emails.primary get ignored and do not return any error.

Note: If the user is not a member in the organization, they cannot be updated. Additionally, users with guest role in the organization cannot be updated.

:param id: User ID. A server-assigned, unique identifier for this user. (required) :type id: str :param user_resource: Payload to update user information. (required) :type user_resource: UserResource :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_group_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user group.')], create_group_member_request: miro_api.models.create_group_member_request.CreateGroupMemberRequest, _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_member.GroupMember: View Source

13205    @validate_call
13206    def enterprise_create_group_member(
13207        self,
13208        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
13209        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
13210        create_group_member_request: CreateGroupMemberRequest,
13211        _request_timeout: Union[
13212            None,
13213            Annotated[StrictFloat, Field(gt=0)],
13214            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13215        ] = None,
13216        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13217        _content_type: Optional[StrictStr] = None,
13218        _headers: Optional[Dict[StrictStr, Any]] = None,
13219        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13220    ) -> GroupMember:
13221        """Create user group member
13222
13223        Adds a member to a user group in an organization.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:write</a><br/> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
13224
13225        :param org_id: The ID of an organization. (required)
13226        :type org_id: str
13227        :param group_id: The ID of a user group. (required)
13228        :type group_id: str
13229        :param create_group_member_request: (required)
13230        :type create_group_member_request: CreateGroupMemberRequest
13231        :param _request_timeout: timeout setting for this request. If one
13232                                 number provided, it will be total request
13233                                 timeout. It can also be a pair (tuple) of
13234                                 (connection, read) timeouts.
13235        :type _request_timeout: int, tuple(int, int), optional
13236        :param _request_auth: set to override the auth_settings for an a single
13237                              request; this effectively ignores the
13238                              authentication in the spec for a single request.
13239        :type _request_auth: dict, optional
13240        :param _content_type: force content-type for the request.
13241        :type _content_type: str, Optional
13242        :param _headers: set to override the headers for a single
13243                         request; this effectively ignores the headers
13244                         in the spec for a single request.
13245        :type _headers: dict, optional
13246        :param _host_index: set to override the host_index for a single
13247                            request; this effectively ignores the host_index
13248                            in the spec for a single request.
13249        :type _host_index: int, optional
13250        :return: Returns the result object.
13251        """  # noqa: E501
13252
13253        _param = self._enterprise_create_group_member_serialize(
13254            org_id=org_id,
13255            group_id=group_id,
13256            create_group_member_request=create_group_member_request,
13257            _request_auth=_request_auth,
13258            _content_type=_content_type,
13259            _headers=_headers,
13260            _host_index=_host_index,
13261        )
13262
13263        _response_types_map: Dict[str, Optional[str]] = {
13264            "201": "GroupMember",
13265            "400": None,
13266            "401": None,
13267            "403": None,
13268            "409": None,
13269            "429": None,
13270        }
13271        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13272        response_data.read()
13273        return self.api_client.response_deserialize(
13274            response_data=response_data,
13275            response_types_map=_response_types_map,
13276        ).data

Create user group member

Adds a member to a user group in 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 an organization. (required) :type org_id: str :param group_id: The ID of a user group. (required) :type group_id: str :param create_group_member_request: (required) :type create_group_member_request: CreateGroupMemberRequest :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_group_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user group.')], member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a group 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

13341    @validate_call
13342    def enterprise_delete_group_member(
13343        self,
13344        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
13345        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
13346        member_id: Annotated[StrictStr, Field(description="The ID of a group member.")],
13347        _request_timeout: Union[
13348            None,
13349            Annotated[StrictFloat, Field(gt=0)],
13350            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13351        ] = None,
13352        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13353        _content_type: Optional[StrictStr] = None,
13354        _headers: Optional[Dict[StrictStr, Any]] = None,
13355        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13356    ) -> None:
13357        """Delete user group member
13358
13359        Removes a member from a user group in an organization.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:write</a><br/> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
13360
13361        :param org_id: The ID of an organization. (required)
13362        :type org_id: str
13363        :param group_id: The ID of a user group. (required)
13364        :type group_id: str
13365        :param member_id: The ID of a group member. (required)
13366        :type member_id: str
13367        :param _request_timeout: timeout setting for this request. If one
13368                                 number provided, it will be total request
13369                                 timeout. It can also be a pair (tuple) of
13370                                 (connection, read) timeouts.
13371        :type _request_timeout: int, tuple(int, int), optional
13372        :param _request_auth: set to override the auth_settings for an a single
13373                              request; this effectively ignores the
13374                              authentication in the spec for a single request.
13375        :type _request_auth: dict, optional
13376        :param _content_type: force content-type for the request.
13377        :type _content_type: str, Optional
13378        :param _headers: set to override the headers for a single
13379                         request; this effectively ignores the headers
13380                         in the spec for a single request.
13381        :type _headers: dict, optional
13382        :param _host_index: set to override the host_index for a single
13383                            request; this effectively ignores the host_index
13384                            in the spec for a single request.
13385        :type _host_index: int, optional
13386        :return: Returns the result object.
13387        """  # noqa: E501
13388
13389        _param = self._enterprise_delete_group_member_serialize(
13390            org_id=org_id,
13391            group_id=group_id,
13392            member_id=member_id,
13393            _request_auth=_request_auth,
13394            _content_type=_content_type,
13395            _headers=_headers,
13396            _host_index=_host_index,
13397        )
13398
13399        _response_types_map: Dict[str, Optional[str]] = {
13400            "204": None,
13401            "400": None,
13402            "401": None,
13403            "403": None,
13404            "404": None,
13405            "429": None,
13406        }
13407        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13408        response_data.read()
13409        return self.api_client.response_deserialize(
13410            response_data=response_data,
13411            response_types_map=_response_types_map,
13412        ).data

Delete user group member

Removes a member from a user group in 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 an organization. (required) :type org_id: str :param group_id: The ID of a user group. (required) :type group_id: str :param member_id: The ID of a group 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_group_member( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user group.')], member_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a group 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.group_member.GroupMember: View Source

13466    @validate_call
13467    def enterprise_get_group_member(
13468        self,
13469        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
13470        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
13471        member_id: Annotated[StrictStr, Field(description="The ID of a group member.")],
13472        _request_timeout: Union[
13473            None,
13474            Annotated[StrictFloat, Field(gt=0)],
13475            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13476        ] = None,
13477        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13478        _content_type: Optional[StrictStr] = None,
13479        _headers: Optional[Dict[StrictStr, Any]] = None,
13480        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13481    ) -> GroupMember:
13482        """Get user group member
13483
13484        Retrieves information about a user group member in an organization.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a><br/> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
13485
13486        :param org_id: The ID of an organization. (required)
13487        :type org_id: str
13488        :param group_id: The ID of a user group. (required)
13489        :type group_id: str
13490        :param member_id: The ID of a group member. (required)
13491        :type member_id: str
13492        :param _request_timeout: timeout setting for this request. If one
13493                                 number provided, it will be total request
13494                                 timeout. It can also be a pair (tuple) of
13495                                 (connection, read) timeouts.
13496        :type _request_timeout: int, tuple(int, int), optional
13497        :param _request_auth: set to override the auth_settings for an a single
13498                              request; this effectively ignores the
13499                              authentication in the spec for a single request.
13500        :type _request_auth: dict, optional
13501        :param _content_type: force content-type for the request.
13502        :type _content_type: str, Optional
13503        :param _headers: set to override the headers for a single
13504                         request; this effectively ignores the headers
13505                         in the spec for a single request.
13506        :type _headers: dict, optional
13507        :param _host_index: set to override the host_index for a single
13508                            request; this effectively ignores the host_index
13509                            in the spec for a single request.
13510        :type _host_index: int, optional
13511        :return: Returns the result object.
13512        """  # noqa: E501
13513
13514        _param = self._enterprise_get_group_member_serialize(
13515            org_id=org_id,
13516            group_id=group_id,
13517            member_id=member_id,
13518            _request_auth=_request_auth,
13519            _content_type=_content_type,
13520            _headers=_headers,
13521            _host_index=_host_index,
13522        )
13523
13524        _response_types_map: Dict[str, Optional[str]] = {
13525            "200": "GroupMember",
13526            "400": None,
13527            "401": None,
13528            "403": None,
13529            "404": None,
13530            "429": None,
13531        }
13532        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13533        response_data.read()
13534        return self.api_client.response_deserialize(
13535            response_data=response_data,
13536            response_types_map=_response_types_map,
13537        ).data

Get user group member

Retrieves information about a user group member in 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 an organization. (required) :type org_id: str :param group_id: The ID of a user group. (required) :type group_id: str :param member_id: The ID of a group 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_group_members( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user group.')], 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 members in the result list.')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A representation of the position of a member in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.')] = 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.group_members_page.GroupMembersPage: View Source

13594    @validate_call
13595    def enterprise_get_group_members(
13596        self,
13597        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
13598        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
13599        limit: Annotated[
13600            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
13601            Field(description="The maximum number of members in the result list."),
13602        ] = None,
13603        cursor: Annotated[
13604            Optional[StrictStr],
13605            Field(
13606                description="A representation of the position of a member in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning."
13607            ),
13608        ] = None,
13609        _request_timeout: Union[
13610            None,
13611            Annotated[StrictFloat, Field(gt=0)],
13612            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13613        ] = None,
13614        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13615        _content_type: Optional[StrictStr] = None,
13616        _headers: Optional[Dict[StrictStr, Any]] = None,
13617        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13618    ) -> GroupMembersPage:
13619        """List of user group members
13620
13621        Retrieves the list of members who are part of a team in an existing organization.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a><br/> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
13622
13623        :param org_id: The ID of an organization. (required)
13624        :type org_id: str
13625        :param group_id: The ID of a user group. (required)
13626        :type group_id: str
13627        :param limit: The maximum number of members in the result list.
13628        :type limit: int
13629        :param cursor: A representation of the position of a member in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.
13630        :type cursor: str
13631        :param _request_timeout: timeout setting for this request. If one
13632                                 number provided, it will be total request
13633                                 timeout. It can also be a pair (tuple) of
13634                                 (connection, read) timeouts.
13635        :type _request_timeout: int, tuple(int, int), optional
13636        :param _request_auth: set to override the auth_settings for an a single
13637                              request; this effectively ignores the
13638                              authentication in the spec for a single request.
13639        :type _request_auth: dict, optional
13640        :param _content_type: force content-type for the request.
13641        :type _content_type: str, Optional
13642        :param _headers: set to override the headers for a single
13643                         request; this effectively ignores the headers
13644                         in the spec for a single request.
13645        :type _headers: dict, optional
13646        :param _host_index: set to override the host_index for a single
13647                            request; this effectively ignores the host_index
13648                            in the spec for a single request.
13649        :type _host_index: int, optional
13650        :return: Returns the result object.
13651        """  # noqa: E501
13652
13653        _param = self._enterprise_get_group_members_serialize(
13654            org_id=org_id,
13655            group_id=group_id,
13656            limit=limit,
13657            cursor=cursor,
13658            _request_auth=_request_auth,
13659            _content_type=_content_type,
13660            _headers=_headers,
13661            _host_index=_host_index,
13662        )
13663
13664        _response_types_map: Dict[str, Optional[str]] = {
13665            "200": "GroupMembersPage",
13666            "400": None,
13667            "401": None,
13668            "403": None,
13669            "429": None,
13670        }
13671        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13672        response_data.read()
13673        return self.api_client.response_deserialize(
13674            response_data=response_data,
13675            response_types_map=_response_types_map,
13676        ).data

List of user group members

Retrieves the list of members who are part of a 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 an organization. (required) :type org_id: str :param group_id: The ID of a user group. (required) :type group_id: str :param limit: The maximum number of members in the result list. :type limit: int :param cursor: A representation of the position of a member in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning. :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_group_members( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user group.')], update_user_group_members_request: miro_api.models.update_user_group_members_request.UpdateUserGroupMembersRequest, _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) -> List[miro_api.models.update_user_group_members_result_inner.UpdateUserGroupMembersResultInner]: View Source

13740    @validate_call
13741    def enterprise_update_group_members(
13742        self,
13743        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
13744        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
13745        update_user_group_members_request: UpdateUserGroupMembersRequest,
13746        _request_timeout: Union[
13747            None,
13748            Annotated[StrictFloat, Field(gt=0)],
13749            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13750        ] = None,
13751        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13752        _content_type: Optional[StrictStr] = None,
13753        _headers: Optional[Dict[StrictStr, Any]] = None,
13754        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13755    ) -> List[UpdateUserGroupMembersResultInner]:
13756        """Bulk edit of membership in user group
13757
13758        Add and remove members in one request. For example, remove user A and add user B.<br/> <h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:write</a><br/> <h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a> per item. For example, if you want to add 10 users and remove 5, the rate limiting applicable will be 750 credits. This is because each user addition or deletion takes Level 1 rate limiting of 50 credits, so 15 * 50 = 750.<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>
13759
13760        :param org_id: The ID of an organization. (required)
13761        :type org_id: str
13762        :param group_id: The ID of a user group. (required)
13763        :type group_id: str
13764        :param update_user_group_members_request: (required)
13765        :type update_user_group_members_request: UpdateUserGroupMembersRequest
13766        :param _request_timeout: timeout setting for this request. If one
13767                                 number provided, it will be total request
13768                                 timeout. It can also be a pair (tuple) of
13769                                 (connection, read) timeouts.
13770        :type _request_timeout: int, tuple(int, int), optional
13771        :param _request_auth: set to override the auth_settings for an a single
13772                              request; this effectively ignores the
13773                              authentication in the spec for a single request.
13774        :type _request_auth: dict, optional
13775        :param _content_type: force content-type for the request.
13776        :type _content_type: str, Optional
13777        :param _headers: set to override the headers for a single
13778                         request; this effectively ignores the headers
13779                         in the spec for a single request.
13780        :type _headers: dict, optional
13781        :param _host_index: set to override the host_index for a single
13782                            request; this effectively ignores the host_index
13783                            in the spec for a single request.
13784        :type _host_index: int, optional
13785        :return: Returns the result object.
13786        """  # noqa: E501
13787
13788        _param = self._enterprise_update_group_members_serialize(
13789            org_id=org_id,
13790            group_id=group_id,
13791            update_user_group_members_request=update_user_group_members_request,
13792            _request_auth=_request_auth,
13793            _content_type=_content_type,
13794            _headers=_headers,
13795            _host_index=_host_index,
13796        )
13797
13798        _response_types_map: Dict[str, Optional[str]] = {
13799            "207": "List[UpdateUserGroupMembersResultInner]",
13800            "400": None,
13801            "401": None,
13802            "403": None,
13803            "404": None,
13804            "409": None,
13805            "413": None,
13806            "429": None,
13807        }
13808        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13809        response_data.read()
13810        return self.api_client.response_deserialize(
13811            response_data=response_data,
13812            response_types_map=_response_types_map,
13813        ).data

Bulk edit of membership in user group

Add and remove members in one request. For example, remove user A and add user B.

Required scope

Rate limiting

Level 1 per item. For example, if you want to add 10 users and remove 5, the rate limiting applicable will be 750 credits. This is because each user addition or deletion takes Level 1 rate limiting of 50 credits, so 15 * 50 = 750.

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 group_id: The ID of a user group. (required) :type group_id: str :param update_user_group_members_request: (required) :type update_user_group_members_request: UpdateUserGroupMembersRequest :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_groups_get_team( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user group.')], team_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a 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.group_team.GroupTeam: View Source

13878    @validate_call
13879    def enterprise_groups_get_team(
13880        self,
13881        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
13882        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
13883        team_id: Annotated[StrictStr, Field(description="The ID of a team.")],
13884        _request_timeout: Union[
13885            None,
13886            Annotated[StrictFloat, Field(gt=0)],
13887            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
13888        ] = None,
13889        _request_auth: Optional[Dict[StrictStr, Any]] = None,
13890        _content_type: Optional[StrictStr] = None,
13891        _headers: Optional[Dict[StrictStr, Any]] = None,
13892        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
13893    ) -> GroupTeam:
13894        """Get user group team
13895
13896        Retrieves information of a team that the user group is a part of in an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/><a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a><h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
13897
13898        :param org_id: The ID of an organization. (required)
13899        :type org_id: str
13900        :param group_id: The ID of a user group. (required)
13901        :type group_id: str
13902        :param team_id: The ID of a team. (required)
13903        :type team_id: str
13904        :param _request_timeout: timeout setting for this request. If one
13905                                 number provided, it will be total request
13906                                 timeout. It can also be a pair (tuple) of
13907                                 (connection, read) timeouts.
13908        :type _request_timeout: int, tuple(int, int), optional
13909        :param _request_auth: set to override the auth_settings for an a single
13910                              request; this effectively ignores the
13911                              authentication in the spec for a single request.
13912        :type _request_auth: dict, optional
13913        :param _content_type: force content-type for the request.
13914        :type _content_type: str, Optional
13915        :param _headers: set to override the headers for a single
13916                         request; this effectively ignores the headers
13917                         in the spec for a single request.
13918        :type _headers: dict, optional
13919        :param _host_index: set to override the host_index for a single
13920                            request; this effectively ignores the host_index
13921                            in the spec for a single request.
13922        :type _host_index: int, optional
13923        :return: Returns the result object.
13924        """  # noqa: E501
13925
13926        _param = self._enterprise_groups_get_team_serialize(
13927            org_id=org_id,
13928            group_id=group_id,
13929            team_id=team_id,
13930            _request_auth=_request_auth,
13931            _content_type=_content_type,
13932            _headers=_headers,
13933            _host_index=_host_index,
13934        )
13935
13936        _response_types_map: Dict[str, Optional[str]] = {
13937            "200": "GroupTeam",
13938            "400": None,
13939            "401": None,
13940            "403": None,
13941            "429": None,
13942        }
13943        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
13944        response_data.read()
13945        return self.api_client.response_deserialize(
13946            response_data=response_data,
13947            response_types_map=_response_types_map,
13948        ).data

Get user group team

Retrieves information of a team that the user group is a part of in 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 an organization. (required) :type org_id: str :param group_id: The ID of a user group. (required) :type group_id: str :param team_id: The ID of a 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_groups_get_teams( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user group.')], 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 teams in the result list.')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A representation of the position of a team in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.')] = 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.group_teams_page.GroupTeamsPage: View Source

14005    @validate_call
14006    def enterprise_groups_get_teams(
14007        self,
14008        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
14009        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
14010        limit: Annotated[
14011            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
14012            Field(description="The maximum number of teams in the result list."),
14013        ] = None,
14014        cursor: Annotated[
14015            Optional[StrictStr],
14016            Field(
14017                description="A representation of the position of a team in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning."
14018            ),
14019        ] = None,
14020        _request_timeout: Union[
14021            None,
14022            Annotated[StrictFloat, Field(gt=0)],
14023            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14024        ] = None,
14025        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14026        _content_type: Optional[StrictStr] = None,
14027        _headers: Optional[Dict[StrictStr, Any]] = None,
14028        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14029    ) -> GroupTeamsPage:
14030        """Get teams of a user group
14031
14032        Retrieves the list of teams that the user group is a part of.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/><a target=_blank href=https://developers.miro.com/reference/scopes>organizations:teams:read</a><h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
14033
14034        :param org_id: The ID of an organization. (required)
14035        :type org_id: str
14036        :param group_id: The ID of a user group. (required)
14037        :type group_id: str
14038        :param limit: The maximum number of teams in the result list.
14039        :type limit: int
14040        :param cursor: A representation of the position of a team in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.
14041        :type cursor: str
14042        :param _request_timeout: timeout setting for this request. If one
14043                                 number provided, it will be total request
14044                                 timeout. It can also be a pair (tuple) of
14045                                 (connection, read) timeouts.
14046        :type _request_timeout: int, tuple(int, int), optional
14047        :param _request_auth: set to override the auth_settings for an a single
14048                              request; this effectively ignores the
14049                              authentication in the spec for a single request.
14050        :type _request_auth: dict, optional
14051        :param _content_type: force content-type for the request.
14052        :type _content_type: str, Optional
14053        :param _headers: set to override the headers for a single
14054                         request; this effectively ignores the headers
14055                         in the spec for a single request.
14056        :type _headers: dict, optional
14057        :param _host_index: set to override the host_index for a single
14058                            request; this effectively ignores the host_index
14059                            in the spec for a single request.
14060        :type _host_index: int, optional
14061        :return: Returns the result object.
14062        """  # noqa: E501
14063
14064        _param = self._enterprise_groups_get_teams_serialize(
14065            org_id=org_id,
14066            group_id=group_id,
14067            limit=limit,
14068            cursor=cursor,
14069            _request_auth=_request_auth,
14070            _content_type=_content_type,
14071            _headers=_headers,
14072            _host_index=_host_index,
14073        )
14074
14075        _response_types_map: Dict[str, Optional[str]] = {
14076            "200": "GroupTeamsPage",
14077            "400": None,
14078            "401": None,
14079            "403": None,
14080            "429": None,
14081        }
14082        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14083        response_data.read()
14084        return self.api_client.response_deserialize(
14085            response_data=response_data,
14086            response_types_map=_response_types_map,
14087        ).data

Get teams of a user group

Retrieves the list of teams that the user group is a part of.

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 group_id: The ID of a user group. (required) :type group_id: str :param limit: The maximum number of teams in the result list. :type limit: int :param cursor: A representation of the position of a team in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning. :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_create_group( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], create_group_request: miro_api.models.create_group_request.CreateGroupRequest, _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.Group: View Source

14151    @validate_call
14152    def enterprise_create_group(
14153        self,
14154        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
14155        create_group_request: CreateGroupRequest,
14156        _request_timeout: Union[
14157            None,
14158            Annotated[StrictFloat, Field(gt=0)],
14159            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14160        ] = None,
14161        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14162        _content_type: Optional[StrictStr] = None,
14163        _headers: Optional[Dict[StrictStr, Any]] = None,
14164        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14165    ) -> Group:
14166        """Create user group
14167
14168        Creates a new user group in an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
14169
14170        :param org_id: The ID of an organization. (required)
14171        :type org_id: str
14172        :param create_group_request: (required)
14173        :type create_group_request: CreateGroupRequest
14174        :param _request_timeout: timeout setting for this request. If one
14175                                 number provided, it will be total request
14176                                 timeout. It can also be a pair (tuple) of
14177                                 (connection, read) timeouts.
14178        :type _request_timeout: int, tuple(int, int), optional
14179        :param _request_auth: set to override the auth_settings for an a single
14180                              request; this effectively ignores the
14181                              authentication in the spec for a single request.
14182        :type _request_auth: dict, optional
14183        :param _content_type: force content-type for the request.
14184        :type _content_type: str, Optional
14185        :param _headers: set to override the headers for a single
14186                         request; this effectively ignores the headers
14187                         in the spec for a single request.
14188        :type _headers: dict, optional
14189        :param _host_index: set to override the host_index for a single
14190                            request; this effectively ignores the host_index
14191                            in the spec for a single request.
14192        :type _host_index: int, optional
14193        :return: Returns the result object.
14194        """  # noqa: E501
14195
14196        _param = self._enterprise_create_group_serialize(
14197            org_id=org_id,
14198            create_group_request=create_group_request,
14199            _request_auth=_request_auth,
14200            _content_type=_content_type,
14201            _headers=_headers,
14202            _host_index=_host_index,
14203        )
14204
14205        _response_types_map: Dict[str, Optional[str]] = {
14206            "201": "Group",
14207            "400": None,
14208            "401": None,
14209            "403": None,
14210            "409": None,
14211            "429": None,
14212        }
14213        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14214        response_data.read()
14215        return self.api_client.response_deserialize(
14216            response_data=response_data,
14217            response_types_map=_response_types_map,
14218        ).data

Create user group

Creates a new user group in 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 an organization. (required) :type org_id: str :param create_group_request: (required) :type create_group_request: CreateGroupRequest :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_group( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user 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) -> None: View Source

14280    @validate_call
14281    def enterprise_delete_group(
14282        self,
14283        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
14284        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
14285        _request_timeout: Union[
14286            None,
14287            Annotated[StrictFloat, Field(gt=0)],
14288            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14289        ] = None,
14290        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14291        _content_type: Optional[StrictStr] = None,
14292        _headers: Optional[Dict[StrictStr, Any]] = None,
14293        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14294    ) -> None:
14295        """Delete user group
14296
14297        Deletes a user group from an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
14298
14299        :param org_id: The ID of an organization. (required)
14300        :type org_id: str
14301        :param group_id: The ID of a user group. (required)
14302        :type group_id: str
14303        :param _request_timeout: timeout setting for this request. If one
14304                                 number provided, it will be total request
14305                                 timeout. It can also be a pair (tuple) of
14306                                 (connection, read) timeouts.
14307        :type _request_timeout: int, tuple(int, int), optional
14308        :param _request_auth: set to override the auth_settings for an a single
14309                              request; this effectively ignores the
14310                              authentication in the spec for a single request.
14311        :type _request_auth: dict, optional
14312        :param _content_type: force content-type for the request.
14313        :type _content_type: str, Optional
14314        :param _headers: set to override the headers for a single
14315                         request; this effectively ignores the headers
14316                         in the spec for a single request.
14317        :type _headers: dict, optional
14318        :param _host_index: set to override the host_index for a single
14319                            request; this effectively ignores the host_index
14320                            in the spec for a single request.
14321        :type _host_index: int, optional
14322        :return: Returns the result object.
14323        """  # noqa: E501
14324
14325        _param = self._enterprise_delete_group_serialize(
14326            org_id=org_id,
14327            group_id=group_id,
14328            _request_auth=_request_auth,
14329            _content_type=_content_type,
14330            _headers=_headers,
14331            _host_index=_host_index,
14332        )
14333
14334        _response_types_map: Dict[str, Optional[str]] = {
14335            "204": None,
14336            "400": None,
14337            "401": None,
14338            "403": None,
14339            "404": None,
14340            "429": None,
14341        }
14342        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14343        response_data.read()
14344        return self.api_client.response_deserialize(
14345            response_data=response_data,
14346            response_types_map=_response_types_map,
14347        ).data

Delete user group

Deletes a user group from 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 an organization. (required) :type org_id: str :param group_id: The ID of a user 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 enterprise_get_group( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user 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.Group: View Source

14398    @validate_call
14399    def enterprise_get_group(
14400        self,
14401        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
14402        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
14403        _request_timeout: Union[
14404            None,
14405            Annotated[StrictFloat, Field(gt=0)],
14406            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14407        ] = None,
14408        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14409        _content_type: Optional[StrictStr] = None,
14410        _headers: Optional[Dict[StrictStr, Any]] = None,
14411        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14412    ) -> Group:
14413        """Get user group
14414
14415        Retrieves a user group in an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
14416
14417        :param org_id: The ID of an organization. (required)
14418        :type org_id: str
14419        :param group_id: The ID of a user group. (required)
14420        :type group_id: str
14421        :param _request_timeout: timeout setting for this request. If one
14422                                 number provided, it will be total request
14423                                 timeout. It can also be a pair (tuple) of
14424                                 (connection, read) timeouts.
14425        :type _request_timeout: int, tuple(int, int), optional
14426        :param _request_auth: set to override the auth_settings for an a single
14427                              request; this effectively ignores the
14428                              authentication in the spec for a single request.
14429        :type _request_auth: dict, optional
14430        :param _content_type: force content-type for the request.
14431        :type _content_type: str, Optional
14432        :param _headers: set to override the headers for a single
14433                         request; this effectively ignores the headers
14434                         in the spec for a single request.
14435        :type _headers: dict, optional
14436        :param _host_index: set to override the host_index for a single
14437                            request; this effectively ignores the host_index
14438                            in the spec for a single request.
14439        :type _host_index: int, optional
14440        :return: Returns the result object.
14441        """  # noqa: E501
14442
14443        _param = self._enterprise_get_group_serialize(
14444            org_id=org_id,
14445            group_id=group_id,
14446            _request_auth=_request_auth,
14447            _content_type=_content_type,
14448            _headers=_headers,
14449            _host_index=_host_index,
14450        )
14451
14452        _response_types_map: Dict[str, Optional[str]] = {
14453            "200": "Group",
14454            "400": None,
14455            "401": None,
14456            "403": None,
14457            "404": None,
14458            "429": None,
14459        }
14460        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14461        response_data.read()
14462        return self.api_client.response_deserialize(
14463            response_data=response_data,
14464            response_types_map=_response_types_map,
14465        ).data

Get user group

Retrieves a user group in 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 an organization. (required) :type org_id: str :param group_id: The ID of a user 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 enterprise_get_groups( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], 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 user groups in the result list.')] = None, cursor: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.')] = 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.groups_page.GroupsPage: View Source

14519    @validate_call
14520    def enterprise_get_groups(
14521        self,
14522        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
14523        limit: Annotated[
14524            Optional[Annotated[int, Field(le=100, strict=True, ge=1)]],
14525            Field(description="The maximum number of user groups in the result list."),
14526        ] = None,
14527        cursor: Annotated[
14528            Optional[StrictStr],
14529            Field(
14530                description="A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning."
14531            ),
14532        ] = None,
14533        _request_timeout: Union[
14534            None,
14535            Annotated[StrictFloat, Field(gt=0)],
14536            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14537        ] = None,
14538        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14539        _content_type: Optional[StrictStr] = None,
14540        _headers: Optional[Dict[StrictStr, Any]] = None,
14541        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14542    ) -> GroupsPage:
14543        """List of user groups
14544
14545        Retrieves the list of user groups in an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:read</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
14546
14547        :param org_id: The ID of an organization. (required)
14548        :type org_id: str
14549        :param limit: The maximum number of user groups in the result list.
14550        :type limit: int
14551        :param cursor: A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning.
14552        :type cursor: str
14553        :param _request_timeout: timeout setting for this request. If one
14554                                 number provided, it will be total request
14555                                 timeout. It can also be a pair (tuple) of
14556                                 (connection, read) timeouts.
14557        :type _request_timeout: int, tuple(int, int), optional
14558        :param _request_auth: set to override the auth_settings for an a single
14559                              request; this effectively ignores the
14560                              authentication in the spec for a single request.
14561        :type _request_auth: dict, optional
14562        :param _content_type: force content-type for the request.
14563        :type _content_type: str, Optional
14564        :param _headers: set to override the headers for a single
14565                         request; this effectively ignores the headers
14566                         in the spec for a single request.
14567        :type _headers: dict, optional
14568        :param _host_index: set to override the host_index for a single
14569                            request; this effectively ignores the host_index
14570                            in the spec for a single request.
14571        :type _host_index: int, optional
14572        :return: Returns the result object.
14573        """  # noqa: E501
14574
14575        _param = self._enterprise_get_groups_serialize(
14576            org_id=org_id,
14577            limit=limit,
14578            cursor=cursor,
14579            _request_auth=_request_auth,
14580            _content_type=_content_type,
14581            _headers=_headers,
14582            _host_index=_host_index,
14583        )
14584
14585        _response_types_map: Dict[str, Optional[str]] = {
14586            "200": "GroupsPage",
14587            "400": None,
14588            "401": None,
14589            "403": None,
14590            "429": None,
14591        }
14592        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14593        response_data.read()
14594        return self.api_client.response_deserialize(
14595            response_data=response_data,
14596            response_types_map=_response_types_map,
14597        ).data

List of user groups

Retrieves the list of user groups in 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 an organization. (required) :type org_id: str :param limit: The maximum number of user groups in the result list. :type limit: int :param cursor: A representation of the position of a user group in the full set of results. It is used to determine the first item of the resulting set. Leave empty to retrieve items from the beginning. :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_group( self, org_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of an organization.')], group_id: typing.Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of a user group.')], update_group_request: miro_api.models.update_group_request.UpdateGroupRequest, _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.Group: View Source

14658    @validate_call
14659    def enterprise_update_group(
14660        self,
14661        org_id: Annotated[StrictStr, Field(description="The ID of an organization.")],
14662        group_id: Annotated[StrictStr, Field(description="The ID of a user group.")],
14663        update_group_request: UpdateGroupRequest,
14664        _request_timeout: Union[
14665            None,
14666            Annotated[StrictFloat, Field(gt=0)],
14667            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14668        ] = None,
14669        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14670        _content_type: Optional[StrictStr] = None,
14671        _headers: Optional[Dict[StrictStr, Any]] = None,
14672        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14673    ) -> Group:
14674        """Update user group
14675
14676        Updates a user group in an organization.<br/><h3>Required scope</h3> <a target=_blank href=https://developers.miro.com/reference/scopes>organizations:groups:write</a> <br/><h3>Rate limiting</h3> <a target=_blank href=\"/reference/rate-limiting#rate-limit-tiers\">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>
14677
14678        :param org_id: The ID of an organization. (required)
14679        :type org_id: str
14680        :param group_id: The ID of a user group. (required)
14681        :type group_id: str
14682        :param update_group_request: (required)
14683        :type update_group_request: UpdateGroupRequest
14684        :param _request_timeout: timeout setting for this request. If one
14685                                 number provided, it will be total request
14686                                 timeout. It can also be a pair (tuple) of
14687                                 (connection, read) timeouts.
14688        :type _request_timeout: int, tuple(int, int), optional
14689        :param _request_auth: set to override the auth_settings for an a single
14690                              request; this effectively ignores the
14691                              authentication in the spec for a single request.
14692        :type _request_auth: dict, optional
14693        :param _content_type: force content-type for the request.
14694        :type _content_type: str, Optional
14695        :param _headers: set to override the headers for a single
14696                         request; this effectively ignores the headers
14697                         in the spec for a single request.
14698        :type _headers: dict, optional
14699        :param _host_index: set to override the host_index for a single
14700                            request; this effectively ignores the host_index
14701                            in the spec for a single request.
14702        :type _host_index: int, optional
14703        :return: Returns the result object.
14704        """  # noqa: E501
14705
14706        _param = self._enterprise_update_group_serialize(
14707            org_id=org_id,
14708            group_id=group_id,
14709            update_group_request=update_group_request,
14710            _request_auth=_request_auth,
14711            _content_type=_content_type,
14712            _headers=_headers,
14713            _host_index=_host_index,
14714        )
14715
14716        _response_types_map: Dict[str, Optional[str]] = {
14717            "200": "Group",
14718            "400": None,
14719            "401": None,
14720            "403": None,
14721            "404": None,
14722            "409": None,
14723            "429": None,
14724        }
14725        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14726        response_data.read()
14727        return self.api_client.response_deserialize(
14728            response_data=response_data,
14729            response_types_map=_response_types_map,
14730        ).data

Update user group

Updates a user group in 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 an organization. (required) :type org_id: str :param group_id: The ID of a user group. (required) :type group_id: str :param update_group_request: (required) :type update_group_request: UpdateGroupRequest :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

14795    @validate_call
14796    def create_app_card_item(
14797        self,
14798        board_id: Annotated[
14799            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
14800        ],
14801        app_card_create_request: AppCardCreateRequest,
14802        _request_timeout: Union[
14803            None,
14804            Annotated[StrictFloat, Field(gt=0)],
14805            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14806        ] = None,
14807        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14808        _content_type: Optional[StrictStr] = None,
14809        _headers: Optional[Dict[StrictStr, Any]] = None,
14810        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14811    ) -> AppCardItem:
14812        """Create app card item
14813
14814        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
14815
14816        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
14817        :type board_id: str
14818        :param app_card_create_request: (required)
14819        :type app_card_create_request: AppCardCreateRequest
14820        :param _request_timeout: timeout setting for this request. If one
14821                                 number provided, it will be total request
14822                                 timeout. It can also be a pair (tuple) of
14823                                 (connection, read) timeouts.
14824        :type _request_timeout: int, tuple(int, int), optional
14825        :param _request_auth: set to override the auth_settings for an a single
14826                              request; this effectively ignores the
14827                              authentication in the spec for a single request.
14828        :type _request_auth: dict, optional
14829        :param _content_type: force content-type for the request.
14830        :type _content_type: str, Optional
14831        :param _headers: set to override the headers for a single
14832                         request; this effectively ignores the headers
14833                         in the spec for a single request.
14834        :type _headers: dict, optional
14835        :param _host_index: set to override the host_index for a single
14836                            request; this effectively ignores the host_index
14837                            in the spec for a single request.
14838        :type _host_index: int, optional
14839        :return: Returns the result object.
14840        """  # noqa: E501
14841
14842        _param = self._create_app_card_item_serialize(
14843            board_id=board_id,
14844            app_card_create_request=app_card_create_request,
14845            _request_auth=_request_auth,
14846            _content_type=_content_type,
14847            _headers=_headers,
14848            _host_index=_host_index,
14849        )
14850
14851        _response_types_map: Dict[str, Optional[str]] = {
14852            "201": "AppCardItem",
14853            "400": None,
14854            "404": None,
14855            "429": None,
14856        }
14857        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14858        response_data.read()
14859        return self.api_client.response_deserialize(
14860            response_data=response_data,
14861            response_types_map=_response_types_map,
14862        ).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

14924    @validate_call
14925    def delete_app_card_item(
14926        self,
14927        board_id: Annotated[
14928            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete an item.")
14929        ],
14930        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
14931        _request_timeout: Union[
14932            None,
14933            Annotated[StrictFloat, Field(gt=0)],
14934            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
14935        ] = None,
14936        _request_auth: Optional[Dict[StrictStr, Any]] = None,
14937        _content_type: Optional[StrictStr] = None,
14938        _headers: Optional[Dict[StrictStr, Any]] = None,
14939        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
14940    ) -> object:
14941        """Delete app card item
14942
14943        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
14944
14945        :param board_id: Unique identifier (ID) of the board from which you want to delete an item. (required)
14946        :type board_id: str
14947        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
14948        :type item_id: str
14949        :param _request_timeout: timeout setting for this request. If one
14950                                 number provided, it will be total request
14951                                 timeout. It can also be a pair (tuple) of
14952                                 (connection, read) timeouts.
14953        :type _request_timeout: int, tuple(int, int), optional
14954        :param _request_auth: set to override the auth_settings for an a single
14955                              request; this effectively ignores the
14956                              authentication in the spec for a single request.
14957        :type _request_auth: dict, optional
14958        :param _content_type: force content-type for the request.
14959        :type _content_type: str, Optional
14960        :param _headers: set to override the headers for a single
14961                         request; this effectively ignores the headers
14962                         in the spec for a single request.
14963        :type _headers: dict, optional
14964        :param _host_index: set to override the host_index for a single
14965                            request; this effectively ignores the host_index
14966                            in the spec for a single request.
14967        :type _host_index: int, optional
14968        :return: Returns the result object.
14969        """  # noqa: E501
14970
14971        _param = self._delete_app_card_item_serialize(
14972            board_id=board_id,
14973            item_id=item_id,
14974            _request_auth=_request_auth,
14975            _content_type=_content_type,
14976            _headers=_headers,
14977            _host_index=_host_index,
14978        )
14979
14980        _response_types_map: Dict[str, Optional[str]] = {
14981            "204": "object",
14982            "400": None,
14983            "404": None,
14984            "429": None,
14985        }
14986        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
14987        response_data.read()
14988        return self.api_client.response_deserialize(
14989            response_data=response_data,
14990            response_types_map=_response_types_map,
14991        ).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

15045    @validate_call
15046    def get_app_card_item(
15047        self,
15048        board_id: Annotated[
15049            StrictStr,
15050            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
15051        ],
15052        item_id: Annotated[
15053            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
15054        ],
15055        _request_timeout: Union[
15056            None,
15057            Annotated[StrictFloat, Field(gt=0)],
15058            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15059        ] = None,
15060        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15061        _content_type: Optional[StrictStr] = None,
15062        _headers: Optional[Dict[StrictStr, Any]] = None,
15063        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15064    ) -> AppCardItem:
15065        """Get app card item
15066
15067        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
15068
15069        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
15070        :type board_id: str
15071        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
15072        :type item_id: str
15073        :param _request_timeout: timeout setting for this request. If one
15074                                 number provided, it will be total request
15075                                 timeout. It can also be a pair (tuple) of
15076                                 (connection, read) timeouts.
15077        :type _request_timeout: int, tuple(int, int), optional
15078        :param _request_auth: set to override the auth_settings for an a single
15079                              request; this effectively ignores the
15080                              authentication in the spec for a single request.
15081        :type _request_auth: dict, optional
15082        :param _content_type: force content-type for the request.
15083        :type _content_type: str, Optional
15084        :param _headers: set to override the headers for a single
15085                         request; this effectively ignores the headers
15086                         in the spec for a single request.
15087        :type _headers: dict, optional
15088        :param _host_index: set to override the host_index for a single
15089                            request; this effectively ignores the host_index
15090                            in the spec for a single request.
15091        :type _host_index: int, optional
15092        :return: Returns the result object.
15093        """  # noqa: E501
15094
15095        _param = self._get_app_card_item_serialize(
15096            board_id=board_id,
15097            item_id=item_id,
15098            _request_auth=_request_auth,
15099            _content_type=_content_type,
15100            _headers=_headers,
15101            _host_index=_host_index,
15102        )
15103
15104        _response_types_map: Dict[str, Optional[str]] = {
15105            "200": "AppCardItem",
15106            "400": None,
15107            "404": None,
15108            "429": None,
15109        }
15110        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15111        response_data.read()
15112        return self.api_client.response_deserialize(
15113            response_data=response_data,
15114            response_types_map=_response_types_map,
15115        ).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

15169    @validate_call
15170    def update_app_card_item(
15171        self,
15172        board_id: Annotated[
15173            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
15174        ],
15175        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
15176        app_card_update_request: AppCardUpdateRequest,
15177        _request_timeout: Union[
15178            None,
15179            Annotated[StrictFloat, Field(gt=0)],
15180            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15181        ] = None,
15182        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15183        _content_type: Optional[StrictStr] = None,
15184        _headers: Optional[Dict[StrictStr, Any]] = None,
15185        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15186    ) -> AppCardItem:
15187        """Update app card item
15188
15189        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
15190
15191        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
15192        :type board_id: str
15193        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
15194        :type item_id: str
15195        :param app_card_update_request: (required)
15196        :type app_card_update_request: AppCardUpdateRequest
15197        :param _request_timeout: timeout setting for this request. If one
15198                                 number provided, it will be total request
15199                                 timeout. It can also be a pair (tuple) of
15200                                 (connection, read) timeouts.
15201        :type _request_timeout: int, tuple(int, int), optional
15202        :param _request_auth: set to override the auth_settings for an a single
15203                              request; this effectively ignores the
15204                              authentication in the spec for a single request.
15205        :type _request_auth: dict, optional
15206        :param _content_type: force content-type for the request.
15207        :type _content_type: str, Optional
15208        :param _headers: set to override the headers for a single
15209                         request; this effectively ignores the headers
15210                         in the spec for a single request.
15211        :type _headers: dict, optional
15212        :param _host_index: set to override the host_index for a single
15213                            request; this effectively ignores the host_index
15214                            in the spec for a single request.
15215        :type _host_index: int, optional
15216        :return: Returns the result object.
15217        """  # noqa: E501
15218
15219        _param = self._update_app_card_item_serialize(
15220            board_id=board_id,
15221            item_id=item_id,
15222            app_card_update_request=app_card_update_request,
15223            _request_auth=_request_auth,
15224            _content_type=_content_type,
15225            _headers=_headers,
15226            _host_index=_host_index,
15227        )
15228
15229        _response_types_map: Dict[str, Optional[str]] = {
15230            "200": "AppCardItem",
15231            "400": None,
15232            "404": None,
15233            "409": None,
15234            "429": None,
15235        }
15236        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15237        response_data.read()
15238        return self.api_client.response_deserialize(
15239            response_data=response_data,
15240            response_types_map=_response_types_map,
15241        ).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

15306    @validate_call
15307    def get_board_members(
15308        self,
15309        board_id: Annotated[
15310            StrictStr, Field(description="Unique identifier (ID) of the board to which the board member belongs.")
15311        ],
15312        limit: Optional[Annotated[str, Field(strict=True)]] = None,
15313        offset: Optional[StrictStr] = None,
15314        _request_timeout: Union[
15315            None,
15316            Annotated[StrictFloat, Field(gt=0)],
15317            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15318        ] = None,
15319        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15320        _content_type: Optional[StrictStr] = None,
15321        _headers: Optional[Dict[StrictStr, Any]] = None,
15322        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15323    ) -> BoardMembersPagedResponse:
15324        """Get all board members
15325
15326        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
15327
15328        :param board_id: Unique identifier (ID) of the board to which the board member belongs. (required)
15329        :type board_id: str
15330        :param limit:
15331        :type limit: str
15332        :param offset:
15333        :type offset: str
15334        :param _request_timeout: timeout setting for this request. If one
15335                                 number provided, it will be total request
15336                                 timeout. It can also be a pair (tuple) of
15337                                 (connection, read) timeouts.
15338        :type _request_timeout: int, tuple(int, int), optional
15339        :param _request_auth: set to override the auth_settings for an a single
15340                              request; this effectively ignores the
15341                              authentication in the spec for a single request.
15342        :type _request_auth: dict, optional
15343        :param _content_type: force content-type for the request.
15344        :type _content_type: str, Optional
15345        :param _headers: set to override the headers for a single
15346                         request; this effectively ignores the headers
15347                         in the spec for a single request.
15348        :type _headers: dict, optional
15349        :param _host_index: set to override the host_index for a single
15350                            request; this effectively ignores the host_index
15351                            in the spec for a single request.
15352        :type _host_index: int, optional
15353        :return: Returns the result object.
15354        """  # noqa: E501
15355
15356        _param = self._get_board_members_serialize(
15357            board_id=board_id,
15358            limit=limit,
15359            offset=offset,
15360            _request_auth=_request_auth,
15361            _content_type=_content_type,
15362            _headers=_headers,
15363            _host_index=_host_index,
15364        )
15365
15366        _response_types_map: Dict[str, Optional[str]] = {
15367            "200": "BoardMembersPagedResponse",
15368            "400": None,
15369            "404": None,
15370            "429": None,
15371        }
15372        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15373        response_data.read()
15374        return self.api_client.response_deserialize(
15375            response_data=response_data,
15376            response_types_map=_response_types_map,
15377        ).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

15438    @validate_call
15439    def get_specific_board_member(
15440        self,
15441        board_id: Annotated[
15442            StrictStr, Field(description="Unique identifier (ID) of the board to which the board member belongs.")
15443        ],
15444        board_member_id: Annotated[
15445            StrictStr, Field(description="Unique identifier (ID) of the board member whose role you want to retrieve.")
15446        ],
15447        _request_timeout: Union[
15448            None,
15449            Annotated[StrictFloat, Field(gt=0)],
15450            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15451        ] = None,
15452        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15453        _content_type: Optional[StrictStr] = None,
15454        _headers: Optional[Dict[StrictStr, Any]] = None,
15455        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15456    ) -> BoardMemberWithLinks:
15457        """Get specific board member
15458
15459        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
15460
15461        :param board_id: Unique identifier (ID) of the board to which the board member belongs. (required)
15462        :type board_id: str
15463        :param board_member_id: Unique identifier (ID) of the board member whose role you want to retrieve. (required)
15464        :type board_member_id: str
15465        :param _request_timeout: timeout setting for this request. If one
15466                                 number provided, it will be total request
15467                                 timeout. It can also be a pair (tuple) of
15468                                 (connection, read) timeouts.
15469        :type _request_timeout: int, tuple(int, int), optional
15470        :param _request_auth: set to override the auth_settings for an a single
15471                              request; this effectively ignores the
15472                              authentication in the spec for a single request.
15473        :type _request_auth: dict, optional
15474        :param _content_type: force content-type for the request.
15475        :type _content_type: str, Optional
15476        :param _headers: set to override the headers for a single
15477                         request; this effectively ignores the headers
15478                         in the spec for a single request.
15479        :type _headers: dict, optional
15480        :param _host_index: set to override the host_index for a single
15481                            request; this effectively ignores the host_index
15482                            in the spec for a single request.
15483        :type _host_index: int, optional
15484        :return: Returns the result object.
15485        """  # noqa: E501
15486
15487        _param = self._get_specific_board_member_serialize(
15488            board_id=board_id,
15489            board_member_id=board_member_id,
15490            _request_auth=_request_auth,
15491            _content_type=_content_type,
15492            _headers=_headers,
15493            _host_index=_host_index,
15494        )
15495
15496        _response_types_map: Dict[str, Optional[str]] = {
15497            "200": "BoardMemberWithLinks",
15498            "400": None,
15499            "404": None,
15500            "429": None,
15501        }
15502        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15503        response_data.read()
15504        return self.api_client.response_deserialize(
15505            response_data=response_data,
15506            response_types_map=_response_types_map,
15507        ).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

15561    @validate_call
15562    def remove_board_member(
15563        self,
15564        board_id: Annotated[
15565            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete an item.")
15566        ],
15567        board_member_id: Annotated[
15568            StrictStr, Field(description="Unique identifier (ID) of the board member whose role you want to delete.")
15569        ],
15570        _request_timeout: Union[
15571            None,
15572            Annotated[StrictFloat, Field(gt=0)],
15573            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15574        ] = None,
15575        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15576        _content_type: Optional[StrictStr] = None,
15577        _headers: Optional[Dict[StrictStr, Any]] = None,
15578        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15579    ) -> object:
15580        """Remove board member
15581
15582        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
15583
15584        :param board_id: Unique identifier (ID) of the board from which you want to delete an item. (required)
15585        :type board_id: str
15586        :param board_member_id: Unique identifier (ID) of the board member whose role you want to delete. (required)
15587        :type board_member_id: str
15588        :param _request_timeout: timeout setting for this request. If one
15589                                 number provided, it will be total request
15590                                 timeout. It can also be a pair (tuple) of
15591                                 (connection, read) timeouts.
15592        :type _request_timeout: int, tuple(int, int), optional
15593        :param _request_auth: set to override the auth_settings for an a single
15594                              request; this effectively ignores the
15595                              authentication in the spec for a single request.
15596        :type _request_auth: dict, optional
15597        :param _content_type: force content-type for the request.
15598        :type _content_type: str, Optional
15599        :param _headers: set to override the headers for a single
15600                         request; this effectively ignores the headers
15601                         in the spec for a single request.
15602        :type _headers: dict, optional
15603        :param _host_index: set to override the host_index for a single
15604                            request; this effectively ignores the host_index
15605                            in the spec for a single request.
15606        :type _host_index: int, optional
15607        :return: Returns the result object.
15608        """  # noqa: E501
15609
15610        _param = self._remove_board_member_serialize(
15611            board_id=board_id,
15612            board_member_id=board_member_id,
15613            _request_auth=_request_auth,
15614            _content_type=_content_type,
15615            _headers=_headers,
15616            _host_index=_host_index,
15617        )
15618
15619        _response_types_map: Dict[str, Optional[str]] = {
15620            "204": "object",
15621            "400": None,
15622            "404": None,
15623            "429": None,
15624        }
15625        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15626        response_data.read()
15627        return self.api_client.response_deserialize(
15628            response_data=response_data,
15629            response_types_map=_response_types_map,
15630        ).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

15684    @validate_call
15685    def share_board(
15686        self,
15687        board_id: Annotated[
15688            StrictStr, Field(description="Unique identifier (ID) of the board to which the board member belongs.")
15689        ],
15690        board_members_invite: BoardMembersInvite,
15691        _request_timeout: Union[
15692            None,
15693            Annotated[StrictFloat, Field(gt=0)],
15694            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15695        ] = None,
15696        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15697        _content_type: Optional[StrictStr] = None,
15698        _headers: Optional[Dict[StrictStr, Any]] = None,
15699        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15700    ) -> InvitationResult:
15701        """Share board
15702
15703        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
15704
15705        :param board_id: Unique identifier (ID) of the board to which the board member belongs. (required)
15706        :type board_id: str
15707        :param board_members_invite: (required)
15708        :type board_members_invite: BoardMembersInvite
15709        :param _request_timeout: timeout setting for this request. If one
15710                                 number provided, it will be total request
15711                                 timeout. It can also be a pair (tuple) of
15712                                 (connection, read) timeouts.
15713        :type _request_timeout: int, tuple(int, int), optional
15714        :param _request_auth: set to override the auth_settings for an a single
15715                              request; this effectively ignores the
15716                              authentication in the spec for a single request.
15717        :type _request_auth: dict, optional
15718        :param _content_type: force content-type for the request.
15719        :type _content_type: str, Optional
15720        :param _headers: set to override the headers for a single
15721                         request; this effectively ignores the headers
15722                         in the spec for a single request.
15723        :type _headers: dict, optional
15724        :param _host_index: set to override the host_index for a single
15725                            request; this effectively ignores the host_index
15726                            in the spec for a single request.
15727        :type _host_index: int, optional
15728        :return: Returns the result object.
15729        """  # noqa: E501
15730
15731        _param = self._share_board_serialize(
15732            board_id=board_id,
15733            board_members_invite=board_members_invite,
15734            _request_auth=_request_auth,
15735            _content_type=_content_type,
15736            _headers=_headers,
15737            _host_index=_host_index,
15738        )
15739
15740        _response_types_map: Dict[str, Optional[str]] = {
15741            "201": "InvitationResult",
15742            "400": None,
15743            "404": None,
15744            "429": None,
15745        }
15746        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15747        response_data.read()
15748        return self.api_client.response_deserialize(
15749            response_data=response_data,
15750            response_types_map=_response_types_map,
15751        ).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

15813    @validate_call
15814    def update_board_member(
15815        self,
15816        board_id: Annotated[
15817            StrictStr,
15818            Field(
15819                description="Unique identifier (ID) of the board for which you want to update the role of the board member."
15820            ),
15821        ],
15822        board_member_id: Annotated[
15823            StrictStr, Field(description="Unique identifier (ID) of the board member whose role you want to update.")
15824        ],
15825        board_member_changes: BoardMemberChanges,
15826        _request_timeout: Union[
15827            None,
15828            Annotated[StrictFloat, Field(gt=0)],
15829            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15830        ] = None,
15831        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15832        _content_type: Optional[StrictStr] = None,
15833        _headers: Optional[Dict[StrictStr, Any]] = None,
15834        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15835    ) -> BoardMemberWithLinks:
15836        """Update board member
15837
15838        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
15839
15840        :param board_id: Unique identifier (ID) of the board for which you want to update the role of the board member. (required)
15841        :type board_id: str
15842        :param board_member_id: Unique identifier (ID) of the board member whose role you want to update. (required)
15843        :type board_member_id: str
15844        :param board_member_changes: (required)
15845        :type board_member_changes: BoardMemberChanges
15846        :param _request_timeout: timeout setting for this request. If one
15847                                 number provided, it will be total request
15848                                 timeout. It can also be a pair (tuple) of
15849                                 (connection, read) timeouts.
15850        :type _request_timeout: int, tuple(int, int), optional
15851        :param _request_auth: set to override the auth_settings for an a single
15852                              request; this effectively ignores the
15853                              authentication in the spec for a single request.
15854        :type _request_auth: dict, optional
15855        :param _content_type: force content-type for the request.
15856        :type _content_type: str, Optional
15857        :param _headers: set to override the headers for a single
15858                         request; this effectively ignores the headers
15859                         in the spec for a single request.
15860        :type _headers: dict, optional
15861        :param _host_index: set to override the host_index for a single
15862                            request; this effectively ignores the host_index
15863                            in the spec for a single request.
15864        :type _host_index: int, optional
15865        :return: Returns the result object.
15866        """  # noqa: E501
15867
15868        _param = self._update_board_member_serialize(
15869            board_id=board_id,
15870            board_member_id=board_member_id,
15871            board_member_changes=board_member_changes,
15872            _request_auth=_request_auth,
15873            _content_type=_content_type,
15874            _headers=_headers,
15875            _host_index=_host_index,
15876        )
15877
15878        _response_types_map: Dict[str, Optional[str]] = {
15879            "200": "BoardMemberWithLinks",
15880            "400": None,
15881            "404": None,
15882            "429": None,
15883        }
15884        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
15885        response_data.read()
15886        return self.api_client.response_deserialize(
15887            response_data=response_data,
15888            response_types_map=_response_types_map,
15889        ).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

15954    @validate_call
15955    def copy_board(
15956        self,
15957        copy_from: Annotated[
15958            StrictStr, Field(description="Unique identifier (ID) of the board that you want to copy.")
15959        ],
15960        copy_board_changes: Optional[CopyBoardChanges] = None,
15961        _request_timeout: Union[
15962            None,
15963            Annotated[StrictFloat, Field(gt=0)],
15964            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
15965        ] = None,
15966        _request_auth: Optional[Dict[StrictStr, Any]] = None,
15967        _content_type: Optional[StrictStr] = None,
15968        _headers: Optional[Dict[StrictStr, Any]] = None,
15969        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
15970    ) -> BoardWithLinksAndWithoutProject:
15971        """Copy board
15972
15973        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 4</a><br/>
15974
15975        :param copy_from: Unique identifier (ID) of the board that you want to copy. (required)
15976        :type copy_from: str
15977        :param copy_board_changes:
15978        :type copy_board_changes: CopyBoardChanges
15979        :param _request_timeout: timeout setting for this request. If one
15980                                 number provided, it will be total request
15981                                 timeout. It can also be a pair (tuple) of
15982                                 (connection, read) timeouts.
15983        :type _request_timeout: int, tuple(int, int), optional
15984        :param _request_auth: set to override the auth_settings for an a single
15985                              request; this effectively ignores the
15986                              authentication in the spec for a single request.
15987        :type _request_auth: dict, optional
15988        :param _content_type: force content-type for the request.
15989        :type _content_type: str, Optional
15990        :param _headers: set to override the headers for a single
15991                         request; this effectively ignores the headers
15992                         in the spec for a single request.
15993        :type _headers: dict, optional
15994        :param _host_index: set to override the host_index for a single
15995                            request; this effectively ignores the host_index
15996                            in the spec for a single request.
15997        :type _host_index: int, optional
15998        :return: Returns the result object.
15999        """  # noqa: E501
16000
16001        _param = self._copy_board_serialize(
16002            copy_from=copy_from,
16003            copy_board_changes=copy_board_changes,
16004            _request_auth=_request_auth,
16005            _content_type=_content_type,
16006            _headers=_headers,
16007            _host_index=_host_index,
16008        )
16009
16010        _response_types_map: Dict[str, Optional[str]] = {
16011            "201": "BoardWithLinksAndWithoutProject",
16012            "400": None,
16013            "404": None,
16014            "409": None,
16015            "429": None,
16016        }
16017        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16018        response_data.read()
16019        return self.api_client.response_deserialize(
16020            response_data=response_data,
16021            response_types_map=_response_types_map,
16022        ).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

16086    @validate_call
16087    def create_board(
16088        self,
16089        board_changes: Optional[BoardChanges] = None,
16090        _request_timeout: Union[
16091            None,
16092            Annotated[StrictFloat, Field(gt=0)],
16093            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16094        ] = None,
16095        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16096        _content_type: Optional[StrictStr] = None,
16097        _headers: Optional[Dict[StrictStr, Any]] = None,
16098        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16099    ) -> BoardWithLinks:
16100        """Create board
16101
16102        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
16103
16104        :param board_changes:
16105        :type board_changes: BoardChanges
16106        :param _request_timeout: timeout setting for this request. If one
16107                                 number provided, it will be total request
16108                                 timeout. It can also be a pair (tuple) of
16109                                 (connection, read) timeouts.
16110        :type _request_timeout: int, tuple(int, int), optional
16111        :param _request_auth: set to override the auth_settings for an a single
16112                              request; this effectively ignores the
16113                              authentication in the spec for a single request.
16114        :type _request_auth: dict, optional
16115        :param _content_type: force content-type for the request.
16116        :type _content_type: str, Optional
16117        :param _headers: set to override the headers for a single
16118                         request; this effectively ignores the headers
16119                         in the spec for a single request.
16120        :type _headers: dict, optional
16121        :param _host_index: set to override the host_index for a single
16122                            request; this effectively ignores the host_index
16123                            in the spec for a single request.
16124        :type _host_index: int, optional
16125        :return: Returns the result object.
16126        """  # noqa: E501
16127
16128        _param = self._create_board_serialize(
16129            board_changes=board_changes,
16130            _request_auth=_request_auth,
16131            _content_type=_content_type,
16132            _headers=_headers,
16133            _host_index=_host_index,
16134        )
16135
16136        _response_types_map: Dict[str, Optional[str]] = {
16137            "201": "BoardWithLinks",
16138            "400": None,
16139            "404": None,
16140            "409": None,
16141            "429": None,
16142        }
16143        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16144        response_data.read()
16145        return self.api_client.response_deserialize(
16146            response_data=response_data,
16147            response_types_map=_response_types_map,
16148        ).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

16207    @validate_call
16208    def delete_board(
16209        self,
16210        board_id: Annotated[
16211            StrictStr, Field(description="Unique identifier (ID) of the board that you want to delete.")
16212        ],
16213        _request_timeout: Union[
16214            None,
16215            Annotated[StrictFloat, Field(gt=0)],
16216            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16217        ] = None,
16218        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16219        _content_type: Optional[StrictStr] = None,
16220        _headers: Optional[Dict[StrictStr, Any]] = None,
16221        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16222    ) -> object:
16223        """Delete board
16224
16225        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
16226
16227        :param board_id: Unique identifier (ID) of the board that you want to delete. (required)
16228        :type board_id: str
16229        :param _request_timeout: timeout setting for this request. If one
16230                                 number provided, it will be total request
16231                                 timeout. It can also be a pair (tuple) of
16232                                 (connection, read) timeouts.
16233        :type _request_timeout: int, tuple(int, int), optional
16234        :param _request_auth: set to override the auth_settings for an a single
16235                              request; this effectively ignores the
16236                              authentication in the spec for a single request.
16237        :type _request_auth: dict, optional
16238        :param _content_type: force content-type for the request.
16239        :type _content_type: str, Optional
16240        :param _headers: set to override the headers for a single
16241                         request; this effectively ignores the headers
16242                         in the spec for a single request.
16243        :type _headers: dict, optional
16244        :param _host_index: set to override the host_index for a single
16245                            request; this effectively ignores the host_index
16246                            in the spec for a single request.
16247        :type _host_index: int, optional
16248        :return: Returns the result object.
16249        """  # noqa: E501
16250
16251        _param = self._delete_board_serialize(
16252            board_id=board_id,
16253            _request_auth=_request_auth,
16254            _content_type=_content_type,
16255            _headers=_headers,
16256            _host_index=_host_index,
16257        )
16258
16259        _response_types_map: Dict[str, Optional[str]] = {
16260            "204": "object",
16261            "400": None,
16262            "404": None,
16263            "409": None,
16264            "429": None,
16265        }
16266        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16267        response_data.read()
16268        return self.api_client.response_deserialize(
16269            response_data=response_data,
16270            response_types_map=_response_types_map,
16271        ).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

16322    @validate_call
16323    def get_boards(
16324        self,
16325        team_id: Optional[StrictStr] = None,
16326        project_id: Optional[StrictStr] = None,
16327        query: Optional[Annotated[str, Field(strict=True, max_length=500)]] = None,
16328        owner: Optional[StrictStr] = None,
16329        limit: Optional[Annotated[str, Field(strict=True)]] = None,
16330        offset: Optional[StrictStr] = None,
16331        sort: Optional[StrictStr] = None,
16332        _request_timeout: Union[
16333            None,
16334            Annotated[StrictFloat, Field(gt=0)],
16335            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16336        ] = None,
16337        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16338        _content_type: Optional[StrictStr] = None,
16339        _headers: Optional[Dict[StrictStr, Any]] = None,
16340        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16341    ) -> BoardsPagedResponse:
16342        """Get boards
16343
16344        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
16345
16346        :param team_id:
16347        :type team_id: str
16348        :param project_id:
16349        :type project_id: str
16350        :param query:
16351        :type query: str
16352        :param owner:
16353        :type owner: str
16354        :param limit:
16355        :type limit: str
16356        :param offset:
16357        :type offset: str
16358        :param sort:
16359        :type sort: str
16360        :param _request_timeout: timeout setting for this request. If one
16361                                 number provided, it will be total request
16362                                 timeout. It can also be a pair (tuple) of
16363                                 (connection, read) timeouts.
16364        :type _request_timeout: int, tuple(int, int), optional
16365        :param _request_auth: set to override the auth_settings for an a single
16366                              request; this effectively ignores the
16367                              authentication in the spec for a single request.
16368        :type _request_auth: dict, optional
16369        :param _content_type: force content-type for the request.
16370        :type _content_type: str, Optional
16371        :param _headers: set to override the headers for a single
16372                         request; this effectively ignores the headers
16373                         in the spec for a single request.
16374        :type _headers: dict, optional
16375        :param _host_index: set to override the host_index for a single
16376                            request; this effectively ignores the host_index
16377                            in the spec for a single request.
16378        :type _host_index: int, optional
16379        :return: Returns the result object.
16380        """  # noqa: E501
16381
16382        _param = self._get_boards_serialize(
16383            team_id=team_id,
16384            project_id=project_id,
16385            query=query,
16386            owner=owner,
16387            limit=limit,
16388            offset=offset,
16389            sort=sort,
16390            _request_auth=_request_auth,
16391            _content_type=_content_type,
16392            _headers=_headers,
16393            _host_index=_host_index,
16394        )
16395
16396        _response_types_map: Dict[str, Optional[str]] = {
16397            "200": "BoardsPagedResponse",
16398            "400": None,
16399            "404": None,
16400            "429": None,
16401        }
16402        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16403        response_data.read()
16404        return self.api_client.response_deserialize(
16405            response_data=response_data,
16406            response_types_map=_response_types_map,
16407        ).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

16490    @validate_call
16491    def get_specific_board(
16492        self,
16493        board_id: Annotated[
16494            StrictStr, Field(description="Unique identifier (ID) of the board that you want to retrieve.")
16495        ],
16496        _request_timeout: Union[
16497            None,
16498            Annotated[StrictFloat, Field(gt=0)],
16499            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16500        ] = None,
16501        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16502        _content_type: Optional[StrictStr] = None,
16503        _headers: Optional[Dict[StrictStr, Any]] = None,
16504        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16505    ) -> BoardWithLinksAndLastOpened:
16506        """Get specific board
16507
16508        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
16509
16510        :param board_id: Unique identifier (ID) of the board that you want to retrieve. (required)
16511        :type board_id: str
16512        :param _request_timeout: timeout setting for this request. If one
16513                                 number provided, it will be total request
16514                                 timeout. It can also be a pair (tuple) of
16515                                 (connection, read) timeouts.
16516        :type _request_timeout: int, tuple(int, int), optional
16517        :param _request_auth: set to override the auth_settings for an a single
16518                              request; this effectively ignores the
16519                              authentication in the spec for a single request.
16520        :type _request_auth: dict, optional
16521        :param _content_type: force content-type for the request.
16522        :type _content_type: str, Optional
16523        :param _headers: set to override the headers for a single
16524                         request; this effectively ignores the headers
16525                         in the spec for a single request.
16526        :type _headers: dict, optional
16527        :param _host_index: set to override the host_index for a single
16528                            request; this effectively ignores the host_index
16529                            in the spec for a single request.
16530        :type _host_index: int, optional
16531        :return: Returns the result object.
16532        """  # noqa: E501
16533
16534        _param = self._get_specific_board_serialize(
16535            board_id=board_id,
16536            _request_auth=_request_auth,
16537            _content_type=_content_type,
16538            _headers=_headers,
16539            _host_index=_host_index,
16540        )
16541
16542        _response_types_map: Dict[str, Optional[str]] = {
16543            "200": "BoardWithLinksAndLastOpened",
16544            "400": None,
16545            "404": None,
16546            "429": None,
16547        }
16548        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16549        response_data.read()
16550        return self.api_client.response_deserialize(
16551            response_data=response_data,
16552            response_types_map=_response_types_map,
16553        ).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

16604    @validate_call
16605    def update_board(
16606        self,
16607        board_id: Annotated[
16608            StrictStr, Field(description="Unique identifier (ID) of the board that you want to update.")
16609        ],
16610        board_changes: BoardChanges,
16611        _request_timeout: Union[
16612            None,
16613            Annotated[StrictFloat, Field(gt=0)],
16614            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16615        ] = None,
16616        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16617        _content_type: Optional[StrictStr] = None,
16618        _headers: Optional[Dict[StrictStr, Any]] = None,
16619        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16620    ) -> BoardWithLinks:
16621        """Update board
16622
16623        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
16624
16625        :param board_id: Unique identifier (ID) of the board that you want to update. (required)
16626        :type board_id: str
16627        :param board_changes: (required)
16628        :type board_changes: BoardChanges
16629        :param _request_timeout: timeout setting for this request. If one
16630                                 number provided, it will be total request
16631                                 timeout. It can also be a pair (tuple) of
16632                                 (connection, read) timeouts.
16633        :type _request_timeout: int, tuple(int, int), optional
16634        :param _request_auth: set to override the auth_settings for an a single
16635                              request; this effectively ignores the
16636                              authentication in the spec for a single request.
16637        :type _request_auth: dict, optional
16638        :param _content_type: force content-type for the request.
16639        :type _content_type: str, Optional
16640        :param _headers: set to override the headers for a single
16641                         request; this effectively ignores the headers
16642                         in the spec for a single request.
16643        :type _headers: dict, optional
16644        :param _host_index: set to override the host_index for a single
16645                            request; this effectively ignores the host_index
16646                            in the spec for a single request.
16647        :type _host_index: int, optional
16648        :return: Returns the result object.
16649        """  # noqa: E501
16650
16651        _param = self._update_board_serialize(
16652            board_id=board_id,
16653            board_changes=board_changes,
16654            _request_auth=_request_auth,
16655            _content_type=_content_type,
16656            _headers=_headers,
16657            _host_index=_host_index,
16658        )
16659
16660        _response_types_map: Dict[str, Optional[str]] = {
16661            "200": "BoardWithLinks",
16662            "202": None,
16663            "400": None,
16664            "404": None,
16665            "409": None,
16666            "429": None,
16667        }
16668        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16669        response_data.read()
16670        return self.api_client.response_deserialize(
16671            response_data=response_data,
16672            response_types_map=_response_types_map,
16673        ).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

16735    @validate_call
16736    def create_card_item(
16737        self,
16738        board_id: Annotated[
16739            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
16740        ],
16741        card_create_request: CardCreateRequest,
16742        _request_timeout: Union[
16743            None,
16744            Annotated[StrictFloat, Field(gt=0)],
16745            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16746        ] = None,
16747        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16748        _content_type: Optional[StrictStr] = None,
16749        _headers: Optional[Dict[StrictStr, Any]] = None,
16750        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16751    ) -> CardItem:
16752        """Create card item
16753
16754        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
16755
16756        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
16757        :type board_id: str
16758        :param card_create_request: (required)
16759        :type card_create_request: CardCreateRequest
16760        :param _request_timeout: timeout setting for this request. If one
16761                                 number provided, it will be total request
16762                                 timeout. It can also be a pair (tuple) of
16763                                 (connection, read) timeouts.
16764        :type _request_timeout: int, tuple(int, int), optional
16765        :param _request_auth: set to override the auth_settings for an a single
16766                              request; this effectively ignores the
16767                              authentication in the spec for a single request.
16768        :type _request_auth: dict, optional
16769        :param _content_type: force content-type for the request.
16770        :type _content_type: str, Optional
16771        :param _headers: set to override the headers for a single
16772                         request; this effectively ignores the headers
16773                         in the spec for a single request.
16774        :type _headers: dict, optional
16775        :param _host_index: set to override the host_index for a single
16776                            request; this effectively ignores the host_index
16777                            in the spec for a single request.
16778        :type _host_index: int, optional
16779        :return: Returns the result object.
16780        """  # noqa: E501
16781
16782        _param = self._create_card_item_serialize(
16783            board_id=board_id,
16784            card_create_request=card_create_request,
16785            _request_auth=_request_auth,
16786            _content_type=_content_type,
16787            _headers=_headers,
16788            _host_index=_host_index,
16789        )
16790
16791        _response_types_map: Dict[str, Optional[str]] = {
16792            "201": "CardItem",
16793            "400": None,
16794            "404": None,
16795            "429": None,
16796        }
16797        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16798        response_data.read()
16799        return self.api_client.response_deserialize(
16800            response_data=response_data,
16801            response_types_map=_response_types_map,
16802        ).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

16864    @validate_call
16865    def delete_card_item(
16866        self,
16867        board_id: Annotated[
16868            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
16869        ],
16870        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
16871        _request_timeout: Union[
16872            None,
16873            Annotated[StrictFloat, Field(gt=0)],
16874            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16875        ] = None,
16876        _request_auth: Optional[Dict[StrictStr, Any]] = None,
16877        _content_type: Optional[StrictStr] = None,
16878        _headers: Optional[Dict[StrictStr, Any]] = None,
16879        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
16880    ) -> object:
16881        """Delete card item
16882
16883        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
16884
16885        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
16886        :type board_id: str
16887        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
16888        :type item_id: str
16889        :param _request_timeout: timeout setting for this request. If one
16890                                 number provided, it will be total request
16891                                 timeout. It can also be a pair (tuple) of
16892                                 (connection, read) timeouts.
16893        :type _request_timeout: int, tuple(int, int), optional
16894        :param _request_auth: set to override the auth_settings for an a single
16895                              request; this effectively ignores the
16896                              authentication in the spec for a single request.
16897        :type _request_auth: dict, optional
16898        :param _content_type: force content-type for the request.
16899        :type _content_type: str, Optional
16900        :param _headers: set to override the headers for a single
16901                         request; this effectively ignores the headers
16902                         in the spec for a single request.
16903        :type _headers: dict, optional
16904        :param _host_index: set to override the host_index for a single
16905                            request; this effectively ignores the host_index
16906                            in the spec for a single request.
16907        :type _host_index: int, optional
16908        :return: Returns the result object.
16909        """  # noqa: E501
16910
16911        _param = self._delete_card_item_serialize(
16912            board_id=board_id,
16913            item_id=item_id,
16914            _request_auth=_request_auth,
16915            _content_type=_content_type,
16916            _headers=_headers,
16917            _host_index=_host_index,
16918        )
16919
16920        _response_types_map: Dict[str, Optional[str]] = {
16921            "204": "object",
16922            "400": None,
16923            "404": None,
16924            "429": None,
16925        }
16926        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
16927        response_data.read()
16928        return self.api_client.response_deserialize(
16929            response_data=response_data,
16930            response_types_map=_response_types_map,
16931        ).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

16985    @validate_call
16986    def get_card_item(
16987        self,
16988        board_id: Annotated[
16989            StrictStr,
16990            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
16991        ],
16992        item_id: Annotated[
16993            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
16994        ],
16995        _request_timeout: Union[
16996            None,
16997            Annotated[StrictFloat, Field(gt=0)],
16998            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
16999        ] = None,
17000        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17001        _content_type: Optional[StrictStr] = None,
17002        _headers: Optional[Dict[StrictStr, Any]] = None,
17003        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17004    ) -> CardItem:
17005        """Get card item
17006
17007        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
17008
17009        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
17010        :type board_id: str
17011        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
17012        :type item_id: str
17013        :param _request_timeout: timeout setting for this request. If one
17014                                 number provided, it will be total request
17015                                 timeout. It can also be a pair (tuple) of
17016                                 (connection, read) timeouts.
17017        :type _request_timeout: int, tuple(int, int), optional
17018        :param _request_auth: set to override the auth_settings for an a single
17019                              request; this effectively ignores the
17020                              authentication in the spec for a single request.
17021        :type _request_auth: dict, optional
17022        :param _content_type: force content-type for the request.
17023        :type _content_type: str, Optional
17024        :param _headers: set to override the headers for a single
17025                         request; this effectively ignores the headers
17026                         in the spec for a single request.
17027        :type _headers: dict, optional
17028        :param _host_index: set to override the host_index for a single
17029                            request; this effectively ignores the host_index
17030                            in the spec for a single request.
17031        :type _host_index: int, optional
17032        :return: Returns the result object.
17033        """  # noqa: E501
17034
17035        _param = self._get_card_item_serialize(
17036            board_id=board_id,
17037            item_id=item_id,
17038            _request_auth=_request_auth,
17039            _content_type=_content_type,
17040            _headers=_headers,
17041            _host_index=_host_index,
17042        )
17043
17044        _response_types_map: Dict[str, Optional[str]] = {
17045            "200": "CardItem",
17046            "400": None,
17047            "404": None,
17048            "429": None,
17049        }
17050        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17051        response_data.read()
17052        return self.api_client.response_deserialize(
17053            response_data=response_data,
17054            response_types_map=_response_types_map,
17055        ).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

17109    @validate_call
17110    def update_card_item(
17111        self,
17112        board_id: Annotated[
17113            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
17114        ],
17115        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
17116        card_update_request: CardUpdateRequest,
17117        _request_timeout: Union[
17118            None,
17119            Annotated[StrictFloat, Field(gt=0)],
17120            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17121        ] = None,
17122        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17123        _content_type: Optional[StrictStr] = None,
17124        _headers: Optional[Dict[StrictStr, Any]] = None,
17125        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17126    ) -> CardItem:
17127        """Update card item
17128
17129        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
17130
17131        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
17132        :type board_id: str
17133        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
17134        :type item_id: str
17135        :param card_update_request: (required)
17136        :type card_update_request: CardUpdateRequest
17137        :param _request_timeout: timeout setting for this request. If one
17138                                 number provided, it will be total request
17139                                 timeout. It can also be a pair (tuple) of
17140                                 (connection, read) timeouts.
17141        :type _request_timeout: int, tuple(int, int), optional
17142        :param _request_auth: set to override the auth_settings for an a single
17143                              request; this effectively ignores the
17144                              authentication in the spec for a single request.
17145        :type _request_auth: dict, optional
17146        :param _content_type: force content-type for the request.
17147        :type _content_type: str, Optional
17148        :param _headers: set to override the headers for a single
17149                         request; this effectively ignores the headers
17150                         in the spec for a single request.
17151        :type _headers: dict, optional
17152        :param _host_index: set to override the host_index for a single
17153                            request; this effectively ignores the host_index
17154                            in the spec for a single request.
17155        :type _host_index: int, optional
17156        :return: Returns the result object.
17157        """  # noqa: E501
17158
17159        _param = self._update_card_item_serialize(
17160            board_id=board_id,
17161            item_id=item_id,
17162            card_update_request=card_update_request,
17163            _request_auth=_request_auth,
17164            _content_type=_content_type,
17165            _headers=_headers,
17166            _host_index=_host_index,
17167        )
17168
17169        _response_types_map: Dict[str, Optional[str]] = {
17170            "200": "CardItem",
17171            "400": None,
17172            "404": None,
17173            "409": None,
17174            "429": None,
17175        }
17176        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17177        response_data.read()
17178        return self.api_client.response_deserialize(
17179            response_data=response_data,
17180            response_types_map=_response_types_map,
17181        ).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

17246    @validate_call
17247    def create_connector(
17248        self,
17249        board_id: Annotated[
17250            StrictStr,
17251            Field(description="Unique identifier (ID) of the board for which you want to create the connector."),
17252        ],
17253        connector_creation_data: ConnectorCreationData,
17254        _request_timeout: Union[
17255            None,
17256            Annotated[StrictFloat, Field(gt=0)],
17257            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17258        ] = None,
17259        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17260        _content_type: Optional[StrictStr] = None,
17261        _headers: Optional[Dict[StrictStr, Any]] = None,
17262        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17263    ) -> ConnectorWithLinks:
17264        """Create connector
17265
17266        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
17267
17268        :param board_id: Unique identifier (ID) of the board for which you want to create the connector. (required)
17269        :type board_id: str
17270        :param connector_creation_data: (required)
17271        :type connector_creation_data: ConnectorCreationData
17272        :param _request_timeout: timeout setting for this request. If one
17273                                 number provided, it will be total request
17274                                 timeout. It can also be a pair (tuple) of
17275                                 (connection, read) timeouts.
17276        :type _request_timeout: int, tuple(int, int), optional
17277        :param _request_auth: set to override the auth_settings for an a single
17278                              request; this effectively ignores the
17279                              authentication in the spec for a single request.
17280        :type _request_auth: dict, optional
17281        :param _content_type: force content-type for the request.
17282        :type _content_type: str, Optional
17283        :param _headers: set to override the headers for a single
17284                         request; this effectively ignores the headers
17285                         in the spec for a single request.
17286        :type _headers: dict, optional
17287        :param _host_index: set to override the host_index for a single
17288                            request; this effectively ignores the host_index
17289                            in the spec for a single request.
17290        :type _host_index: int, optional
17291        :return: Returns the result object.
17292        """  # noqa: E501
17293
17294        _param = self._create_connector_serialize(
17295            board_id=board_id,
17296            connector_creation_data=connector_creation_data,
17297            _request_auth=_request_auth,
17298            _content_type=_content_type,
17299            _headers=_headers,
17300            _host_index=_host_index,
17301        )
17302
17303        _response_types_map: Dict[str, Optional[str]] = {
17304            "200": "ConnectorWithLinks",
17305            "400": None,
17306            "404": None,
17307            "429": None,
17308        }
17309        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17310        response_data.read()
17311        return self.api_client.response_deserialize(
17312            response_data=response_data,
17313            response_types_map=_response_types_map,
17314        ).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

17376    @validate_call
17377    def delete_connector(
17378        self,
17379        board_id: Annotated[
17380            StrictStr,
17381            Field(description="Unique identifier (ID) of the board from which you want to delete the connector."),
17382        ],
17383        connector_id: Annotated[
17384            StrictStr, Field(description="Unique identifier (ID) of the connector that you want to delete.")
17385        ],
17386        _request_timeout: Union[
17387            None,
17388            Annotated[StrictFloat, Field(gt=0)],
17389            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17390        ] = None,
17391        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17392        _content_type: Optional[StrictStr] = None,
17393        _headers: Optional[Dict[StrictStr, Any]] = None,
17394        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17395    ) -> object:
17396        """Delete connector
17397
17398        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
17399
17400        :param board_id: Unique identifier (ID) of the board from which you want to delete the connector. (required)
17401        :type board_id: str
17402        :param connector_id: Unique identifier (ID) of the connector that you want to delete. (required)
17403        :type connector_id: str
17404        :param _request_timeout: timeout setting for this request. If one
17405                                 number provided, it will be total request
17406                                 timeout. It can also be a pair (tuple) of
17407                                 (connection, read) timeouts.
17408        :type _request_timeout: int, tuple(int, int), optional
17409        :param _request_auth: set to override the auth_settings for an a single
17410                              request; this effectively ignores the
17411                              authentication in the spec for a single request.
17412        :type _request_auth: dict, optional
17413        :param _content_type: force content-type for the request.
17414        :type _content_type: str, Optional
17415        :param _headers: set to override the headers for a single
17416                         request; this effectively ignores the headers
17417                         in the spec for a single request.
17418        :type _headers: dict, optional
17419        :param _host_index: set to override the host_index for a single
17420                            request; this effectively ignores the host_index
17421                            in the spec for a single request.
17422        :type _host_index: int, optional
17423        :return: Returns the result object.
17424        """  # noqa: E501
17425
17426        _param = self._delete_connector_serialize(
17427            board_id=board_id,
17428            connector_id=connector_id,
17429            _request_auth=_request_auth,
17430            _content_type=_content_type,
17431            _headers=_headers,
17432            _host_index=_host_index,
17433        )
17434
17435        _response_types_map: Dict[str, Optional[str]] = {
17436            "204": "object",
17437            "400": None,
17438            "404": None,
17439            "429": None,
17440        }
17441        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17442        response_data.read()
17443        return self.api_client.response_deserialize(
17444            response_data=response_data,
17445            response_types_map=_response_types_map,
17446        ).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

17500    @validate_call
17501    def get_connector(
17502        self,
17503        board_id: Annotated[
17504            StrictStr,
17505            Field(
17506                description="Unique identifier (ID) of the board from which you want to retrieve a specific connector."
17507            ),
17508        ],
17509        connector_id: Annotated[
17510            StrictStr, Field(description="Unique identifier (ID) of the connector that you want to retrieve.")
17511        ],
17512        _request_timeout: Union[
17513            None,
17514            Annotated[StrictFloat, Field(gt=0)],
17515            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17516        ] = None,
17517        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17518        _content_type: Optional[StrictStr] = None,
17519        _headers: Optional[Dict[StrictStr, Any]] = None,
17520        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17521    ) -> ConnectorWithLinks:
17522        """Get specific connector
17523
17524        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
17525
17526        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific connector. (required)
17527        :type board_id: str
17528        :param connector_id: Unique identifier (ID) of the connector that you want to retrieve. (required)
17529        :type connector_id: str
17530        :param _request_timeout: timeout setting for this request. If one
17531                                 number provided, it will be total request
17532                                 timeout. It can also be a pair (tuple) of
17533                                 (connection, read) timeouts.
17534        :type _request_timeout: int, tuple(int, int), optional
17535        :param _request_auth: set to override the auth_settings for an a single
17536                              request; this effectively ignores the
17537                              authentication in the spec for a single request.
17538        :type _request_auth: dict, optional
17539        :param _content_type: force content-type for the request.
17540        :type _content_type: str, Optional
17541        :param _headers: set to override the headers for a single
17542                         request; this effectively ignores the headers
17543                         in the spec for a single request.
17544        :type _headers: dict, optional
17545        :param _host_index: set to override the host_index for a single
17546                            request; this effectively ignores the host_index
17547                            in the spec for a single request.
17548        :type _host_index: int, optional
17549        :return: Returns the result object.
17550        """  # noqa: E501
17551
17552        _param = self._get_connector_serialize(
17553            board_id=board_id,
17554            connector_id=connector_id,
17555            _request_auth=_request_auth,
17556            _content_type=_content_type,
17557            _headers=_headers,
17558            _host_index=_host_index,
17559        )
17560
17561        _response_types_map: Dict[str, Optional[str]] = {
17562            "200": "ConnectorWithLinks",
17563            "400": None,
17564            "404": None,
17565            "429": None,
17566        }
17567        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17568        response_data.read()
17569        return self.api_client.response_deserialize(
17570            response_data=response_data,
17571            response_types_map=_response_types_map,
17572        ).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

17626    @validate_call
17627    def get_connectors(
17628        self,
17629        board_id: Annotated[
17630            StrictStr,
17631            Field(
17632                description="Unique identifier (ID) of the board from which you want to retrieve a list of connectors."
17633            ),
17634        ],
17635        limit: Optional[Annotated[str, Field(strict=True)]] = None,
17636        cursor: Optional[StrictStr] = None,
17637        _request_timeout: Union[
17638            None,
17639            Annotated[StrictFloat, Field(gt=0)],
17640            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17641        ] = None,
17642        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17643        _content_type: Optional[StrictStr] = None,
17644        _headers: Optional[Dict[StrictStr, Any]] = None,
17645        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17646    ) -> ConnectorsCursorPaged:
17647        """Get connectors
17648
17649        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
17650
17651        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a list of connectors. (required)
17652        :type board_id: str
17653        :param limit:
17654        :type limit: str
17655        :param cursor:
17656        :type cursor: str
17657        :param _request_timeout: timeout setting for this request. If one
17658                                 number provided, it will be total request
17659                                 timeout. It can also be a pair (tuple) of
17660                                 (connection, read) timeouts.
17661        :type _request_timeout: int, tuple(int, int), optional
17662        :param _request_auth: set to override the auth_settings for an a single
17663                              request; this effectively ignores the
17664                              authentication in the spec for a single request.
17665        :type _request_auth: dict, optional
17666        :param _content_type: force content-type for the request.
17667        :type _content_type: str, Optional
17668        :param _headers: set to override the headers for a single
17669                         request; this effectively ignores the headers
17670                         in the spec for a single request.
17671        :type _headers: dict, optional
17672        :param _host_index: set to override the host_index for a single
17673                            request; this effectively ignores the host_index
17674                            in the spec for a single request.
17675        :type _host_index: int, optional
17676        :return: Returns the result object.
17677        """  # noqa: E501
17678
17679        _param = self._get_connectors_serialize(
17680            board_id=board_id,
17681            limit=limit,
17682            cursor=cursor,
17683            _request_auth=_request_auth,
17684            _content_type=_content_type,
17685            _headers=_headers,
17686            _host_index=_host_index,
17687        )
17688
17689        _response_types_map: Dict[str, Optional[str]] = {
17690            "200": "ConnectorsCursorPaged",
17691            "400": None,
17692            "404": None,
17693            "429": None,
17694        }
17695        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17696        response_data.read()
17697        return self.api_client.response_deserialize(
17698            response_data=response_data,
17699            response_types_map=_response_types_map,
17700        ).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

17761    @validate_call
17762    def update_connector(
17763        self,
17764        board_id: Annotated[
17765            StrictStr,
17766            Field(description="Unique identifier (ID) of the board for which you want to update the connector."),
17767        ],
17768        connector_id: Annotated[
17769            StrictStr, Field(description="Unique identifier (ID) of the connector that you want to update.")
17770        ],
17771        connector_changes_data: ConnectorChangesData,
17772        _request_timeout: Union[
17773            None,
17774            Annotated[StrictFloat, Field(gt=0)],
17775            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17776        ] = None,
17777        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17778        _content_type: Optional[StrictStr] = None,
17779        _headers: Optional[Dict[StrictStr, Any]] = None,
17780        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17781    ) -> ConnectorWithLinks:
17782        """Update connector
17783
17784        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
17785
17786        :param board_id: Unique identifier (ID) of the board for which you want to update the connector. (required)
17787        :type board_id: str
17788        :param connector_id: Unique identifier (ID) of the connector that you want to update. (required)
17789        :type connector_id: str
17790        :param connector_changes_data: (required)
17791        :type connector_changes_data: ConnectorChangesData
17792        :param _request_timeout: timeout setting for this request. If one
17793                                 number provided, it will be total request
17794                                 timeout. It can also be a pair (tuple) of
17795                                 (connection, read) timeouts.
17796        :type _request_timeout: int, tuple(int, int), optional
17797        :param _request_auth: set to override the auth_settings for an a single
17798                              request; this effectively ignores the
17799                              authentication in the spec for a single request.
17800        :type _request_auth: dict, optional
17801        :param _content_type: force content-type for the request.
17802        :type _content_type: str, Optional
17803        :param _headers: set to override the headers for a single
17804                         request; this effectively ignores the headers
17805                         in the spec for a single request.
17806        :type _headers: dict, optional
17807        :param _host_index: set to override the host_index for a single
17808                            request; this effectively ignores the host_index
17809                            in the spec for a single request.
17810        :type _host_index: int, optional
17811        :return: Returns the result object.
17812        """  # noqa: E501
17813
17814        _param = self._update_connector_serialize(
17815            board_id=board_id,
17816            connector_id=connector_id,
17817            connector_changes_data=connector_changes_data,
17818            _request_auth=_request_auth,
17819            _content_type=_content_type,
17820            _headers=_headers,
17821            _host_index=_host_index,
17822        )
17823
17824        _response_types_map: Dict[str, Optional[str]] = {
17825            "200": "ConnectorWithLinks",
17826            "400": None,
17827            "404": None,
17828            "409": None,
17829            "429": None,
17830        }
17831        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17832        response_data.read()
17833        return self.api_client.response_deserialize(
17834            response_data=response_data,
17835            response_types_map=_response_types_map,
17836        ).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_doc_format_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.')], doc_format_create_request: miro_api.models.doc_format_create_request.DocFormatCreateRequest, _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.doc_format_item.DocFormatItem: View Source

17901    @validate_call
17902    def create_doc_format_item(
17903        self,
17904        board_id: Annotated[
17905            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
17906        ],
17907        doc_format_create_request: DocFormatCreateRequest,
17908        _request_timeout: Union[
17909            None,
17910            Annotated[StrictFloat, Field(gt=0)],
17911            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
17912        ] = None,
17913        _request_auth: Optional[Dict[StrictStr, Any]] = None,
17914        _content_type: Optional[StrictStr] = None,
17915        _headers: Optional[Dict[StrictStr, Any]] = None,
17916        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
17917    ) -> DocFormatItem:
17918        """Create doc format item
17919
17920        Adds a doc format 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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
17921
17922        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
17923        :type board_id: str
17924        :param doc_format_create_request: (required)
17925        :type doc_format_create_request: DocFormatCreateRequest
17926        :param _request_timeout: timeout setting for this request. If one
17927                                 number provided, it will be total request
17928                                 timeout. It can also be a pair (tuple) of
17929                                 (connection, read) timeouts.
17930        :type _request_timeout: int, tuple(int, int), optional
17931        :param _request_auth: set to override the auth_settings for an a single
17932                              request; this effectively ignores the
17933                              authentication in the spec for a single request.
17934        :type _request_auth: dict, optional
17935        :param _content_type: force content-type for the request.
17936        :type _content_type: str, Optional
17937        :param _headers: set to override the headers for a single
17938                         request; this effectively ignores the headers
17939                         in the spec for a single request.
17940        :type _headers: dict, optional
17941        :param _host_index: set to override the host_index for a single
17942                            request; this effectively ignores the host_index
17943                            in the spec for a single request.
17944        :type _host_index: int, optional
17945        :return: Returns the result object.
17946        """  # noqa: E501
17947
17948        _param = self._create_doc_format_item_serialize(
17949            board_id=board_id,
17950            doc_format_create_request=doc_format_create_request,
17951            _request_auth=_request_auth,
17952            _content_type=_content_type,
17953            _headers=_headers,
17954            _host_index=_host_index,
17955        )
17956
17957        _response_types_map: Dict[str, Optional[str]] = {
17958            "201": "DocFormatItem",
17959            "400": None,
17960            "404": None,
17961            "429": None,
17962        }
17963        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
17964        response_data.read()
17965        return self.api_client.response_deserialize(
17966            response_data=response_data,
17967            response_types_map=_response_types_map,
17968        ).data

Create doc format item

Adds a doc format 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 doc_format_create_request: (required) :type doc_format_create_request: DocFormatCreateRequest :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_doc_format_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

18030    @validate_call
18031    def delete_doc_format_item(
18032        self,
18033        board_id: Annotated[
18034            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
18035        ],
18036        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
18037        _request_timeout: Union[
18038            None,
18039            Annotated[StrictFloat, Field(gt=0)],
18040            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18041        ] = None,
18042        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18043        _content_type: Optional[StrictStr] = None,
18044        _headers: Optional[Dict[StrictStr, Any]] = None,
18045        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18046    ) -> object:
18047        """Delete doc format item
18048
18049        Deletes a doc format 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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
18050
18051        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
18052        :type board_id: str
18053        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
18054        :type item_id: str
18055        :param _request_timeout: timeout setting for this request. If one
18056                                 number provided, it will be total request
18057                                 timeout. It can also be a pair (tuple) of
18058                                 (connection, read) timeouts.
18059        :type _request_timeout: int, tuple(int, int), optional
18060        :param _request_auth: set to override the auth_settings for an a single
18061                              request; this effectively ignores the
18062                              authentication in the spec for a single request.
18063        :type _request_auth: dict, optional
18064        :param _content_type: force content-type for the request.
18065        :type _content_type: str, Optional
18066        :param _headers: set to override the headers for a single
18067                         request; this effectively ignores the headers
18068                         in the spec for a single request.
18069        :type _headers: dict, optional
18070        :param _host_index: set to override the host_index for a single
18071                            request; this effectively ignores the host_index
18072                            in the spec for a single request.
18073        :type _host_index: int, optional
18074        :return: Returns the result object.
18075        """  # noqa: E501
18076
18077        _param = self._delete_doc_format_item_serialize(
18078            board_id=board_id,
18079            item_id=item_id,
18080            _request_auth=_request_auth,
18081            _content_type=_content_type,
18082            _headers=_headers,
18083            _host_index=_host_index,
18084        )
18085
18086        _response_types_map: Dict[str, Optional[str]] = {
18087            "204": "object",
18088            "400": None,
18089            "404": None,
18090            "429": None,
18091        }
18092        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18093        response_data.read()
18094        return self.api_client.response_deserialize(
18095            response_data=response_data,
18096            response_types_map=_response_types_map,
18097        ).data

Delete doc format item

Deletes a doc format 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_doc_format_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.')], text_content_type: Annotated[Optional[Annotated[str, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description="Controls the contentType of the returned doc's content.")] = 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.doc_format_item.DocFormatItem: View Source

18151    @validate_call
18152    def get_doc_format_item(
18153        self,
18154        board_id: Annotated[
18155            StrictStr,
18156            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
18157        ],
18158        item_id: Annotated[
18159            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
18160        ],
18161        text_content_type: Annotated[
18162            Optional[StrictStr], Field(description="Controls the contentType of the returned doc's content.")
18163        ] = None,
18164        _request_timeout: Union[
18165            None,
18166            Annotated[StrictFloat, Field(gt=0)],
18167            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18168        ] = None,
18169        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18170        _content_type: Optional[StrictStr] = None,
18171        _headers: Optional[Dict[StrictStr, Any]] = None,
18172        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18173    ) -> DocFormatItem:
18174        """Get doc format item
18175
18176        Retrieves information for a specific doc format 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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
18177
18178        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
18179        :type board_id: str
18180        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
18181        :type item_id: str
18182        :param text_content_type: Controls the contentType of the returned doc's content.
18183        :type text_content_type: str
18184        :param _request_timeout: timeout setting for this request. If one
18185                                 number provided, it will be total request
18186                                 timeout. It can also be a pair (tuple) of
18187                                 (connection, read) timeouts.
18188        :type _request_timeout: int, tuple(int, int), optional
18189        :param _request_auth: set to override the auth_settings for an a single
18190                              request; this effectively ignores the
18191                              authentication in the spec for a single request.
18192        :type _request_auth: dict, optional
18193        :param _content_type: force content-type for the request.
18194        :type _content_type: str, Optional
18195        :param _headers: set to override the headers for a single
18196                         request; this effectively ignores the headers
18197                         in the spec for a single request.
18198        :type _headers: dict, optional
18199        :param _host_index: set to override the host_index for a single
18200                            request; this effectively ignores the host_index
18201                            in the spec for a single request.
18202        :type _host_index: int, optional
18203        :return: Returns the result object.
18204        """  # noqa: E501
18205
18206        _param = self._get_doc_format_item_serialize(
18207            board_id=board_id,
18208            item_id=item_id,
18209            text_content_type=text_content_type,
18210            _request_auth=_request_auth,
18211            _content_type=_content_type,
18212            _headers=_headers,
18213            _host_index=_host_index,
18214        )
18215
18216        _response_types_map: Dict[str, Optional[str]] = {
18217            "200": "DocFormatItem",
18218            "400": None,
18219            "404": None,
18220            "429": None,
18221        }
18222        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18223        response_data.read()
18224        return self.api_client.response_deserialize(
18225            response_data=response_data,
18226            response_types_map=_response_types_map,
18227        ).data

Get doc format item

Retrieves information for a specific doc format 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 text_content_type: Controls the contentType of the returned doc's content. :type text_content_type: 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_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

18286    @validate_call
18287    def create_document_item_using_file_from_device(
18288        self,
18289        board_id_platform_file_upload: Annotated[
18290            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
18291        ],
18292        resource: Annotated[
18293            Union[StrictBytes, StrictStr], Field(description="Select a file to upload. Maximum file size is 6 MB.")
18294        ],
18295        data: Optional[CreateDocumentItemUsingFileFromDeviceRequestData] = None,
18296        _request_timeout: Union[
18297            None,
18298            Annotated[StrictFloat, Field(gt=0)],
18299            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18300        ] = None,
18301        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18302        _content_type: Optional[StrictStr] = None,
18303        _headers: Optional[Dict[StrictStr, Any]] = None,
18304        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18305    ) -> DocumentItem:
18306        """Create document item using file from device
18307
18308        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
18309
18310        :param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to create the item. (required)
18311        :type board_id_platform_file_upload: str
18312        :param resource: Select a file to upload. Maximum file size is 6 MB. (required)
18313        :type resource: bytearray
18314        :param data:
18315        :type data: CreateDocumentItemUsingFileFromDeviceRequestData
18316        :param _request_timeout: timeout setting for this request. If one
18317                                 number provided, it will be total request
18318                                 timeout. It can also be a pair (tuple) of
18319                                 (connection, read) timeouts.
18320        :type _request_timeout: int, tuple(int, int), optional
18321        :param _request_auth: set to override the auth_settings for an a single
18322                              request; this effectively ignores the
18323                              authentication in the spec for a single request.
18324        :type _request_auth: dict, optional
18325        :param _content_type: force content-type for the request.
18326        :type _content_type: str, Optional
18327        :param _headers: set to override the headers for a single
18328                         request; this effectively ignores the headers
18329                         in the spec for a single request.
18330        :type _headers: dict, optional
18331        :param _host_index: set to override the host_index for a single
18332                            request; this effectively ignores the host_index
18333                            in the spec for a single request.
18334        :type _host_index: int, optional
18335        :return: Returns the result object.
18336        """  # noqa: E501
18337
18338        _param = self._create_document_item_using_file_from_device_serialize(
18339            board_id_platform_file_upload=board_id_platform_file_upload,
18340            resource=resource,
18341            data=data,
18342            _request_auth=_request_auth,
18343            _content_type=_content_type,
18344            _headers=_headers,
18345            _host_index=_host_index,
18346        )
18347
18348        _response_types_map: Dict[str, Optional[str]] = {
18349            "201": "DocumentItem",
18350        }
18351        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18352        response_data.read()
18353        return self.api_client.response_deserialize(
18354            response_data=response_data,
18355            response_types_map=_response_types_map,
18356        ).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

18421    @validate_call
18422    def create_document_item_using_url(
18423        self,
18424        board_id: Annotated[
18425            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
18426        ],
18427        document_create_request: DocumentCreateRequest,
18428        _request_timeout: Union[
18429            None,
18430            Annotated[StrictFloat, Field(gt=0)],
18431            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18432        ] = None,
18433        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18434        _content_type: Optional[StrictStr] = None,
18435        _headers: Optional[Dict[StrictStr, Any]] = None,
18436        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18437    ) -> DocumentItem:
18438        """Create document item using URL
18439
18440        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
18441
18442        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
18443        :type board_id: str
18444        :param document_create_request: (required)
18445        :type document_create_request: DocumentCreateRequest
18446        :param _request_timeout: timeout setting for this request. If one
18447                                 number provided, it will be total request
18448                                 timeout. It can also be a pair (tuple) of
18449                                 (connection, read) timeouts.
18450        :type _request_timeout: int, tuple(int, int), optional
18451        :param _request_auth: set to override the auth_settings for an a single
18452                              request; this effectively ignores the
18453                              authentication in the spec for a single request.
18454        :type _request_auth: dict, optional
18455        :param _content_type: force content-type for the request.
18456        :type _content_type: str, Optional
18457        :param _headers: set to override the headers for a single
18458                         request; this effectively ignores the headers
18459                         in the spec for a single request.
18460        :type _headers: dict, optional
18461        :param _host_index: set to override the host_index for a single
18462                            request; this effectively ignores the host_index
18463                            in the spec for a single request.
18464        :type _host_index: int, optional
18465        :return: Returns the result object.
18466        """  # noqa: E501
18467
18468        _param = self._create_document_item_using_url_serialize(
18469            board_id=board_id,
18470            document_create_request=document_create_request,
18471            _request_auth=_request_auth,
18472            _content_type=_content_type,
18473            _headers=_headers,
18474            _host_index=_host_index,
18475        )
18476
18477        _response_types_map: Dict[str, Optional[str]] = {
18478            "201": "DocumentItem",
18479            "400": None,
18480            "404": None,
18481            "429": None,
18482        }
18483        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18484        response_data.read()
18485        return self.api_client.response_deserialize(
18486            response_data=response_data,
18487            response_types_map=_response_types_map,
18488        ).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

18550    @validate_call
18551    def delete_document_item(
18552        self,
18553        board_id: Annotated[
18554            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
18555        ],
18556        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
18557        _request_timeout: Union[
18558            None,
18559            Annotated[StrictFloat, Field(gt=0)],
18560            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18561        ] = None,
18562        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18563        _content_type: Optional[StrictStr] = None,
18564        _headers: Optional[Dict[StrictStr, Any]] = None,
18565        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18566    ) -> object:
18567        """Delete document item
18568
18569        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
18570
18571        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
18572        :type board_id: str
18573        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
18574        :type item_id: str
18575        :param _request_timeout: timeout setting for this request. If one
18576                                 number provided, it will be total request
18577                                 timeout. It can also be a pair (tuple) of
18578                                 (connection, read) timeouts.
18579        :type _request_timeout: int, tuple(int, int), optional
18580        :param _request_auth: set to override the auth_settings for an a single
18581                              request; this effectively ignores the
18582                              authentication in the spec for a single request.
18583        :type _request_auth: dict, optional
18584        :param _content_type: force content-type for the request.
18585        :type _content_type: str, Optional
18586        :param _headers: set to override the headers for a single
18587                         request; this effectively ignores the headers
18588                         in the spec for a single request.
18589        :type _headers: dict, optional
18590        :param _host_index: set to override the host_index for a single
18591                            request; this effectively ignores the host_index
18592                            in the spec for a single request.
18593        :type _host_index: int, optional
18594        :return: Returns the result object.
18595        """  # noqa: E501
18596
18597        _param = self._delete_document_item_serialize(
18598            board_id=board_id,
18599            item_id=item_id,
18600            _request_auth=_request_auth,
18601            _content_type=_content_type,
18602            _headers=_headers,
18603            _host_index=_host_index,
18604        )
18605
18606        _response_types_map: Dict[str, Optional[str]] = {
18607            "204": "object",
18608            "400": None,
18609            "404": None,
18610            "429": None,
18611        }
18612        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18613        response_data.read()
18614        return self.api_client.response_deserialize(
18615            response_data=response_data,
18616            response_types_map=_response_types_map,
18617        ).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

18671    @validate_call
18672    def get_document_item(
18673        self,
18674        board_id: Annotated[
18675            StrictStr,
18676            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
18677        ],
18678        item_id: Annotated[
18679            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
18680        ],
18681        _request_timeout: Union[
18682            None,
18683            Annotated[StrictFloat, Field(gt=0)],
18684            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18685        ] = None,
18686        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18687        _content_type: Optional[StrictStr] = None,
18688        _headers: Optional[Dict[StrictStr, Any]] = None,
18689        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18690    ) -> DocumentItem:
18691        """Get document item
18692
18693        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
18694
18695        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
18696        :type board_id: str
18697        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
18698        :type item_id: str
18699        :param _request_timeout: timeout setting for this request. If one
18700                                 number provided, it will be total request
18701                                 timeout. It can also be a pair (tuple) of
18702                                 (connection, read) timeouts.
18703        :type _request_timeout: int, tuple(int, int), optional
18704        :param _request_auth: set to override the auth_settings for an a single
18705                              request; this effectively ignores the
18706                              authentication in the spec for a single request.
18707        :type _request_auth: dict, optional
18708        :param _content_type: force content-type for the request.
18709        :type _content_type: str, Optional
18710        :param _headers: set to override the headers for a single
18711                         request; this effectively ignores the headers
18712                         in the spec for a single request.
18713        :type _headers: dict, optional
18714        :param _host_index: set to override the host_index for a single
18715                            request; this effectively ignores the host_index
18716                            in the spec for a single request.
18717        :type _host_index: int, optional
18718        :return: Returns the result object.
18719        """  # noqa: E501
18720
18721        _param = self._get_document_item_serialize(
18722            board_id=board_id,
18723            item_id=item_id,
18724            _request_auth=_request_auth,
18725            _content_type=_content_type,
18726            _headers=_headers,
18727            _host_index=_host_index,
18728        )
18729
18730        _response_types_map: Dict[str, Optional[str]] = {
18731            "200": "DocumentItem",
18732            "400": None,
18733            "404": None,
18734            "429": None,
18735        }
18736        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18737        response_data.read()
18738        return self.api_client.response_deserialize(
18739            response_data=response_data,
18740            response_types_map=_response_types_map,
18741        ).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

18795    @validate_call
18796    def update_document_item_using_file_from_device(
18797        self,
18798        board_id_platform_file_upload: Annotated[
18799            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
18800        ],
18801        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
18802        resource: Annotated[
18803            Union[StrictBytes, StrictStr], Field(description="Select a file to upload. Maximum file size is 6 MB.")
18804        ],
18805        data: Optional[UploadFileFromDeviceData] = None,
18806        _request_timeout: Union[
18807            None,
18808            Annotated[StrictFloat, Field(gt=0)],
18809            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18810        ] = None,
18811        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18812        _content_type: Optional[StrictStr] = None,
18813        _headers: Optional[Dict[StrictStr, Any]] = None,
18814        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18815    ) -> DocumentItem:
18816        """Update document item using file from device
18817
18818        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
18819
18820        :param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to update the item. (required)
18821        :type board_id_platform_file_upload: str
18822        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
18823        :type item_id: str
18824        :param resource: Select a file to upload. Maximum file size is 6 MB. (required)
18825        :type resource: bytearray
18826        :param data:
18827        :type data: UploadFileFromDeviceData
18828        :param _request_timeout: timeout setting for this request. If one
18829                                 number provided, it will be total request
18830                                 timeout. It can also be a pair (tuple) of
18831                                 (connection, read) timeouts.
18832        :type _request_timeout: int, tuple(int, int), optional
18833        :param _request_auth: set to override the auth_settings for an a single
18834                              request; this effectively ignores the
18835                              authentication in the spec for a single request.
18836        :type _request_auth: dict, optional
18837        :param _content_type: force content-type for the request.
18838        :type _content_type: str, Optional
18839        :param _headers: set to override the headers for a single
18840                         request; this effectively ignores the headers
18841                         in the spec for a single request.
18842        :type _headers: dict, optional
18843        :param _host_index: set to override the host_index for a single
18844                            request; this effectively ignores the host_index
18845                            in the spec for a single request.
18846        :type _host_index: int, optional
18847        :return: Returns the result object.
18848        """  # noqa: E501
18849
18850        _param = self._update_document_item_using_file_from_device_serialize(
18851            board_id_platform_file_upload=board_id_platform_file_upload,
18852            item_id=item_id,
18853            resource=resource,
18854            data=data,
18855            _request_auth=_request_auth,
18856            _content_type=_content_type,
18857            _headers=_headers,
18858            _host_index=_host_index,
18859        )
18860
18861        _response_types_map: Dict[str, Optional[str]] = {
18862            "200": "DocumentItem",
18863        }
18864        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
18865        response_data.read()
18866        return self.api_client.response_deserialize(
18867            response_data=response_data,
18868            response_types_map=_response_types_map,
18869        ).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

18937    @validate_call
18938    def update_document_item_using_url(
18939        self,
18940        board_id: Annotated[
18941            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
18942        ],
18943        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
18944        document_update_request: DocumentUpdateRequest,
18945        _request_timeout: Union[
18946            None,
18947            Annotated[StrictFloat, Field(gt=0)],
18948            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
18949        ] = None,
18950        _request_auth: Optional[Dict[StrictStr, Any]] = None,
18951        _content_type: Optional[StrictStr] = None,
18952        _headers: Optional[Dict[StrictStr, Any]] = None,
18953        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
18954    ) -> DocumentItem:
18955        """Update document item using URL
18956
18957        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
18958
18959        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
18960        :type board_id: str
18961        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
18962        :type item_id: str
18963        :param document_update_request: (required)
18964        :type document_update_request: DocumentUpdateRequest
18965        :param _request_timeout: timeout setting for this request. If one
18966                                 number provided, it will be total request
18967                                 timeout. It can also be a pair (tuple) of
18968                                 (connection, read) timeouts.
18969        :type _request_timeout: int, tuple(int, int), optional
18970        :param _request_auth: set to override the auth_settings for an a single
18971                              request; this effectively ignores the
18972                              authentication in the spec for a single request.
18973        :type _request_auth: dict, optional
18974        :param _content_type: force content-type for the request.
18975        :type _content_type: str, Optional
18976        :param _headers: set to override the headers for a single
18977                         request; this effectively ignores the headers
18978                         in the spec for a single request.
18979        :type _headers: dict, optional
18980        :param _host_index: set to override the host_index for a single
18981                            request; this effectively ignores the host_index
18982                            in the spec for a single request.
18983        :type _host_index: int, optional
18984        :return: Returns the result object.
18985        """  # noqa: E501
18986
18987        _param = self._update_document_item_using_url_serialize(
18988            board_id=board_id,
18989            item_id=item_id,
18990            document_update_request=document_update_request,
18991            _request_auth=_request_auth,
18992            _content_type=_content_type,
18993            _headers=_headers,
18994            _host_index=_host_index,
18995        )
18996
18997        _response_types_map: Dict[str, Optional[str]] = {
18998            "200": "DocumentItem",
18999            "400": None,
19000            "404": None,
19001            "409": None,
19002            "429": None,
19003        }
19004        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
19005        response_data.read()
19006        return self.api_client.response_deserialize(
19007            response_data=response_data,
19008            response_types_map=_response_types_map,
19009        ).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

19074    @validate_call
19075    def create_embed_item(
19076        self,
19077        board_id: Annotated[
19078            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
19079        ],
19080        embed_create_request: EmbedCreateRequest,
19081        _request_timeout: Union[
19082            None,
19083            Annotated[StrictFloat, Field(gt=0)],
19084            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
19085        ] = None,
19086        _request_auth: Optional[Dict[StrictStr, Any]] = None,
19087        _content_type: Optional[StrictStr] = None,
19088        _headers: Optional[Dict[StrictStr, Any]] = None,
19089        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
19090    ) -> EmbedItem:
19091        """Create embed item
19092
19093        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
19094
19095        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
19096        :type board_id: str
19097        :param embed_create_request: (required)
19098        :type embed_create_request: EmbedCreateRequest
19099        :param _request_timeout: timeout setting for this request. If one
19100                                 number provided, it will be total request
19101                                 timeout. It can also be a pair (tuple) of
19102                                 (connection, read) timeouts.
19103        :type _request_timeout: int, tuple(int, int), optional
19104        :param _request_auth: set to override the auth_settings for an a single
19105                              request; this effectively ignores the
19106                              authentication in the spec for a single request.
19107        :type _request_auth: dict, optional
19108        :param _content_type: force content-type for the request.
19109        :type _content_type: str, Optional
19110        :param _headers: set to override the headers for a single
19111                         request; this effectively ignores the headers
19112                         in the spec for a single request.
19113        :type _headers: dict, optional
19114        :param _host_index: set to override the host_index for a single
19115                            request; this effectively ignores the host_index
19116                            in the spec for a single request.
19117        :type _host_index: int, optional
19118        :return: Returns the result object.
19119        """  # noqa: E501
19120
19121        _param = self._create_embed_item_serialize(
19122            board_id=board_id,
19123            embed_create_request=embed_create_request,
19124            _request_auth=_request_auth,
19125            _content_type=_content_type,
19126            _headers=_headers,
19127            _host_index=_host_index,
19128        )
19129
19130        _response_types_map: Dict[str, Optional[str]] = {
19131            "201": "EmbedItem",
19132            "400": None,
19133            "404": None,
19134            "429": None,
19135        }
19136        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
19137        response_data.read()
19138        return self.api_client.response_deserialize(
19139            response_data=response_data,
19140            response_types_map=_response_types_map,
19141        ).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

19203    @validate_call
19204    def delete_embed_item(
19205        self,
19206        board_id: Annotated[
19207            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
19208        ],
19209        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
19210        _request_timeout: Union[
19211            None,
19212            Annotated[StrictFloat, Field(gt=0)],
19213            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
19214        ] = None,
19215        _request_auth: Optional[Dict[StrictStr, Any]] = None,
19216        _content_type: Optional[StrictStr] = None,
19217        _headers: Optional[Dict[StrictStr, Any]] = None,
19218        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
19219    ) -> object:
19220        """Delete embed item
19221
19222        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
19223
19224        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
19225        :type board_id: str
19226        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
19227        :type item_id: str
19228        :param _request_timeout: timeout setting for this request. If one
19229                                 number provided, it will be total request
19230                                 timeout. It can also be a pair (tuple) of
19231                                 (connection, read) timeouts.
19232        :type _request_timeout: int, tuple(int, int), optional
19233        :param _request_auth: set to override the auth_settings for an a single
19234                              request; this effectively ignores the
19235                              authentication in the spec for a single request.
19236        :type _request_auth: dict, optional
19237        :param _content_type: force content-type for the request.
19238        :type _content_type: str, Optional
19239        :param _headers: set to override the headers for a single
19240                         request; this effectively ignores the headers
19241                         in the spec for a single request.
19242        :type _headers: dict, optional
19243        :param _host_index: set to override the host_index for a single
19244                            request; this effectively ignores the host_index
19245                            in the spec for a single request.
19246        :type _host_index: int, optional
19247        :return: Returns the result object.
19248        """  # noqa: E501
19249
19250        _param = self._delete_embed_item_serialize(
19251            board_id=board_id,
19252            item_id=item_id,
19253            _request_auth=_request_auth,
19254            _content_type=_content_type,
19255            _headers=_headers,
19256            _host_index=_host_index,
19257        )
19258
19259        _response_types_map: Dict[str, Optional[str]] = {
19260            "204": "object",
19261            "400": None,
19262            "404": None,
19263            "429": None,
19264        }
19265        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
19266        response_data.read()
19267        return self.api_client.response_deserialize(
19268            response_data=response_data,
19269            response_types_map=_response_types_map,
19270        ).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

19324    @validate_call
19325    def get_embed_item(
19326        self,
19327        board_id: Annotated[
19328            StrictStr,
19329            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
19330        ],
19331        item_id: Annotated[
19332            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
19333        ],
19334        _request_timeout: Union[
19335            None,
19336            Annotated[StrictFloat, Field(gt=0)],
19337            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
19338        ] = None,
19339        _request_auth: Optional[Dict[StrictStr, Any]] = None,
19340        _content_type: Optional[StrictStr] = None,
19341        _headers: Optional[Dict[StrictStr, Any]] = None,
19342        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
19343    ) -> EmbedItem:
19344        """Get embed item
19345
19346        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
19347
19348        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
19349        :type board_id: str
19350        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
19351        :type item_id: str
19352        :param _request_timeout: timeout setting for this request. If one
19353                                 number provided, it will be total request
19354                                 timeout. It can also be a pair (tuple) of
19355                                 (connection, read) timeouts.
19356        :type _request_timeout: int, tuple(int, int), optional
19357        :param _request_auth: set to override the auth_settings for an a single
19358                              request; this effectively ignores the
19359                              authentication in the spec for a single request.
19360        :type _request_auth: dict, optional
19361        :param _content_type: force content-type for the request.
19362        :type _content_type: str, Optional
19363        :param _headers: set to override the headers for a single
19364                         request; this effectively ignores the headers
19365                         in the spec for a single request.
19366        :type _headers: dict, optional
19367        :param _host_index: set to override the host_index for a single
19368                            request; this effectively ignores the host_index
19369                            in the spec for a single request.
19370        :type _host_index: int, optional
19371        :return: Returns the result object.
19372        """  # noqa: E501
19373
19374        _param = self._get_embed_item_serialize(
19375            board_id=board_id,
19376            item_id=item_id,
19377            _request_auth=_request_auth,
19378            _content_type=_content_type,
19379            _headers=_headers,
19380            _host_index=_host_index,
19381        )
19382
19383        _response_types_map: Dict[str, Optional[str]] = {
19384            "200": "EmbedItem",
19385            "400": None,
19386            "404": None,
19387            "429": None,
19388        }
19389        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
19390        response_data.read()
19391        return self.api_client.response_deserialize(
19392            response_data=response_data,
19393            response_types_map=_response_types_map,
19394        ).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

19448    @validate_call
19449    def update_embed_item(
19450        self,
19451        board_id: Annotated[
19452            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
19453        ],
19454        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
19455        embed_update_request: EmbedUpdateRequest,
19456        _request_timeout: Union[
19457            None,
19458            Annotated[StrictFloat, Field(gt=0)],
19459            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
19460        ] = None,
19461        _request_auth: Optional[Dict[StrictStr, Any]] = None,
19462        _content_type: Optional[StrictStr] = None,
19463        _headers: Optional[Dict[StrictStr, Any]] = None,
19464        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
19465    ) -> EmbedItem:
19466        """Update embed item
19467
19468        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
19469
19470        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
19471        :type board_id: str
19472        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
19473        :type item_id: str
19474        :param embed_update_request: (required)
19475        :type embed_update_request: EmbedUpdateRequest
19476        :param _request_timeout: timeout setting for this request. If one
19477                                 number provided, it will be total request
19478                                 timeout. It can also be a pair (tuple) of
19479                                 (connection, read) timeouts.
19480        :type _request_timeout: int, tuple(int, int), optional
19481        :param _request_auth: set to override the auth_settings for an a single
19482                              request; this effectively ignores the
19483                              authentication in the spec for a single request.
19484        :type _request_auth: dict, optional
19485        :param _content_type: force content-type for the request.
19486        :type _content_type: str, Optional
19487        :param _headers: set to override the headers for a single
19488                         request; this effectively ignores the headers
19489                         in the spec for a single request.
19490        :type _headers: dict, optional
19491        :param _host_index: set to override the host_index for a single
19492                            request; this effectively ignores the host_index
19493                            in the spec for a single request.
19494        :type _host_index: int, optional
19495        :return: Returns the result object.
19496        """  # noqa: E501
19497
19498        _param = self._update_embed_item_serialize(
19499            board_id=board_id,
19500            item_id=item_id,
19501            embed_update_request=embed_update_request,
19502            _request_auth=_request_auth,
19503            _content_type=_content_type,
19504            _headers=_headers,
19505            _host_index=_host_index,
19506        )
19507
19508        _response_types_map: Dict[str, Optional[str]] = {
19509            "200": "EmbedItem",
19510            "400": None,
19511            "404": None,
19512            "409": None,
19513            "429": None,
19514        }
19515        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
19516        response_data.read()
19517        return self.api_client.response_deserialize(
19518            response_data=response_data,
19519            response_types_map=_response_types_map,
19520        ).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

19585    @validate_call
19586    def create_frame_item(
19587        self,
19588        board_id: Annotated[
19589            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create a frame.")
19590        ],
19591        frame_create_request: FrameCreateRequest,
19592        _request_timeout: Union[
19593            None,
19594            Annotated[StrictFloat, Field(gt=0)],
19595            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
19596        ] = None,
19597        _request_auth: Optional[Dict[StrictStr, Any]] = None,
19598        _content_type: Optional[StrictStr] = None,
19599        _headers: Optional[Dict[StrictStr, Any]] = None,
19600        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
19601    ) -> FrameItem:
19602        """Create frame
19603
19604        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
19605
19606        :param board_id: Unique identifier (ID) of the board where you want to create a frame. (required)
19607        :type board_id: str
19608        :param frame_create_request: (required)
19609        :type frame_create_request: FrameCreateRequest
19610        :param _request_timeout: timeout setting for this request. If one
19611                                 number provided, it will be total request
19612                                 timeout. It can also be a pair (tuple) of
19613                                 (connection, read) timeouts.
19614        :type _request_timeout: int, tuple(int, int), optional
19615        :param _request_auth: set to override the auth_settings for an a single
19616                              request; this effectively ignores the
19617                              authentication in the spec for a single request.
19618        :type _request_auth: dict, optional
19619        :param _content_type: force content-type for the request.
19620        :type _content_type: str, Optional
19621        :param _headers: set to override the headers for a single
19622                         request; this effectively ignores the headers
19623                         in the spec for a single request.
19624        :type _headers: dict, optional
19625        :param _host_index: set to override the host_index for a single
19626                            request; this effectively ignores the host_index
19627                            in the spec for a single request.
19628        :type _host_index: int, optional
19629        :return: Returns the result object.
19630        """  # noqa: E501
19631
19632        _param = self._create_frame_item_serialize(
19633            board_id=board_id,
19634            frame_create_request=frame_create_request,
19635            _request_auth=_request_auth,
19636            _content_type=_content_type,
19637            _headers=_headers,
19638            _host_index=_host_index,
19639        )
19640
19641        _response_types_map: Dict[str, Optional[str]] = {
19642            "201": "FrameItem",
19643            "400": "CreateFrameItem400Response",
19644            "404": "CreateFrameItem400Response",
19645            "429": "CreateFrameItem400Response",
19646        }
19647        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
19648        response_data.read()
19649        return self.api_client.response_deserialize(
19650            response_data=response_data,
19651            response_types_map=_response_types_map,
19652        ).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

19714    @validate_call
19715    def delete_frame_item(
19716        self,
19717        board_id: Annotated[
19718            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the frame.")
19719        ],
19720        item_id: Annotated[
19721            StrictStr, Field(description="Unique identifier (ID) of the frame that you want to delete.")
19722        ],
19723        _request_timeout: Union[
19724            None,
19725            Annotated[StrictFloat, Field(gt=0)],
19726            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
19727        ] = None,
19728        _request_auth: Optional[Dict[StrictStr, Any]] = None,
19729        _content_type: Optional[StrictStr] = None,
19730        _headers: Optional[Dict[StrictStr, Any]] = None,
19731        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
19732    ) -> object:
19733        """Delete frame
19734
19735        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
19736
19737        :param board_id: Unique identifier (ID) of the board from which you want to delete the frame. (required)
19738        :type board_id: str
19739        :param item_id: Unique identifier (ID) of the frame that you want to delete. (required)
19740        :type item_id: str
19741        :param _request_timeout: timeout setting for this request. If one
19742                                 number provided, it will be total request
19743                                 timeout. It can also be a pair (tuple) of
19744                                 (connection, read) timeouts.
19745        :type _request_timeout: int, tuple(int, int), optional
19746        :param _request_auth: set to override the auth_settings for an a single
19747                              request; this effectively ignores the
19748                              authentication in the spec for a single request.
19749        :type _request_auth: dict, optional
19750        :param _content_type: force content-type for the request.
19751        :type _content_type: str, Optional
19752        :param _headers: set to override the headers for a single
19753                         request; this effectively ignores the headers
19754                         in the spec for a single request.
19755        :type _headers: dict, optional
19756        :param _host_index: set to override the host_index for a single
19757                            request; this effectively ignores the host_index
19758                            in the spec for a single request.
19759        :type _host_index: int, optional
19760        :return: Returns the result object.
19761        """  # noqa: E501
19762
19763        _param = self._delete_frame_item_serialize(
19764            board_id=board_id,
19765            item_id=item_id,
19766            _request_auth=_request_auth,
19767            _content_type=_content_type,
19768            _headers=_headers,
19769            _host_index=_host_index,
19770        )
19771
19772        _response_types_map: Dict[str, Optional[str]] = {
19773            "204": "object",
19774            "400": "CreateFrameItem400Response",
19775            "404": "CreateFrameItem400Response",
19776            "429": "CreateFrameItem400Response",
19777        }
19778        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
19779        response_data.read()
19780        return self.api_client.response_deserialize(
19781            response_data=response_data,
19782            response_types_map=_response_types_map,
19783        ).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

19837    @validate_call
19838    def get_frame_item(
19839        self,
19840        board_id: Annotated[
19841            StrictStr,
19842            Field(description="Unique identifier (ID) of the board that contains the frame that you want to retrieve"),
19843        ],
19844        item_id: Annotated[
19845            StrictStr, Field(description="Unique identifier (ID) of the frame that you want to retrieve.")
19846        ],
19847        _request_timeout: Union[
19848            None,
19849            Annotated[StrictFloat, Field(gt=0)],
19850            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
19851        ] = None,
19852        _request_auth: Optional[Dict[StrictStr, Any]] = None,
19853        _content_type: Optional[StrictStr] = None,
19854        _headers: Optional[Dict[StrictStr, Any]] = None,
19855        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
19856    ) -> FrameItem:
19857        """Get frame
19858
19859        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
19860
19861        :param board_id: Unique identifier (ID) of the board that contains the frame that you want to retrieve (required)
19862        :type board_id: str
19863        :param item_id: Unique identifier (ID) of the frame that you want to retrieve. (required)
19864        :type item_id: str
19865        :param _request_timeout: timeout setting for this request. If one
19866                                 number provided, it will be total request
19867                                 timeout. It can also be a pair (tuple) of
19868                                 (connection, read) timeouts.
19869        :type _request_timeout: int, tuple(int, int), optional
19870        :param _request_auth: set to override the auth_settings for an a single
19871                              request; this effectively ignores the
19872                              authentication in the spec for a single request.
19873        :type _request_auth: dict, optional
19874        :param _content_type: force content-type for the request.
19875        :type _content_type: str, Optional
19876        :param _headers: set to override the headers for a single
19877                         request; this effectively ignores the headers
19878                         in the spec for a single request.
19879        :type _headers: dict, optional
19880        :param _host_index: set to override the host_index for a single
19881                            request; this effectively ignores the host_index
19882                            in the spec for a single request.
19883        :type _host_index: int, optional
19884        :return: Returns the result object.
19885        """  # noqa: E501
19886
19887        _param = self._get_frame_item_serialize(
19888            board_id=board_id,
19889            item_id=item_id,
19890            _request_auth=_request_auth,
19891            _content_type=_content_type,
19892            _headers=_headers,
19893            _host_index=_host_index,
19894        )
19895
19896        _response_types_map: Dict[str, Optional[str]] = {
19897            "200": "FrameItem",
19898            "400": "CreateFrameItem400Response",
19899            "404": "CreateFrameItem400Response",
19900            "429": "CreateFrameItem400Response",
19901        }
19902        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
19903        response_data.read()
19904        return self.api_client.response_deserialize(
19905            response_data=response_data,
19906            response_types_map=_response_types_map,
19907        ).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

19961    @validate_call
19962    def update_frame_item(
19963        self,
19964        board_id: Annotated[
19965            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the frame.")
19966        ],
19967        item_id: Annotated[
19968            StrictStr, Field(description="Unique identifier (ID) of the frame that you want to update.")
19969        ],
19970        frame_update_request: FrameUpdateRequest,
19971        _request_timeout: Union[
19972            None,
19973            Annotated[StrictFloat, Field(gt=0)],
19974            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
19975        ] = None,
19976        _request_auth: Optional[Dict[StrictStr, Any]] = None,
19977        _content_type: Optional[StrictStr] = None,
19978        _headers: Optional[Dict[StrictStr, Any]] = None,
19979        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
19980    ) -> FrameItem:
19981        """Update frame
19982
19983        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
19984
19985        :param board_id: Unique identifier (ID) of the board where you want to update the frame. (required)
19986        :type board_id: str
19987        :param item_id: Unique identifier (ID) of the frame that you want to update. (required)
19988        :type item_id: str
19989        :param frame_update_request: (required)
19990        :type frame_update_request: FrameUpdateRequest
19991        :param _request_timeout: timeout setting for this request. If one
19992                                 number provided, it will be total request
19993                                 timeout. It can also be a pair (tuple) of
19994                                 (connection, read) timeouts.
19995        :type _request_timeout: int, tuple(int, int), optional
19996        :param _request_auth: set to override the auth_settings for an a single
19997                              request; this effectively ignores the
19998                              authentication in the spec for a single request.
19999        :type _request_auth: dict, optional
20000        :param _content_type: force content-type for the request.
20001        :type _content_type: str, Optional
20002        :param _headers: set to override the headers for a single
20003                         request; this effectively ignores the headers
20004                         in the spec for a single request.
20005        :type _headers: dict, optional
20006        :param _host_index: set to override the host_index for a single
20007                            request; this effectively ignores the host_index
20008                            in the spec for a single request.
20009        :type _host_index: int, optional
20010        :return: Returns the result object.
20011        """  # noqa: E501
20012
20013        _param = self._update_frame_item_serialize(
20014            board_id=board_id,
20015            item_id=item_id,
20016            frame_update_request=frame_update_request,
20017            _request_auth=_request_auth,
20018            _content_type=_content_type,
20019            _headers=_headers,
20020            _host_index=_host_index,
20021        )
20022
20023        _response_types_map: Dict[str, Optional[str]] = {
20024            "200": "FrameItem",
20025            "400": "CreateFrameItem400Response",
20026            "404": "CreateFrameItem400Response",
20027            "409": "UpdateFrameItem409Response",
20028            "429": "CreateFrameItem400Response",
20029        }
20030        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
20031        response_data.read()
20032        return self.api_client.response_deserialize(
20033            response_data=response_data,
20034            response_types_map=_response_types_map,
20035        ).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

20100    @validate_call
20101    def create_group(
20102        self,
20103        board_id: StrictStr,
20104        group: Group,
20105        _request_timeout: Union[
20106            None,
20107            Annotated[StrictFloat, Field(gt=0)],
20108            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
20109        ] = None,
20110        _request_auth: Optional[Dict[StrictStr, Any]] = None,
20111        _content_type: Optional[StrictStr] = None,
20112        _headers: Optional[Dict[StrictStr, Any]] = None,
20113        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
20114    ) -> GroupResponseShort:
20115        """Create group
20116
20117        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
20118
20119        :param board_id: (required)
20120        :type board_id: str
20121        :param group: (required)
20122        :type group: Group
20123        :param _request_timeout: timeout setting for this request. If one
20124                                 number provided, it will be total request
20125                                 timeout. It can also be a pair (tuple) of
20126                                 (connection, read) timeouts.
20127        :type _request_timeout: int, tuple(int, int), optional
20128        :param _request_auth: set to override the auth_settings for an a single
20129                              request; this effectively ignores the
20130                              authentication in the spec for a single request.
20131        :type _request_auth: dict, optional
20132        :param _content_type: force content-type for the request.
20133        :type _content_type: str, Optional
20134        :param _headers: set to override the headers for a single
20135                         request; this effectively ignores the headers
20136                         in the spec for a single request.
20137        :type _headers: dict, optional
20138        :param _host_index: set to override the host_index for a single
20139                            request; this effectively ignores the host_index
20140                            in the spec for a single request.
20141        :type _host_index: int, optional
20142        :return: Returns the result object.
20143        """  # noqa: E501
20144
20145        _param = self._create_group_serialize(
20146            board_id=board_id,
20147            group=group,
20148            _request_auth=_request_auth,
20149            _content_type=_content_type,
20150            _headers=_headers,
20151            _host_index=_host_index,
20152        )
20153
20154        _response_types_map: Dict[str, Optional[str]] = {
20155            "201": "GroupResponseShort",
20156            "400": "GetAllGroups400Response",
20157            "404": "GetAllGroups404Response",
20158            "429": "GetAllGroups429Response",
20159        }
20160        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
20161        response_data.read()
20162        return self.api_client.response_deserialize(
20163            response_data=response_data,
20164            response_types_map=_response_types_map,
20165        ).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

20227    @validate_call
20228    def delete_group(
20229        self,
20230        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
20231        group_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the group.")],
20232        delete_items: Annotated[
20233            StrictBool,
20234            Field(
20235                description="Indicates whether the items should be removed. Set to `true` to delete items in the group."
20236            ),
20237        ],
20238        _request_timeout: Union[
20239            None,
20240            Annotated[StrictFloat, Field(gt=0)],
20241            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
20242        ] = None,
20243        _request_auth: Optional[Dict[StrictStr, Any]] = None,
20244        _content_type: Optional[StrictStr] = None,
20245        _headers: Optional[Dict[StrictStr, Any]] = None,
20246        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
20247    ) -> object:
20248        """Deletes the group
20249
20250        Deletes a group from a board. All the items in the group are deleted along with the group.  <b>Note - this endpoint will delete items which are locked as well. </b> <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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
20251
20252        :param board_id: Unique identifier (ID) of the board. (required)
20253        :type board_id: str
20254        :param group_id: Unique identifier (ID) of the group. (required)
20255        :type group_id: str
20256        :param delete_items: Indicates whether the items should be removed. Set to `true` to delete items in the group. (required)
20257        :type delete_items: bool
20258        :param _request_timeout: timeout setting for this request. If one
20259                                 number provided, it will be total request
20260                                 timeout. It can also be a pair (tuple) of
20261                                 (connection, read) timeouts.
20262        :type _request_timeout: int, tuple(int, int), optional
20263        :param _request_auth: set to override the auth_settings for an a single
20264                              request; this effectively ignores the
20265                              authentication in the spec for a single request.
20266        :type _request_auth: dict, optional
20267        :param _content_type: force content-type for the request.
20268        :type _content_type: str, Optional
20269        :param _headers: set to override the headers for a single
20270                         request; this effectively ignores the headers
20271                         in the spec for a single request.
20272        :type _headers: dict, optional
20273        :param _host_index: set to override the host_index for a single
20274                            request; this effectively ignores the host_index
20275                            in the spec for a single request.
20276        :type _host_index: int, optional
20277        :return: Returns the result object.
20278        """  # noqa: E501
20279
20280        _param = self._delete_group_serialize(
20281            board_id=board_id,
20282            group_id=group_id,
20283            delete_items=delete_items,
20284            _request_auth=_request_auth,
20285            _content_type=_content_type,
20286            _headers=_headers,
20287            _host_index=_host_index,
20288        )
20289
20290        _response_types_map: Dict[str, Optional[str]] = {
20291            "204": "object",
20292            "400": "UnGroup400Response",
20293            "404": "UnGroup404Response",
20294            "429": "UnGroup429Response",
20295        }
20296        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
20297        response_data.read()
20298        return self.api_client.response_deserialize(
20299            response_data=response_data,
20300            response_types_map=_response_types_map,
20301        ).data

Deletes the group

Deletes a group from a board. All the items in the group are deleted along with the group. Note - this endpoint will delete items which are locked as well.

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

20360    @validate_call
20361    def get_all_groups(
20362        self,
20363        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
20364        limit: Annotated[
20365            Optional[Annotated[int, Field(le=50, strict=True, ge=10)]],
20366            Field(description="The maximum number of items to return at one time, default is 10, maximum is 50."),
20367        ] = None,
20368        cursor: Optional[StrictStr] = None,
20369        _request_timeout: Union[
20370            None,
20371            Annotated[StrictFloat, Field(gt=0)],
20372            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
20373        ] = None,
20374        _request_auth: Optional[Dict[StrictStr, Any]] = None,
20375        _content_type: Optional[StrictStr] = None,
20376        _headers: Optional[Dict[StrictStr, Any]] = None,
20377        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
20378    ) -> GetAllGroups200Response:
20379        """Get all groups on a board
20380
20381        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
20382
20383        :param board_id: Unique identifier (ID) of the board. (required)
20384        :type board_id: str
20385        :param limit: The maximum number of items to return at one time, default is 10, maximum is 50.
20386        :type limit: int
20387        :param cursor:
20388        :type cursor: str
20389        :param _request_timeout: timeout setting for this request. If one
20390                                 number provided, it will be total request
20391                                 timeout. It can also be a pair (tuple) of
20392                                 (connection, read) timeouts.
20393        :type _request_timeout: int, tuple(int, int), optional
20394        :param _request_auth: set to override the auth_settings for an a single
20395                              request; this effectively ignores the
20396                              authentication in the spec for a single request.
20397        :type _request_auth: dict, optional
20398        :param _content_type: force content-type for the request.
20399        :type _content_type: str, Optional
20400        :param _headers: set to override the headers for a single
20401                         request; this effectively ignores the headers
20402                         in the spec for a single request.
20403        :type _headers: dict, optional
20404        :param _host_index: set to override the host_index for a single
20405                            request; this effectively ignores the host_index
20406                            in the spec for a single request.
20407        :type _host_index: int, optional
20408        :return: Returns the result object.
20409        """  # noqa: E501
20410
20411        _param = self._get_all_groups_serialize(
20412            board_id=board_id,
20413            limit=limit,
20414            cursor=cursor,
20415            _request_auth=_request_auth,
20416            _content_type=_content_type,
20417            _headers=_headers,
20418            _host_index=_host_index,
20419        )
20420
20421        _response_types_map: Dict[str, Optional[str]] = {
20422            "200": "GetAllGroups200Response",
20423            "400": "GetAllGroups400Response",
20424            "404": "GetAllGroups404Response",
20425            "429": "GetAllGroups429Response",
20426        }
20427        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
20428        response_data.read()
20429        return self.api_client.response_deserialize(
20430            response_data=response_data,
20431            response_types_map=_response_types_map,
20432        ).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

20493    @validate_call
20494    def get_group_by_id(
20495        self,
20496        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
20497        group_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the group.")],
20498        _request_timeout: Union[
20499            None,
20500            Annotated[StrictFloat, Field(gt=0)],
20501            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
20502        ] = None,
20503        _request_auth: Optional[Dict[StrictStr, Any]] = None,
20504        _content_type: Optional[StrictStr] = None,
20505        _headers: Optional[Dict[StrictStr, Any]] = None,
20506        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
20507    ) -> GroupResponseShort:
20508        """Get a group by its ID
20509
20510        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a> per item ID
20511
20512        :param board_id: Unique identifier (ID) of the board. (required)
20513        :type board_id: str
20514        :param group_id: Unique identifier (ID) of the group. (required)
20515        :type group_id: str
20516        :param _request_timeout: timeout setting for this request. If one
20517                                 number provided, it will be total request
20518                                 timeout. It can also be a pair (tuple) of
20519                                 (connection, read) timeouts.
20520        :type _request_timeout: int, tuple(int, int), optional
20521        :param _request_auth: set to override the auth_settings for an a single
20522                              request; this effectively ignores the
20523                              authentication in the spec for a single request.
20524        :type _request_auth: dict, optional
20525        :param _content_type: force content-type for the request.
20526        :type _content_type: str, Optional
20527        :param _headers: set to override the headers for a single
20528                         request; this effectively ignores the headers
20529                         in the spec for a single request.
20530        :type _headers: dict, optional
20531        :param _host_index: set to override the host_index for a single
20532                            request; this effectively ignores the host_index
20533                            in the spec for a single request.
20534        :type _host_index: int, optional
20535        :return: Returns the result object.
20536        """  # noqa: E501
20537
20538        _param = self._get_group_by_id_serialize(
20539            board_id=board_id,
20540            group_id=group_id,
20541            _request_auth=_request_auth,
20542            _content_type=_content_type,
20543            _headers=_headers,
20544            _host_index=_host_index,
20545        )
20546
20547        _response_types_map: Dict[str, Optional[str]] = {
20548            "200": "GroupResponseShort",
20549            "400": "GetAllGroups400Response",
20550            "404": "GetAllGroups404Response",
20551            "429": "GetAllGroups429Response",
20552        }
20553        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
20554        response_data.read()
20555        return self.api_client.response_deserialize(
20556            response_data=response_data,
20557            response_types_map=_response_types_map,
20558        ).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

20612    @validate_call
20613    def get_items_by_group_id(
20614        self,
20615        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
20616        group_item_id: Annotated[StrictStr, Field(description="The ID of the group item to retrieve.")],
20617        limit: Annotated[
20618            Optional[Annotated[int, Field(le=50, strict=True, ge=10)]],
20619            Field(description="The maximum number of items to return at one time, default is 10, maximum is 50."),
20620        ] = None,
20621        cursor: Optional[StrictStr] = None,
20622        _request_timeout: Union[
20623            None,
20624            Annotated[StrictFloat, Field(gt=0)],
20625            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
20626        ] = None,
20627        _request_auth: Optional[Dict[StrictStr, Any]] = None,
20628        _content_type: Optional[StrictStr] = None,
20629        _headers: Optional[Dict[StrictStr, Any]] = None,
20630        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
20631    ) -> GetItemsByGroupId200Response:
20632        """Get items of a group by ID
20633
20634        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
20635
20636        :param board_id: Unique identifier (ID) of the board. (required)
20637        :type board_id: str
20638        :param group_item_id: The ID of the group item to retrieve. (required)
20639        :type group_item_id: str
20640        :param limit: The maximum number of items to return at one time, default is 10, maximum is 50.
20641        :type limit: int
20642        :param cursor:
20643        :type cursor: str
20644        :param _request_timeout: timeout setting for this request. If one
20645                                 number provided, it will be total request
20646                                 timeout. It can also be a pair (tuple) of
20647                                 (connection, read) timeouts.
20648        :type _request_timeout: int, tuple(int, int), optional
20649        :param _request_auth: set to override the auth_settings for an a single
20650                              request; this effectively ignores the
20651                              authentication in the spec for a single request.
20652        :type _request_auth: dict, optional
20653        :param _content_type: force content-type for the request.
20654        :type _content_type: str, Optional
20655        :param _headers: set to override the headers for a single
20656                         request; this effectively ignores the headers
20657                         in the spec for a single request.
20658        :type _headers: dict, optional
20659        :param _host_index: set to override the host_index for a single
20660                            request; this effectively ignores the host_index
20661                            in the spec for a single request.
20662        :type _host_index: int, optional
20663        :return: Returns the result object.
20664        """  # noqa: E501
20665
20666        _param = self._get_items_by_group_id_serialize(
20667            board_id=board_id,
20668            group_item_id=group_item_id,
20669            limit=limit,
20670            cursor=cursor,
20671            _request_auth=_request_auth,
20672            _content_type=_content_type,
20673            _headers=_headers,
20674            _host_index=_host_index,
20675        )
20676
20677        _response_types_map: Dict[str, Optional[str]] = {
20678            "200": "GetItemsByGroupId200Response",
20679            "400": "GetAllGroups400Response",
20680            "404": "GetAllGroups404Response",
20681            "429": "GetAllGroups429Response",
20682        }
20683        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
20684        response_data.read()
20685        return self.api_client.response_deserialize(
20686            response_data=response_data,
20687            response_types_map=_response_types_map,
20688        ).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

20754    @validate_call
20755    def un_group(
20756        self,
20757        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
20758        group_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the group.")],
20759        delete_items: Annotated[
20760            Optional[StrictBool], Field(description="Indicates whether the items should be removed. By default, false.")
20761        ] = None,
20762        _request_timeout: Union[
20763            None,
20764            Annotated[StrictFloat, Field(gt=0)],
20765            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
20766        ] = None,
20767        _request_auth: Optional[Dict[StrictStr, Any]] = None,
20768        _content_type: Optional[StrictStr] = None,
20769        _headers: Optional[Dict[StrictStr, Any]] = None,
20770        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
20771    ) -> object:
20772        """Ungroup items
20773
20774        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
20775
20776        :param board_id: Unique identifier (ID) of the board. (required)
20777        :type board_id: str
20778        :param group_id: Unique identifier (ID) of the group. (required)
20779        :type group_id: str
20780        :param delete_items: Indicates whether the items should be removed. By default, false.
20781        :type delete_items: bool
20782        :param _request_timeout: timeout setting for this request. If one
20783                                 number provided, it will be total request
20784                                 timeout. It can also be a pair (tuple) of
20785                                 (connection, read) timeouts.
20786        :type _request_timeout: int, tuple(int, int), optional
20787        :param _request_auth: set to override the auth_settings for an a single
20788                              request; this effectively ignores the
20789                              authentication in the spec for a single request.
20790        :type _request_auth: dict, optional
20791        :param _content_type: force content-type for the request.
20792        :type _content_type: str, Optional
20793        :param _headers: set to override the headers for a single
20794                         request; this effectively ignores the headers
20795                         in the spec for a single request.
20796        :type _headers: dict, optional
20797        :param _host_index: set to override the host_index for a single
20798                            request; this effectively ignores the host_index
20799                            in the spec for a single request.
20800        :type _host_index: int, optional
20801        :return: Returns the result object.
20802        """  # noqa: E501
20803
20804        _param = self._un_group_serialize(
20805            board_id=board_id,
20806            group_id=group_id,
20807            delete_items=delete_items,
20808            _request_auth=_request_auth,
20809            _content_type=_content_type,
20810            _headers=_headers,
20811            _host_index=_host_index,
20812        )
20813
20814        _response_types_map: Dict[str, Optional[str]] = {
20815            "204": "object",
20816            "400": "UnGroup400Response",
20817            "404": "UnGroup404Response",
20818            "429": "UnGroup429Response",
20819        }
20820        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
20821        response_data.read()
20822        return self.api_client.response_deserialize(
20823            response_data=response_data,
20824            response_types_map=_response_types_map,
20825        ).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

20884    @validate_call
20885    def update_group(
20886        self,
20887        board_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the board.")],
20888        group_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the group.")],
20889        group: Group,
20890        _request_timeout: Union[
20891            None,
20892            Annotated[StrictFloat, Field(gt=0)],
20893            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
20894        ] = None,
20895        _request_auth: Optional[Dict[StrictStr, Any]] = None,
20896        _content_type: Optional[StrictStr] = None,
20897        _headers: Optional[Dict[StrictStr, Any]] = None,
20898        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
20899    ) -> GroupResponseShort:
20900        """Updates a group with new items
20901
20902        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
20903
20904        :param board_id: Unique identifier (ID) of the board. (required)
20905        :type board_id: str
20906        :param group_id: Unique identifier (ID) of the group. (required)
20907        :type group_id: str
20908        :param group: (required)
20909        :type group: Group
20910        :param _request_timeout: timeout setting for this request. If one
20911                                 number provided, it will be total request
20912                                 timeout. It can also be a pair (tuple) of
20913                                 (connection, read) timeouts.
20914        :type _request_timeout: int, tuple(int, int), optional
20915        :param _request_auth: set to override the auth_settings for an a single
20916                              request; this effectively ignores the
20917                              authentication in the spec for a single request.
20918        :type _request_auth: dict, optional
20919        :param _content_type: force content-type for the request.
20920        :type _content_type: str, Optional
20921        :param _headers: set to override the headers for a single
20922                         request; this effectively ignores the headers
20923                         in the spec for a single request.
20924        :type _headers: dict, optional
20925        :param _host_index: set to override the host_index for a single
20926                            request; this effectively ignores the host_index
20927                            in the spec for a single request.
20928        :type _host_index: int, optional
20929        :return: Returns the result object.
20930        """  # noqa: E501
20931
20932        _param = self._update_group_serialize(
20933            board_id=board_id,
20934            group_id=group_id,
20935            group=group,
20936            _request_auth=_request_auth,
20937            _content_type=_content_type,
20938            _headers=_headers,
20939            _host_index=_host_index,
20940        )
20941
20942        _response_types_map: Dict[str, Optional[str]] = {
20943            "200": "GroupResponseShort",
20944            "400": "GetAllGroups400Response",
20945            "404": "GetAllGroups404Response",
20946            "429": "GetAllGroups429Response",
20947        }
20948        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
20949        response_data.read()
20950        return self.api_client.response_deserialize(
20951            response_data=response_data,
20952            response_types_map=_response_types_map,
20953        ).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

21018    @validate_call
21019    def create_image_item_using_local_file(
21020        self,
21021        board_id_platform_file_upload: Annotated[
21022            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
21023        ],
21024        resource: Annotated[
21025            Union[StrictBytes, StrictStr], Field(description="Select a file to upload. Maximum file size is 6 MB.")
21026        ],
21027        data: Optional[UploadFileFromDeviceData] = None,
21028        _request_timeout: Union[
21029            None,
21030            Annotated[StrictFloat, Field(gt=0)],
21031            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
21032        ] = None,
21033        _request_auth: Optional[Dict[StrictStr, Any]] = None,
21034        _content_type: Optional[StrictStr] = None,
21035        _headers: Optional[Dict[StrictStr, Any]] = None,
21036        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
21037    ) -> ImageItem:
21038        """Create image item using file from device
21039
21040        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
21041
21042        :param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to create the item. (required)
21043        :type board_id_platform_file_upload: str
21044        :param resource: Select a file to upload. Maximum file size is 6 MB. (required)
21045        :type resource: bytearray
21046        :param data:
21047        :type data: UploadFileFromDeviceData
21048        :param _request_timeout: timeout setting for this request. If one
21049                                 number provided, it will be total request
21050                                 timeout. It can also be a pair (tuple) of
21051                                 (connection, read) timeouts.
21052        :type _request_timeout: int, tuple(int, int), optional
21053        :param _request_auth: set to override the auth_settings for an a single
21054                              request; this effectively ignores the
21055                              authentication in the spec for a single request.
21056        :type _request_auth: dict, optional
21057        :param _content_type: force content-type for the request.
21058        :type _content_type: str, Optional
21059        :param _headers: set to override the headers for a single
21060                         request; this effectively ignores the headers
21061                         in the spec for a single request.
21062        :type _headers: dict, optional
21063        :param _host_index: set to override the host_index for a single
21064                            request; this effectively ignores the host_index
21065                            in the spec for a single request.
21066        :type _host_index: int, optional
21067        :return: Returns the result object.
21068        """  # noqa: E501
21069
21070        _param = self._create_image_item_using_local_file_serialize(
21071            board_id_platform_file_upload=board_id_platform_file_upload,
21072            resource=resource,
21073            data=data,
21074            _request_auth=_request_auth,
21075            _content_type=_content_type,
21076            _headers=_headers,
21077            _host_index=_host_index,
21078        )
21079
21080        _response_types_map: Dict[str, Optional[str]] = {
21081            "201": "ImageItem",
21082        }
21083        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
21084        response_data.read()
21085        return self.api_client.response_deserialize(
21086            response_data=response_data,
21087            response_types_map=_response_types_map,
21088        ).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

21153    @validate_call
21154    def create_image_item_using_url(
21155        self,
21156        board_id: Annotated[
21157            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
21158        ],
21159        image_create_request: ImageCreateRequest,
21160        _request_timeout: Union[
21161            None,
21162            Annotated[StrictFloat, Field(gt=0)],
21163            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
21164        ] = None,
21165        _request_auth: Optional[Dict[StrictStr, Any]] = None,
21166        _content_type: Optional[StrictStr] = None,
21167        _headers: Optional[Dict[StrictStr, Any]] = None,
21168        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
21169    ) -> ImageItem:
21170        """Create image item using URL
21171
21172        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
21173
21174        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
21175        :type board_id: str
21176        :param image_create_request: (required)
21177        :type image_create_request: ImageCreateRequest
21178        :param _request_timeout: timeout setting for this request. If one
21179                                 number provided, it will be total request
21180                                 timeout. It can also be a pair (tuple) of
21181                                 (connection, read) timeouts.
21182        :type _request_timeout: int, tuple(int, int), optional
21183        :param _request_auth: set to override the auth_settings for an a single
21184                              request; this effectively ignores the
21185                              authentication in the spec for a single request.
21186        :type _request_auth: dict, optional
21187        :param _content_type: force content-type for the request.
21188        :type _content_type: str, Optional
21189        :param _headers: set to override the headers for a single
21190                         request; this effectively ignores the headers
21191                         in the spec for a single request.
21192        :type _headers: dict, optional
21193        :param _host_index: set to override the host_index for a single
21194                            request; this effectively ignores the host_index
21195                            in the spec for a single request.
21196        :type _host_index: int, optional
21197        :return: Returns the result object.
21198        """  # noqa: E501
21199
21200        _param = self._create_image_item_using_url_serialize(
21201            board_id=board_id,
21202            image_create_request=image_create_request,
21203            _request_auth=_request_auth,
21204            _content_type=_content_type,
21205            _headers=_headers,
21206            _host_index=_host_index,
21207        )
21208
21209        _response_types_map: Dict[str, Optional[str]] = {
21210            "201": "ImageItem",
21211            "400": None,
21212            "404": None,
21213            "429": None,
21214        }
21215        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
21216        response_data.read()
21217        return self.api_client.response_deserialize(
21218            response_data=response_data,
21219            response_types_map=_response_types_map,
21220        ).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

21282    @validate_call
21283    def delete_image_item(
21284        self,
21285        board_id: Annotated[
21286            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
21287        ],
21288        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
21289        _request_timeout: Union[
21290            None,
21291            Annotated[StrictFloat, Field(gt=0)],
21292            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
21293        ] = None,
21294        _request_auth: Optional[Dict[StrictStr, Any]] = None,
21295        _content_type: Optional[StrictStr] = None,
21296        _headers: Optional[Dict[StrictStr, Any]] = None,
21297        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
21298    ) -> object:
21299        """Delete image item
21300
21301        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
21302
21303        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
21304        :type board_id: str
21305        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
21306        :type item_id: str
21307        :param _request_timeout: timeout setting for this request. If one
21308                                 number provided, it will be total request
21309                                 timeout. It can also be a pair (tuple) of
21310                                 (connection, read) timeouts.
21311        :type _request_timeout: int, tuple(int, int), optional
21312        :param _request_auth: set to override the auth_settings for an a single
21313                              request; this effectively ignores the
21314                              authentication in the spec for a single request.
21315        :type _request_auth: dict, optional
21316        :param _content_type: force content-type for the request.
21317        :type _content_type: str, Optional
21318        :param _headers: set to override the headers for a single
21319                         request; this effectively ignores the headers
21320                         in the spec for a single request.
21321        :type _headers: dict, optional
21322        :param _host_index: set to override the host_index for a single
21323                            request; this effectively ignores the host_index
21324                            in the spec for a single request.
21325        :type _host_index: int, optional
21326        :return: Returns the result object.
21327        """  # noqa: E501
21328
21329        _param = self._delete_image_item_serialize(
21330            board_id=board_id,
21331            item_id=item_id,
21332            _request_auth=_request_auth,
21333            _content_type=_content_type,
21334            _headers=_headers,
21335            _host_index=_host_index,
21336        )
21337
21338        _response_types_map: Dict[str, Optional[str]] = {
21339            "204": "object",
21340            "400": None,
21341            "404": None,
21342            "429": None,
21343        }
21344        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
21345        response_data.read()
21346        return self.api_client.response_deserialize(
21347            response_data=response_data,
21348            response_types_map=_response_types_map,
21349        ).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

21403    @validate_call
21404    def get_image_item(
21405        self,
21406        board_id: Annotated[
21407            StrictStr,
21408            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
21409        ],
21410        item_id: Annotated[
21411            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
21412        ],
21413        _request_timeout: Union[
21414            None,
21415            Annotated[StrictFloat, Field(gt=0)],
21416            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
21417        ] = None,
21418        _request_auth: Optional[Dict[StrictStr, Any]] = None,
21419        _content_type: Optional[StrictStr] = None,
21420        _headers: Optional[Dict[StrictStr, Any]] = None,
21421        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
21422    ) -> ImageItem:
21423        """Get image item
21424
21425        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
21426
21427        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
21428        :type board_id: str
21429        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
21430        :type item_id: str
21431        :param _request_timeout: timeout setting for this request. If one
21432                                 number provided, it will be total request
21433                                 timeout. It can also be a pair (tuple) of
21434                                 (connection, read) timeouts.
21435        :type _request_timeout: int, tuple(int, int), optional
21436        :param _request_auth: set to override the auth_settings for an a single
21437                              request; this effectively ignores the
21438                              authentication in the spec for a single request.
21439        :type _request_auth: dict, optional
21440        :param _content_type: force content-type for the request.
21441        :type _content_type: str, Optional
21442        :param _headers: set to override the headers for a single
21443                         request; this effectively ignores the headers
21444                         in the spec for a single request.
21445        :type _headers: dict, optional
21446        :param _host_index: set to override the host_index for a single
21447                            request; this effectively ignores the host_index
21448                            in the spec for a single request.
21449        :type _host_index: int, optional
21450        :return: Returns the result object.
21451        """  # noqa: E501
21452
21453        _param = self._get_image_item_serialize(
21454            board_id=board_id,
21455            item_id=item_id,
21456            _request_auth=_request_auth,
21457            _content_type=_content_type,
21458            _headers=_headers,
21459            _host_index=_host_index,
21460        )
21461
21462        _response_types_map: Dict[str, Optional[str]] = {
21463            "200": "ImageItem",
21464            "400": None,
21465            "404": None,
21466            "429": None,
21467        }
21468        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
21469        response_data.read()
21470        return self.api_client.response_deserialize(
21471            response_data=response_data,
21472            response_types_map=_response_types_map,
21473        ).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

21527    @validate_call
21528    def update_image_item_using_file_from_device(
21529        self,
21530        board_id_platform_file_upload: Annotated[
21531            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
21532        ],
21533        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
21534        resource: Annotated[
21535            Union[StrictBytes, StrictStr], Field(description="Select a file to upload. Maximum file size is 6 MB.")
21536        ],
21537        data: Optional[UploadFileFromDeviceData] = None,
21538        _request_timeout: Union[
21539            None,
21540            Annotated[StrictFloat, Field(gt=0)],
21541            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
21542        ] = None,
21543        _request_auth: Optional[Dict[StrictStr, Any]] = None,
21544        _content_type: Optional[StrictStr] = None,
21545        _headers: Optional[Dict[StrictStr, Any]] = None,
21546        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
21547    ) -> ImageItem:
21548        """Update image item using file from device
21549
21550        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
21551
21552        :param board_id_platform_file_upload: Unique identifier (ID) of the board where you want to update the item. (required)
21553        :type board_id_platform_file_upload: str
21554        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
21555        :type item_id: str
21556        :param resource: Select a file to upload. Maximum file size is 6 MB. (required)
21557        :type resource: bytearray
21558        :param data:
21559        :type data: UploadFileFromDeviceData
21560        :param _request_timeout: timeout setting for this request. If one
21561                                 number provided, it will be total request
21562                                 timeout. It can also be a pair (tuple) of
21563                                 (connection, read) timeouts.
21564        :type _request_timeout: int, tuple(int, int), optional
21565        :param _request_auth: set to override the auth_settings for an a single
21566                              request; this effectively ignores the
21567                              authentication in the spec for a single request.
21568        :type _request_auth: dict, optional
21569        :param _content_type: force content-type for the request.
21570        :type _content_type: str, Optional
21571        :param _headers: set to override the headers for a single
21572                         request; this effectively ignores the headers
21573                         in the spec for a single request.
21574        :type _headers: dict, optional
21575        :param _host_index: set to override the host_index for a single
21576                            request; this effectively ignores the host_index
21577                            in the spec for a single request.
21578        :type _host_index: int, optional
21579        :return: Returns the result object.
21580        """  # noqa: E501
21581
21582        _param = self._update_image_item_using_file_from_device_serialize(
21583            board_id_platform_file_upload=board_id_platform_file_upload,
21584            item_id=item_id,
21585            resource=resource,
21586            data=data,
21587            _request_auth=_request_auth,
21588            _content_type=_content_type,
21589            _headers=_headers,
21590            _host_index=_host_index,
21591        )
21592
21593        _response_types_map: Dict[str, Optional[str]] = {
21594            "200": "ImageItem",
21595        }
21596        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
21597        response_data.read()
21598        return self.api_client.response_deserialize(
21599            response_data=response_data,
21600            response_types_map=_response_types_map,
21601        ).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

21669    @validate_call
21670    def update_image_item_using_url(
21671        self,
21672        board_id: Annotated[
21673            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
21674        ],
21675        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
21676        image_update_request: ImageUpdateRequest,
21677        _request_timeout: Union[
21678            None,
21679            Annotated[StrictFloat, Field(gt=0)],
21680            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
21681        ] = None,
21682        _request_auth: Optional[Dict[StrictStr, Any]] = None,
21683        _content_type: Optional[StrictStr] = None,
21684        _headers: Optional[Dict[StrictStr, Any]] = None,
21685        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
21686    ) -> ImageItem:
21687        """Update image item using URL
21688
21689        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
21690
21691        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
21692        :type board_id: str
21693        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
21694        :type item_id: str
21695        :param image_update_request: (required)
21696        :type image_update_request: ImageUpdateRequest
21697        :param _request_timeout: timeout setting for this request. If one
21698                                 number provided, it will be total request
21699                                 timeout. It can also be a pair (tuple) of
21700                                 (connection, read) timeouts.
21701        :type _request_timeout: int, tuple(int, int), optional
21702        :param _request_auth: set to override the auth_settings for an a single
21703                              request; this effectively ignores the
21704                              authentication in the spec for a single request.
21705        :type _request_auth: dict, optional
21706        :param _content_type: force content-type for the request.
21707        :type _content_type: str, Optional
21708        :param _headers: set to override the headers for a single
21709                         request; this effectively ignores the headers
21710                         in the spec for a single request.
21711        :type _headers: dict, optional
21712        :param _host_index: set to override the host_index for a single
21713                            request; this effectively ignores the host_index
21714                            in the spec for a single request.
21715        :type _host_index: int, optional
21716        :return: Returns the result object.
21717        """  # noqa: E501
21718
21719        _param = self._update_image_item_using_url_serialize(
21720            board_id=board_id,
21721            item_id=item_id,
21722            image_update_request=image_update_request,
21723            _request_auth=_request_auth,
21724            _content_type=_content_type,
21725            _headers=_headers,
21726            _host_index=_host_index,
21727        )
21728
21729        _response_types_map: Dict[str, Optional[str]] = {
21730            "200": "ImageItem",
21731            "400": None,
21732            "404": None,
21733            "409": None,
21734            "429": None,
21735        }
21736        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
21737        response_data.read()
21738        return self.api_client.response_deserialize(
21739            response_data=response_data,
21740            response_types_map=_response_types_map,
21741        ).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

21806    @validate_call
21807    def delete_item(
21808        self,
21809        board_id: Annotated[
21810            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
21811        ],
21812        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
21813        _request_timeout: Union[
21814            None,
21815            Annotated[StrictFloat, Field(gt=0)],
21816            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
21817        ] = None,
21818        _request_auth: Optional[Dict[StrictStr, Any]] = None,
21819        _content_type: Optional[StrictStr] = None,
21820        _headers: Optional[Dict[StrictStr, Any]] = None,
21821        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
21822    ) -> object:
21823        """Delete item
21824
21825        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
21826
21827        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
21828        :type board_id: str
21829        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
21830        :type item_id: str
21831        :param _request_timeout: timeout setting for this request. If one
21832                                 number provided, it will be total request
21833                                 timeout. It can also be a pair (tuple) of
21834                                 (connection, read) timeouts.
21835        :type _request_timeout: int, tuple(int, int), optional
21836        :param _request_auth: set to override the auth_settings for an a single
21837                              request; this effectively ignores the
21838                              authentication in the spec for a single request.
21839        :type _request_auth: dict, optional
21840        :param _content_type: force content-type for the request.
21841        :type _content_type: str, Optional
21842        :param _headers: set to override the headers for a single
21843                         request; this effectively ignores the headers
21844                         in the spec for a single request.
21845        :type _headers: dict, optional
21846        :param _host_index: set to override the host_index for a single
21847                            request; this effectively ignores the host_index
21848                            in the spec for a single request.
21849        :type _host_index: int, optional
21850        :return: Returns the result object.
21851        """  # noqa: E501
21852
21853        _param = self._delete_item_serialize(
21854            board_id=board_id,
21855            item_id=item_id,
21856            _request_auth=_request_auth,
21857            _content_type=_content_type,
21858            _headers=_headers,
21859            _host_index=_host_index,
21860        )
21861
21862        _response_types_map: Dict[str, Optional[str]] = {
21863            "204": "object",
21864            "400": None,
21865            "404": None,
21866            "429": None,
21867        }
21868        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
21869        response_data.read()
21870        return self.api_client.response_deserialize(
21871            response_data=response_data,
21872            response_types_map=_response_types_map,
21873        ).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

21927    @validate_call
21928    def delete_item_experimental(
21929        self,
21930        board_id: Annotated[
21931            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
21932        ],
21933        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
21934        _request_timeout: Union[
21935            None,
21936            Annotated[StrictFloat, Field(gt=0)],
21937            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
21938        ] = None,
21939        _request_auth: Optional[Dict[StrictStr, Any]] = None,
21940        _content_type: Optional[StrictStr] = None,
21941        _headers: Optional[Dict[StrictStr, Any]] = None,
21942        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
21943    ) -> object:
21944        """Delete item
21945
21946        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
21947
21948        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
21949        :type board_id: str
21950        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
21951        :type item_id: str
21952        :param _request_timeout: timeout setting for this request. If one
21953                                 number provided, it will be total request
21954                                 timeout. It can also be a pair (tuple) of
21955                                 (connection, read) timeouts.
21956        :type _request_timeout: int, tuple(int, int), optional
21957        :param _request_auth: set to override the auth_settings for an a single
21958                              request; this effectively ignores the
21959                              authentication in the spec for a single request.
21960        :type _request_auth: dict, optional
21961        :param _content_type: force content-type for the request.
21962        :type _content_type: str, Optional
21963        :param _headers: set to override the headers for a single
21964                         request; this effectively ignores the headers
21965                         in the spec for a single request.
21966        :type _headers: dict, optional
21967        :param _host_index: set to override the host_index for a single
21968                            request; this effectively ignores the host_index
21969                            in the spec for a single request.
21970        :type _host_index: int, optional
21971        :return: Returns the result object.
21972        """  # noqa: E501
21973
21974        _param = self._delete_item_experimental_serialize(
21975            board_id=board_id,
21976            item_id=item_id,
21977            _request_auth=_request_auth,
21978            _content_type=_content_type,
21979            _headers=_headers,
21980            _host_index=_host_index,
21981        )
21982
21983        _response_types_map: Dict[str, Optional[str]] = {
21984            "204": "object",
21985            "400": "CreateFrameItem400Response",
21986            "404": "CreateFrameItem400Response",
21987            "429": "CreateFrameItem400Response",
21988        }
21989        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
21990        response_data.read()
21991        return self.api_client.response_deserialize(
21992            response_data=response_data,
21993            response_types_map=_response_types_map,
21994        ).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

22048    @validate_call
22049    def get_items(
22050        self,
22051        board_id: Annotated[
22052            StrictStr,
22053            Field(
22054                description="Unique identifier (ID) of the board for which you want to retrieve the list of available items."
22055            ),
22056        ],
22057        limit: Optional[Annotated[str, Field(strict=True)]] = None,
22058        type: Optional[StrictStr] = None,
22059        cursor: Optional[StrictStr] = None,
22060        _request_timeout: Union[
22061            None,
22062            Annotated[StrictFloat, Field(gt=0)],
22063            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
22064        ] = None,
22065        _request_auth: Optional[Dict[StrictStr, Any]] = None,
22066        _content_type: Optional[StrictStr] = None,
22067        _headers: Optional[Dict[StrictStr, Any]] = None,
22068        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
22069    ) -> GenericItemCursorPaged:
22070        """Get items on board
22071
22072        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
22073
22074        :param board_id: Unique identifier (ID) of the board for which you want to retrieve the list of available items. (required)
22075        :type board_id: str
22076        :param limit:
22077        :type limit: str
22078        :param type:
22079        :type type: str
22080        :param cursor:
22081        :type cursor: str
22082        :param _request_timeout: timeout setting for this request. If one
22083                                 number provided, it will be total request
22084                                 timeout. It can also be a pair (tuple) of
22085                                 (connection, read) timeouts.
22086        :type _request_timeout: int, tuple(int, int), optional
22087        :param _request_auth: set to override the auth_settings for an a single
22088                              request; this effectively ignores the
22089                              authentication in the spec for a single request.
22090        :type _request_auth: dict, optional
22091        :param _content_type: force content-type for the request.
22092        :type _content_type: str, Optional
22093        :param _headers: set to override the headers for a single
22094                         request; this effectively ignores the headers
22095                         in the spec for a single request.
22096        :type _headers: dict, optional
22097        :param _host_index: set to override the host_index for a single
22098                            request; this effectively ignores the host_index
22099                            in the spec for a single request.
22100        :type _host_index: int, optional
22101        :return: Returns the result object.
22102        """  # noqa: E501
22103
22104        _param = self._get_items_serialize(
22105            board_id=board_id,
22106            limit=limit,
22107            type=type,
22108            cursor=cursor,
22109            _request_auth=_request_auth,
22110            _content_type=_content_type,
22111            _headers=_headers,
22112            _host_index=_host_index,
22113        )
22114
22115        _response_types_map: Dict[str, Optional[str]] = {
22116            "200": "GenericItemCursorPaged",
22117            "400": None,
22118            "404": None,
22119            "429": None,
22120        }
22121        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
22122        response_data.read()
22123        return self.api_client.response_deserialize(
22124            response_data=response_data,
22125            response_types_map=_response_types_map,
22126        ).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

22192    @validate_call
22193    def get_items_within_frame(
22194        self,
22195        board_id_platform_containers: Annotated[
22196            StrictStr,
22197            Field(
22198                description="Unique identifier (ID) of the board that contains the frame for which you want to retrieve the list of available items."
22199            ),
22200        ],
22201        parent_item_id: Annotated[
22202            str,
22203            Field(
22204                strict=True, description="ID of the frame for which you want to retrieve the list of available items."
22205            ),
22206        ],
22207        limit: Optional[Annotated[str, Field(strict=True)]] = None,
22208        type: Optional[StrictStr] = None,
22209        cursor: Optional[StrictStr] = None,
22210        _request_timeout: Union[
22211            None,
22212            Annotated[StrictFloat, Field(gt=0)],
22213            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
22214        ] = None,
22215        _request_auth: Optional[Dict[StrictStr, Any]] = None,
22216        _content_type: Optional[StrictStr] = None,
22217        _headers: Optional[Dict[StrictStr, Any]] = None,
22218        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
22219    ) -> GenericItemCursorPaged:
22220        """Get items within frame
22221
22222        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
22223
22224        :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)
22225        :type board_id_platform_containers: str
22226        :param parent_item_id: ID of the frame for which you want to retrieve the list of available items. (required)
22227        :type parent_item_id: str
22228        :param limit:
22229        :type limit: str
22230        :param type:
22231        :type type: str
22232        :param cursor:
22233        :type cursor: str
22234        :param _request_timeout: timeout setting for this request. If one
22235                                 number provided, it will be total request
22236                                 timeout. It can also be a pair (tuple) of
22237                                 (connection, read) timeouts.
22238        :type _request_timeout: int, tuple(int, int), optional
22239        :param _request_auth: set to override the auth_settings for an a single
22240                              request; this effectively ignores the
22241                              authentication in the spec for a single request.
22242        :type _request_auth: dict, optional
22243        :param _content_type: force content-type for the request.
22244        :type _content_type: str, Optional
22245        :param _headers: set to override the headers for a single
22246                         request; this effectively ignores the headers
22247                         in the spec for a single request.
22248        :type _headers: dict, optional
22249        :param _host_index: set to override the host_index for a single
22250                            request; this effectively ignores the host_index
22251                            in the spec for a single request.
22252        :type _host_index: int, optional
22253        :return: Returns the result object.
22254        """  # noqa: E501
22255
22256        _param = self._get_items_within_frame_serialize(
22257            board_id_platform_containers=board_id_platform_containers,
22258            parent_item_id=parent_item_id,
22259            limit=limit,
22260            type=type,
22261            cursor=cursor,
22262            _request_auth=_request_auth,
22263            _content_type=_content_type,
22264            _headers=_headers,
22265            _host_index=_host_index,
22266        )
22267
22268        _response_types_map: Dict[str, Optional[str]] = {
22269            "200": "GenericItemCursorPaged",
22270            "400": "CreateFrameItem400Response",
22271            "404": "CreateFrameItem400Response",
22272            "429": "CreateFrameItem400Response",
22273        }
22274        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
22275        response_data.read()
22276        return self.api_client.response_deserialize(
22277            response_data=response_data,
22278            response_types_map=_response_types_map,
22279        ).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

22350    @validate_call
22351    def get_specific_item(
22352        self,
22353        board_id: Annotated[
22354            StrictStr,
22355            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
22356        ],
22357        item_id: Annotated[
22358            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
22359        ],
22360        _request_timeout: Union[
22361            None,
22362            Annotated[StrictFloat, Field(gt=0)],
22363            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
22364        ] = None,
22365        _request_auth: Optional[Dict[StrictStr, Any]] = None,
22366        _content_type: Optional[StrictStr] = None,
22367        _headers: Optional[Dict[StrictStr, Any]] = None,
22368        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
22369    ) -> GenericItem:
22370        """Get specific item on board
22371
22372        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
22373
22374        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
22375        :type board_id: str
22376        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
22377        :type item_id: str
22378        :param _request_timeout: timeout setting for this request. If one
22379                                 number provided, it will be total request
22380                                 timeout. It can also be a pair (tuple) of
22381                                 (connection, read) timeouts.
22382        :type _request_timeout: int, tuple(int, int), optional
22383        :param _request_auth: set to override the auth_settings for an a single
22384                              request; this effectively ignores the
22385                              authentication in the spec for a single request.
22386        :type _request_auth: dict, optional
22387        :param _content_type: force content-type for the request.
22388        :type _content_type: str, Optional
22389        :param _headers: set to override the headers for a single
22390                         request; this effectively ignores the headers
22391                         in the spec for a single request.
22392        :type _headers: dict, optional
22393        :param _host_index: set to override the host_index for a single
22394                            request; this effectively ignores the host_index
22395                            in the spec for a single request.
22396        :type _host_index: int, optional
22397        :return: Returns the result object.
22398        """  # noqa: E501
22399
22400        _param = self._get_specific_item_serialize(
22401            board_id=board_id,
22402            item_id=item_id,
22403            _request_auth=_request_auth,
22404            _content_type=_content_type,
22405            _headers=_headers,
22406            _host_index=_host_index,
22407        )
22408
22409        _response_types_map: Dict[str, Optional[str]] = {
22410            "200": "GenericItem",
22411            "400": None,
22412            "404": None,
22413            "429": None,
22414        }
22415        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
22416        response_data.read()
22417        return self.api_client.response_deserialize(
22418            response_data=response_data,
22419            response_types_map=_response_types_map,
22420        ).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

22474    @validate_call
22475    def update_item_position_or_parent(
22476        self,
22477        board_id: Annotated[
22478            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
22479        ],
22480        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
22481        generic_item_update: GenericItemUpdate,
22482        _request_timeout: Union[
22483            None,
22484            Annotated[StrictFloat, Field(gt=0)],
22485            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
22486        ] = None,
22487        _request_auth: Optional[Dict[StrictStr, Any]] = None,
22488        _content_type: Optional[StrictStr] = None,
22489        _headers: Optional[Dict[StrictStr, Any]] = None,
22490        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
22491    ) -> GenericItem:
22492        """Update item position or parent
22493
22494        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
22495
22496        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
22497        :type board_id: str
22498        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
22499        :type item_id: str
22500        :param generic_item_update: (required)
22501        :type generic_item_update: GenericItemUpdate
22502        :param _request_timeout: timeout setting for this request. If one
22503                                 number provided, it will be total request
22504                                 timeout. It can also be a pair (tuple) of
22505                                 (connection, read) timeouts.
22506        :type _request_timeout: int, tuple(int, int), optional
22507        :param _request_auth: set to override the auth_settings for an a single
22508                              request; this effectively ignores the
22509                              authentication in the spec for a single request.
22510        :type _request_auth: dict, optional
22511        :param _content_type: force content-type for the request.
22512        :type _content_type: str, Optional
22513        :param _headers: set to override the headers for a single
22514                         request; this effectively ignores the headers
22515                         in the spec for a single request.
22516        :type _headers: dict, optional
22517        :param _host_index: set to override the host_index for a single
22518                            request; this effectively ignores the host_index
22519                            in the spec for a single request.
22520        :type _host_index: int, optional
22521        :return: Returns the result object.
22522        """  # noqa: E501
22523
22524        _param = self._update_item_position_or_parent_serialize(
22525            board_id=board_id,
22526            item_id=item_id,
22527            generic_item_update=generic_item_update,
22528            _request_auth=_request_auth,
22529            _content_type=_content_type,
22530            _headers=_headers,
22531            _host_index=_host_index,
22532        )
22533
22534        _response_types_map: Dict[str, Optional[str]] = {
22535            "200": "GenericItem",
22536            "400": None,
22537            "404": None,
22538            "429": None,
22539        }
22540        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
22541        response_data.read()
22542        return self.api_client.response_deserialize(
22543            response_data=response_data,
22544            response_types_map=_response_types_map,
22545        ).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

22610    @validate_call
22611    def create_shape_item(
22612        self,
22613        board_id: Annotated[
22614            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
22615        ],
22616        shape_create_request: ShapeCreateRequest,
22617        _request_timeout: Union[
22618            None,
22619            Annotated[StrictFloat, Field(gt=0)],
22620            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
22621        ] = None,
22622        _request_auth: Optional[Dict[StrictStr, Any]] = None,
22623        _content_type: Optional[StrictStr] = None,
22624        _headers: Optional[Dict[StrictStr, Any]] = None,
22625        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
22626    ) -> ShapeItem:
22627        """Create shape item
22628
22629        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
22630
22631        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
22632        :type board_id: str
22633        :param shape_create_request: (required)
22634        :type shape_create_request: ShapeCreateRequest
22635        :param _request_timeout: timeout setting for this request. If one
22636                                 number provided, it will be total request
22637                                 timeout. It can also be a pair (tuple) of
22638                                 (connection, read) timeouts.
22639        :type _request_timeout: int, tuple(int, int), optional
22640        :param _request_auth: set to override the auth_settings for an a single
22641                              request; this effectively ignores the
22642                              authentication in the spec for a single request.
22643        :type _request_auth: dict, optional
22644        :param _content_type: force content-type for the request.
22645        :type _content_type: str, Optional
22646        :param _headers: set to override the headers for a single
22647                         request; this effectively ignores the headers
22648                         in the spec for a single request.
22649        :type _headers: dict, optional
22650        :param _host_index: set to override the host_index for a single
22651                            request; this effectively ignores the host_index
22652                            in the spec for a single request.
22653        :type _host_index: int, optional
22654        :return: Returns the result object.
22655        """  # noqa: E501
22656
22657        _param = self._create_shape_item_serialize(
22658            board_id=board_id,
22659            shape_create_request=shape_create_request,
22660            _request_auth=_request_auth,
22661            _content_type=_content_type,
22662            _headers=_headers,
22663            _host_index=_host_index,
22664        )
22665
22666        _response_types_map: Dict[str, Optional[str]] = {
22667            "201": "ShapeItem",
22668            "400": None,
22669            "404": None,
22670            "429": None,
22671        }
22672        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
22673        response_data.read()
22674        return self.api_client.response_deserialize(
22675            response_data=response_data,
22676            response_types_map=_response_types_map,
22677        ).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

22739    @validate_call
22740    def delete_shape_item(
22741        self,
22742        board_id: Annotated[
22743            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
22744        ],
22745        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
22746        _request_timeout: Union[
22747            None,
22748            Annotated[StrictFloat, Field(gt=0)],
22749            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
22750        ] = None,
22751        _request_auth: Optional[Dict[StrictStr, Any]] = None,
22752        _content_type: Optional[StrictStr] = None,
22753        _headers: Optional[Dict[StrictStr, Any]] = None,
22754        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
22755    ) -> object:
22756        """Delete shape item
22757
22758        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
22759
22760        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
22761        :type board_id: str
22762        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
22763        :type item_id: str
22764        :param _request_timeout: timeout setting for this request. If one
22765                                 number provided, it will be total request
22766                                 timeout. It can also be a pair (tuple) of
22767                                 (connection, read) timeouts.
22768        :type _request_timeout: int, tuple(int, int), optional
22769        :param _request_auth: set to override the auth_settings for an a single
22770                              request; this effectively ignores the
22771                              authentication in the spec for a single request.
22772        :type _request_auth: dict, optional
22773        :param _content_type: force content-type for the request.
22774        :type _content_type: str, Optional
22775        :param _headers: set to override the headers for a single
22776                         request; this effectively ignores the headers
22777                         in the spec for a single request.
22778        :type _headers: dict, optional
22779        :param _host_index: set to override the host_index for a single
22780                            request; this effectively ignores the host_index
22781                            in the spec for a single request.
22782        :type _host_index: int, optional
22783        :return: Returns the result object.
22784        """  # noqa: E501
22785
22786        _param = self._delete_shape_item_serialize(
22787            board_id=board_id,
22788            item_id=item_id,
22789            _request_auth=_request_auth,
22790            _content_type=_content_type,
22791            _headers=_headers,
22792            _host_index=_host_index,
22793        )
22794
22795        _response_types_map: Dict[str, Optional[str]] = {
22796            "204": "object",
22797            "400": None,
22798            "404": None,
22799            "429": None,
22800        }
22801        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
22802        response_data.read()
22803        return self.api_client.response_deserialize(
22804            response_data=response_data,
22805            response_types_map=_response_types_map,
22806        ).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

22860    @validate_call
22861    def get_shape_item(
22862        self,
22863        board_id: Annotated[
22864            StrictStr,
22865            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
22866        ],
22867        item_id: Annotated[
22868            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
22869        ],
22870        _request_timeout: Union[
22871            None,
22872            Annotated[StrictFloat, Field(gt=0)],
22873            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
22874        ] = None,
22875        _request_auth: Optional[Dict[StrictStr, Any]] = None,
22876        _content_type: Optional[StrictStr] = None,
22877        _headers: Optional[Dict[StrictStr, Any]] = None,
22878        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
22879    ) -> ShapeItem:
22880        """Get shape item
22881
22882        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
22883
22884        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
22885        :type board_id: str
22886        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
22887        :type item_id: str
22888        :param _request_timeout: timeout setting for this request. If one
22889                                 number provided, it will be total request
22890                                 timeout. It can also be a pair (tuple) of
22891                                 (connection, read) timeouts.
22892        :type _request_timeout: int, tuple(int, int), optional
22893        :param _request_auth: set to override the auth_settings for an a single
22894                              request; this effectively ignores the
22895                              authentication in the spec for a single request.
22896        :type _request_auth: dict, optional
22897        :param _content_type: force content-type for the request.
22898        :type _content_type: str, Optional
22899        :param _headers: set to override the headers for a single
22900                         request; this effectively ignores the headers
22901                         in the spec for a single request.
22902        :type _headers: dict, optional
22903        :param _host_index: set to override the host_index for a single
22904                            request; this effectively ignores the host_index
22905                            in the spec for a single request.
22906        :type _host_index: int, optional
22907        :return: Returns the result object.
22908        """  # noqa: E501
22909
22910        _param = self._get_shape_item_serialize(
22911            board_id=board_id,
22912            item_id=item_id,
22913            _request_auth=_request_auth,
22914            _content_type=_content_type,
22915            _headers=_headers,
22916            _host_index=_host_index,
22917        )
22918
22919        _response_types_map: Dict[str, Optional[str]] = {
22920            "200": "ShapeItem",
22921            "400": None,
22922            "404": None,
22923            "429": None,
22924        }
22925        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
22926        response_data.read()
22927        return self.api_client.response_deserialize(
22928            response_data=response_data,
22929            response_types_map=_response_types_map,
22930        ).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

22984    @validate_call
22985    def update_shape_item(
22986        self,
22987        board_id: Annotated[
22988            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
22989        ],
22990        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
22991        shape_update_request: ShapeUpdateRequest,
22992        _request_timeout: Union[
22993            None,
22994            Annotated[StrictFloat, Field(gt=0)],
22995            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
22996        ] = None,
22997        _request_auth: Optional[Dict[StrictStr, Any]] = None,
22998        _content_type: Optional[StrictStr] = None,
22999        _headers: Optional[Dict[StrictStr, Any]] = None,
23000        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
23001    ) -> ShapeItem:
23002        """Update shape item
23003
23004        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
23005
23006        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
23007        :type board_id: str
23008        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
23009        :type item_id: str
23010        :param shape_update_request: (required)
23011        :type shape_update_request: ShapeUpdateRequest
23012        :param _request_timeout: timeout setting for this request. If one
23013                                 number provided, it will be total request
23014                                 timeout. It can also be a pair (tuple) of
23015                                 (connection, read) timeouts.
23016        :type _request_timeout: int, tuple(int, int), optional
23017        :param _request_auth: set to override the auth_settings for an a single
23018                              request; this effectively ignores the
23019                              authentication in the spec for a single request.
23020        :type _request_auth: dict, optional
23021        :param _content_type: force content-type for the request.
23022        :type _content_type: str, Optional
23023        :param _headers: set to override the headers for a single
23024                         request; this effectively ignores the headers
23025                         in the spec for a single request.
23026        :type _headers: dict, optional
23027        :param _host_index: set to override the host_index for a single
23028                            request; this effectively ignores the host_index
23029                            in the spec for a single request.
23030        :type _host_index: int, optional
23031        :return: Returns the result object.
23032        """  # noqa: E501
23033
23034        _param = self._update_shape_item_serialize(
23035            board_id=board_id,
23036            item_id=item_id,
23037            shape_update_request=shape_update_request,
23038            _request_auth=_request_auth,
23039            _content_type=_content_type,
23040            _headers=_headers,
23041            _host_index=_host_index,
23042        )
23043
23044        _response_types_map: Dict[str, Optional[str]] = {
23045            "200": "ShapeItem",
23046            "400": None,
23047            "404": None,
23048            "409": None,
23049            "429": None,
23050        }
23051        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
23052        response_data.read()
23053        return self.api_client.response_deserialize(
23054            response_data=response_data,
23055            response_types_map=_response_types_map,
23056        ).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

23121    @validate_call
23122    def create_sticky_note_item(
23123        self,
23124        board_id: Annotated[
23125            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
23126        ],
23127        sticky_note_create_request: StickyNoteCreateRequest,
23128        _request_timeout: Union[
23129            None,
23130            Annotated[StrictFloat, Field(gt=0)],
23131            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
23132        ] = None,
23133        _request_auth: Optional[Dict[StrictStr, Any]] = None,
23134        _content_type: Optional[StrictStr] = None,
23135        _headers: Optional[Dict[StrictStr, Any]] = None,
23136        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
23137    ) -> StickyNoteItem:
23138        """Create sticky note item
23139
23140        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
23141
23142        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
23143        :type board_id: str
23144        :param sticky_note_create_request: (required)
23145        :type sticky_note_create_request: StickyNoteCreateRequest
23146        :param _request_timeout: timeout setting for this request. If one
23147                                 number provided, it will be total request
23148                                 timeout. It can also be a pair (tuple) of
23149                                 (connection, read) timeouts.
23150        :type _request_timeout: int, tuple(int, int), optional
23151        :param _request_auth: set to override the auth_settings for an a single
23152                              request; this effectively ignores the
23153                              authentication in the spec for a single request.
23154        :type _request_auth: dict, optional
23155        :param _content_type: force content-type for the request.
23156        :type _content_type: str, Optional
23157        :param _headers: set to override the headers for a single
23158                         request; this effectively ignores the headers
23159                         in the spec for a single request.
23160        :type _headers: dict, optional
23161        :param _host_index: set to override the host_index for a single
23162                            request; this effectively ignores the host_index
23163                            in the spec for a single request.
23164        :type _host_index: int, optional
23165        :return: Returns the result object.
23166        """  # noqa: E501
23167
23168        _param = self._create_sticky_note_item_serialize(
23169            board_id=board_id,
23170            sticky_note_create_request=sticky_note_create_request,
23171            _request_auth=_request_auth,
23172            _content_type=_content_type,
23173            _headers=_headers,
23174            _host_index=_host_index,
23175        )
23176
23177        _response_types_map: Dict[str, Optional[str]] = {
23178            "201": "StickyNoteItem",
23179            "400": None,
23180            "404": None,
23181            "429": None,
23182        }
23183        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
23184        response_data.read()
23185        return self.api_client.response_deserialize(
23186            response_data=response_data,
23187            response_types_map=_response_types_map,
23188        ).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

23250    @validate_call
23251    def delete_sticky_note_item(
23252        self,
23253        board_id: Annotated[
23254            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
23255        ],
23256        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
23257        _request_timeout: Union[
23258            None,
23259            Annotated[StrictFloat, Field(gt=0)],
23260            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
23261        ] = None,
23262        _request_auth: Optional[Dict[StrictStr, Any]] = None,
23263        _content_type: Optional[StrictStr] = None,
23264        _headers: Optional[Dict[StrictStr, Any]] = None,
23265        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
23266    ) -> object:
23267        """Delete sticky note item
23268
23269        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
23270
23271        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
23272        :type board_id: str
23273        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
23274        :type item_id: str
23275        :param _request_timeout: timeout setting for this request. If one
23276                                 number provided, it will be total request
23277                                 timeout. It can also be a pair (tuple) of
23278                                 (connection, read) timeouts.
23279        :type _request_timeout: int, tuple(int, int), optional
23280        :param _request_auth: set to override the auth_settings for an a single
23281                              request; this effectively ignores the
23282                              authentication in the spec for a single request.
23283        :type _request_auth: dict, optional
23284        :param _content_type: force content-type for the request.
23285        :type _content_type: str, Optional
23286        :param _headers: set to override the headers for a single
23287                         request; this effectively ignores the headers
23288                         in the spec for a single request.
23289        :type _headers: dict, optional
23290        :param _host_index: set to override the host_index for a single
23291                            request; this effectively ignores the host_index
23292                            in the spec for a single request.
23293        :type _host_index: int, optional
23294        :return: Returns the result object.
23295        """  # noqa: E501
23296
23297        _param = self._delete_sticky_note_item_serialize(
23298            board_id=board_id,
23299            item_id=item_id,
23300            _request_auth=_request_auth,
23301            _content_type=_content_type,
23302            _headers=_headers,
23303            _host_index=_host_index,
23304        )
23305
23306        _response_types_map: Dict[str, Optional[str]] = {
23307            "204": "object",
23308            "400": None,
23309            "404": None,
23310            "429": None,
23311        }
23312        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
23313        response_data.read()
23314        return self.api_client.response_deserialize(
23315            response_data=response_data,
23316            response_types_map=_response_types_map,
23317        ).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

23371    @validate_call
23372    def get_sticky_note_item(
23373        self,
23374        board_id: Annotated[
23375            StrictStr,
23376            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
23377        ],
23378        item_id: Annotated[
23379            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
23380        ],
23381        _request_timeout: Union[
23382            None,
23383            Annotated[StrictFloat, Field(gt=0)],
23384            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
23385        ] = None,
23386        _request_auth: Optional[Dict[StrictStr, Any]] = None,
23387        _content_type: Optional[StrictStr] = None,
23388        _headers: Optional[Dict[StrictStr, Any]] = None,
23389        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
23390    ) -> StickyNoteItem:
23391        """Get sticky note item
23392
23393        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
23394
23395        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
23396        :type board_id: str
23397        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
23398        :type item_id: str
23399        :param _request_timeout: timeout setting for this request. If one
23400                                 number provided, it will be total request
23401                                 timeout. It can also be a pair (tuple) of
23402                                 (connection, read) timeouts.
23403        :type _request_timeout: int, tuple(int, int), optional
23404        :param _request_auth: set to override the auth_settings for an a single
23405                              request; this effectively ignores the
23406                              authentication in the spec for a single request.
23407        :type _request_auth: dict, optional
23408        :param _content_type: force content-type for the request.
23409        :type _content_type: str, Optional
23410        :param _headers: set to override the headers for a single
23411                         request; this effectively ignores the headers
23412                         in the spec for a single request.
23413        :type _headers: dict, optional
23414        :param _host_index: set to override the host_index for a single
23415                            request; this effectively ignores the host_index
23416                            in the spec for a single request.
23417        :type _host_index: int, optional
23418        :return: Returns the result object.
23419        """  # noqa: E501
23420
23421        _param = self._get_sticky_note_item_serialize(
23422            board_id=board_id,
23423            item_id=item_id,
23424            _request_auth=_request_auth,
23425            _content_type=_content_type,
23426            _headers=_headers,
23427            _host_index=_host_index,
23428        )
23429
23430        _response_types_map: Dict[str, Optional[str]] = {
23431            "200": "StickyNoteItem",
23432            "400": None,
23433            "404": None,
23434            "429": None,
23435        }
23436        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
23437        response_data.read()
23438        return self.api_client.response_deserialize(
23439            response_data=response_data,
23440            response_types_map=_response_types_map,
23441        ).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

23495    @validate_call
23496    def update_sticky_note_item(
23497        self,
23498        board_id: Annotated[
23499            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
23500        ],
23501        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
23502        sticky_note_update_request: StickyNoteUpdateRequest,
23503        _request_timeout: Union[
23504            None,
23505            Annotated[StrictFloat, Field(gt=0)],
23506            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
23507        ] = None,
23508        _request_auth: Optional[Dict[StrictStr, Any]] = None,
23509        _content_type: Optional[StrictStr] = None,
23510        _headers: Optional[Dict[StrictStr, Any]] = None,
23511        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
23512    ) -> StickyNoteItem:
23513        """Update sticky note item
23514
23515        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
23516
23517        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
23518        :type board_id: str
23519        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
23520        :type item_id: str
23521        :param sticky_note_update_request: (required)
23522        :type sticky_note_update_request: StickyNoteUpdateRequest
23523        :param _request_timeout: timeout setting for this request. If one
23524                                 number provided, it will be total request
23525                                 timeout. It can also be a pair (tuple) of
23526                                 (connection, read) timeouts.
23527        :type _request_timeout: int, tuple(int, int), optional
23528        :param _request_auth: set to override the auth_settings for an a single
23529                              request; this effectively ignores the
23530                              authentication in the spec for a single request.
23531        :type _request_auth: dict, optional
23532        :param _content_type: force content-type for the request.
23533        :type _content_type: str, Optional
23534        :param _headers: set to override the headers for a single
23535                         request; this effectively ignores the headers
23536                         in the spec for a single request.
23537        :type _headers: dict, optional
23538        :param _host_index: set to override the host_index for a single
23539                            request; this effectively ignores the host_index
23540                            in the spec for a single request.
23541        :type _host_index: int, optional
23542        :return: Returns the result object.
23543        """  # noqa: E501
23544
23545        _param = self._update_sticky_note_item_serialize(
23546            board_id=board_id,
23547            item_id=item_id,
23548            sticky_note_update_request=sticky_note_update_request,
23549            _request_auth=_request_auth,
23550            _content_type=_content_type,
23551            _headers=_headers,
23552            _host_index=_host_index,
23553        )
23554
23555        _response_types_map: Dict[str, Optional[str]] = {
23556            "200": "StickyNoteItem",
23557            "400": None,
23558            "404": None,
23559            "409": None,
23560            "429": None,
23561        }
23562        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
23563        response_data.read()
23564        return self.api_client.response_deserialize(
23565            response_data=response_data,
23566            response_types_map=_response_types_map,
23567        ).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

23632    @validate_call
23633    def attach_tag_to_item(
23634        self,
23635        board_id_platform_tags: Annotated[
23636            StrictStr,
23637            Field(description="Unique identifier (ID) of the board with the item that you want to add a tag to."),
23638        ],
23639        item_id: Annotated[
23640            StrictStr, Field(description="Unique identifier (ID) of the item to which you want to add a tag.")
23641        ],
23642        tag_id: Annotated[
23643            StrictStr, Field(description="Unique identifier (ID) of the tag you want to add to the item.")
23644        ],
23645        _request_timeout: Union[
23646            None,
23647            Annotated[StrictFloat, Field(gt=0)],
23648            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
23649        ] = None,
23650        _request_auth: Optional[Dict[StrictStr, Any]] = None,
23651        _content_type: Optional[StrictStr] = None,
23652        _headers: Optional[Dict[StrictStr, Any]] = None,
23653        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
23654    ) -> object:
23655        """Attach tag to item
23656
23657        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
23658
23659        :param board_id_platform_tags: Unique identifier (ID) of the board with the item that you want to add a tag to. (required)
23660        :type board_id_platform_tags: str
23661        :param item_id: Unique identifier (ID) of the item to which you want to add a tag. (required)
23662        :type item_id: str
23663        :param tag_id: Unique identifier (ID) of the tag you want to add to the item. (required)
23664        :type tag_id: str
23665        :param _request_timeout: timeout setting for this request. If one
23666                                 number provided, it will be total request
23667                                 timeout. It can also be a pair (tuple) of
23668                                 (connection, read) timeouts.
23669        :type _request_timeout: int, tuple(int, int), optional
23670        :param _request_auth: set to override the auth_settings for an a single
23671                              request; this effectively ignores the
23672                              authentication in the spec for a single request.
23673        :type _request_auth: dict, optional
23674        :param _content_type: force content-type for the request.
23675        :type _content_type: str, Optional
23676        :param _headers: set to override the headers for a single
23677                         request; this effectively ignores the headers
23678                         in the spec for a single request.
23679        :type _headers: dict, optional
23680        :param _host_index: set to override the host_index for a single
23681                            request; this effectively ignores the host_index
23682                            in the spec for a single request.
23683        :type _host_index: int, optional
23684        :return: Returns the result object.
23685        """  # noqa: E501
23686
23687        _param = self._attach_tag_to_item_serialize(
23688            board_id_platform_tags=board_id_platform_tags,
23689            item_id=item_id,
23690            tag_id=tag_id,
23691            _request_auth=_request_auth,
23692            _content_type=_content_type,
23693            _headers=_headers,
23694            _host_index=_host_index,
23695        )
23696
23697        _response_types_map: Dict[str, Optional[str]] = {
23698            "204": "object",
23699            "400": "GetTagsFromItem400Response",
23700            "404": "GetTagsFromItem400Response",
23701            "429": "GetTagsFromItem400Response",
23702        }
23703        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
23704        response_data.read()
23705        return self.api_client.response_deserialize(
23706            response_data=response_data,
23707            response_types_map=_response_types_map,
23708        ).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

23767    @validate_call
23768    def create_tag(
23769        self,
23770        board_id: Annotated[
23771            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the tag.")
23772        ],
23773        tag_create_request: TagCreateRequest,
23774        _request_timeout: Union[
23775            None,
23776            Annotated[StrictFloat, Field(gt=0)],
23777            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
23778        ] = None,
23779        _request_auth: Optional[Dict[StrictStr, Any]] = None,
23780        _content_type: Optional[StrictStr] = None,
23781        _headers: Optional[Dict[StrictStr, Any]] = None,
23782        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
23783    ) -> TagWithLinks:
23784        """Create tag
23785
23786        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
23787
23788        :param board_id: Unique identifier (ID) of the board where you want to create the tag. (required)
23789        :type board_id: str
23790        :param tag_create_request: (required)
23791        :type tag_create_request: TagCreateRequest
23792        :param _request_timeout: timeout setting for this request. If one
23793                                 number provided, it will be total request
23794                                 timeout. It can also be a pair (tuple) of
23795                                 (connection, read) timeouts.
23796        :type _request_timeout: int, tuple(int, int), optional
23797        :param _request_auth: set to override the auth_settings for an a single
23798                              request; this effectively ignores the
23799                              authentication in the spec for a single request.
23800        :type _request_auth: dict, optional
23801        :param _content_type: force content-type for the request.
23802        :type _content_type: str, Optional
23803        :param _headers: set to override the headers for a single
23804                         request; this effectively ignores the headers
23805                         in the spec for a single request.
23806        :type _headers: dict, optional
23807        :param _host_index: set to override the host_index for a single
23808                            request; this effectively ignores the host_index
23809                            in the spec for a single request.
23810        :type _host_index: int, optional
23811        :return: Returns the result object.
23812        """  # noqa: E501
23813
23814        _param = self._create_tag_serialize(
23815            board_id=board_id,
23816            tag_create_request=tag_create_request,
23817            _request_auth=_request_auth,
23818            _content_type=_content_type,
23819            _headers=_headers,
23820            _host_index=_host_index,
23821        )
23822
23823        _response_types_map: Dict[str, Optional[str]] = {
23824            "201": "TagWithLinks",
23825            "400": "GetTagsFromItem400Response",
23826            "404": "GetTagsFromItem400Response",
23827            "429": "GetTagsFromItem400Response",
23828        }
23829        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
23830        response_data.read()
23831        return self.api_client.response_deserialize(
23832            response_data=response_data,
23833            response_types_map=_response_types_map,
23834        ).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

23896    @validate_call
23897    def delete_tag(
23898        self,
23899        board_id: Annotated[
23900            StrictStr, Field(description="Unique identifier (ID) of the board where you want to delete a specific tag.")
23901        ],
23902        tag_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the tag that you want to delete.")],
23903        _request_timeout: Union[
23904            None,
23905            Annotated[StrictFloat, Field(gt=0)],
23906            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
23907        ] = None,
23908        _request_auth: Optional[Dict[StrictStr, Any]] = None,
23909        _content_type: Optional[StrictStr] = None,
23910        _headers: Optional[Dict[StrictStr, Any]] = None,
23911        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
23912    ) -> object:
23913        """Delete tag
23914
23915        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
23916
23917        :param board_id: Unique identifier (ID) of the board where you want to delete a specific tag. (required)
23918        :type board_id: str
23919        :param tag_id: Unique identifier (ID) of the tag that you want to delete. (required)
23920        :type tag_id: str
23921        :param _request_timeout: timeout setting for this request. If one
23922                                 number provided, it will be total request
23923                                 timeout. It can also be a pair (tuple) of
23924                                 (connection, read) timeouts.
23925        :type _request_timeout: int, tuple(int, int), optional
23926        :param _request_auth: set to override the auth_settings for an a single
23927                              request; this effectively ignores the
23928                              authentication in the spec for a single request.
23929        :type _request_auth: dict, optional
23930        :param _content_type: force content-type for the request.
23931        :type _content_type: str, Optional
23932        :param _headers: set to override the headers for a single
23933                         request; this effectively ignores the headers
23934                         in the spec for a single request.
23935        :type _headers: dict, optional
23936        :param _host_index: set to override the host_index for a single
23937                            request; this effectively ignores the host_index
23938                            in the spec for a single request.
23939        :type _host_index: int, optional
23940        :return: Returns the result object.
23941        """  # noqa: E501
23942
23943        _param = self._delete_tag_serialize(
23944            board_id=board_id,
23945            tag_id=tag_id,
23946            _request_auth=_request_auth,
23947            _content_type=_content_type,
23948            _headers=_headers,
23949            _host_index=_host_index,
23950        )
23951
23952        _response_types_map: Dict[str, Optional[str]] = {
23953            "204": "object",
23954            "400": "GetTagsFromItem400Response",
23955            "404": "GetTagsFromItem400Response",
23956            "429": "GetTagsFromItem400Response",
23957        }
23958        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
23959        response_data.read()
23960        return self.api_client.response_deserialize(
23961            response_data=response_data,
23962            response_types_map=_response_types_map,
23963        ).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

24017    @validate_call
24018    def get_items_by_tag(
24019        self,
24020        board_id_platform_tags: Annotated[
24021            StrictStr,
24022            Field(description="Unique identifier (ID) of the board where you want to retrieve a specific tag."),
24023        ],
24024        tag_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the tag that you want to retrieve.")],
24025        limit: Optional[Annotated[str, Field(strict=True)]] = None,
24026        offset: Optional[StrictStr] = None,
24027        _request_timeout: Union[
24028            None,
24029            Annotated[StrictFloat, Field(gt=0)],
24030            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
24031        ] = None,
24032        _request_auth: Optional[Dict[StrictStr, Any]] = None,
24033        _content_type: Optional[StrictStr] = None,
24034        _headers: Optional[Dict[StrictStr, Any]] = None,
24035        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
24036    ) -> ItemPagedResponse:
24037        """Get items by tag
24038
24039        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
24040
24041        :param board_id_platform_tags: Unique identifier (ID) of the board where you want to retrieve a specific tag. (required)
24042        :type board_id_platform_tags: str
24043        :param tag_id: Unique identifier (ID) of the tag that you want to retrieve. (required)
24044        :type tag_id: str
24045        :param limit:
24046        :type limit: str
24047        :param offset:
24048        :type offset: str
24049        :param _request_timeout: timeout setting for this request. If one
24050                                 number provided, it will be total request
24051                                 timeout. It can also be a pair (tuple) of
24052                                 (connection, read) timeouts.
24053        :type _request_timeout: int, tuple(int, int), optional
24054        :param _request_auth: set to override the auth_settings for an a single
24055                              request; this effectively ignores the
24056                              authentication in the spec for a single request.
24057        :type _request_auth: dict, optional
24058        :param _content_type: force content-type for the request.
24059        :type _content_type: str, Optional
24060        :param _headers: set to override the headers for a single
24061                         request; this effectively ignores the headers
24062                         in the spec for a single request.
24063        :type _headers: dict, optional
24064        :param _host_index: set to override the host_index for a single
24065                            request; this effectively ignores the host_index
24066                            in the spec for a single request.
24067        :type _host_index: int, optional
24068        :return: Returns the result object.
24069        """  # noqa: E501
24070
24071        _param = self._get_items_by_tag_serialize(
24072            board_id_platform_tags=board_id_platform_tags,
24073            tag_id=tag_id,
24074            limit=limit,
24075            offset=offset,
24076            _request_auth=_request_auth,
24077            _content_type=_content_type,
24078            _headers=_headers,
24079            _host_index=_host_index,
24080        )
24081
24082        _response_types_map: Dict[str, Optional[str]] = {
24083            "200": "ItemPagedResponse",
24084            "400": "GetTagsFromItem400Response",
24085            "404": "GetTagsFromItem400Response",
24086            "429": "GetTagsFromItem400Response",
24087        }
24088        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
24089        response_data.read()
24090        return self.api_client.response_deserialize(
24091            response_data=response_data,
24092            response_types_map=_response_types_map,
24093        ).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

24159    @validate_call
24160    def get_tag(
24161        self,
24162        board_id: Annotated[
24163            StrictStr,
24164            Field(description="Unique identifier (ID) of the board where you want to retrieve a specific tag."),
24165        ],
24166        tag_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the tag that you want to retrieve.")],
24167        _request_timeout: Union[
24168            None,
24169            Annotated[StrictFloat, Field(gt=0)],
24170            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
24171        ] = None,
24172        _request_auth: Optional[Dict[StrictStr, Any]] = None,
24173        _content_type: Optional[StrictStr] = None,
24174        _headers: Optional[Dict[StrictStr, Any]] = None,
24175        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
24176    ) -> TagWithLinks:
24177        """Get tag
24178
24179        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
24180
24181        :param board_id: Unique identifier (ID) of the board where you want to retrieve a specific tag. (required)
24182        :type board_id: str
24183        :param tag_id: Unique identifier (ID) of the tag that you want to retrieve. (required)
24184        :type tag_id: str
24185        :param _request_timeout: timeout setting for this request. If one
24186                                 number provided, it will be total request
24187                                 timeout. It can also be a pair (tuple) of
24188                                 (connection, read) timeouts.
24189        :type _request_timeout: int, tuple(int, int), optional
24190        :param _request_auth: set to override the auth_settings for an a single
24191                              request; this effectively ignores the
24192                              authentication in the spec for a single request.
24193        :type _request_auth: dict, optional
24194        :param _content_type: force content-type for the request.
24195        :type _content_type: str, Optional
24196        :param _headers: set to override the headers for a single
24197                         request; this effectively ignores the headers
24198                         in the spec for a single request.
24199        :type _headers: dict, optional
24200        :param _host_index: set to override the host_index for a single
24201                            request; this effectively ignores the host_index
24202                            in the spec for a single request.
24203        :type _host_index: int, optional
24204        :return: Returns the result object.
24205        """  # noqa: E501
24206
24207        _param = self._get_tag_serialize(
24208            board_id=board_id,
24209            tag_id=tag_id,
24210            _request_auth=_request_auth,
24211            _content_type=_content_type,
24212            _headers=_headers,
24213            _host_index=_host_index,
24214        )
24215
24216        _response_types_map: Dict[str, Optional[str]] = {
24217            "200": "TagWithLinks",
24218            "400": "GetTagsFromItem400Response",
24219            "404": "GetTagsFromItem400Response",
24220            "429": "GetTagsFromItem400Response",
24221        }
24222        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
24223        response_data.read()
24224        return self.api_client.response_deserialize(
24225            response_data=response_data,
24226            response_types_map=_response_types_map,
24227        ).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

24281    @validate_call
24282    def get_tags_from_board(
24283        self,
24284        board_id: Annotated[
24285            StrictStr, Field(description="Unique identifier (ID) of the board whose tags you want to retrieve.")
24286        ],
24287        limit: Optional[Annotated[str, Field(strict=True)]] = None,
24288        offset: Optional[StrictStr] = None,
24289        _request_timeout: Union[
24290            None,
24291            Annotated[StrictFloat, Field(gt=0)],
24292            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
24293        ] = None,
24294        _request_auth: Optional[Dict[StrictStr, Any]] = None,
24295        _content_type: Optional[StrictStr] = None,
24296        _headers: Optional[Dict[StrictStr, Any]] = None,
24297        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
24298    ) -> TagsPagedResponse:
24299        """Get tags from board
24300
24301        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
24302
24303        :param board_id: Unique identifier (ID) of the board whose tags you want to retrieve. (required)
24304        :type board_id: str
24305        :param limit:
24306        :type limit: str
24307        :param offset:
24308        :type offset: str
24309        :param _request_timeout: timeout setting for this request. If one
24310                                 number provided, it will be total request
24311                                 timeout. It can also be a pair (tuple) of
24312                                 (connection, read) timeouts.
24313        :type _request_timeout: int, tuple(int, int), optional
24314        :param _request_auth: set to override the auth_settings for an a single
24315                              request; this effectively ignores the
24316                              authentication in the spec for a single request.
24317        :type _request_auth: dict, optional
24318        :param _content_type: force content-type for the request.
24319        :type _content_type: str, Optional
24320        :param _headers: set to override the headers for a single
24321                         request; this effectively ignores the headers
24322                         in the spec for a single request.
24323        :type _headers: dict, optional
24324        :param _host_index: set to override the host_index for a single
24325                            request; this effectively ignores the host_index
24326                            in the spec for a single request.
24327        :type _host_index: int, optional
24328        :return: Returns the result object.
24329        """  # noqa: E501
24330
24331        _param = self._get_tags_from_board_serialize(
24332            board_id=board_id,
24333            limit=limit,
24334            offset=offset,
24335            _request_auth=_request_auth,
24336            _content_type=_content_type,
24337            _headers=_headers,
24338            _host_index=_host_index,
24339        )
24340
24341        _response_types_map: Dict[str, Optional[str]] = {
24342            "200": "TagsPagedResponse",
24343            "400": "GetTagsFromItem400Response",
24344            "404": "GetTagsFromItem400Response",
24345            "429": "GetTagsFromItem400Response",
24346        }
24347        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
24348        response_data.read()
24349        return self.api_client.response_deserialize(
24350            response_data=response_data,
24351            response_types_map=_response_types_map,
24352        ).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

24413    @validate_call
24414    def get_tags_from_item(
24415        self,
24416        board_id: Annotated[
24417            StrictStr,
24418            Field(description="Unique identifier (ID) of the board with the item whose tags you want to retrieve."),
24419        ],
24420        item_id: Annotated[
24421            StrictStr, Field(description="Unique identifier (ID) of the item whose tags you want to retrieve.")
24422        ],
24423        _request_timeout: Union[
24424            None,
24425            Annotated[StrictFloat, Field(gt=0)],
24426            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
24427        ] = None,
24428        _request_auth: Optional[Dict[StrictStr, Any]] = None,
24429        _content_type: Optional[StrictStr] = None,
24430        _headers: Optional[Dict[StrictStr, Any]] = None,
24431        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
24432    ) -> GetTagsResponse:
24433        """Get tags from item
24434
24435        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
24436
24437        :param board_id: Unique identifier (ID) of the board with the item whose tags you want to retrieve. (required)
24438        :type board_id: str
24439        :param item_id: Unique identifier (ID) of the item whose tags you want to retrieve. (required)
24440        :type item_id: str
24441        :param _request_timeout: timeout setting for this request. If one
24442                                 number provided, it will be total request
24443                                 timeout. It can also be a pair (tuple) of
24444                                 (connection, read) timeouts.
24445        :type _request_timeout: int, tuple(int, int), optional
24446        :param _request_auth: set to override the auth_settings for an a single
24447                              request; this effectively ignores the
24448                              authentication in the spec for a single request.
24449        :type _request_auth: dict, optional
24450        :param _content_type: force content-type for the request.
24451        :type _content_type: str, Optional
24452        :param _headers: set to override the headers for a single
24453                         request; this effectively ignores the headers
24454                         in the spec for a single request.
24455        :type _headers: dict, optional
24456        :param _host_index: set to override the host_index for a single
24457                            request; this effectively ignores the host_index
24458                            in the spec for a single request.
24459        :type _host_index: int, optional
24460        :return: Returns the result object.
24461        """  # noqa: E501
24462
24463        _param = self._get_tags_from_item_serialize(
24464            board_id=board_id,
24465            item_id=item_id,
24466            _request_auth=_request_auth,
24467            _content_type=_content_type,
24468            _headers=_headers,
24469            _host_index=_host_index,
24470        )
24471
24472        _response_types_map: Dict[str, Optional[str]] = {
24473            "200": "GetTagsResponse",
24474            "400": "GetTagsFromItem400Response",
24475            "404": "GetTagsFromItem400Response",
24476            "429": "GetTagsFromItem400Response",
24477        }
24478        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
24479        response_data.read()
24480        return self.api_client.response_deserialize(
24481            response_data=response_data,
24482            response_types_map=_response_types_map,
24483        ).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

24537    @validate_call
24538    def remove_tag_from_item(
24539        self,
24540        board_id_platform_tags: Annotated[
24541            StrictStr,
24542            Field(description="Unique identifier (ID) of the board with the item that you want to remove a tag from."),
24543        ],
24544        item_id: Annotated[
24545            StrictStr, Field(description="Unique identifier (ID) of the item that you want to remove the tag from.")
24546        ],
24547        tag_id: Annotated[
24548            StrictStr, Field(description="Unique identifier (ID) of the tag that you want to remove from the item.")
24549        ],
24550        _request_timeout: Union[
24551            None,
24552            Annotated[StrictFloat, Field(gt=0)],
24553            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
24554        ] = None,
24555        _request_auth: Optional[Dict[StrictStr, Any]] = None,
24556        _content_type: Optional[StrictStr] = None,
24557        _headers: Optional[Dict[StrictStr, Any]] = None,
24558        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
24559    ) -> object:
24560        """Remove tag from item
24561
24562        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
24563
24564        :param board_id_platform_tags: Unique identifier (ID) of the board with the item that you want to remove a tag from. (required)
24565        :type board_id_platform_tags: str
24566        :param item_id: Unique identifier (ID) of the item that you want to remove the tag from. (required)
24567        :type item_id: str
24568        :param tag_id: Unique identifier (ID) of the tag that you want to remove from the item. (required)
24569        :type tag_id: str
24570        :param _request_timeout: timeout setting for this request. If one
24571                                 number provided, it will be total request
24572                                 timeout. It can also be a pair (tuple) of
24573                                 (connection, read) timeouts.
24574        :type _request_timeout: int, tuple(int, int), optional
24575        :param _request_auth: set to override the auth_settings for an a single
24576                              request; this effectively ignores the
24577                              authentication in the spec for a single request.
24578        :type _request_auth: dict, optional
24579        :param _content_type: force content-type for the request.
24580        :type _content_type: str, Optional
24581        :param _headers: set to override the headers for a single
24582                         request; this effectively ignores the headers
24583                         in the spec for a single request.
24584        :type _headers: dict, optional
24585        :param _host_index: set to override the host_index for a single
24586                            request; this effectively ignores the host_index
24587                            in the spec for a single request.
24588        :type _host_index: int, optional
24589        :return: Returns the result object.
24590        """  # noqa: E501
24591
24592        _param = self._remove_tag_from_item_serialize(
24593            board_id_platform_tags=board_id_platform_tags,
24594            item_id=item_id,
24595            tag_id=tag_id,
24596            _request_auth=_request_auth,
24597            _content_type=_content_type,
24598            _headers=_headers,
24599            _host_index=_host_index,
24600        )
24601
24602        _response_types_map: Dict[str, Optional[str]] = {
24603            "204": "object",
24604            "400": "GetTagsFromItem400Response",
24605            "404": "GetTagsFromItem400Response",
24606            "429": "GetTagsFromItem400Response",
24607        }
24608        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
24609        response_data.read()
24610        return self.api_client.response_deserialize(
24611            response_data=response_data,
24612            response_types_map=_response_types_map,
24613        ).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

24672    @validate_call
24673    def update_tag(
24674        self,
24675        board_id: Annotated[
24676            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update a specific tag.")
24677        ],
24678        tag_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the tag that you want to update.")],
24679        tag_update_request: TagUpdateRequest,
24680        _request_timeout: Union[
24681            None,
24682            Annotated[StrictFloat, Field(gt=0)],
24683            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
24684        ] = None,
24685        _request_auth: Optional[Dict[StrictStr, Any]] = None,
24686        _content_type: Optional[StrictStr] = None,
24687        _headers: Optional[Dict[StrictStr, Any]] = None,
24688        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
24689    ) -> TagWithLinks:
24690        """Update tag
24691
24692        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
24693
24694        :param board_id: Unique identifier (ID) of the board where you want to update a specific tag. (required)
24695        :type board_id: str
24696        :param tag_id: Unique identifier (ID) of the tag that you want to update. (required)
24697        :type tag_id: str
24698        :param tag_update_request: (required)
24699        :type tag_update_request: TagUpdateRequest
24700        :param _request_timeout: timeout setting for this request. If one
24701                                 number provided, it will be total request
24702                                 timeout. It can also be a pair (tuple) of
24703                                 (connection, read) timeouts.
24704        :type _request_timeout: int, tuple(int, int), optional
24705        :param _request_auth: set to override the auth_settings for an a single
24706                              request; this effectively ignores the
24707                              authentication in the spec for a single request.
24708        :type _request_auth: dict, optional
24709        :param _content_type: force content-type for the request.
24710        :type _content_type: str, Optional
24711        :param _headers: set to override the headers for a single
24712                         request; this effectively ignores the headers
24713                         in the spec for a single request.
24714        :type _headers: dict, optional
24715        :param _host_index: set to override the host_index for a single
24716                            request; this effectively ignores the host_index
24717                            in the spec for a single request.
24718        :type _host_index: int, optional
24719        :return: Returns the result object.
24720        """  # noqa: E501
24721
24722        _param = self._update_tag_serialize(
24723            board_id=board_id,
24724            tag_id=tag_id,
24725            tag_update_request=tag_update_request,
24726            _request_auth=_request_auth,
24727            _content_type=_content_type,
24728            _headers=_headers,
24729            _host_index=_host_index,
24730        )
24731
24732        _response_types_map: Dict[str, Optional[str]] = {
24733            "200": "TagWithLinks",
24734            "400": "GetTagsFromItem400Response",
24735            "404": "GetTagsFromItem400Response",
24736            "429": "GetTagsFromItem400Response",
24737        }
24738        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
24739        response_data.read()
24740        return self.api_client.response_deserialize(
24741            response_data=response_data,
24742            response_types_map=_response_types_map,
24743        ).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

24808    @validate_call
24809    def create_text_item(
24810        self,
24811        board_id: Annotated[
24812            StrictStr, Field(description="Unique identifier (ID) of the board where you want to create the item.")
24813        ],
24814        text_create_request: TextCreateRequest,
24815        _request_timeout: Union[
24816            None,
24817            Annotated[StrictFloat, Field(gt=0)],
24818            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
24819        ] = None,
24820        _request_auth: Optional[Dict[StrictStr, Any]] = None,
24821        _content_type: Optional[StrictStr] = None,
24822        _headers: Optional[Dict[StrictStr, Any]] = None,
24823        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
24824    ) -> TextItem:
24825        """Create text item
24826
24827        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
24828
24829        :param board_id: Unique identifier (ID) of the board where you want to create the item. (required)
24830        :type board_id: str
24831        :param text_create_request: (required)
24832        :type text_create_request: TextCreateRequest
24833        :param _request_timeout: timeout setting for this request. If one
24834                                 number provided, it will be total request
24835                                 timeout. It can also be a pair (tuple) of
24836                                 (connection, read) timeouts.
24837        :type _request_timeout: int, tuple(int, int), optional
24838        :param _request_auth: set to override the auth_settings for an a single
24839                              request; this effectively ignores the
24840                              authentication in the spec for a single request.
24841        :type _request_auth: dict, optional
24842        :param _content_type: force content-type for the request.
24843        :type _content_type: str, Optional
24844        :param _headers: set to override the headers for a single
24845                         request; this effectively ignores the headers
24846                         in the spec for a single request.
24847        :type _headers: dict, optional
24848        :param _host_index: set to override the host_index for a single
24849                            request; this effectively ignores the host_index
24850                            in the spec for a single request.
24851        :type _host_index: int, optional
24852        :return: Returns the result object.
24853        """  # noqa: E501
24854
24855        _param = self._create_text_item_serialize(
24856            board_id=board_id,
24857            text_create_request=text_create_request,
24858            _request_auth=_request_auth,
24859            _content_type=_content_type,
24860            _headers=_headers,
24861            _host_index=_host_index,
24862        )
24863
24864        _response_types_map: Dict[str, Optional[str]] = {
24865            "201": "TextItem",
24866            "400": None,
24867            "404": None,
24868            "429": None,
24869        }
24870        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
24871        response_data.read()
24872        return self.api_client.response_deserialize(
24873            response_data=response_data,
24874            response_types_map=_response_types_map,
24875        ).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

24937    @validate_call
24938    def delete_text_item(
24939        self,
24940        board_id: Annotated[
24941            StrictStr, Field(description="Unique identifier (ID) of the board from which you want to delete the item.")
24942        ],
24943        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to delete.")],
24944        _request_timeout: Union[
24945            None,
24946            Annotated[StrictFloat, Field(gt=0)],
24947            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
24948        ] = None,
24949        _request_auth: Optional[Dict[StrictStr, Any]] = None,
24950        _content_type: Optional[StrictStr] = None,
24951        _headers: Optional[Dict[StrictStr, Any]] = None,
24952        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
24953    ) -> object:
24954        """Delete text item
24955
24956        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 3</a><br/>
24957
24958        :param board_id: Unique identifier (ID) of the board from which you want to delete the item. (required)
24959        :type board_id: str
24960        :param item_id: Unique identifier (ID) of the item that you want to delete. (required)
24961        :type item_id: str
24962        :param _request_timeout: timeout setting for this request. If one
24963                                 number provided, it will be total request
24964                                 timeout. It can also be a pair (tuple) of
24965                                 (connection, read) timeouts.
24966        :type _request_timeout: int, tuple(int, int), optional
24967        :param _request_auth: set to override the auth_settings for an a single
24968                              request; this effectively ignores the
24969                              authentication in the spec for a single request.
24970        :type _request_auth: dict, optional
24971        :param _content_type: force content-type for the request.
24972        :type _content_type: str, Optional
24973        :param _headers: set to override the headers for a single
24974                         request; this effectively ignores the headers
24975                         in the spec for a single request.
24976        :type _headers: dict, optional
24977        :param _host_index: set to override the host_index for a single
24978                            request; this effectively ignores the host_index
24979                            in the spec for a single request.
24980        :type _host_index: int, optional
24981        :return: Returns the result object.
24982        """  # noqa: E501
24983
24984        _param = self._delete_text_item_serialize(
24985            board_id=board_id,
24986            item_id=item_id,
24987            _request_auth=_request_auth,
24988            _content_type=_content_type,
24989            _headers=_headers,
24990            _host_index=_host_index,
24991        )
24992
24993        _response_types_map: Dict[str, Optional[str]] = {
24994            "204": "object",
24995            "400": None,
24996            "404": None,
24997            "429": None,
24998        }
24999        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
25000        response_data.read()
25001        return self.api_client.response_deserialize(
25002            response_data=response_data,
25003            response_types_map=_response_types_map,
25004        ).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

25058    @validate_call
25059    def get_text_item(
25060        self,
25061        board_id: Annotated[
25062            StrictStr,
25063            Field(description="Unique identifier (ID) of the board from which you want to retrieve a specific item."),
25064        ],
25065        item_id: Annotated[
25066            StrictStr, Field(description="Unique identifier (ID) of the item that you want to retrieve.")
25067        ],
25068        _request_timeout: Union[
25069            None,
25070            Annotated[StrictFloat, Field(gt=0)],
25071            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
25072        ] = None,
25073        _request_auth: Optional[Dict[StrictStr, Any]] = None,
25074        _content_type: Optional[StrictStr] = None,
25075        _headers: Optional[Dict[StrictStr, Any]] = None,
25076        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
25077    ) -> TextItem:
25078        """Get text item
25079
25080        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 1</a><br/>
25081
25082        :param board_id: Unique identifier (ID) of the board from which you want to retrieve a specific item. (required)
25083        :type board_id: str
25084        :param item_id: Unique identifier (ID) of the item that you want to retrieve. (required)
25085        :type item_id: str
25086        :param _request_timeout: timeout setting for this request. If one
25087                                 number provided, it will be total request
25088                                 timeout. It can also be a pair (tuple) of
25089                                 (connection, read) timeouts.
25090        :type _request_timeout: int, tuple(int, int), optional
25091        :param _request_auth: set to override the auth_settings for an a single
25092                              request; this effectively ignores the
25093                              authentication in the spec for a single request.
25094        :type _request_auth: dict, optional
25095        :param _content_type: force content-type for the request.
25096        :type _content_type: str, Optional
25097        :param _headers: set to override the headers for a single
25098                         request; this effectively ignores the headers
25099                         in the spec for a single request.
25100        :type _headers: dict, optional
25101        :param _host_index: set to override the host_index for a single
25102                            request; this effectively ignores the host_index
25103                            in the spec for a single request.
25104        :type _host_index: int, optional
25105        :return: Returns the result object.
25106        """  # noqa: E501
25107
25108        _param = self._get_text_item_serialize(
25109            board_id=board_id,
25110            item_id=item_id,
25111            _request_auth=_request_auth,
25112            _content_type=_content_type,
25113            _headers=_headers,
25114            _host_index=_host_index,
25115        )
25116
25117        _response_types_map: Dict[str, Optional[str]] = {
25118            "200": "TextItem",
25119            "400": None,
25120            "404": None,
25121            "429": None,
25122        }
25123        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
25124        response_data.read()
25125        return self.api_client.response_deserialize(
25126            response_data=response_data,
25127            response_types_map=_response_types_map,
25128        ).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

25182    @validate_call
25183    def update_text_item(
25184        self,
25185        board_id: Annotated[
25186            StrictStr, Field(description="Unique identifier (ID) of the board where you want to update the item.")
25187        ],
25188        item_id: Annotated[StrictStr, Field(description="Unique identifier (ID) of the item that you want to update.")],
25189        text_update_request: TextUpdateRequest,
25190        _request_timeout: Union[
25191            None,
25192            Annotated[StrictFloat, Field(gt=0)],
25193            Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
25194        ] = None,
25195        _request_auth: Optional[Dict[StrictStr, Any]] = None,
25196        _content_type: Optional[StrictStr] = None,
25197        _headers: Optional[Dict[StrictStr, Any]] = None,
25198        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
25199    ) -> TextItem:
25200        """Update text item
25201
25202        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=\"/reference/rate-limiting#rate-limit-tiers\">Level 2</a><br/>
25203
25204        :param board_id: Unique identifier (ID) of the board where you want to update the item. (required)
25205        :type board_id: str
25206        :param item_id: Unique identifier (ID) of the item that you want to update. (required)
25207        :type item_id: str
25208        :param text_update_request: (required)
25209        :type text_update_request: TextUpdateRequest
25210        :param _request_timeout: timeout setting for this request. If one
25211                                 number provided, it will be total request
25212                                 timeout. It can also be a pair (tuple) of
25213                                 (connection, read) timeouts.
25214        :type _request_timeout: int, tuple(int, int), optional
25215        :param _request_auth: set to override the auth_settings for an a single
25216                              request; this effectively ignores the
25217                              authentication in the spec for a single request.
25218        :type _request_auth: dict, optional
25219        :param _content_type: force content-type for the request.
25220        :type _content_type: str, Optional
25221        :param _headers: set to override the headers for a single
25222                         request; this effectively ignores the headers
25223                         in the spec for a single request.
25224        :type _headers: dict, optional
25225        :param _host_index: set to override the host_index for a single
25226                            request; this effectively ignores the host_index
25227                            in the spec for a single request.
25228        :type _host_index: int, optional
25229        :return: Returns the result object.
25230        """  # noqa: E501
25231
25232        _param = self._update_text_item_serialize(
25233            board_id=board_id,
25234            item_id=item_id,
25235            text_update_request=text_update_request,
25236            _request_auth=_request_auth,
25237            _content_type=_content_type,
25238            _headers=_headers,
25239            _host_index=_host_index,
25240        )
25241
25242        _response_types_map: Dict[str, Optional[str]] = {
25243            "200": "TextItem",
25244            "400": None,
25245            "404": None,
25246            "409": None,
25247            "429": None,
25248        }
25249        response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
25250        response_data.read()
25251        return self.api_client.response_deserialize(
25252            response_data=response_data,
25253            response_types_map=_response_types_map,
25254        ).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