vectorize_client.api.destination_connectors_api

   1# coding: utf-8
   2
   3"""
   4    Vectorize API
   5
   6    API for Vectorize services (Beta)
   7
   8    The version of the OpenAPI document: 0.1.2
   9    Generated by OpenAPI Generator (https://openapi-generator.tech)
  10
  11    Do not edit the class manually.
  12"""  # noqa: E501
  13
  14import warnings
  15from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
  16from typing import Any, Dict, List, Optional, Tuple, Union
  17from typing_extensions import Annotated
  18
  19from pydantic import StrictStr
  20from typing import Optional
  21from vectorize_client.models.create_destination_connector_request import CreateDestinationConnectorRequest
  22from vectorize_client.models.create_destination_connector_response import CreateDestinationConnectorResponse
  23from vectorize_client.models.delete_destination_connector_response import DeleteDestinationConnectorResponse
  24from vectorize_client.models.destination_connector import DestinationConnector
  25from vectorize_client.models.get_destination_connectors200_response import GetDestinationConnectors200Response
  26from vectorize_client.models.update_destination_connector_request import UpdateDestinationConnectorRequest
  27from vectorize_client.models.update_destination_connector_response import UpdateDestinationConnectorResponse
  28
  29from vectorize_client.api_client import ApiClient, RequestSerialized
  30from vectorize_client.api_response import ApiResponse
  31from vectorize_client.rest import RESTResponseType
  32
  33
  34class DestinationConnectorsApi:
  35    """NOTE: This class is auto generated by OpenAPI Generator
  36    Ref: https://openapi-generator.tech
  37
  38    Do not edit the class manually.
  39    """
  40
  41    def __init__(self, api_client=None) -> None:
  42        if api_client is None:
  43            api_client = ApiClient.get_default()
  44        self.api_client = api_client
  45
  46
  47    @validate_call
  48    def create_destination_connector(
  49        self,
  50        organization_id: StrictStr,
  51        create_destination_connector_request: CreateDestinationConnectorRequest,
  52        workspace_id: Optional[StrictStr] = None,
  53        _request_timeout: Union[
  54            None,
  55            Annotated[StrictFloat, Field(gt=0)],
  56            Tuple[
  57                Annotated[StrictFloat, Field(gt=0)],
  58                Annotated[StrictFloat, Field(gt=0)]
  59            ]
  60        ] = None,
  61        _request_auth: Optional[Dict[StrictStr, Any]] = None,
  62        _content_type: Optional[StrictStr] = None,
  63        _headers: Optional[Dict[StrictStr, Any]] = None,
  64        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
  65    ) -> CreateDestinationConnectorResponse:
  66        """Create a new destination connector
  67
  68        Creates a new destination connector for data storage. The specific configuration fields required depend on the connector type selected.
  69
  70        :param organization_id: (required)
  71        :type organization_id: str
  72        :param create_destination_connector_request: (required)
  73        :type create_destination_connector_request: CreateDestinationConnectorRequest
  74        :param workspace_id:
  75        :type workspace_id: str
  76        :param _request_timeout: timeout setting for this request. If one
  77                                 number provided, it will be total request
  78                                 timeout. It can also be a pair (tuple) of
  79                                 (connection, read) timeouts.
  80        :type _request_timeout: int, tuple(int, int), optional
  81        :param _request_auth: set to override the auth_settings for an a single
  82                              request; this effectively ignores the
  83                              authentication in the spec for a single request.
  84        :type _request_auth: dict, optional
  85        :param _content_type: force content-type for the request.
  86        :type _content_type: str, Optional
  87        :param _headers: set to override the headers for a single
  88                         request; this effectively ignores the headers
  89                         in the spec for a single request.
  90        :type _headers: dict, optional
  91        :param _host_index: set to override the host_index for a single
  92                            request; this effectively ignores the host_index
  93                            in the spec for a single request.
  94        :type _host_index: int, optional
  95        :return: Returns the result object.
  96        """ # noqa: E501
  97
  98        _param = self._create_destination_connector_serialize(
  99            organization_id=organization_id,
 100            create_destination_connector_request=create_destination_connector_request,
 101            workspace_id=workspace_id,
 102            _request_auth=_request_auth,
 103            _content_type=_content_type,
 104            _headers=_headers,
 105            _host_index=_host_index
 106        )
 107
 108        _response_types_map: Dict[str, Optional[str]] = {
 109            '200': "CreateDestinationConnectorResponse",
 110            '400': "GetPipelines400Response",
 111            '401': "GetPipelines400Response",
 112            '403': "GetPipelines400Response",
 113            '404': "GetPipelines400Response",
 114            '500': "GetPipelines400Response",
 115        }
 116        response_data = self.api_client.call_api(
 117            *_param,
 118            _request_timeout=_request_timeout
 119        )
 120        response_data.read()
 121        return self.api_client.response_deserialize(
 122            response_data=response_data,
 123            response_types_map=_response_types_map,
 124        ).data
 125
 126
 127    @validate_call
 128    def create_destination_connector_with_http_info(
 129        self,
 130        organization_id: StrictStr,
 131        create_destination_connector_request: CreateDestinationConnectorRequest,
 132        workspace_id: Optional[StrictStr] = None,
 133        _request_timeout: Union[
 134            None,
 135            Annotated[StrictFloat, Field(gt=0)],
 136            Tuple[
 137                Annotated[StrictFloat, Field(gt=0)],
 138                Annotated[StrictFloat, Field(gt=0)]
 139            ]
 140        ] = None,
 141        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 142        _content_type: Optional[StrictStr] = None,
 143        _headers: Optional[Dict[StrictStr, Any]] = None,
 144        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 145    ) -> ApiResponse[CreateDestinationConnectorResponse]:
 146        """Create a new destination connector
 147
 148        Creates a new destination connector for data storage. The specific configuration fields required depend on the connector type selected.
 149
 150        :param organization_id: (required)
 151        :type organization_id: str
 152        :param create_destination_connector_request: (required)
 153        :type create_destination_connector_request: CreateDestinationConnectorRequest
 154        :param workspace_id:
 155        :type workspace_id: str
 156        :param _request_timeout: timeout setting for this request. If one
 157                                 number provided, it will be total request
 158                                 timeout. It can also be a pair (tuple) of
 159                                 (connection, read) timeouts.
 160        :type _request_timeout: int, tuple(int, int), optional
 161        :param _request_auth: set to override the auth_settings for an a single
 162                              request; this effectively ignores the
 163                              authentication in the spec for a single request.
 164        :type _request_auth: dict, optional
 165        :param _content_type: force content-type for the request.
 166        :type _content_type: str, Optional
 167        :param _headers: set to override the headers for a single
 168                         request; this effectively ignores the headers
 169                         in the spec for a single request.
 170        :type _headers: dict, optional
 171        :param _host_index: set to override the host_index for a single
 172                            request; this effectively ignores the host_index
 173                            in the spec for a single request.
 174        :type _host_index: int, optional
 175        :return: Returns the result object.
 176        """ # noqa: E501
 177
 178        _param = self._create_destination_connector_serialize(
 179            organization_id=organization_id,
 180            create_destination_connector_request=create_destination_connector_request,
 181            workspace_id=workspace_id,
 182            _request_auth=_request_auth,
 183            _content_type=_content_type,
 184            _headers=_headers,
 185            _host_index=_host_index
 186        )
 187
 188        _response_types_map: Dict[str, Optional[str]] = {
 189            '200': "CreateDestinationConnectorResponse",
 190            '400': "GetPipelines400Response",
 191            '401': "GetPipelines400Response",
 192            '403': "GetPipelines400Response",
 193            '404': "GetPipelines400Response",
 194            '500': "GetPipelines400Response",
 195        }
 196        response_data = self.api_client.call_api(
 197            *_param,
 198            _request_timeout=_request_timeout
 199        )
 200        response_data.read()
 201        return self.api_client.response_deserialize(
 202            response_data=response_data,
 203            response_types_map=_response_types_map,
 204        )
 205
 206
 207    @validate_call
 208    def create_destination_connector_without_preload_content(
 209        self,
 210        organization_id: StrictStr,
 211        create_destination_connector_request: CreateDestinationConnectorRequest,
 212        workspace_id: Optional[StrictStr] = None,
 213        _request_timeout: Union[
 214            None,
 215            Annotated[StrictFloat, Field(gt=0)],
 216            Tuple[
 217                Annotated[StrictFloat, Field(gt=0)],
 218                Annotated[StrictFloat, Field(gt=0)]
 219            ]
 220        ] = None,
 221        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 222        _content_type: Optional[StrictStr] = None,
 223        _headers: Optional[Dict[StrictStr, Any]] = None,
 224        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 225    ) -> RESTResponseType:
 226        """Create a new destination connector
 227
 228        Creates a new destination connector for data storage. The specific configuration fields required depend on the connector type selected.
 229
 230        :param organization_id: (required)
 231        :type organization_id: str
 232        :param create_destination_connector_request: (required)
 233        :type create_destination_connector_request: CreateDestinationConnectorRequest
 234        :param workspace_id:
 235        :type workspace_id: str
 236        :param _request_timeout: timeout setting for this request. If one
 237                                 number provided, it will be total request
 238                                 timeout. It can also be a pair (tuple) of
 239                                 (connection, read) timeouts.
 240        :type _request_timeout: int, tuple(int, int), optional
 241        :param _request_auth: set to override the auth_settings for an a single
 242                              request; this effectively ignores the
 243                              authentication in the spec for a single request.
 244        :type _request_auth: dict, optional
 245        :param _content_type: force content-type for the request.
 246        :type _content_type: str, Optional
 247        :param _headers: set to override the headers for a single
 248                         request; this effectively ignores the headers
 249                         in the spec for a single request.
 250        :type _headers: dict, optional
 251        :param _host_index: set to override the host_index for a single
 252                            request; this effectively ignores the host_index
 253                            in the spec for a single request.
 254        :type _host_index: int, optional
 255        :return: Returns the result object.
 256        """ # noqa: E501
 257
 258        _param = self._create_destination_connector_serialize(
 259            organization_id=organization_id,
 260            create_destination_connector_request=create_destination_connector_request,
 261            workspace_id=workspace_id,
 262            _request_auth=_request_auth,
 263            _content_type=_content_type,
 264            _headers=_headers,
 265            _host_index=_host_index
 266        )
 267
 268        _response_types_map: Dict[str, Optional[str]] = {
 269            '200': "CreateDestinationConnectorResponse",
 270            '400': "GetPipelines400Response",
 271            '401': "GetPipelines400Response",
 272            '403': "GetPipelines400Response",
 273            '404': "GetPipelines400Response",
 274            '500': "GetPipelines400Response",
 275        }
 276        response_data = self.api_client.call_api(
 277            *_param,
 278            _request_timeout=_request_timeout
 279        )
 280        return response_data.response
 281
 282
 283    def _create_destination_connector_serialize(
 284        self,
 285        organization_id,
 286        create_destination_connector_request,
 287        workspace_id,
 288        _request_auth,
 289        _content_type,
 290        _headers,
 291        _host_index,
 292    ) -> RequestSerialized:
 293
 294        _host = None
 295
 296        _collection_formats: Dict[str, str] = {
 297        }
 298
 299        _path_params: Dict[str, str] = {}
 300        _query_params: List[Tuple[str, str]] = []
 301        _header_params: Dict[str, Optional[str]] = _headers or {}
 302        _form_params: List[Tuple[str, str]] = []
 303        _files: Dict[
 304            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
 305        ] = {}
 306        _body_params: Optional[bytes] = None
 307
 308        # process the path parameters
 309        if organization_id is not None:
 310            _path_params['organizationId'] = organization_id
 311        # process the query parameters
 312        if workspace_id is not None:
 313            
 314            _query_params.append(('workspaceId', workspace_id))
 315            
 316        # process the header parameters
 317        # process the form parameters
 318        # process the body parameter
 319        if create_destination_connector_request is not None:
 320            _body_params = create_destination_connector_request
 321
 322
 323        # set the HTTP header `Accept`
 324        if 'Accept' not in _header_params:
 325            _header_params['Accept'] = self.api_client.select_header_accept(
 326                [
 327                    'application/json'
 328                ]
 329            )
 330
 331        # set the HTTP header `Content-Type`
 332        if _content_type:
 333            _header_params['Content-Type'] = _content_type
 334        else:
 335            _default_content_type = (
 336                self.api_client.select_header_content_type(
 337                    [
 338                        'application/json'
 339                    ]
 340                )
 341            )
 342            if _default_content_type is not None:
 343                _header_params['Content-Type'] = _default_content_type
 344
 345        # authentication setting
 346        _auth_settings: List[str] = [
 347            'bearerAuth'
 348        ]
 349
 350        return self.api_client.param_serialize(
 351            method='POST',
 352            resource_path='/org/{organizationId}/connectors/destinations',
 353            path_params=_path_params,
 354            query_params=_query_params,
 355            header_params=_header_params,
 356            body=_body_params,
 357            post_params=_form_params,
 358            files=_files,
 359            auth_settings=_auth_settings,
 360            collection_formats=_collection_formats,
 361            _host=_host,
 362            _request_auth=_request_auth
 363        )
 364
 365
 366
 367
 368    @validate_call
 369    def delete_destination_connector(
 370        self,
 371        organization_id: StrictStr,
 372        destination_connector_id: StrictStr,
 373        _request_timeout: Union[
 374            None,
 375            Annotated[StrictFloat, Field(gt=0)],
 376            Tuple[
 377                Annotated[StrictFloat, Field(gt=0)],
 378                Annotated[StrictFloat, Field(gt=0)]
 379            ]
 380        ] = None,
 381        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 382        _content_type: Optional[StrictStr] = None,
 383        _headers: Optional[Dict[StrictStr, Any]] = None,
 384        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 385    ) -> DeleteDestinationConnectorResponse:
 386        """Delete a destination connector
 387
 388        Delete a destination connector
 389
 390        :param organization_id: (required)
 391        :type organization_id: str
 392        :param destination_connector_id: (required)
 393        :type destination_connector_id: str
 394        :param _request_timeout: timeout setting for this request. If one
 395                                 number provided, it will be total request
 396                                 timeout. It can also be a pair (tuple) of
 397                                 (connection, read) timeouts.
 398        :type _request_timeout: int, tuple(int, int), optional
 399        :param _request_auth: set to override the auth_settings for an a single
 400                              request; this effectively ignores the
 401                              authentication in the spec for a single request.
 402        :type _request_auth: dict, optional
 403        :param _content_type: force content-type for the request.
 404        :type _content_type: str, Optional
 405        :param _headers: set to override the headers for a single
 406                         request; this effectively ignores the headers
 407                         in the spec for a single request.
 408        :type _headers: dict, optional
 409        :param _host_index: set to override the host_index for a single
 410                            request; this effectively ignores the host_index
 411                            in the spec for a single request.
 412        :type _host_index: int, optional
 413        :return: Returns the result object.
 414        """ # noqa: E501
 415
 416        _param = self._delete_destination_connector_serialize(
 417            organization_id=organization_id,
 418            destination_connector_id=destination_connector_id,
 419            _request_auth=_request_auth,
 420            _content_type=_content_type,
 421            _headers=_headers,
 422            _host_index=_host_index
 423        )
 424
 425        _response_types_map: Dict[str, Optional[str]] = {
 426            '200': "DeleteDestinationConnectorResponse",
 427            '400': "GetPipelines400Response",
 428            '401': "GetPipelines400Response",
 429            '403': "GetPipelines400Response",
 430            '404': "GetPipelines400Response",
 431            '500': "GetPipelines400Response",
 432        }
 433        response_data = self.api_client.call_api(
 434            *_param,
 435            _request_timeout=_request_timeout
 436        )
 437        response_data.read()
 438        return self.api_client.response_deserialize(
 439            response_data=response_data,
 440            response_types_map=_response_types_map,
 441        ).data
 442
 443
 444    @validate_call
 445    def delete_destination_connector_with_http_info(
 446        self,
 447        organization_id: StrictStr,
 448        destination_connector_id: StrictStr,
 449        _request_timeout: Union[
 450            None,
 451            Annotated[StrictFloat, Field(gt=0)],
 452            Tuple[
 453                Annotated[StrictFloat, Field(gt=0)],
 454                Annotated[StrictFloat, Field(gt=0)]
 455            ]
 456        ] = None,
 457        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 458        _content_type: Optional[StrictStr] = None,
 459        _headers: Optional[Dict[StrictStr, Any]] = None,
 460        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 461    ) -> ApiResponse[DeleteDestinationConnectorResponse]:
 462        """Delete a destination connector
 463
 464        Delete a destination connector
 465
 466        :param organization_id: (required)
 467        :type organization_id: str
 468        :param destination_connector_id: (required)
 469        :type destination_connector_id: str
 470        :param _request_timeout: timeout setting for this request. If one
 471                                 number provided, it will be total request
 472                                 timeout. It can also be a pair (tuple) of
 473                                 (connection, read) timeouts.
 474        :type _request_timeout: int, tuple(int, int), optional
 475        :param _request_auth: set to override the auth_settings for an a single
 476                              request; this effectively ignores the
 477                              authentication in the spec for a single request.
 478        :type _request_auth: dict, optional
 479        :param _content_type: force content-type for the request.
 480        :type _content_type: str, Optional
 481        :param _headers: set to override the headers for a single
 482                         request; this effectively ignores the headers
 483                         in the spec for a single request.
 484        :type _headers: dict, optional
 485        :param _host_index: set to override the host_index for a single
 486                            request; this effectively ignores the host_index
 487                            in the spec for a single request.
 488        :type _host_index: int, optional
 489        :return: Returns the result object.
 490        """ # noqa: E501
 491
 492        _param = self._delete_destination_connector_serialize(
 493            organization_id=organization_id,
 494            destination_connector_id=destination_connector_id,
 495            _request_auth=_request_auth,
 496            _content_type=_content_type,
 497            _headers=_headers,
 498            _host_index=_host_index
 499        )
 500
 501        _response_types_map: Dict[str, Optional[str]] = {
 502            '200': "DeleteDestinationConnectorResponse",
 503            '400': "GetPipelines400Response",
 504            '401': "GetPipelines400Response",
 505            '403': "GetPipelines400Response",
 506            '404': "GetPipelines400Response",
 507            '500': "GetPipelines400Response",
 508        }
 509        response_data = self.api_client.call_api(
 510            *_param,
 511            _request_timeout=_request_timeout
 512        )
 513        response_data.read()
 514        return self.api_client.response_deserialize(
 515            response_data=response_data,
 516            response_types_map=_response_types_map,
 517        )
 518
 519
 520    @validate_call
 521    def delete_destination_connector_without_preload_content(
 522        self,
 523        organization_id: StrictStr,
 524        destination_connector_id: StrictStr,
 525        _request_timeout: Union[
 526            None,
 527            Annotated[StrictFloat, Field(gt=0)],
 528            Tuple[
 529                Annotated[StrictFloat, Field(gt=0)],
 530                Annotated[StrictFloat, Field(gt=0)]
 531            ]
 532        ] = None,
 533        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 534        _content_type: Optional[StrictStr] = None,
 535        _headers: Optional[Dict[StrictStr, Any]] = None,
 536        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 537    ) -> RESTResponseType:
 538        """Delete a destination connector
 539
 540        Delete a destination connector
 541
 542        :param organization_id: (required)
 543        :type organization_id: str
 544        :param destination_connector_id: (required)
 545        :type destination_connector_id: str
 546        :param _request_timeout: timeout setting for this request. If one
 547                                 number provided, it will be total request
 548                                 timeout. It can also be a pair (tuple) of
 549                                 (connection, read) timeouts.
 550        :type _request_timeout: int, tuple(int, int), optional
 551        :param _request_auth: set to override the auth_settings for an a single
 552                              request; this effectively ignores the
 553                              authentication in the spec for a single request.
 554        :type _request_auth: dict, optional
 555        :param _content_type: force content-type for the request.
 556        :type _content_type: str, Optional
 557        :param _headers: set to override the headers for a single
 558                         request; this effectively ignores the headers
 559                         in the spec for a single request.
 560        :type _headers: dict, optional
 561        :param _host_index: set to override the host_index for a single
 562                            request; this effectively ignores the host_index
 563                            in the spec for a single request.
 564        :type _host_index: int, optional
 565        :return: Returns the result object.
 566        """ # noqa: E501
 567
 568        _param = self._delete_destination_connector_serialize(
 569            organization_id=organization_id,
 570            destination_connector_id=destination_connector_id,
 571            _request_auth=_request_auth,
 572            _content_type=_content_type,
 573            _headers=_headers,
 574            _host_index=_host_index
 575        )
 576
 577        _response_types_map: Dict[str, Optional[str]] = {
 578            '200': "DeleteDestinationConnectorResponse",
 579            '400': "GetPipelines400Response",
 580            '401': "GetPipelines400Response",
 581            '403': "GetPipelines400Response",
 582            '404': "GetPipelines400Response",
 583            '500': "GetPipelines400Response",
 584        }
 585        response_data = self.api_client.call_api(
 586            *_param,
 587            _request_timeout=_request_timeout
 588        )
 589        return response_data.response
 590
 591
 592    def _delete_destination_connector_serialize(
 593        self,
 594        organization_id,
 595        destination_connector_id,
 596        _request_auth,
 597        _content_type,
 598        _headers,
 599        _host_index,
 600    ) -> RequestSerialized:
 601
 602        _host = None
 603
 604        _collection_formats: Dict[str, str] = {
 605        }
 606
 607        _path_params: Dict[str, str] = {}
 608        _query_params: List[Tuple[str, str]] = []
 609        _header_params: Dict[str, Optional[str]] = _headers or {}
 610        _form_params: List[Tuple[str, str]] = []
 611        _files: Dict[
 612            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
 613        ] = {}
 614        _body_params: Optional[bytes] = None
 615
 616        # process the path parameters
 617        if organization_id is not None:
 618            _path_params['organizationId'] = organization_id
 619        if destination_connector_id is not None:
 620            _path_params['destinationConnectorId'] = destination_connector_id
 621        # process the query parameters
 622        # process the header parameters
 623        # process the form parameters
 624        # process the body parameter
 625
 626
 627        # set the HTTP header `Accept`
 628        if 'Accept' not in _header_params:
 629            _header_params['Accept'] = self.api_client.select_header_accept(
 630                [
 631                    'application/json'
 632                ]
 633            )
 634
 635
 636        # authentication setting
 637        _auth_settings: List[str] = [
 638            'bearerAuth'
 639        ]
 640
 641        return self.api_client.param_serialize(
 642            method='DELETE',
 643            resource_path='/org/{organizationId}/connectors/destinations/{destinationConnectorId}',
 644            path_params=_path_params,
 645            query_params=_query_params,
 646            header_params=_header_params,
 647            body=_body_params,
 648            post_params=_form_params,
 649            files=_files,
 650            auth_settings=_auth_settings,
 651            collection_formats=_collection_formats,
 652            _host=_host,
 653            _request_auth=_request_auth
 654        )
 655
 656
 657
 658
 659    @validate_call
 660    def get_destination_connector(
 661        self,
 662        organization_id: StrictStr,
 663        destination_connector_id: StrictStr,
 664        _request_timeout: Union[
 665            None,
 666            Annotated[StrictFloat, Field(gt=0)],
 667            Tuple[
 668                Annotated[StrictFloat, Field(gt=0)],
 669                Annotated[StrictFloat, Field(gt=0)]
 670            ]
 671        ] = None,
 672        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 673        _content_type: Optional[StrictStr] = None,
 674        _headers: Optional[Dict[StrictStr, Any]] = None,
 675        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 676    ) -> DestinationConnector:
 677        """Get a destination connector
 678
 679        Get a destination connector
 680
 681        :param organization_id: (required)
 682        :type organization_id: str
 683        :param destination_connector_id: (required)
 684        :type destination_connector_id: str
 685        :param _request_timeout: timeout setting for this request. If one
 686                                 number provided, it will be total request
 687                                 timeout. It can also be a pair (tuple) of
 688                                 (connection, read) timeouts.
 689        :type _request_timeout: int, tuple(int, int), optional
 690        :param _request_auth: set to override the auth_settings for an a single
 691                              request; this effectively ignores the
 692                              authentication in the spec for a single request.
 693        :type _request_auth: dict, optional
 694        :param _content_type: force content-type for the request.
 695        :type _content_type: str, Optional
 696        :param _headers: set to override the headers for a single
 697                         request; this effectively ignores the headers
 698                         in the spec for a single request.
 699        :type _headers: dict, optional
 700        :param _host_index: set to override the host_index for a single
 701                            request; this effectively ignores the host_index
 702                            in the spec for a single request.
 703        :type _host_index: int, optional
 704        :return: Returns the result object.
 705        """ # noqa: E501
 706
 707        _param = self._get_destination_connector_serialize(
 708            organization_id=organization_id,
 709            destination_connector_id=destination_connector_id,
 710            _request_auth=_request_auth,
 711            _content_type=_content_type,
 712            _headers=_headers,
 713            _host_index=_host_index
 714        )
 715
 716        _response_types_map: Dict[str, Optional[str]] = {
 717            '200': "DestinationConnector",
 718            '400': "GetPipelines400Response",
 719            '401': "GetPipelines400Response",
 720            '403': "GetPipelines400Response",
 721            '404': "GetPipelines400Response",
 722            '500': "GetPipelines400Response",
 723        }
 724        response_data = self.api_client.call_api(
 725            *_param,
 726            _request_timeout=_request_timeout
 727        )
 728        response_data.read()
 729        return self.api_client.response_deserialize(
 730            response_data=response_data,
 731            response_types_map=_response_types_map,
 732        ).data
 733
 734
 735    @validate_call
 736    def get_destination_connector_with_http_info(
 737        self,
 738        organization_id: StrictStr,
 739        destination_connector_id: StrictStr,
 740        _request_timeout: Union[
 741            None,
 742            Annotated[StrictFloat, Field(gt=0)],
 743            Tuple[
 744                Annotated[StrictFloat, Field(gt=0)],
 745                Annotated[StrictFloat, Field(gt=0)]
 746            ]
 747        ] = None,
 748        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 749        _content_type: Optional[StrictStr] = None,
 750        _headers: Optional[Dict[StrictStr, Any]] = None,
 751        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 752    ) -> ApiResponse[DestinationConnector]:
 753        """Get a destination connector
 754
 755        Get a destination connector
 756
 757        :param organization_id: (required)
 758        :type organization_id: str
 759        :param destination_connector_id: (required)
 760        :type destination_connector_id: str
 761        :param _request_timeout: timeout setting for this request. If one
 762                                 number provided, it will be total request
 763                                 timeout. It can also be a pair (tuple) of
 764                                 (connection, read) timeouts.
 765        :type _request_timeout: int, tuple(int, int), optional
 766        :param _request_auth: set to override the auth_settings for an a single
 767                              request; this effectively ignores the
 768                              authentication in the spec for a single request.
 769        :type _request_auth: dict, optional
 770        :param _content_type: force content-type for the request.
 771        :type _content_type: str, Optional
 772        :param _headers: set to override the headers for a single
 773                         request; this effectively ignores the headers
 774                         in the spec for a single request.
 775        :type _headers: dict, optional
 776        :param _host_index: set to override the host_index for a single
 777                            request; this effectively ignores the host_index
 778                            in the spec for a single request.
 779        :type _host_index: int, optional
 780        :return: Returns the result object.
 781        """ # noqa: E501
 782
 783        _param = self._get_destination_connector_serialize(
 784            organization_id=organization_id,
 785            destination_connector_id=destination_connector_id,
 786            _request_auth=_request_auth,
 787            _content_type=_content_type,
 788            _headers=_headers,
 789            _host_index=_host_index
 790        )
 791
 792        _response_types_map: Dict[str, Optional[str]] = {
 793            '200': "DestinationConnector",
 794            '400': "GetPipelines400Response",
 795            '401': "GetPipelines400Response",
 796            '403': "GetPipelines400Response",
 797            '404': "GetPipelines400Response",
 798            '500': "GetPipelines400Response",
 799        }
 800        response_data = self.api_client.call_api(
 801            *_param,
 802            _request_timeout=_request_timeout
 803        )
 804        response_data.read()
 805        return self.api_client.response_deserialize(
 806            response_data=response_data,
 807            response_types_map=_response_types_map,
 808        )
 809
 810
 811    @validate_call
 812    def get_destination_connector_without_preload_content(
 813        self,
 814        organization_id: StrictStr,
 815        destination_connector_id: StrictStr,
 816        _request_timeout: Union[
 817            None,
 818            Annotated[StrictFloat, Field(gt=0)],
 819            Tuple[
 820                Annotated[StrictFloat, Field(gt=0)],
 821                Annotated[StrictFloat, Field(gt=0)]
 822            ]
 823        ] = None,
 824        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 825        _content_type: Optional[StrictStr] = None,
 826        _headers: Optional[Dict[StrictStr, Any]] = None,
 827        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 828    ) -> RESTResponseType:
 829        """Get a destination connector
 830
 831        Get a destination connector
 832
 833        :param organization_id: (required)
 834        :type organization_id: str
 835        :param destination_connector_id: (required)
 836        :type destination_connector_id: str
 837        :param _request_timeout: timeout setting for this request. If one
 838                                 number provided, it will be total request
 839                                 timeout. It can also be a pair (tuple) of
 840                                 (connection, read) timeouts.
 841        :type _request_timeout: int, tuple(int, int), optional
 842        :param _request_auth: set to override the auth_settings for an a single
 843                              request; this effectively ignores the
 844                              authentication in the spec for a single request.
 845        :type _request_auth: dict, optional
 846        :param _content_type: force content-type for the request.
 847        :type _content_type: str, Optional
 848        :param _headers: set to override the headers for a single
 849                         request; this effectively ignores the headers
 850                         in the spec for a single request.
 851        :type _headers: dict, optional
 852        :param _host_index: set to override the host_index for a single
 853                            request; this effectively ignores the host_index
 854                            in the spec for a single request.
 855        :type _host_index: int, optional
 856        :return: Returns the result object.
 857        """ # noqa: E501
 858
 859        _param = self._get_destination_connector_serialize(
 860            organization_id=organization_id,
 861            destination_connector_id=destination_connector_id,
 862            _request_auth=_request_auth,
 863            _content_type=_content_type,
 864            _headers=_headers,
 865            _host_index=_host_index
 866        )
 867
 868        _response_types_map: Dict[str, Optional[str]] = {
 869            '200': "DestinationConnector",
 870            '400': "GetPipelines400Response",
 871            '401': "GetPipelines400Response",
 872            '403': "GetPipelines400Response",
 873            '404': "GetPipelines400Response",
 874            '500': "GetPipelines400Response",
 875        }
 876        response_data = self.api_client.call_api(
 877            *_param,
 878            _request_timeout=_request_timeout
 879        )
 880        return response_data.response
 881
 882
 883    def _get_destination_connector_serialize(
 884        self,
 885        organization_id,
 886        destination_connector_id,
 887        _request_auth,
 888        _content_type,
 889        _headers,
 890        _host_index,
 891    ) -> RequestSerialized:
 892
 893        _host = None
 894
 895        _collection_formats: Dict[str, str] = {
 896        }
 897
 898        _path_params: Dict[str, str] = {}
 899        _query_params: List[Tuple[str, str]] = []
 900        _header_params: Dict[str, Optional[str]] = _headers or {}
 901        _form_params: List[Tuple[str, str]] = []
 902        _files: Dict[
 903            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
 904        ] = {}
 905        _body_params: Optional[bytes] = None
 906
 907        # process the path parameters
 908        if organization_id is not None:
 909            _path_params['organizationId'] = organization_id
 910        if destination_connector_id is not None:
 911            _path_params['destinationConnectorId'] = destination_connector_id
 912        # process the query parameters
 913        # process the header parameters
 914        # process the form parameters
 915        # process the body parameter
 916
 917
 918        # set the HTTP header `Accept`
 919        if 'Accept' not in _header_params:
 920            _header_params['Accept'] = self.api_client.select_header_accept(
 921                [
 922                    'application/json'
 923                ]
 924            )
 925
 926
 927        # authentication setting
 928        _auth_settings: List[str] = [
 929            'bearerAuth'
 930        ]
 931
 932        return self.api_client.param_serialize(
 933            method='GET',
 934            resource_path='/org/{organizationId}/connectors/destinations/{destinationConnectorId}',
 935            path_params=_path_params,
 936            query_params=_query_params,
 937            header_params=_header_params,
 938            body=_body_params,
 939            post_params=_form_params,
 940            files=_files,
 941            auth_settings=_auth_settings,
 942            collection_formats=_collection_formats,
 943            _host=_host,
 944            _request_auth=_request_auth
 945        )
 946
 947
 948
 949
 950    @validate_call
 951    def get_destination_connectors(
 952        self,
 953        organization_id: StrictStr,
 954        workspace_id: Optional[StrictStr] = None,
 955        _request_timeout: Union[
 956            None,
 957            Annotated[StrictFloat, Field(gt=0)],
 958            Tuple[
 959                Annotated[StrictFloat, Field(gt=0)],
 960                Annotated[StrictFloat, Field(gt=0)]
 961            ]
 962        ] = None,
 963        _request_auth: Optional[Dict[StrictStr, Any]] = None,
 964        _content_type: Optional[StrictStr] = None,
 965        _headers: Optional[Dict[StrictStr, Any]] = None,
 966        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
 967    ) -> GetDestinationConnectors200Response:
 968        """Get all existing destination connectors
 969
 970        Get all existing destination connectors
 971
 972        :param organization_id: (required)
 973        :type organization_id: str
 974        :param workspace_id:
 975        :type workspace_id: str
 976        :param _request_timeout: timeout setting for this request. If one
 977                                 number provided, it will be total request
 978                                 timeout. It can also be a pair (tuple) of
 979                                 (connection, read) timeouts.
 980        :type _request_timeout: int, tuple(int, int), optional
 981        :param _request_auth: set to override the auth_settings for an a single
 982                              request; this effectively ignores the
 983                              authentication in the spec for a single request.
 984        :type _request_auth: dict, optional
 985        :param _content_type: force content-type for the request.
 986        :type _content_type: str, Optional
 987        :param _headers: set to override the headers for a single
 988                         request; this effectively ignores the headers
 989                         in the spec for a single request.
 990        :type _headers: dict, optional
 991        :param _host_index: set to override the host_index for a single
 992                            request; this effectively ignores the host_index
 993                            in the spec for a single request.
 994        :type _host_index: int, optional
 995        :return: Returns the result object.
 996        """ # noqa: E501
 997
 998        _param = self._get_destination_connectors_serialize(
 999            organization_id=organization_id,
1000            workspace_id=workspace_id,
1001            _request_auth=_request_auth,
1002            _content_type=_content_type,
1003            _headers=_headers,
1004            _host_index=_host_index
1005        )
1006
1007        _response_types_map: Dict[str, Optional[str]] = {
1008            '200': "GetDestinationConnectors200Response",
1009            '400': "GetPipelines400Response",
1010            '401': "GetPipelines400Response",
1011            '403': "GetPipelines400Response",
1012            '404': "GetPipelines400Response",
1013            '500': "GetPipelines400Response",
1014        }
1015        response_data = self.api_client.call_api(
1016            *_param,
1017            _request_timeout=_request_timeout
1018        )
1019        response_data.read()
1020        return self.api_client.response_deserialize(
1021            response_data=response_data,
1022            response_types_map=_response_types_map,
1023        ).data
1024
1025
1026    @validate_call
1027    def get_destination_connectors_with_http_info(
1028        self,
1029        organization_id: StrictStr,
1030        workspace_id: Optional[StrictStr] = None,
1031        _request_timeout: Union[
1032            None,
1033            Annotated[StrictFloat, Field(gt=0)],
1034            Tuple[
1035                Annotated[StrictFloat, Field(gt=0)],
1036                Annotated[StrictFloat, Field(gt=0)]
1037            ]
1038        ] = None,
1039        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1040        _content_type: Optional[StrictStr] = None,
1041        _headers: Optional[Dict[StrictStr, Any]] = None,
1042        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1043    ) -> ApiResponse[GetDestinationConnectors200Response]:
1044        """Get all existing destination connectors
1045
1046        Get all existing destination connectors
1047
1048        :param organization_id: (required)
1049        :type organization_id: str
1050        :param workspace_id:
1051        :type workspace_id: str
1052        :param _request_timeout: timeout setting for this request. If one
1053                                 number provided, it will be total request
1054                                 timeout. It can also be a pair (tuple) of
1055                                 (connection, read) timeouts.
1056        :type _request_timeout: int, tuple(int, int), optional
1057        :param _request_auth: set to override the auth_settings for an a single
1058                              request; this effectively ignores the
1059                              authentication in the spec for a single request.
1060        :type _request_auth: dict, optional
1061        :param _content_type: force content-type for the request.
1062        :type _content_type: str, Optional
1063        :param _headers: set to override the headers for a single
1064                         request; this effectively ignores the headers
1065                         in the spec for a single request.
1066        :type _headers: dict, optional
1067        :param _host_index: set to override the host_index for a single
1068                            request; this effectively ignores the host_index
1069                            in the spec for a single request.
1070        :type _host_index: int, optional
1071        :return: Returns the result object.
1072        """ # noqa: E501
1073
1074        _param = self._get_destination_connectors_serialize(
1075            organization_id=organization_id,
1076            workspace_id=workspace_id,
1077            _request_auth=_request_auth,
1078            _content_type=_content_type,
1079            _headers=_headers,
1080            _host_index=_host_index
1081        )
1082
1083        _response_types_map: Dict[str, Optional[str]] = {
1084            '200': "GetDestinationConnectors200Response",
1085            '400': "GetPipelines400Response",
1086            '401': "GetPipelines400Response",
1087            '403': "GetPipelines400Response",
1088            '404': "GetPipelines400Response",
1089            '500': "GetPipelines400Response",
1090        }
1091        response_data = self.api_client.call_api(
1092            *_param,
1093            _request_timeout=_request_timeout
1094        )
1095        response_data.read()
1096        return self.api_client.response_deserialize(
1097            response_data=response_data,
1098            response_types_map=_response_types_map,
1099        )
1100
1101
1102    @validate_call
1103    def get_destination_connectors_without_preload_content(
1104        self,
1105        organization_id: StrictStr,
1106        workspace_id: Optional[StrictStr] = None,
1107        _request_timeout: Union[
1108            None,
1109            Annotated[StrictFloat, Field(gt=0)],
1110            Tuple[
1111                Annotated[StrictFloat, Field(gt=0)],
1112                Annotated[StrictFloat, Field(gt=0)]
1113            ]
1114        ] = None,
1115        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1116        _content_type: Optional[StrictStr] = None,
1117        _headers: Optional[Dict[StrictStr, Any]] = None,
1118        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1119    ) -> RESTResponseType:
1120        """Get all existing destination connectors
1121
1122        Get all existing destination connectors
1123
1124        :param organization_id: (required)
1125        :type organization_id: str
1126        :param workspace_id:
1127        :type workspace_id: str
1128        :param _request_timeout: timeout setting for this request. If one
1129                                 number provided, it will be total request
1130                                 timeout. It can also be a pair (tuple) of
1131                                 (connection, read) timeouts.
1132        :type _request_timeout: int, tuple(int, int), optional
1133        :param _request_auth: set to override the auth_settings for an a single
1134                              request; this effectively ignores the
1135                              authentication in the spec for a single request.
1136        :type _request_auth: dict, optional
1137        :param _content_type: force content-type for the request.
1138        :type _content_type: str, Optional
1139        :param _headers: set to override the headers for a single
1140                         request; this effectively ignores the headers
1141                         in the spec for a single request.
1142        :type _headers: dict, optional
1143        :param _host_index: set to override the host_index for a single
1144                            request; this effectively ignores the host_index
1145                            in the spec for a single request.
1146        :type _host_index: int, optional
1147        :return: Returns the result object.
1148        """ # noqa: E501
1149
1150        _param = self._get_destination_connectors_serialize(
1151            organization_id=organization_id,
1152            workspace_id=workspace_id,
1153            _request_auth=_request_auth,
1154            _content_type=_content_type,
1155            _headers=_headers,
1156            _host_index=_host_index
1157        )
1158
1159        _response_types_map: Dict[str, Optional[str]] = {
1160            '200': "GetDestinationConnectors200Response",
1161            '400': "GetPipelines400Response",
1162            '401': "GetPipelines400Response",
1163            '403': "GetPipelines400Response",
1164            '404': "GetPipelines400Response",
1165            '500': "GetPipelines400Response",
1166        }
1167        response_data = self.api_client.call_api(
1168            *_param,
1169            _request_timeout=_request_timeout
1170        )
1171        return response_data.response
1172
1173
1174    def _get_destination_connectors_serialize(
1175        self,
1176        organization_id,
1177        workspace_id,
1178        _request_auth,
1179        _content_type,
1180        _headers,
1181        _host_index,
1182    ) -> RequestSerialized:
1183
1184        _host = None
1185
1186        _collection_formats: Dict[str, str] = {
1187        }
1188
1189        _path_params: Dict[str, str] = {}
1190        _query_params: List[Tuple[str, str]] = []
1191        _header_params: Dict[str, Optional[str]] = _headers or {}
1192        _form_params: List[Tuple[str, str]] = []
1193        _files: Dict[
1194            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1195        ] = {}
1196        _body_params: Optional[bytes] = None
1197
1198        # process the path parameters
1199        if organization_id is not None:
1200            _path_params['organizationId'] = organization_id
1201        # process the query parameters
1202        if workspace_id is not None:
1203            
1204            _query_params.append(('workspaceId', workspace_id))
1205            
1206        # process the header parameters
1207        # process the form parameters
1208        # process the body parameter
1209
1210
1211        # set the HTTP header `Accept`
1212        if 'Accept' not in _header_params:
1213            _header_params['Accept'] = self.api_client.select_header_accept(
1214                [
1215                    'application/json'
1216                ]
1217            )
1218
1219
1220        # authentication setting
1221        _auth_settings: List[str] = [
1222            'bearerAuth'
1223        ]
1224
1225        return self.api_client.param_serialize(
1226            method='GET',
1227            resource_path='/org/{organizationId}/connectors/destinations',
1228            path_params=_path_params,
1229            query_params=_query_params,
1230            header_params=_header_params,
1231            body=_body_params,
1232            post_params=_form_params,
1233            files=_files,
1234            auth_settings=_auth_settings,
1235            collection_formats=_collection_formats,
1236            _host=_host,
1237            _request_auth=_request_auth
1238        )
1239
1240
1241
1242
1243    @validate_call
1244    def update_destination_connector(
1245        self,
1246        organization_id: StrictStr,
1247        destination_connector_id: StrictStr,
1248        update_destination_connector_request: UpdateDestinationConnectorRequest,
1249        _request_timeout: Union[
1250            None,
1251            Annotated[StrictFloat, Field(gt=0)],
1252            Tuple[
1253                Annotated[StrictFloat, Field(gt=0)],
1254                Annotated[StrictFloat, Field(gt=0)]
1255            ]
1256        ] = None,
1257        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1258        _content_type: Optional[StrictStr] = None,
1259        _headers: Optional[Dict[StrictStr, Any]] = None,
1260        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1261    ) -> UpdateDestinationConnectorResponse:
1262        """Update a destination connector
1263
1264        Update a destination connector
1265
1266        :param organization_id: (required)
1267        :type organization_id: str
1268        :param destination_connector_id: (required)
1269        :type destination_connector_id: str
1270        :param update_destination_connector_request: (required)
1271        :type update_destination_connector_request: UpdateDestinationConnectorRequest
1272        :param _request_timeout: timeout setting for this request. If one
1273                                 number provided, it will be total request
1274                                 timeout. It can also be a pair (tuple) of
1275                                 (connection, read) timeouts.
1276        :type _request_timeout: int, tuple(int, int), optional
1277        :param _request_auth: set to override the auth_settings for an a single
1278                              request; this effectively ignores the
1279                              authentication in the spec for a single request.
1280        :type _request_auth: dict, optional
1281        :param _content_type: force content-type for the request.
1282        :type _content_type: str, Optional
1283        :param _headers: set to override the headers for a single
1284                         request; this effectively ignores the headers
1285                         in the spec for a single request.
1286        :type _headers: dict, optional
1287        :param _host_index: set to override the host_index for a single
1288                            request; this effectively ignores the host_index
1289                            in the spec for a single request.
1290        :type _host_index: int, optional
1291        :return: Returns the result object.
1292        """ # noqa: E501
1293
1294        _param = self._update_destination_connector_serialize(
1295            organization_id=organization_id,
1296            destination_connector_id=destination_connector_id,
1297            update_destination_connector_request=update_destination_connector_request,
1298            _request_auth=_request_auth,
1299            _content_type=_content_type,
1300            _headers=_headers,
1301            _host_index=_host_index
1302        )
1303
1304        _response_types_map: Dict[str, Optional[str]] = {
1305            '200': "UpdateDestinationConnectorResponse",
1306            '400': "GetPipelines400Response",
1307            '401': "GetPipelines400Response",
1308            '403': "GetPipelines400Response",
1309            '404': "GetPipelines400Response",
1310            '500': "GetPipelines400Response",
1311        }
1312        response_data = self.api_client.call_api(
1313            *_param,
1314            _request_timeout=_request_timeout
1315        )
1316        response_data.read()
1317        return self.api_client.response_deserialize(
1318            response_data=response_data,
1319            response_types_map=_response_types_map,
1320        ).data
1321
1322
1323    @validate_call
1324    def update_destination_connector_with_http_info(
1325        self,
1326        organization_id: StrictStr,
1327        destination_connector_id: StrictStr,
1328        update_destination_connector_request: UpdateDestinationConnectorRequest,
1329        _request_timeout: Union[
1330            None,
1331            Annotated[StrictFloat, Field(gt=0)],
1332            Tuple[
1333                Annotated[StrictFloat, Field(gt=0)],
1334                Annotated[StrictFloat, Field(gt=0)]
1335            ]
1336        ] = None,
1337        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1338        _content_type: Optional[StrictStr] = None,
1339        _headers: Optional[Dict[StrictStr, Any]] = None,
1340        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1341    ) -> ApiResponse[UpdateDestinationConnectorResponse]:
1342        """Update a destination connector
1343
1344        Update a destination connector
1345
1346        :param organization_id: (required)
1347        :type organization_id: str
1348        :param destination_connector_id: (required)
1349        :type destination_connector_id: str
1350        :param update_destination_connector_request: (required)
1351        :type update_destination_connector_request: UpdateDestinationConnectorRequest
1352        :param _request_timeout: timeout setting for this request. If one
1353                                 number provided, it will be total request
1354                                 timeout. It can also be a pair (tuple) of
1355                                 (connection, read) timeouts.
1356        :type _request_timeout: int, tuple(int, int), optional
1357        :param _request_auth: set to override the auth_settings for an a single
1358                              request; this effectively ignores the
1359                              authentication in the spec for a single request.
1360        :type _request_auth: dict, optional
1361        :param _content_type: force content-type for the request.
1362        :type _content_type: str, Optional
1363        :param _headers: set to override the headers for a single
1364                         request; this effectively ignores the headers
1365                         in the spec for a single request.
1366        :type _headers: dict, optional
1367        :param _host_index: set to override the host_index for a single
1368                            request; this effectively ignores the host_index
1369                            in the spec for a single request.
1370        :type _host_index: int, optional
1371        :return: Returns the result object.
1372        """ # noqa: E501
1373
1374        _param = self._update_destination_connector_serialize(
1375            organization_id=organization_id,
1376            destination_connector_id=destination_connector_id,
1377            update_destination_connector_request=update_destination_connector_request,
1378            _request_auth=_request_auth,
1379            _content_type=_content_type,
1380            _headers=_headers,
1381            _host_index=_host_index
1382        )
1383
1384        _response_types_map: Dict[str, Optional[str]] = {
1385            '200': "UpdateDestinationConnectorResponse",
1386            '400': "GetPipelines400Response",
1387            '401': "GetPipelines400Response",
1388            '403': "GetPipelines400Response",
1389            '404': "GetPipelines400Response",
1390            '500': "GetPipelines400Response",
1391        }
1392        response_data = self.api_client.call_api(
1393            *_param,
1394            _request_timeout=_request_timeout
1395        )
1396        response_data.read()
1397        return self.api_client.response_deserialize(
1398            response_data=response_data,
1399            response_types_map=_response_types_map,
1400        )
1401
1402
1403    @validate_call
1404    def update_destination_connector_without_preload_content(
1405        self,
1406        organization_id: StrictStr,
1407        destination_connector_id: StrictStr,
1408        update_destination_connector_request: UpdateDestinationConnectorRequest,
1409        _request_timeout: Union[
1410            None,
1411            Annotated[StrictFloat, Field(gt=0)],
1412            Tuple[
1413                Annotated[StrictFloat, Field(gt=0)],
1414                Annotated[StrictFloat, Field(gt=0)]
1415            ]
1416        ] = None,
1417        _request_auth: Optional[Dict[StrictStr, Any]] = None,
1418        _content_type: Optional[StrictStr] = None,
1419        _headers: Optional[Dict[StrictStr, Any]] = None,
1420        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1421    ) -> RESTResponseType:
1422        """Update a destination connector
1423
1424        Update a destination connector
1425
1426        :param organization_id: (required)
1427        :type organization_id: str
1428        :param destination_connector_id: (required)
1429        :type destination_connector_id: str
1430        :param update_destination_connector_request: (required)
1431        :type update_destination_connector_request: UpdateDestinationConnectorRequest
1432        :param _request_timeout: timeout setting for this request. If one
1433                                 number provided, it will be total request
1434                                 timeout. It can also be a pair (tuple) of
1435                                 (connection, read) timeouts.
1436        :type _request_timeout: int, tuple(int, int), optional
1437        :param _request_auth: set to override the auth_settings for an a single
1438                              request; this effectively ignores the
1439                              authentication in the spec for a single request.
1440        :type _request_auth: dict, optional
1441        :param _content_type: force content-type for the request.
1442        :type _content_type: str, Optional
1443        :param _headers: set to override the headers for a single
1444                         request; this effectively ignores the headers
1445                         in the spec for a single request.
1446        :type _headers: dict, optional
1447        :param _host_index: set to override the host_index for a single
1448                            request; this effectively ignores the host_index
1449                            in the spec for a single request.
1450        :type _host_index: int, optional
1451        :return: Returns the result object.
1452        """ # noqa: E501
1453
1454        _param = self._update_destination_connector_serialize(
1455            organization_id=organization_id,
1456            destination_connector_id=destination_connector_id,
1457            update_destination_connector_request=update_destination_connector_request,
1458            _request_auth=_request_auth,
1459            _content_type=_content_type,
1460            _headers=_headers,
1461            _host_index=_host_index
1462        )
1463
1464        _response_types_map: Dict[str, Optional[str]] = {
1465            '200': "UpdateDestinationConnectorResponse",
1466            '400': "GetPipelines400Response",
1467            '401': "GetPipelines400Response",
1468            '403': "GetPipelines400Response",
1469            '404': "GetPipelines400Response",
1470            '500': "GetPipelines400Response",
1471        }
1472        response_data = self.api_client.call_api(
1473            *_param,
1474            _request_timeout=_request_timeout
1475        )
1476        return response_data.response
1477
1478
1479    def _update_destination_connector_serialize(
1480        self,
1481        organization_id,
1482        destination_connector_id,
1483        update_destination_connector_request,
1484        _request_auth,
1485        _content_type,
1486        _headers,
1487        _host_index,
1488    ) -> RequestSerialized:
1489
1490        _host = None
1491
1492        _collection_formats: Dict[str, str] = {
1493        }
1494
1495        _path_params: Dict[str, str] = {}
1496        _query_params: List[Tuple[str, str]] = []
1497        _header_params: Dict[str, Optional[str]] = _headers or {}
1498        _form_params: List[Tuple[str, str]] = []
1499        _files: Dict[
1500            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1501        ] = {}
1502        _body_params: Optional[bytes] = None
1503
1504        # process the path parameters
1505        if organization_id is not None:
1506            _path_params['organizationId'] = organization_id
1507        if destination_connector_id is not None:
1508            _path_params['destinationConnectorId'] = destination_connector_id
1509        # process the query parameters
1510        # process the header parameters
1511        # process the form parameters
1512        # process the body parameter
1513        if update_destination_connector_request is not None:
1514            _body_params = update_destination_connector_request
1515
1516
1517        # set the HTTP header `Accept`
1518        if 'Accept' not in _header_params:
1519            _header_params['Accept'] = self.api_client.select_header_accept(
1520                [
1521                    'application/json'
1522                ]
1523            )
1524
1525        # set the HTTP header `Content-Type`
1526        if _content_type:
1527            _header_params['Content-Type'] = _content_type
1528        else:
1529            _default_content_type = (
1530                self.api_client.select_header_content_type(
1531                    [
1532                        'application/json'
1533                    ]
1534                )
1535            )
1536            if _default_content_type is not None:
1537                _header_params['Content-Type'] = _default_content_type
1538
1539        # authentication setting
1540        _auth_settings: List[str] = [
1541            'bearerAuth'
1542        ]
1543
1544        return self.api_client.param_serialize(
1545            method='PATCH',
1546            resource_path='/org/{organizationId}/connectors/destinations/{destinationConnectorId}',
1547            path_params=_path_params,
1548            query_params=_query_params,
1549            header_params=_header_params,
1550            body=_body_params,
1551            post_params=_form_params,
1552            files=_files,
1553            auth_settings=_auth_settings,
1554            collection_formats=_collection_formats,
1555            _host=_host,
1556            _request_auth=_request_auth
1557        )