addAnnotation: (
  annotation: Partial<Annotation>
) => Annotation;

def add_annotation(
    self, annotation: Union[AnnotationCreationProps, dict]
) -> Optional[Annotation]

map.addAnnotation({
  id: "annotation-1",
  kind: "POINT",
  isVisible: true,
  autoSize: true,
  autoSizeY: true,
  anchorPoint: [-69.30788156774667, -7.1582370789647],
  label: "Annotation 1",
  lineColor: "#C32899",
  lineWidth: 5,
  textWidth: 82.1796875,
  textHeight: 29,
  textVerticalAlign: "bottom",
  armLength: 50,
  angle: -45,
})

map.add_annotation(
    AnnotationCreationProps(
        id="ann_1",
        kind="POINT",
        is_visible=True,
        auto_size=True,
        auto_size_y=True,
        anchor_point=(-69.30788156774667, -7.1582370789647),
        label="Annotation 45",
        line_color="#C32899",
        line_width=5,
        text_width=82.1796875,
        text_height=29,
        text_vertical_align="bottom",
        arm_length=50,
        angle=-45,
    )
)

getAnnotations: () => Annotation[];

 def get_annotations(self) -> List[Annotation]:

map.getAnnotations();

map.get_annotations()

getAnnotationById: (annotationId: string) => Annotation | null;

def get_annotation_by_id(self, annotation_id: str) -> Optional[Annotation]:

map.getAnnotationById("annotation-1");

map.get_annotation_by_id("annotation-1")

removeAnnotation: (annotationId: string) => void;

def remove_annotation(self, annotation_id: str) -> None:

map.removeAnnotation("annotation-1");

map.remove_annotation("annotation-1")

updateAnnotation: (
  annotationId: string,
  values: AnnotationUpdateProps
) => Annotation;

def update_annotation(
    self,
    annotation_id: str,
    values: Union[AnnotationUpdateProps, dict],
) -> Optional[Annotation]

map.updateAnnotation("annotation-1", {
  label: "A new label",
  lineColor: "#FF0000",
})

map.update_annotation("annotation-1", AnnotationUpdateProps(
  label="A new label",
  line_color="#FF0000",
))

addDataset(
  dataset: DatasetCreationProps,
  options?: AddDatasetOptions
): Dataset;

def add_dataset(
    self,
    dataset: Union[
        LocalDatasetCreationProps,
        RasterTileDatasetCreationProps,
        VectorTileDatasetCreationProps,
        Dict,
    ],
    *,
    auto_create_layers: bool = True,
    center_map: bool = True,
) -> Optional[Dataset]

// Assume dataset is a valid dataset

map.addDataset({
  id: "test-dataset-01",
  label: "Cities",
  color: [245, 166, 35],
  data: datasetData
},
{
  autoCreateLayers: true,
  centerMap: true
}
)

map.add_dataset(
    LocalDatasetCreationProps(
        id="test-data-id",
        data=TIME_DF,
    )
)

addTileDataset(
  dataset: TileDatasetCreationProps,
  options?: AddDatasetOptions
): Promise<Dataset>;`

def add_tile_dataset(
    self,
    dataset: Union[
        VectorTileDatasetRemoteCreationProps,
        RasterTileDatasetRemoteCreationProps,
        Dict,
    ],
    *,
    auto_create_layers: bool = True,
    center_map: bool = True,
) -> Optional[Dataset]

map.addTileDataset(
  {
    id: 'foo',
    type: 'raster-tile',
    label: 'Dataset',
    color: [0, 92, 255],
    metadata: {
      // NOTE: This must be a live, reachable URL
      metadataUrl: 'https://path.to.metadata.json'
    }
  },
  {
    autoCreateLayers: true,
    centerMap: true
  }
)

map.add_tile_dataset(RasterTileDatasetRemoteCreationProps(
    id="dataset-id",
    label="dataset-label",
    metadata=RasterTileRemoteMetadata(
        metadata_url=Url("http://example.com"),
    )
))

getDatasetById(
  datasetId: string
): Dataset | null;

get_dataset_by_id(
  self,
  dataset_id: str
) -> Optional[Dataset]:

dataset = map.getDatasetById('test-dataset-01');

dataset = map.get_dataset_by_id("test-dataset-01")

getDatasetWithData(
  datasetId: string
): DatasetWithData | null;`}

get_dataset_with_data(
  self,
  dataset_id: str
) -> Optional[DatasetWithData]

dataset = map.getDatasetWithData('test-dataset-01');

dataset = map.get_dataset_with_data('test-dataset-01')

getDatasets(): Dataset[];

get_datasets(self) -> List[Dataset]

datasets = map.getDatasets();

datasets = map.get_datasets()

removeDataset(
  datasetId: string
): void;

remove_dataset(
  self,
  dataset_id: str
)-> None

map.removeDataset('test-dataset-01');

map.remove_dataset('test-dataset-01')

replaceDataset(
  thisDatasetId: string,
  withDataset: DatasetCreationProps
  options?: ReplaceDatasetOptions
): Dataset;

def replace_dataset(
    self,
    this_dataset_id: str,
    with_dataset: Union[
        LocalDatasetCreationProps,
        RasterTileDatasetCreationProps,
        VectorTileDatasetCreationProps,
        Dict,
    ],
    *,
    force: bool = False,
    strict: bool = False,
) -> Dataset

// suppose newDataset is a valid Dataset object
map.replaceDataset('old-dataset-01', newDataset);

map.replace_dataset(
    this_dataset_id="dataset-id-to-replace",
    with_dataset=LocalDatasetCreationProps(
        data=my_data,
    ),
    strict=True
)

updateDataset(
  datasetId: string,
  values: DatasetUpdateProps
): Dataset;

def update_dataset(
    self,
    dataset_id: str,
    values: Union[DatasetUpdateProps, dict],
) -> Dataset

map.updateDataset(
  "test-dataset-01",
  {
    label: "Dataset",
    color: [245, 166, 35],
  }
);

map.update_dataset('dataset-id', DatasetUpdateProps(
    label="My new label",
    color=(255,0,0)
))

addFilter(filter: FilterCreationProps): Filter

def add_filter(
    self,
    filter: Union[
      PartialRangeFilter,
      PartialSelectFilter,
      PartialTimeRangeFilter,
      PartialMultiSelectFilter,
      dict
    ],
) -> Optional[Union[RangeFilter, SelectFilter, TimeRangeFilter, MultiSelectFilter]]

map.addFilter({
  "type": "range",
  "sources": [
    {
      "dataId": "test-dataset-filter",
      "fieldName": "Magnitude"
    }
  ],
  "value": [
    4,
    5
  ]
});

map.add_filter(PartialRangeFilter(
    sources=[PartialFilterSource(
        data_id="test-dataset-filter",
        field_name="Magnitude"
    )],
    value=(4,5)
))

addFilterFromConfig(filterConfig: FilterCreationFromConfigProps): Filter

add_filter_from_config(
  self,
  filter_config: Union[Dict, str]
) -> Filter:

map.addFilterFromConfig({
  name: ['time'],
  type: 'timeRange',
  dataId: [TIME_DATASET_ID],
  view: 'minified',
  value: [1655250010, 1655250990],
  animationWindow: 'free',
  yAxis: null,
  speed: 1,
  plotType: {
    type: 'histogram',
    interval: '1-minute',
    aggregation: 'SUM',
    defaultTimeFormat: 'L  LT'
  }
});

map.add_filter_from_config("""{
  "id": "test-filter",
  "type": "timeRange",
  "name": ["time"],
  "dataId": ["test-data-id"],
  "view": "minified",
  "value": [1655250010, 1655250990],
  "animationWindow": "free",
  "yAxis": null,
  "speed": 1,
  "plotType": { "type": "histogram" }
}""")

getFilterById(
  filterId: string
): Filter | null;

get_filter_by_id(
  self,
  filter_id: str
) -> Optional[Filter]`}

filter = map.getFilterById('test-filter-01');

filter = map.get_filter_by_id('test-filter-01')

getFilters(): Filter[];

get_filters(self) -> List[Filter]

filters = map.getFilters();

filters = map.get_filters()

removeFilter(
  filterId: string
): void;

remove_filter(
  self,
  filter_id: str
) -> None

map.removeFilter('test-filter-01');

map.remove_filter('test-filter-01')

updateFilter(
  filterId: string,
  values: FilterUpdateProps
): Filter;`

update_filter(
  self,
  filter_id: str,
  values: Union[FilterUpdateProps, dict, None] = None,
) -> Filter

map.addFilter('test-filter-1',{
  "type": "range",
  "sources": [
    {
      "dataId": "test-dataset-filter",
      "fieldName": "Magnitude"
    }
  ],
  "value": [
    5,
    6
  ]
})

def update_filter(
    self,
    filter_id: str,
    values: Union[
        PartialRangeFilter,
        PartialSelectFilter,
        PartialTimeRangeFilter,
        PartialMultiSelectFilter,
        dict,
    ],
) -> Union[RangeFilter, SelectFilter, TimeRangeFilter, MultiSelectFilter]

updateTimeline(
  filterId: string,
  values: FilterTimelineUpdateProps
): TimeRangeFilter;

def update_timeline(
    self,
    filter_id: str,
    values: Union[FilterTimelineUpdateProps, dict],
) -> TimeRangeFilter

map.updateTimeline('test-timeline-1', {
  timeFormat: 'DD/MM/YYYY',
  isAnimating: false
});

map.update_timeline("filter-id", FilterTimelineUpdateProps(
    view="side",
    is_animating=True
))

addLayer(
  layer: LayerCreationProps
): Layer;

def add_layer(self, layer: Union[LayerCreationProps, dict]) -> Optional[Layer]

map.addLayer({
  id: 'test-layer-01',
  type: 'point',
  dataId: 'test-dataset-01',
  label: 'New Layer',
  isVisible: true,
  fields: {
    lat: 'latitude',
    lng: 'longitude'
  },
  config: {
    visualChannels: {
      colorField: {
        name: 'cityName',
        type: 'string'
      },
      colorScale: 'ordinal'
    }
  }
});

map.add_layer(
    LayerCreationProps(
        id="test-layer-01",
        type=LayerType.POINT
        data_id="test-dataset-01",
        label="New Layer",
        is_visible=True,
        fields={"lat": "latitude", "lng": "longitude"},
        config={
            "visual_channels": {
                "color_field": {"name": "city_name", "type": "string"},
                "color_scale":"ordinal",
            }
        },
    )
)

addLayerFromConfig(layerConfig: LayerCreationFromConfigProps): Layer;

add_layer_from_config(
  self, layer_config: FullLayerConfig
) -> Layer:

map.addLayerFromConfig({
  type: 'point',
  config: {
    dataId: myDataset.id,
    columnMode: 'points',
    columns: {
      lat: 'lat',
      lng: 'lon'
    },
    visConfig: {},
    color: [0, 255, 0]
  }
});

# create a disctionary or...
map.add_layer_from_config(
  {
    "id": "sample-layer",
    "type": "point",
    "config": {
      "dataId": "sample-data",
      "label": "Sample layer",
      "columnMode": "points",
      "columns": {"lat": "Latitude", "lng": "Longitude"},
      "visConfig": {},
      "color": [0, 255, 0],
      "textLabel": [],
    },
  }
)

# ...paste a JSON string directly from the JSON editor
map.add_layer_from_config("""
{
  "id": "sample-layer-json-str",
  "type": "point",
  "config": {
    "dataId": "sample-data",
    "label": "Sample layer str",
    ...
    ...
    "columnMode": "points",
    "columns": {
    "lat": "Latitude",
    "lng": "Longitude"
    }
  },
  "visualChannels": {
    "colorField": null,
    "colorScale": "quantile",
    "strokeColorField": null,
    "strokeColorScale": "quantile",
    "sizeField": null,
    "sizeScale": "linear"
  }
}
""")

addLayerGroup(layerGroup: LayerGroup): LayerGroup;

def add_layer_group(
    self, layer_group: Union[LayerGroupCreationProps, dict]
) -> LayerGroup

map.addLayerGroup({
  id: 'layer-group-1',
  label: 'Layer Group 1',
  isVisible: true,
  layerIds: ['layer1', 'layer2', 'layer3']
});

map.add_layer_group(LayerGroupCreationProps(
    id="layer-group-1",
    label="Layer Group 1",
    is_visible=True,
    layer_ids=["layer1", "layer2", "layer3"]
))

getLayerById(
  layerId: string
): Layer | null;

def get_layer_by_id(
  self,
  layer_id: str
) -> Optional[Layer]

layer = map.getLayerById('test-layer-01');

layer = map.get_layer_by_id('test-layer-01')

getLayerGroupById(layerGroupId: string): LayerGroup | null;

get_layer_group_by_id(self, layer_group_id: str) -> Optional[LayerGroup]:

layerGroup = map.getLayerGroupById('layer-group-1');

layer_group = map.get_layer_group_by_id("layer-group-1")

getLayerGroups(): LayerGroup[];

get_layer_groups(self) -> List[LayerGroup]

layerGroups = map.getLayerGroups();

layer_groups = map.get_layer_groups()

getLayerTimeline(): LayerTimeline | null;

get_layer_timeline(self) -> Optional[LayerTimeline]:

layerTimeline = map.getLayerTimeline();

layer_timeline = map.get_layer_timeline()

getLayers(): Layer[];

get_layers(self) -> List[Layer]

layers = map.getLayers();

layers = map.get_layers()

getLayerTimeline(): LayerTimeline | null;

get_layer_timeline(self) -> Optional[LayerTimeline]:

layerTimeline = map.getLayerTimeline();

layer_timeline = map.get_layer_timeline()

removeLayer(
  layerId: string
): void;

remove_layer(
  self,
  layer_id: str
) -> None

map.removeLayer('test-layer-01');

map.remove_layer('test-layer-01')

removeLayerGroup(layerGroupId: string): void;

remove_layer_group(self, layer_group_id: str) -> None:

map.removeLayerGroup('layer-group-1');

remove_layer_group(self, layer_group_id: str) -> None:

updateLayer(
  layerId: string,
  values: LayerUpdateProps
): Layer;

def update_layer(
    self, layer_id: str, values: Union[LayerUpdateProps, dict]
) -> Layer

map.updateLayer({
  type: 'point',
  dataId: 'test-dataset-01',
  label: 'Updated Layer',
  isVisible: true,
  fields: {
    lat: 'latitude',
    lng: 'longitude',
    alt: 'altitude'
  },
  config: {
    visualChannels: {
      colorField: {
        name: 'cityName',
        type: 'string'
      }
    },
    visConfig: {
      radius: 10,
      fixedRadius: false,
      opacity: 0.8,
      outline: false,
      thickness: 2
    }
  }
});

map.update_layer('layer-id', LayerUpdateProps(
    label="My new label"
))

updateLayerGroup(layerGroupId: string, values: LayerGroupUpdateProps): LayerGroup;

def update_layer_group(
    self,
    layer_group_id: str,
    values: Union[LayerGroupUpdateProps, dict],
) -> LayerGroup

map.updateLayerGroup(
    "layer-group-1",
    {
      id: "layer-group-1",
      label: "Layer Group 1",
      isVisible: false,
      layerIds: ["layer1", "layer2". "layer3"]
    }
);

map.update_layer_group(LayerGroupUpdateProps(
    "layer-group-1",
    label = "New Layer Group 1",
    layers = ["layer1", "layer2"]
))

map.updateLayerTimeline({
    currentTime: 1660637600498,
    isAnimating: true,
    isVisible: true,
    animationSpeed: 1,
    timeFormat: "YYYY-MM-DDTHH:mm:ss",
    timezone: "America/Los_Angeles"
  }
);

def update_layer_timeline(
    self, values: Union[LayerTimelineUpdateProps, dict]
) -> LayerTimeline

map.updateLayerTimeline({
    currentTime: 1660637600498,
    isAnimating = true,
    isVisible = true,
    animationSpeed = 1,
    timeFormat = "YYYY-MM-DDTHH:mm:ss",
    timezone = "America/Los_Angeles"
  }
);

map.update_layer_timeline(LayerTimelineUpdateProps(
    current_time=1660637600498,
    is_animating=True,
    is_visible=True,
    animation_speed=1,
    time_format="YYYY-MM-DDTHH:mm:ss",
    timezone="America/Los_Angeles"
))

addToDOM(
  container: HTMLElement,
  style?: CSSProperties
): void;

map.addToDOM(container, foo.style);

addEffect(
  effect: EffectCreationProps
): Effect;

def add_effect(self, effect: Union[EffectCreationProps, dict]) -> Effect

map.addEffect({
  id: "example-effect",
  type: "light-and-shadow",
  parameters: {
    shadowIntensity: 0.5,
    shadowColor: [0, 0, 0],
    sunLightColor: [255, 255, 255],
    sunLightIntensity: 1,
    ambientLightColor: [255, 255, 255],
    ambientLightIntensity: 1,
    timeMode: "current",
  },
});

map.add_effect(
    EffectCreationProps(
        id="effect-id",
        type=EffectType.INK,
        is_enabled=False,
        parameters={"strength": 0.33},
    )
)

createMap(
  props: MapCreationProps
): Promise<MapApi>

def create_map(
    *,
    api_key: str,
    renderer: Literal["html", "widget", None] = None,
    initial_state: Optional[Dict] = None,
    style: Optional[Dict] = None,
    basemaps: Optional[Dict] = None,
    urls: Optional[Dict] = None,
    iframe: Optional[bool] = None,
    raster: Optional[Dict] = None,
    _internal: Optional[Dict] = None,
) -> Union[HTMLMap, SyncWidgetMap]

const map = createMap({apiKey: "<api-key>"});

map = create_map(api_key="<api-key>")

getEffectById(effectId: string): Effect | null;

get_effect_by_id(effect_id: str) -> Optional[Effect]:

effect = map.getEffectByID();

effect = map.get_effect_by_id()

getEffects(): Effect[];

get_effects(self) -> List[Effect]:

effects = map.getEffects();

effects = map.get_effects()

getMapConfig(): unknown;

get_map_config(self) -> dict:

mapConfig = map.getMapConfig();

map_config = map.get_map_config()

getMapControlVisibility(): MapControlVisibility;

get_map_control_visibility(self) -> MapControlVisibility

mapVisibilitySettings = map.getMapControlVisibility();

map_visibility_settings = map.get_map_control_visibility()

getMapStyles(): MapStyle[];

get_map_styles(self) -> List[MapStyle]

mapStyles = map.getMapStyles();

map_styles = map.get_map_styles()

getSplitMode(): SplitModeProps;

get_split_mode(self) -> SplitModeProps

splitMode = map.getSplitMode();

split_mode = map.get_split_mode();

getView(): View;

get_view(self) -> View

view = map.getView();

view = map.get_view()

getViewLimits(): ViewLimits;

get_view_limits(self) -> ViewLimits

viewLimits = map.getViewLimits();

view_limits = map.get_view_limits()

getViewMode(): ViewMode;

get_view_mode(self) -> ViewMode

viewMode = map.getViewMode();

view_mode = map.get_view_mode()

def remove_event_handlers(
    self, event_handlers: Sequence[Union[str, EventType]]
) -> None:

map.remove_event_handlers(["on_view_update"])

def set_event_handlers(self, event_handlers: Union[dict, EventHandlers]) -> None

map.set_event_handlers(EventHandlers(on_view_update=my_handler_func))

setMapConfig(
  config: object,
  options?: SetMapConfigOptions
): void;

set_map_config(
  self,
  config: dict,
  options: Optional[Union[dict, SetMapConfigOptions]] = None
) -> None:

map.setMapConfig({
  version: "v1",
  config: {
    visState: {
      filters: [],
      layers: [],
      interactionConfig: {
        tooltip: {
          fieldsToShow: {},
          compareMode: false,
          compareType: "absolute",
          enabled: true
        },
        brush: {
          size: 0.5,
          enabled: false
        },
        geocoder: {
          enabled: false
        },
        coordinate: {
          enabled: false
        }
      },
      layerBlending: "normal",
      overlayBlending: "normal",
      splitMaps: [],
      animationConfig: {
        currentTime: null,
        speed: 1
      },
      editor: {
        features: [],
        visible: true
      },
      metrics: [],
      geoKeys: [],
      groupBys: [],
      datasets: {
        fieldDisplayNames: {},
        fieldDisplayFormats: {},
        datasetColors: {}
      },
      joins: [],
      analyses: [],
      charts: []
    },
    mapState: {
      bearing: 0,
      dragRotate: false,
      latitude: 37.75043,
      longitude: -122.34679,
      pitch: 0,
      zoom: 9,
      isSplit: false,
      isViewportSynced: true,
      isZoomLocked: false,
      splitMapViewports: [],
      mapViewMode: "MODE_2D",
      mapSplitMode: "SINGLE_MAP",
      globe: {
        enabled: false,
        config: {
          atmosphere: true,
          azimuth: false,
          azimuthAngle: 45,
          terminator: true,
          terminatorOpacity: 0.35,
          basemap: true,
          labels: false,
          labelsColor: [
            114.75,
            114.75,
            114.75
          ],
          adminLines: true,
          adminLinesColor: [
            40,
            63,
            93
          ],
          water: true,
          waterColor: [
            17,
            35,
            48
          ],
          surface: true,
          surfaceColor: [
            9,
            16,
            29
          ]
        }
      }
    },
    mapStyle: {
      styleType: "dark",
      topLayerGroups: {},
      visibleLayerGroups: {
        label: true,
        road: true,
        border: false,
        building: true,
        water: true,
        land: true,
        3d building: false
      },
      threeDBuildingColor: [
        9.665468314072013,
        17.18305478057247,
        31.1442867897876
      ],
      backgroundColor: [
        255,
        255,
        255
      ],
      mapStyles: {}
    }
  }

map.set_map_config({
  "version": "v1",
  "config": {
    "visState": {
      "filters": [],
      "layers": [],
      "interactionConfig": {
        "tooltip": {
          "fieldsToShow": {},
          "compareMode": False,
          "compareType": "absolute",
          "enabled": True
        },
        "brush": {
          "size": 0.5,
          "enabled": False
        },
        "geocoder": {
          "enabled": False
        },
        "coordinate": {
          "enabled": False
        }
      },
      "layerBlending": "normal",
      "overlayBlending": "normal",
      "splitMaps": [],
      "animationConfig": {
        "currentTime": null,
        "speed": 1
      },
      "editor": {
        "features": [],
        "visible": True
      },
      "metrics": [],
      "geoKeys": [],
      "groupBys": [],
      "datasets": {
        "fieldDisplayNames": {},
        "fieldDisplayFormats": {},
        "datasetColors": {}
      },
      "joins": [],
      "analyses": [],
      "charts": []
    },
    "mapState": {
      "bearing": 0,
      "dragRotate": False,
      "latitude": 37.75043,
      "longitude": -122.34679,
      "pitch": 0,
      "zoom": 9,
      "isSplit": False,
      "isViewportSynced": True,
      "isZoomLocked": False,
      "splitMapViewports": [],
      "mapViewMode": "MODE_2D",
      "mapSplitMode": "SINGLE_MAP",
      "globe": {
        "enabled": False,
        "config": {
          "atmosphere": True,
          "azimuth": False,
          "azimuthAngle": 45,
          "terminator": True,
          "terminatorOpacity": 0.35,
          "basemap": True,
          "labels": False,
          "labelsColor": [
            114.75,
            114.75,
            114.75
          ],
          "adminLines": True,
          "adminLinesColor": [
            40,
            63,
            93
          ],
          "water": True,
          "waterColor": [
            17,
            35,
            48
          ],
          "surface": True,
          "surfaceColor": [
            9,
            16,
            29
          ]
        }
      }
    },
    "mapStyle": {
      "styleType": "dark",
      "topLayerGroups": {},
      "visibleLayerGroups": {
        "label": True,
        "road": True,
        "border": False,
        "building": True,
        "water": True,
        "land": True,
        "3d building": False
      },
      "threeDBuildingColor": [
        9.665468314072013,
        17.18305478057247,
        31.1442867897876
      ],
      "backgroundColor": [
        255,
        255,
        255
      ],
      "mapStyles": {}
    }
  }

setMapControlVisibility(
  visibility: Partial<MapControlVisibility>
): MapControlVisibility;

def set_map_control_visibility(
    self,
    visibility: Union[PartialMapControlVisibility, Dict[str, bool]],
) -> Optional[MapControlVisibility]

map.setMapControlVisibility({
  legend: false,
  map-draw: false,
  split-map: true,
  toggle-3d: false,
  chart: false
});

map.set_map_control_visibility(
    PartialMapControlVisibility(
      legend=False,
      toggle_3d=True
    )
)

map.setSplitMode('swipe', {
  layers: [['left_layer'], ['right_layer']],
  isViewSynced: true,
  isZoomSynced: true
});

def set_split_mode(
    self,
    split_mode: Literal["single", "dual", "swipe"],
    options: Union[PartialSplitModeContext, dict],
) -> Optional[SplitModeDetails]

map.setSplitMode('swipe', {
  layers: ['left_layer', 'right_layer'],
  isViewSynced: true,
  isZoomSynced: true
});

map.set_split_mode(split_mode='dual', options=PartialSplitModeContext(
    is_view_synced=True,
    is_zoom_synced=False,
))

setTheme(
  theme: ThemeUpdateProps
): void;

def set_theme(
    self,
    preset: Optional[Literal["light", "dark"]] = None,
    background_color: Optional[str] = None,
) -> None

map.setTheme({
  preset: 'light',
  options: {
    backgroundColor: 'lightseagreen'
  }
});

map.set_theme(
  preset="dark",
  background_color="lightseagreen"
)

setView(
  view: Partial<View>
): View;

def set_view(
    self, view: Union[PartialView, Dict[str, Number]], *, index: int = 0
) -> Optional[View]

map.setView({
  longitude: -118.8189,
  latitude: 34.01207,
  zoom: 10,
  pitch: 0,
  bearing: 0
});

map.set_view(PartialView(
    longitude = -118.8189,
    latitude = 34.01207,
    zoom = 10,
    pitch = 0,
    bearing = 0
))

setViewLimits(
  viewLimits: Partial<ViewLimits>,
  options?: SetViewLimitsOptions
): ViewLimits;

def set_view_limits(
    self,
    view_limits: Union[PartialViewLimits, dict],
    *,
    index: int = 0,
) -> Optional[ViewLimits]

map.setViewLimits({
  minZoom: 0,
  maxZoom: 22,
  maxBounds: {
    minLongitude: -122.4845632122524,
    maxLongitude: -121.7461580455235,
    minLatitude: 37.49028773126059,
    maxLatitude: 37.94131376494916
  }
});

map.set_view_limits(PartialViewLimits(
    min_zoom=0,
    max_zoom=22,
    max_bounds=Bounds(
        min_longitude=-122.4845632122524,
        max_longitude=-121.7461580455235,
        min_latitude=37.49028773126059,
        max_latitude=37.94131376494916
    )
))

setViewMode(
  viewMode: ViewMode
): ViewMode;

def set_view_mode(
    self,
    view_mode: Literal["2d", "3d", "globe"],
) -> Optional[Literal["2d", "3d", "globe"]]

map.setViewMode("3d");

map.set_view_mode("3d")

setViewFromConfig(
  viewConfig: ViewConfig
): void;

set_view_from_config(
    self,
    view_config: Union[Dict, str]
) -> None:

map.setViewFromConfig({
  isSplit: false,
  mapSplitMode: "SINGLE_MAP",
  mapViewMode: "MODE_2D",
  latitude: 37.3510537,
  longitude: -14.755157,
  zoom: 2.3,
  pitch: 0,
  bearing: 0
});

map.set_view_from_config("""{
  "isSplit": false,
  "mapSplitMode": "SINGLE_MAP",
  "mapViewMode": "MODE_2D",
  "latitude": 37.3510537,
  "longitude": -14.755157,
  "zoom": 2.3,
  "pitch": 0,
  "bearing": 0
}""")

setAnimationFromConfig(
  config: AnimationConfig
): void;

set_animation_from_config(
    self,
    animation_config: Union[dict, str, Animation, FilterAnimation]
) -> None:

map.setAnimationFromConfig({
  currentTime: 123,
  speed: 1.1,
  domain: [100, 200],
  timeFormat: 'L LTS'
});

map.set_animation_from_config("""{
    "currentTime": 1655251000,
    "domain": [1655250000, 1655251000],
    "speed": 1.2,
    "timeFormat": "L LTS"
}""")

updateEffect(
  effectId: string,
  values: EffectUpdateProps
): Effect;

def update_effect(
    self,
    effect_id: str,
    values: Union[EffectUpdateProps, dict],
) -> Optional[Effect]

map.updateEffect({
  id: "effect-id",
  isEnabled: false,
  parameters: {
    shadowIntensity: 0.75,
    shadowColor: [25, 50, 75]
  },
});

map.update_effect(
    "effect-id",
    values=EffectUpdateProps(
        is_enabled=True,
        parameters={"strength": 0.5}
    ),
)

setTooltipConfig: (
    config: TooltipInteractionConfig 
) => TooltipInteractionResponse;

def set_tooltip_config(
    self, tooltip_interaction_config: TooltipInteractionConfig
) -> Optional[TooltipInteractionResponse]:

map.setTooltipConfig({
  enabled: true,
  tooltipConfig: {
      fieldsToShow: {
        compareType: "relative",
        compareMode: true,
        "datasetId1": [{
            name: "lat",
            format: null
        }, {
            name: "lon",
            format: null
        }],
        "datasetId2": [{
            name: "datasetColumnName",
            format: null
        }]
      }
  },
})

map.set_tooltip_config(map.TooltipInteractionConfig(
    enabled=True,
    tooltip_config=map.TooltipConfig(
        compare_type="relative",
        compare_mode=True
        fields_to_show={
            "datasetId1": [
                map_sdk.TooltipField(name = "lat"),
                map_sdk.TooltipField(name = "lon"),
            ],
            "datasetId2: [
                map_sdk.TooltipField(name = "cdeldatasetColumnNameigibil"),
            ]
        }
    )
))