API
grai_source_fivetran
fivetran_api
main

approve_certificate

@app.post("/v1/certificates", response_model=V1CertificatesPostResponse)
def approve_certificate(accept: Optional[str] = Header("application/json",
                                                       alias="Accept"),
                        body: TrustCertificateRequest = None
                        ) -> V1CertificatesPostResponse

Approve a certificate

Arguments:

  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body TrustCertificateRequest, optional - (Default value = None)

Returns:

create_connector

@app.post(
    "/v1/connectors",
    response_model=None,
    responses={"201": {
        "model": V1ConnectorsPostResponse
    }},
)
def create_connector(
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept"),
    body: NewConnectorRequestV1 = None
) -> Union[None, V1ConnectorsPostResponse]

Create a Connector

Arguments:

  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))
  • body NewConnectorRequestV1, optional - (Default value = None)

Returns:

connector_details

@app.get("/v1/connectors/{connector_id}",
         response_model=V1ConnectorsConnectorIdGetResponse)
def connector_details(connector_id: str = Path(..., alias="connectorId"),
                      accept: Optional[str] = Header(
                          "application/json;version=2", alias="Accept")
                      ) -> V1ConnectorsConnectorIdGetResponse

Retrieve Connector Details

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))

Returns:

delete_connector

@app.delete(
    "/v1/connectors/{connector_id}",
    response_model=V1ConnectorsConnectorIdDeleteResponse,
)
def delete_connector(connector_id: str = Path(..., alias="connectorId"),
                     accept: Optional[str] = Header(
                         "application/json;version=2", alias="Accept")
                     ) -> V1ConnectorsConnectorIdDeleteResponse

Delete a Connector

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))

Returns:

modify_connector

@app.patch("/v1/connectors/{connector_id}",
           response_model=V1ConnectorsConnectorIdPatchResponse)
def modify_connector(
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept"),
    body: UpdateConnectorRequest = None
) -> V1ConnectorsConnectorIdPatchResponse

Modify a Connector

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))
  • body UpdateConnectorRequest, optional - (Default value = None)

Returns:

connect_card

@app.post(
    "/v1/connectors/{connector_id}/connect-card",
    response_model=V1ConnectorsConnectorIdConnectCardPostResponse,
)
def connect_card(
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept"),
    body: ConnectCardConfigRequest = None
) -> V1ConnectorsConnectorIdConnectCardPostResponse

Connect Card

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))
  • body ConnectCardConfigRequest, optional - (Default value = None)

Returns:

connect_card_token

@app.post(
    "/v1/connectors/{connector_id}/connect-card-token",
    response_model=CreatePbfTokenResponse,
)
def connect_card_token(connector_id: str = Path(..., alias="connectorId"),
                       accept: Optional[str] = Header(
                           "application/json;version=2",
                           alias="Accept")) -> CreatePbfTokenResponse

Connect Card Token

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))

Returns:

resync_connector

@app.post(
    "/v1/connectors/{connector_id}/resync",
    response_model=V1ConnectorsConnectorIdResyncPostResponse,
)
def resync_connector(
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept"),
    body: ResyncConnectorRequest = None
) -> V1ConnectorsConnectorIdResyncPostResponse

Re-sync Connector Data (Historical Sync)

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))
  • body ResyncConnectorRequest, optional - (Default value = None)

Returns:

connector_schema_config

@app.get(
    "/v1/connectors/{connector_id}/schemas",
    response_model=V1ConnectorsConnectorIdSchemasGetResponse,
)
def connector_schema_config(connector_id: str = Path(..., alias="connectorId"),
                            accept: Optional[str] = Header("application/json",
                                                           alias="Accept")
                            ) -> V1ConnectorsConnectorIdSchemasGetResponse

Retrieve a Connector Schema Config

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

modify_connector_schema_config

@app.patch(
    "/v1/connectors/{connector_id}/schemas",
    response_model=V1ConnectorsConnectorIdSchemasPatchResponse,
)
def modify_connector_schema_config(
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: StandardConfigUpdateRequest = None
) -> V1ConnectorsConnectorIdSchemasPatchResponse

Modify a Connector Schema Config

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body StandardConfigUpdateRequest, optional - (Default value = None)

Returns:

reload_connector_schema_config

@app.post(
    "/v1/connectors/{connector_id}/schemas/reload",
    response_model=V1ConnectorsConnectorIdSchemasReloadPostResponse,
)
def reload_connector_schema_config(
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: ReloadStandardConfigRequest = None
) -> V1ConnectorsConnectorIdSchemasReloadPostResponse

Reload a Connector Schema Config

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body ReloadStandardConfigRequest, optional - (Default value = None)

Returns:

resync_tables

@app.post(
    "/v1/connectors/{connector_id}/schemas/tables/resync",
    response_model=V1ConnectorsConnectorIdSchemasTablesResyncPostResponse,
)
def resync_tables(
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: V1ConnectorsConnectorIdSchemasTablesResyncPostRequest = None
) -> V1ConnectorsConnectorIdSchemasTablesResyncPostResponse

Re-sync Connector Table Data

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body V1ConnectorsConnectorIdSchemasTablesResyncPostRequest, optional - (Default value = None)

Returns:

modify_connector_database_schema_config

@app.patch(
    "/v1/connectors/{connector_id}/schemas/{schema_name}",
    response_model=V1ConnectorsConnectorIdSchemasSchemaNamePatchResponse,
)
def modify_connector_database_schema_config(
    connector_id: str = Path(..., alias="connectorId"),
    schema_name: str = Path(..., alias="schemaName"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: SchemaUpdateRequest = None
) -> V1ConnectorsConnectorIdSchemasSchemaNamePatchResponse

Modify a Connector Database Schema Config

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • schema_name str, optional - (Default value = Path(..., alias="schemaName"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body SchemaUpdateRequest, optional - (Default value = None)

Returns:

modify_connector_table_config

@app.patch(
    "/v1/connectors/{connector_id}/schemas/{schema_name}/tables/{table_name}",
    response_model=
    V1ConnectorsConnectorIdSchemasSchemaNameTablesTableNamePatchResponse,
)
def modify_connector_table_config(
    connector_id: str = Path(..., alias="connectorId"),
    schema_name: str = Path(..., alias="schemaName"),
    table_name: str = Path(..., alias="tableName"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: TableUpdateRequest = None
) -> V1ConnectorsConnectorIdSchemasSchemaNameTablesTableNamePatchResponse

Modify a Connector Table Config

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • schema_name str, optional - (Default value = Path(..., alias="schemaName"))
  • table_name str, optional - (Default value = Path(..., alias="tableName"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body TableUpdateRequest, optional - (Default value = None)

Returns:

modify_connector_column_config

@app.patch(
    "/v1/connectors/{connector_id}/schemas/{schema_name}/tables/{table_name}/columns/{column_name}",
    response_model=
    V1ConnectorsConnectorIdSchemasSchemaNameTablesTableNameColumnsColumnNamePatchResponse,
)
def modify_connector_column_config(
    connector_id: str = Path(..., alias="connectorId"),
    schema_name: str = Path(..., alias="schemaName"),
    table_name: str = Path(..., alias="tableName"),
    column_name: str = Path(..., alias="columnName"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: ColumnUpdateRequest = None
) -> V1ConnectorsConnectorIdSchemasSchemaNameTablesTableNameColumnsColumnNamePatchResponse

Modify a Connector Column Config

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • schema_name str, optional - (Default value = Path(..., alias="schemaName"))
  • table_name str, optional - (Default value = Path(..., alias="tableName"))
  • column_name str, optional - (Default value = Path(..., alias="columnName"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body ColumnUpdateRequest, optional - (Default value = None)

Returns:

connector_column_config

@app.get(
    "/v1/connectors/{connector_id}/schemas/{schema}/tables/{table}/columns",
    response_model=
    V1ConnectorsConnectorIdSchemasSchemaTablesTableColumnsGetResponse,
)
def connector_column_config(
    connector_id: str = Path(..., alias="connectorId"),
    schema: str = ...,
    table: str = ...,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1ConnectorsConnectorIdSchemasSchemaTablesTableColumnsGetResponse

Retrieve Source Table Columns Config

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • schema str, optional - (Default value = ...)
  • table str, optional - (Default value = ...)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

sync_connector

@app.post(
    "/v1/connectors/{connector_id}/sync",
    response_model=V1ConnectorsConnectorIdSyncPostResponse,
)
def sync_connector(
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept"),
    body: SyncConnectorRequest = None
) -> V1ConnectorsConnectorIdSyncPostResponse

Sync Connector Data

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))
  • body SyncConnectorRequest, optional - (Default value = None)

Returns:

run_setup_tests

@app.post(
    "/v1/connectors/{connector_id}/test",
    response_model=V1ConnectorsConnectorIdTestPostResponse,
)
def run_setup_tests(
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept"),
    body: RunSetupTestsRequest = None
) -> V1ConnectorsConnectorIdTestPostResponse

Run connector setup tests

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))
  • body RunSetupTestsRequest, optional - (Default value = None)

Returns:

dbt_model_details

@app.get("/v1/dbt/models/{model_id}",
         response_model=V1DbtModelsModelIdGetResponse)
def dbt_model_details(model_id: str = Path(..., alias="modelId"),
                      accept: Optional[str] = Header(
                          "application/json",
                          alias="Accept")) -> V1DbtModelsModelIdGetResponse

Retrieve DBT Model Details

Arguments:

  • model_id str, optional - (Default value = Path(..., alias="modelId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

list_dbt_projects

@app.get("/v1/dbt/projects", response_model=V1DbtProjectsGetResponse)
def list_dbt_projects(
    group_id: Optional[str] = None,
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1DbtProjectsGetResponse

List All DBT Projects

Arguments:

  • group_id Optional[str], optional - (Default value = None)
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

create_dbt_project

@app.post(
    "/v1/dbt/projects",
    response_model=None,
    responses={"201": {
        "model": V1DbtProjectsPostResponse
    }},
)
def create_dbt_project(
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: NewDbtProjectRequest = None
) -> Union[None, V1DbtProjectsPostResponse]

Create DBT Project

Arguments:

  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body NewDbtProjectRequest, optional - (Default value = None)

Returns:

dbt_project_details

@app.get("/v1/dbt/projects/{project_id}",
         response_model=V1DbtProjectsProjectIdGetResponse)
def dbt_project_details(project_id: str = Path(..., alias="projectId"),
                        accept: Optional[str] = Header("application/json",
                                                       alias="Accept")
                        ) -> V1DbtProjectsProjectIdGetResponse

Retrieve DBT Project Details

Arguments:

  • project_id str, optional - (Default value = Path(..., alias="projectId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

list_dbt_project_models

@app.get(
    "/v1/dbt/projects/{project_id}/models",
    response_model=V1DbtProjectsProjectIdModelsGetResponse,
)
def list_dbt_project_models(
    project_id: str = Path(..., alias="projectId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1DbtProjectsProjectIdModelsGetResponse

List All DBT Models

Arguments:

  • project_id str, optional - (Default value = Path(..., alias="projectId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

test_dbt_project

@app.post(
    "/v1/dbt/projects/{project_id}/test",
    response_model=V1DbtProjectsProjectIdTestPostResponse,
)
def test_dbt_project(project_id: str = Path(..., alias="projectId"),
                     accept: Optional[str] = Header("application/json",
                                                    alias="Accept")
                     ) -> V1DbtProjectsProjectIdTestPostResponse

Test DBT Project

Arguments:

  • project_id str, optional - (Default value = Path(..., alias="projectId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

list_dbt_project_transformations

@app.get(
    "/v1/dbt/projects/{project_id}/transformations",
    response_model=V1DbtProjectsProjectIdTransformationsGetResponse,
)
def list_dbt_project_transformations(
    project_id: str = Path(..., alias="projectId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1DbtProjectsProjectIdTransformationsGetResponse

List All DBT Transformations

Arguments:

  • project_id str, optional - (Default value = Path(..., alias="projectId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

create_dbt_transformation

@app.post(
    "/v1/dbt/projects/{project_id}/transformations",
    response_model=None,
    responses={
        "201": {
            "model": V1DbtProjectsProjectIdTransformationsPostResponse
        }
    },
)
def create_dbt_transformation(
    project_id: str = Path(..., alias="projectId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: NewTransformationRequest = None
) -> Union[None, V1DbtProjectsProjectIdTransformationsPostResponse]

Create DBT Transformation

Arguments:

  • project_id str, optional - (Default value = Path(..., alias="projectId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body NewTransformationRequest, optional - (Default value = None)

Returns:

dbt_transformation_details

@app.get(
    "/v1/dbt/transformations/{transformation_id}",
    response_model=V1DbtTransformationsTransformationIdGetResponse,
)
def dbt_transformation_details(
        transformation_id: str = Path(..., alias="transformationId"),
        accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1DbtTransformationsTransformationIdGetResponse

Retrieve DBT Transformation Details

Arguments:

  • transformation_id str, optional - (Default value = Path(..., alias="transformationId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

delete_dbt_transformation

@app.delete(
    "/v1/dbt/transformations/{transformation_id}",
    response_model=V1DbtTransformationsTransformationIdDeleteResponse,
)
def delete_dbt_transformation(
        transformation_id: str = Path(..., alias="transformationId"),
        accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1DbtTransformationsTransformationIdDeleteResponse

Delete DBT Transformation

Arguments:

  • transformation_id str, optional - (Default value = Path(..., alias="transformationId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

modify_dbt_transformation

@app.patch(
    "/v1/dbt/transformations/{transformation_id}",
    response_model=V1DbtTransformationsTransformationIdPatchResponse,
)
def modify_dbt_transformation(
    transformation_id: str = Path(..., alias="transformationId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: UpdateTransformationRequest = None
) -> V1DbtTransformationsTransformationIdPatchResponse

Modify DBT Transformation

Arguments:

  • transformation_id str, optional - (Default value = Path(..., alias="transformationId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body UpdateTransformationRequest, optional - (Default value = None)

Returns:

create_destination

@app.post(
    "/v1/destinations",
    response_model=None,
    responses={"201": {
        "model": V1DestinationsPostResponse
    }},
)
def create_destination(
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept"),
    body: NewDestinationRequest = None
) -> Union[None, V1DestinationsPostResponse]

Create destination

Arguments:

  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))
  • body NewDestinationRequest, optional - (Default value = None)

Returns:

destination_details

@app.get(
    "/v1/destinations/{destination_id}",
    response_model=V1DestinationsDestinationIdGetResponse,
)
def destination_details(destination_id: str = Path(..., alias="destinationId"),
                        accept: Optional[str] = Header(
                            "application/json;version=2", alias="Accept")
                        ) -> V1DestinationsDestinationIdGetResponse

Retrieve Destination Details

Arguments:

  • destination_id str, optional - (Default value = Path(..., alias="destinationId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))

Returns:

delete_destination

@app.delete(
    "/v1/destinations/{destination_id}",
    response_model=V1DestinationsDestinationIdDeleteResponse,
)
def delete_destination(destination_id: str = Path(..., alias="destinationId"),
                       accept: Optional[str] = Header(
                           "application/json;version=2", alias="Accept")
                       ) -> V1DestinationsDestinationIdDeleteResponse

Delete a destination

Arguments:

  • destination_id str, optional - (Default value = Path(..., alias="destinationId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))

Returns:

modify_destination

@app.patch(
    "/v1/destinations/{destination_id}",
    response_model=V1DestinationsDestinationIdPatchResponse,
)
def modify_destination(
    destination_id: str = Path(..., alias="destinationId"),
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept"),
    body: UpdateDestinationRequest = None
) -> V1DestinationsDestinationIdPatchResponse

Modify a Destination

Arguments:

  • destination_id str, optional - (Default value = Path(..., alias="destinationId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))
  • body UpdateDestinationRequest, optional - (Default value = None)

Returns:

run_destination_setup_tests

@app.post(
    "/v1/destinations/{destination_id}/test",
    response_model=V1DestinationsDestinationIdTestPostResponse,
)
def run_destination_setup_tests(
    destination_id: str = Path(..., alias="destinationId"),
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept"),
    body: RunSetupTestsRequest = None
) -> V1DestinationsDestinationIdTestPostResponse

Run Destination Setup Tests

Arguments:

  • destination_id str, optional - (Default value = Path(..., alias="destinationId"))
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))
  • body RunSetupTestsRequest, optional - (Default value = None)

Returns:

approve_fingerprint

@app.post("/v1/fingerprints", response_model=V1FingerprintsPostResponse)
def approve_fingerprint(accept: Optional[str] = Header("application/json",
                                                       alias="Accept"),
                        body: TrustFingerprintRequest = None
                        ) -> V1FingerprintsPostResponse

Approve a fingerprint

Arguments:

  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body TrustFingerprintRequest, optional - (Default value = None)

Returns:

list_all_groups

@app.get("/v1/groups", response_model=V1GroupsGetResponse)
def list_all_groups(
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1GroupsGetResponse

List All Groups

Arguments:

  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

create_group

@app.post(
    "/v1/groups",
    response_model=None,
    responses={"201": {
        "model": V1GroupsPostResponse
    }},
)
def create_group(accept: Optional[str] = Header("application/json",
                                                alias="Accept"),
                 body: NewGroupRequest = None
                 ) -> Union[None, V1GroupsPostResponse]

Create a Group

Arguments:

  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body NewGroupRequest, optional - (Default value = None)

Returns:

group_details

@app.get("/v1/groups/{group_id}", response_model=V1GroupsGroupIdGetResponse)
def group_details(group_id: str = Path(..., alias="groupId"),
                  accept: Optional[str] = Header(
                      "application/json",
                      alias="Accept")) -> V1GroupsGroupIdGetResponse

Retrieve Group Details

Arguments:

  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

delete_group

@app.delete("/v1/groups/{group_id}",
            response_model=V1GroupsGroupIdDeleteResponse)
def delete_group(group_id: str = Path(..., alias="groupId"),
                 accept: Optional[str] = Header(
                     "application/json",
                     alias="Accept")) -> V1GroupsGroupIdDeleteResponse

Delete a group

Arguments:

  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

modify_group

@app.patch("/v1/groups/{group_id}",
           response_model=V1GroupsGroupIdPatchResponse)
def modify_group(group_id: str = Path(..., alias="groupId"),
                 accept: Optional[str] = Header("application/json",
                                                alias="Accept"),
                 body: UpdateGroupRequest = None
                 ) -> V1GroupsGroupIdPatchResponse

Modify a Group

Arguments:

  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body UpdateGroupRequest, optional - (Default value = None)

Returns:

list_all_connectors_in_group

@app.get(
    "/v1/groups/{group_id}/connectors",
    response_model=V1GroupsGroupIdConnectorsGetResponse,
)
def list_all_connectors_in_group(
    group_id: str = Path(..., alias="groupId"),
    schema: Optional[str] = None,
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1GroupsGroupIdConnectorsGetResponse

List All Connectors within a Group

Arguments:

  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • schema Optional[str], optional - (Default value = None)
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

list_all_users_in_group

@app.get("/v1/groups/{group_id}/users",
         response_model=V1GroupsGroupIdUsersGetResponse)
def list_all_users_in_group(
    group_id: str = Path(..., alias="groupId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1GroupsGroupIdUsersGetResponse

List All Users within a Group

Arguments:

  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

add_user_to_group

@app.post("/v1/groups/{group_id}/users",
          response_model=V1GroupsGroupIdUsersPostResponse)
def add_user_to_group(
        group_id: str = Path(..., alias="groupId"),
        accept: Optional[str] = Header("application/json", alias="Accept"),
        body: AddUserToGroupRequest = None
) -> V1GroupsGroupIdUsersPostResponse

Add a User to a Group

Arguments:

  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body AddUserToGroupRequest, optional - (Default value = None)

Returns:

delete_user_from_group

@app.delete(
    "/v1/groups/{group_id}/users/{user_id}",
    response_model=V1GroupsGroupIdUsersUserIdDeleteResponse,
)
def delete_user_from_group(group_id: str = Path(..., alias="groupId"),
                           user_id: str = Path(..., alias="userId"),
                           accept: Optional[str] = Header("application/json",
                                                          alias="Accept")
                           ) -> V1GroupsGroupIdUsersUserIdDeleteResponse

Remove a User from a Group

Arguments:

  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

column_metadata

@app.get(
    "/v1/metadata/connectors/{connector_id}/columns",
    response_model=V1MetadataConnectorsConnectorIdColumnsGetResponse,
)
def column_metadata(
    connector_id: str = Path(..., alias="connectorId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1MetadataConnectorsConnectorIdColumnsGetResponse

Retrieve column metadata

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

schema_metadata

@app.get(
    "/v1/metadata/connectors/{connector_id}/schemas",
    response_model=V1MetadataConnectorsConnectorIdSchemasGetResponse,
)
def schema_metadata(
    connector_id: str = Path(..., alias="connectorId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1MetadataConnectorsConnectorIdSchemasGetResponse

Retrieve schema metadata

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

table_metadata

@app.get(
    "/v1/metadata/connectors/{connector_id}/tables",
    response_model=V1MetadataConnectorsConnectorIdTablesGetResponse,
)
def table_metadata(
    connector_id: str = Path(..., alias="connectorId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1MetadataConnectorsConnectorIdTablesGetResponse

Retrieve table metadata

Arguments:

  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

metadata_connectors

@app.get("/v1/metadata/{name}", response_model=V1MetadataNameGetResponse)
def metadata_connectors(
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept")
) -> V1MetadataNameGetResponse

Retrieve source metadata

Arguments:

  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))

Returns:

metadata_connector_config

@app.get("/v1/metadata/{name}/{service}",
         response_model=V1MetadataNameServiceGetResponse)
def metadata_connector_config(
    service: str,
    accept: Optional[str] = Header("application/json;version=2",
                                   alias="Accept")
) -> V1MetadataNameServiceGetResponse

Retrieve connector configuration metadata

Arguments:

service (str):

  • accept Optional[str], optional - (Default value = Header("application/json;version=2", alias="Accept"))

Returns:

list_all_roles

@app.get("/v1/roles", response_model=V1RolesGetResponse)
def list_all_roles(
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1RolesGetResponse

List all roles

Arguments:

  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

list_all_teams

@app.get("/v1/teams", response_model=V1TeamsGetResponse)
def list_all_teams(
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1TeamsGetResponse

List all teams

Arguments:

  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

create_team

@app.post("/v1/teams",
          response_model=None,
          responses={"201": {
              "model": V1TeamsPostResponse
          }})
def create_team(accept: Optional[str] = Header("application/json",
                                               alias="Accept"),
                body: TeamRequest = None) -> Union[None, V1TeamsPostResponse]

Create a team

Arguments:

  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body TeamRequest, optional - (Default value = None)

Returns:

team_details

@app.get("/v1/teams/{team_id}", response_model=V1TeamsTeamIdGetResponse)
def team_details(team_id: str = Path(..., alias="teamId"),
                 accept: Optional[str] = Header(
                     "application/json",
                     alias="Accept")) -> V1TeamsTeamIdGetResponse

Retrieve team details

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

delete_team

@app.delete("/v1/teams/{team_id}", response_model=V1TeamsTeamIdDeleteResponse)
def delete_team(team_id: str = Path(..., alias="teamId"),
                accept: Optional[str] = Header(
                    "application/json",
                    alias="Accept")) -> V1TeamsTeamIdDeleteResponse

Delete a team

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

modify_team

@app.patch("/v1/teams/{team_id}", response_model=V1TeamsTeamIdPatchResponse)
def modify_team(team_id: str = Path(..., alias="teamId"),
                accept: Optional[str] = Header("application/json",
                                               alias="Accept"),
                body: TeamRequest = None) -> V1TeamsTeamIdPatchResponse

Modify a team

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body TeamRequest, optional - (Default value = None)

Returns:

get_team_memberships_in_connectors

@app.get("/v1/teams/{team_id}/connectors",
         response_model=V1TeamsTeamIdConnectorsGetResponse)
def get_team_memberships_in_connectors(
    team_id: str = Path(..., alias="teamId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1TeamsTeamIdConnectorsGetResponse

List all connector memberships

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

add_team_membership_in_connector

@app.post(
    "/v1/teams/{team_id}/connectors",
    response_model=None,
    responses={"201": {
        "model": V1TeamsTeamIdConnectorsPostResponse
    }},
)
def add_team_membership_in_connector(
    team_id: str = Path(..., alias="teamId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: MembershipRequest = None
) -> Union[None, V1TeamsTeamIdConnectorsPostResponse]

Add connector membership

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body MembershipRequest, optional - (Default value = None)

Returns:

get_team_membership_in_connector

@app.get(
    "/v1/teams/{team_id}/connectors/{connector_id}",
    response_model=V1TeamsTeamIdConnectorsConnectorIdGetResponse,
)
def get_team_membership_in_connector(
        team_id: str = Path(..., alias="teamId"),
        connector_id: str = Path(..., alias="connectorId"),
        accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1TeamsTeamIdConnectorsConnectorIdGetResponse

Retrieve connector membership

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

delete_team_membership_in_connector

@app.delete(
    "/v1/teams/{team_id}/connectors/{connector_id}",
    response_model=V1TeamsTeamIdConnectorsConnectorIdDeleteResponse,
)
def delete_team_membership_in_connector(
        team_id: str = Path(..., alias="teamId"),
        connector_id: str = Path(..., alias="connectorId"),
        accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1TeamsTeamIdConnectorsConnectorIdDeleteResponse

Delete connector membership

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

update_team_membership_in_connector

@app.patch(
    "/v1/teams/{team_id}/connectors/{connector_id}",
    response_model=V1TeamsTeamIdConnectorsConnectorIdPatchResponse,
)
def update_team_membership_in_connector(
    team_id: str = Path(..., alias="teamId"),
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: UpdateMembershipRequest = None
) -> V1TeamsTeamIdConnectorsConnectorIdPatchResponse

Update connector membership

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body UpdateMembershipRequest, optional - (Default value = None)

Returns:

get_team_memberships_in_groups

@app.get("/v1/teams/{team_id}/groups",
         response_model=V1TeamsTeamIdGroupsGetResponse)
def get_team_memberships_in_groups(
    team_id: str = Path(..., alias="teamId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1TeamsTeamIdGroupsGetResponse

List all group memberships

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

add_team_membership_in_group

@app.post(
    "/v1/teams/{team_id}/groups",
    response_model=None,
    responses={"201": {
        "model": V1TeamsTeamIdGroupsPostResponse
    }},
)
def add_team_membership_in_group(
    team_id: str = Path(..., alias="teamId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: MembershipRequest = None
) -> Union[None, V1TeamsTeamIdGroupsPostResponse]

Add group membership

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body MembershipRequest, optional - (Default value = None)

Returns:

get_team_membership_in_group

@app.get(
    "/v1/teams/{team_id}/groups/{group_id}",
    response_model=V1TeamsTeamIdGroupsGroupIdGetResponse,
)
def get_team_membership_in_group(team_id: str = Path(..., alias="teamId"),
                                 group_id: str = Path(..., alias="groupId"),
                                 accept: Optional[str] = Header(
                                     "application/json", alias="Accept")
                                 ) -> V1TeamsTeamIdGroupsGroupIdGetResponse

Retrieve group membership

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

delete_team_membership_in_group

@app.delete(
    "/v1/teams/{team_id}/groups/{group_id}",
    response_model=V1TeamsTeamIdGroupsGroupIdDeleteResponse,
)
def delete_team_membership_in_group(
        team_id: str = Path(..., alias="teamId"),
        group_id: str = Path(..., alias="groupId"),
        accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1TeamsTeamIdGroupsGroupIdDeleteResponse

Delete group membership

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

update_team_membership_in_group

@app.patch(
    "/v1/teams/{team_id}/groups/{group_id}",
    response_model=V1TeamsTeamIdGroupsGroupIdPatchResponse,
)
def update_team_membership_in_group(
    team_id: str = Path(..., alias="teamId"),
    group_id: str = Path(..., alias="groupId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: UpdateMembershipRequest = None
) -> V1TeamsTeamIdGroupsGroupIdPatchResponse

Update group membership

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body UpdateMembershipRequest, optional - (Default value = None)

Returns:

delete_team_membership_in_account

@app.delete("/v1/teams/{team_id}/role",
            response_model=V1TeamsTeamIdRoleDeleteResponse)
def delete_team_membership_in_account(team_id: str = Path(..., alias="teamId"),
                                      accept: Optional[str] = Header(
                                          "application/json", alias="Accept")
                                      ) -> V1TeamsTeamIdRoleDeleteResponse

Delete team role in account

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

list_users_in_team

@app.get("/v1/teams/{team_id}/users",
         response_model=V1TeamsTeamIdUsersGetResponse)
def list_users_in_team(
    team_id: str = Path(..., alias="teamId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1TeamsTeamIdUsersGetResponse

List all user memberships

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

add_user_to_team

@app.post(
    "/v1/teams/{team_id}/users",
    response_model=None,
    responses={"201": {
        "model": V1TeamsTeamIdUsersPostResponse
    }},
)
def add_user_to_team(
    team_id: str = Path(..., alias="teamId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: TeamMembershipRequest = None
) -> Union[None, V1TeamsTeamIdUsersPostResponse]

Add a user to a team

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body TeamMembershipRequest, optional - (Default value = None)

Returns:

get_user_in_team

@app.get(
    "/v1/teams/{team_id}/users/{user_id}",
    response_model=V1TeamsTeamIdUsersUserIdGetResponse,
)
def get_user_in_team(team_id: str = Path(..., alias="teamId"),
                     user_id: str = Path(..., alias="userId"),
                     accept: Optional[str] = Header("application/json",
                                                    alias="Accept")
                     ) -> V1TeamsTeamIdUsersUserIdGetResponse

Retrieve user membership in a team

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

delete_user_from_team

@app.delete(
    "/v1/teams/{team_id}/users/{user_id}",
    response_model=V1TeamsTeamIdUsersUserIdDeleteResponse,
)
def delete_user_from_team(team_id: str = Path(..., alias="teamId"),
                          user_id: str = Path(..., alias="userId"),
                          accept: Optional[str] = Header("application/json",
                                                         alias="Accept")
                          ) -> V1TeamsTeamIdUsersUserIdDeleteResponse

Delete a user from a team

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

update_user_membership

@app.patch(
    "/v1/teams/{team_id}/users/{user_id}",
    response_model=V1TeamsTeamIdUsersUserIdPatchResponse,
)
def update_user_membership(
    team_id: str = Path(..., alias="teamId"),
    user_id: str = Path(..., alias="userId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: UpdateMembershipRequest = None
) -> V1TeamsTeamIdUsersUserIdPatchResponse

Modify a user membership

Arguments:

  • team_id str, optional - (Default value = Path(..., alias="teamId"))
  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body UpdateMembershipRequest, optional - (Default value = None)

Returns:

list_all_users

@app.get("/v1/users", response_model=V1UsersGetResponse)
def list_all_users(
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1UsersGetResponse

List All Users

Arguments:

  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

create_user

@app.post("/v1/users",
          response_model=None,
          responses={"201": {
              "model": V1UsersPostResponse
          }})
def create_user(accept: Optional[str] = Header("application/json",
                                               alias="Accept"),
                body: NewUserRequest = None
                ) -> Union[None, V1UsersPostResponse]

Invite a User

Arguments:

  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body NewUserRequest, optional - (Default value = None)

Returns:

delete_user

@app.delete("/v1/users/{id}", response_model=V1UsersIdDeleteResponse)
def delete_user(
    id: str,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1UsersIdDeleteResponse

Delete a user

Arguments:

id (str):

  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

user_details

@app.get("/v1/users/{user_id}", response_model=V1UsersUserIdGetResponse)
def user_details(user_id: str = Path(..., alias="userId"),
                 accept: Optional[str] = Header(
                     "application/json",
                     alias="Accept")) -> V1UsersUserIdGetResponse

Retrieve User Details

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

modify_user

@app.patch("/v1/users/{user_id}", response_model=V1UsersUserIdPatchResponse)
def modify_user(user_id: str = Path(..., alias="userId"),
                accept: Optional[str] = Header("application/json",
                                               alias="Accept"),
                body: UpdateUserRequest = None) -> V1UsersUserIdPatchResponse

Modify a User

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body UpdateUserRequest, optional - (Default value = None)

Returns:

get_user_memberships_in_connectors

@app.get("/v1/users/{user_id}/connectors",
         response_model=V1UsersUserIdConnectorsGetResponse)
def get_user_memberships_in_connectors(
    user_id: str = Path(..., alias="userId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1UsersUserIdConnectorsGetResponse

List all connector memberships

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

add_user_membership_in_connector

@app.post(
    "/v1/users/{user_id}/connectors",
    response_model=None,
    responses={"201": {
        "model": MembershipResponse
    }},
)
def add_user_membership_in_connector(user_id: str = Path(..., alias="userId"),
                                     accept: Optional[str] = Header(
                                         "application/json", alias="Accept"),
                                     body: MembershipRequest = None
                                     ) -> Union[None, MembershipResponse]

Add connector membership

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body MembershipRequest, optional - (Default value = None)

Returns:

get_user_membership_in_connector

@app.get(
    "/v1/users/{user_id}/connectors/{connector_id}",
    response_model=V1UsersUserIdConnectorsConnectorIdGetResponse,
)
def get_user_membership_in_connector(
        user_id: str = Path(..., alias="userId"),
        connector_id: str = Path(..., alias="connectorId"),
        accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1UsersUserIdConnectorsConnectorIdGetResponse

Retrieve connector membership

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

delete_user_membership_in_connector

@app.delete(
    "/v1/users/{user_id}/connectors/{connector_id}",
    response_model=V1UsersUserIdConnectorsConnectorIdDeleteResponse,
)
def delete_user_membership_in_connector(
        user_id: str = Path(..., alias="userId"),
        connector_id: str = Path(..., alias="connectorId"),
        accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1UsersUserIdConnectorsConnectorIdDeleteResponse

Delete connector membership

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

update_user_membership_in_connector

@app.patch(
    "/v1/users/{user_id}/connectors/{connector_id}",
    response_model=V1UsersUserIdConnectorsConnectorIdPatchResponse,
)
def update_user_membership_in_connector(
    user_id: str = Path(..., alias="userId"),
    connector_id: str = Path(..., alias="connectorId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: UpdateMembershipRequest = None
) -> V1UsersUserIdConnectorsConnectorIdPatchResponse

Update connector membership

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • connector_id str, optional - (Default value = Path(..., alias="connectorId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body UpdateMembershipRequest, optional - (Default value = None)

Returns:

get_user_memberships_in_groups

@app.get("/v1/users/{user_id}/groups",
         response_model=V1UsersUserIdGroupsGetResponse)
def get_user_memberships_in_groups(
    user_id: str = Path(..., alias="userId"),
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1UsersUserIdGroupsGetResponse

List all group memberships

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

add_user_membership_in_group

@app.post(
    "/v1/users/{user_id}/groups",
    response_model=None,
    responses={"201": {
        "model": V1UsersUserIdGroupsPostResponse
    }},
)
def add_user_membership_in_group(
    user_id: str = Path(..., alias="userId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: MembershipRequest = None
) -> Union[None, V1UsersUserIdGroupsPostResponse]

Add group membership

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body MembershipRequest, optional - (Default value = None)

Returns:

get_user_membership_in_group

@app.get(
    "/v1/users/{user_id}/groups/{group_id}",
    response_model=V1UsersUserIdGroupsGroupIdGetResponse,
)
def get_user_membership_in_group(user_id: str = Path(..., alias="userId"),
                                 group_id: str = Path(..., alias="groupId"),
                                 accept: Optional[str] = Header(
                                     "application/json", alias="Accept")
                                 ) -> V1UsersUserIdGroupsGroupIdGetResponse

Retrieve group membership

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

delete_user_membership_in_group

@app.delete(
    "/v1/users/{user_id}/groups/{group_id}",
    response_model=V1UsersUserIdGroupsGroupIdDeleteResponse,
)
def delete_user_membership_in_group(
        user_id: str = Path(..., alias="userId"),
        group_id: str = Path(..., alias="groupId"),
        accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1UsersUserIdGroupsGroupIdDeleteResponse

Delete group membership

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

update_user_membership_in_group

@app.patch(
    "/v1/users/{user_id}/groups/{group_id}",
    response_model=V1UsersUserIdGroupsGroupIdPatchResponse,
)
def update_user_membership_in_group(
    user_id: str = Path(..., alias="userId"),
    group_id: str = Path(..., alias="groupId"),
    accept: Optional[str] = Header("application/json", alias="Accept"),
    body: UpdateMembershipRequest = None
) -> V1UsersUserIdGroupsGroupIdPatchResponse

Update group membership

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body UpdateMembershipRequest, optional - (Default value = None)

Returns:

delete_user_membership_in_account

@app.delete("/v1/users/{user_id}/role",
            response_model=V1UsersUserIdRoleDeleteResponse)
def delete_user_membership_in_account(user_id: str = Path(..., alias="userId"),
                                      accept: Optional[str] = Header(
                                          "application/json", alias="Accept")
                                      ) -> V1UsersUserIdRoleDeleteResponse

Delete user role in account

Arguments:

  • user_id str, optional - (Default value = Path(..., alias="userId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

list_all_webhooks

@app.get("/v1/webhooks", response_model=V1WebhooksGetResponse)
def list_all_webhooks(
    cursor: Optional[str] = None,
    limit: Optional[int] = None,
    accept: Optional[str] = Header("application/json", alias="Accept")
) -> V1WebhooksGetResponse

Retrieve the list of webhooks

Arguments:

  • cursor Optional[str], optional - (Default value = None)
  • limit Optional[int], optional - (Default value = None)
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

create_account_webhook

@app.post("/v1/webhooks/account", response_model=WebhookResponse)
def create_account_webhook(accept: Optional[str] = Header("application/json",
                                                          alias="Accept"),
                           body: WebhookRequest = None) -> WebhookResponse

Create account webhook

Arguments:

  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body WebhookRequest, optional - (Default value = None)

Returns:

create_group_webhook

@app.post("/v1/webhooks/group/{group_id}", response_model=WebhookResponse)
def create_group_webhook(group_id: str = Path(..., alias="groupId"),
                         accept: Optional[str] = Header("application/json",
                                                        alias="Accept"),
                         body: WebhookRequest = None) -> WebhookResponse

Create group webhook

Arguments:

  • group_id str, optional - (Default value = Path(..., alias="groupId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body WebhookRequest, optional - (Default value = None)

Returns:

webhook_details

@app.get("/v1/webhooks/{webhook_id}", response_model=WebhookResponse)
def webhook_details(webhook_id: str = Path(..., alias="webhookId"),
                    accept: Optional[str] = Header(
                        "application/json",
                        alias="Accept")) -> WebhookResponse

Retrieve webhook details

Arguments:

  • webhook_id str, optional - (Default value = Path(..., alias="webhookId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

delete_webhook

@app.delete("/v1/webhooks/{webhook_id}",
            response_model=None,
            responses={"204": {
                "model": str
            }})
def delete_webhook(webhook_id: str = Path(..., alias="webhookId"),
                   accept: Optional[str] = Header(
                       "application/json",
                       alias="Accept")) -> Union[None, str]

Delete webhook

Arguments:

  • webhook_id str, optional - (Default value = Path(..., alias="webhookId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))

Returns:

modify_webhook

@app.patch("/v1/webhooks/{webhook_id}", response_model=WebhookResponse)
def modify_webhook(webhook_id: str = Path(..., alias="webhookId"),
                   accept: Optional[str] = Header("application/json",
                                                  alias="Accept"),
                   body: WebhookRequest = None) -> WebhookResponse

Update webhook

Arguments:

  • webhook_id str, optional - (Default value = Path(..., alias="webhookId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body WebhookRequest, optional - (Default value = None)

Returns:

test_webhook

@app.post("/v1/webhooks/{webhook_id}/test", response_model=WebhookTestResponse)
def test_webhook(webhook_id: str = Path(..., alias="webhookId"),
                 accept: Optional[str] = Header("application/json",
                                                alias="Accept"),
                 body: WebhookTestRequest = None) -> WebhookTestResponse

Test webhook

Arguments:

  • webhook_id str, optional - (Default value = Path(..., alias="webhookId"))
  • accept Optional[str], optional - (Default value = Header("application/json", alias="Accept"))
  • body WebhookTestRequest, optional - (Default value = None)

Returns:

api_modelsloader