Types

type AnalyticsEventHandlers = {
  onUserEvent?: (event: UserEvent) => void
};

export type NoPayloadEvent =
  | RemoveDatasetEvent
  | AddLayerEvent
  | RemoveLayerEvent
  | AddLayerGroupEvent
  | RemoveLayerGroupEvent;

  assetUrls: string[];
  tileIndex: [number, number, number];
  remainingTiles: number;
  status: 'loading' | 'loaded' | 'canceled';
  error?: Error;

type UserEvent = NoPayloadEvent | MapControlClickedEvent | SidePanelSectionChangedEvent;

type MapControlClickedEvent = EventWithPayload<
  'activate-map-control',
  | {control: 'legend' | 'chart'}
  | {control: 'toggle-3d', mode: ViewMode}
  | {control: 'split-map', mode: SplitMode}
  | {control: 'map-draw', mode: DrawMode}
>;

type SidePanelSectionChangedEvent = EventWithPayload<
  'change-side-panel-section',
  {panel: SidePanelType}
>;

type UserEventType =
  | 'remove-dataset'
  | 'add-layer'
  | 'remove-layer'
  | 'add-layer-group'
  | 'remove-layer-group'
  | 'activate-map-control'
  | 'change-side-panel-section';

Annotation = {
  id: string;
  kind: 'POINT' | 'CIRCLE' | 'ARROW' | 'TEXT';
  isVisible: boolean;
  autoSize?: boolean;
  autoSizeY?: boolean;
  anchorPoint: AnchorPoint;
  label: string;
  editorState?: EditorState;
  mapIndex?: number;
  lineColor: string;
  lineWidth: number;
  textWidth: number;
  textHeight: number;
  textVerticalAlign?: 'top' | 'middle' | 'bottom';
  armLength?: number;
  angle?: number;
  radiusInMeters?: number;
};

class Annotation():
    id: StrictStr
    kind: Literal["TEXT", "ARROW", "POINT", "CIRCLE"]
    is_visible: StrictBool
    auto_size: Optional[StrictBool]
    auto_size_y: Optional[StrictBool]
    anchor_point: Tuple[float, float]
    label: StrictStr
    editor_state: Optional[Any]
    map_index: Optional[int]
    line_color: StrictStr
    line_width: float
    text_width: float
    text_height: float
    text_vertical_align: Literal["top", "middle", "bottom"]
    arm_length: Optional[float]
    angle: Optional[float]
    radius_in_meters: Optional[float]

export const editorContent = {
  root: {
    children: [
      {
        children: [
          {
            detail: 0,
            format: 0,
            mode: "normal",
            style: "",
            text: "This is ",
            type: "text",
            version: 1,
          },
          {
            detail: 0,
            format: 1,
            mode: "normal",
            style: "",
            text: "bold, ",
            type: "text",
            version: 1,
          },
          {
            detail: 0,
            format: 2,
            mode: "normal",
            style: "",
            text: "italic",
            type: "text",
            version: 1,
          },
          {
            detail: 0,
            format: 1,
            mode: "normal",
            style: "",
            text: ", ",
            type: "text",
            version: 1,
          },
          {
            detail: 0,
            format: 8,
            mode: "normal",
            style: "",
            text: "underline",
            type: "text",
            version: 1,
          },
          {
            detail: 0,
            format: 0,
            mode: "normal",
            style: "",
            text: ".",
            type: "text",
            version: 1,
          },
          {
            type: "linebreak",
            version: 1,
          },
          {
            children: [
              {
                detail: 0,
                format: 0,
                mode: "normal",
                style: "",
                text: "Link",
                type: "text",
                version: 1,
              },
            ],
            direction: "ltr",
            format: "",
            indent: 0,
            type: "link",
            version: 1,
            rel: "noopener noreferrer",
            target: "_blank",
            url: "https://studio.foursquare.com",
          },
          {
            detail: 0,
            format: 0,
            mode: "normal",
            style: "",
            text: ", ",
            type: "text",
            version: 1,
          },
          {
            detail: 0,
            format: 0,
            mode: "normal",
            style: "color: #C90000;",
            text: "red text",
            type: "text",
            version: 1,
          },
          {
            detail: 0,
            format: 0,
            mode: "normal",
            style: "",
            text: ", ",
            type: "text",
            version: 1,
          },
          {
            detail: 0,
            format: 0,
            mode: "normal",
            style: "background-color: #52A353;",
            text: "green bg",
            type: "text",
            version: 1,
          },
          {
            detail: 0,
            format: 0,
            mode: "normal",
            style: "",
            text: ".",
            type: "text",
            version: 1,
          },
        ],
        direction: "ltr",
        format: "",
        indent: 0,
        type: "paragraph",
        version: 1,
      },
      {
        children: [
          {
            detail: 0,
            format: 11,
            mode: "normal",
            style: "color: #C90000;background-color: #52A353;",
            text: "All styles",
            type: "text",
            version: 1,
          },
        ],
        direction: "ltr",
        format: "",
        indent: 0,
        type: "paragraph",
        version: 1,
      },
    ],
    direction: "ltr",
    format: "",
    indent: 0,
    type: "root",
    version: 1,
  },
};

editor_content = {
    "root": {
        "children": [
            {
                "children": [
                    {
                        "detail": 0,
                        "format": 0,
                        "mode": "normal",
                        "style": "",
                        "text": "This is ",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "detail": 0,
                        "format": 1,
                        "mode": "normal",
                        "style": "",
                        "text": "bold, ",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "detail": 0,
                        "format": 2,
                        "mode": "normal",
                        "style": "",
                        "text": "italic",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "detail": 0,
                        "format": 1,
                        "mode": "normal",
                        "style": "",
                        "text": ", ",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "detail": 0,
                        "format": 8,
                        "mode": "normal",
                        "style": "",
                        "text": "underline",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "detail": 0,
                        "format": 0,
                        "mode": "normal",
                        "style": "",
                        "text": ".",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "type": "linebreak",
                        "version": 1
                    },
                    {
                        "children": [
                            {
                                "detail": 0,
                                "format": 0,
                                "mode": "normal",
                                "style": "",
                                "text": "Link",
                                "type": "text",
                                "version": 1
                            }
                        ],
                        "direction": "ltr",
                        "format": "",
                        "indent": 0,
                        "type": "link",
                        "version": 1,
                        "rel": "noopener noreferrer",
                        "target": "_blank",
                        "url": "https://studio.foursquare.com"
                    },
                    {
                        "detail": 0,
                        "format": 0,
                        "mode": "normal",
                        "style": "",
                        "text": ", ",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "detail": 0,
                        "format": 0,
                        "mode": "normal",
                        "style": "color: #C90000;",
                        "text": "red text",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "detail": 0,
                        "format": 0,
                        "mode": "normal",
                        "style": "",
                        "text": ", ",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "detail": 0,
                        "format": 0,
                        "mode": "normal",
                        "style": "background-color: #52A353;",
                        "text": "green bg",
                        "type": "text",
                        "version": 1
                    },
                    {
                        "detail": 0,
                        "format": 0,
                        "mode": "normal",
                        "style": "",
                        "text": ".",
                        "type": "text",
                        "version": 1
                    }
                ],
                "direction": "ltr",
                "format": "",
                "indent": 0,
                "type": "paragraph",
                "version": 1
            },
            {
                "children": [
                    {
                        "detail": 0,
                        "format": 11,
                        "mode": "normal",
                        "style": "color: #C90000;background-color: #52A353;",
                        "text": "All styles",
                        "type": "text",
                        "version": 1
                    }
                ],
                "direction": "ltr",
                "format": "",
                "indent": 0,
                "type": "paragraph",
                "version": 1
            }
        ],
        "direction": "ltr",
        "format": "",
        "indent": 0,
        "type": "root",
        "version": 1
    }
}

type AddDatasetOptions = {
  autoCreateLayers?: boolean,
  centerMap?: boolean
};

type BaseDataset = {
  id: string,
  label: string,
  color: RGBColor,
  fields: Field[]
};

class BaseDataset():
  id: str
  type: string
  label: str
  color: RGBColor
  fields: List[Field]

type BaseDatasetCreationProps = Partial<Omit<BaseDataset, 'fields'>> & {
  data: string | object | unknown[][]
};

class DatasetCreationProps():
  id: Optional[str]
  label: Optional[str]
  color: Optional[RGBColor]
  data: Union[str, dict, List[List[Any]]]

type BaseField = {
  name: string,
  label: string
};

class BaseField():
    name: str
    label: str
    type: FieldType

type BasicField = BaseField & {
  type:
    | 'boolean'
    | 'date'
    | 'geojson'
    | 'integer'
    | 'real'
    | 'string'
    | 'array'
    | 'object'
    | 'point'
    | 'h3'
};

class BasicField(BaseField):
  type: BasicFieldType

class BasicFieldType(FieldType):
  BOOLEAN = "boolean"
  DATE = "date"
  GEOJSON = "geojson"
  INTEGER = "integer"
  REAL = "real"
  STRING = "string"
  ARRAY = "array"
  OBJECT = "object"
  POINT = "point"
  H3 = "h3"

type Dataset = LocalDataset | VectorTileDataset | RasterTileDataset;

Dataset = Union[LocalDataset, VectorTileDataset, RasterTileDataset]

type DatasetCreationProps =
  | LocalDatasetCreationProps
  | VectorTileDatasetCreationProps
  | RasterTileDatasetCreationProps;

class DatasetCreationProps() = Union[
    LocalDatasetCreationProps,
    VectorTileDatasetCreationProps,
    RasterTileDatasetCreationProps
  ]

class DatasetType(str, Enum):
    LOCAL = "local"
    VECTOR_TILE = "vector-tile"
    RASTER_TILE = "raster-tile

type DatasetUpdateProps = Partial<Pick<Dataset, 'label' | 'color'>>;

class _DatasetUpdateProps():
  label: Optional[str]
  color: Optional[RGBColor]
  fields: Optional[List[Field]]

type DatasetWithData = Dataset & {
  data: unknown[][]
};

class DatasetWithData(LocalDataset):
  data: List[List[Any]]

type DrawMode = 'select' | 'polygon' | 'rectangle';

type Field = BasicField | TimestampField;

Field = Union[BasicField, TimestampField]

type LocalDataset = BaseDataset & {
  type: 'local'
};

class LocalDataset(BaseDataset):
    type = DatasetType.LOCAL;

LocalDatasetCreationProps = BaseDatasetCreationProps & {
  type?: 'local';
  data: string | object | unknown[][];
};

type RasterTileCreationMetadata = {
  metadataUrl?: string,
  type: 'Feature',
  stac_version: string,
  extensions: string[],
  assets: Record<string, any>
};

type RasterTileDataset = BaseDataset & {
  type: 'raster-tile',
  metadata: RasterTileMetadata
};

class RasterTileDataset(BaseDataset):
  type = DatasetType.RASTER_TILE
  metadata: RasterTileMetadata

type RasterTileDatasetCreationProps = BaseDatasetCreationProps & {
  type: 'raster-tile',
  metadata: RasterTileCreationMetadata
};

type RasterTileDatasetRemoteCreationProps = BaseDatasetCreationProps & {
  type: 'raster-tile',
  metadata: RasterTileRemoteMetadata
};

class RasterTileLocalMetadata(RasterTileBaseMetadata):
    metadata_url: Optional[string]
    type: str = "Feature"
    stac_version: str = PydanticField(..., alias="stac_version")
    stac_extensions: List[str] = PydanticField(..., alias="stac_extensions")
    assets: Dict[str, Any]

type RasterTileMetadata = RasterTileCreationMetadata | RasterTileRemoteMetadata;

RasterTileMetadata = Union[RasterTileLocalMetadata, RasterTileRemoteMetadata]

type RasterTileRemoteMetadata = {
  metadataUrl: string
};

class RasterTileRemoteMetadata(RasterTileBaseMetadata):
  metadata_url: string

LocalDatasetCreationProps = BaseDatasetCreationProps & {
  type?: 'local';
  data: string | object | unknown[][];
};

type RGBColor = [number, number, number];

RGBColor = Tuple[Number, Number, Number]

type ReplaceDatasetOptions = {
  force?: boolean,
  strict?: boolean
};

type TileDatasetCreationProps =
  | VectorTileDatasetRemoteCreationProps
  | RasterTileDatasetRemoteCreationProps;

type TimestampField = BaseField & {
  type: 'timestamp',
  timeFormat: string
};

class TimestampField(BaseField):
  type: TimestampFieldType = TimestampFieldType.TIMESTAMP
  time_format: str

type VectorTileBaseMetadata = {
  dataUrl: string
};

class VectorTileBaseMetadata():
    data_url: string

type VectorTileCreationMetadata = VectorTileBaseMetadata & {
  metadataUrl?: string,
  bounds?: string | number[],
  center?: string | number[],
  maxzoom?: number,
  minzoom?: number,
  json: string | VectorTileEmbeddedMetadata
};

type VectorTileDataset = BaseDataset & {
  type: 'vector-tile',
  metadata: VectorTileMetadata
};

class VectorTileDataset(BaseDataset):
    type = DatasetType.VECTOR_TILE
    metadata: VectorTileMetadata

type VectorTileDatasetCreationProps = BaseDatasetCreationProps & {
  type: 'vector-tile',
  metadata: VectorTileCreationMetadata
};

type VectorTileDatasetRemoteCreationProps = BaseDatasetCreationProps & {
  type: 'vector-tile',
  metadata: VectorTileRemoteMetadata
};

class VectorTileLocalMetadata(VectorTileBaseMetadata):
  metadata_url: Optional[str]
  bounds: Optional[Union[str, List[Number]]]
  center: Optional[Union[str, List[Number]]]
  maxzoom: Optional[Number]
  minzoom: Optional[Number]

type VectorTileMetadata = VectorTileCreationMetadata | VectorTileRemoteMetadata;

VectorTileMetadata = Union[VectorTileLocalMetadata, VectorTileRemoteMetadata]

type VectorTileRemoteMetadata = VectorTileBaseMetadata & {
  metadataUrl: string
};

class VectorTileRemoteMetadata(VectorTileBaseMetadata):
    metadata_url: string

type BaseFilter<Type extends FilterType, Value> = {
  id: string;
  type: Type;
  sources: FilterSource[];
  value: Value;
};

class BaseFilter():
  id: Optional[str]
  type: FilterType
  sources: List[FilterSource]
  value: Any

type Filter = RangeFilter | SelectFilter | TimeRangeFilter | MultiSelectFilter;

Filter = Union[
  RangeFilter,
  SelectFilter,
  TimeRangeFilter,
  MultiSelectFilter,
]

type FilterCreationProps = Optional<
  Omit<Filter, 'sources'> & {sources: PartialFilterSource[]},
  'id'
>;`

FilterCreationProps = _PartialFilter

type FilterEventHandlers = {
  onFilterUpdate?: (filter: Filter) => void
};

class FilterEventHandlers():
    on_filter_update: Optional[Callable[[Filter], None]]

type FilterSource = {
  dataId: string,
  fieldName: string
};

class FilterSource():
  data_id: str
  field_name: str

type FilterTimeline = {
  view: 'side' | 'enlarged' | 'minified',
  timeFormat: string,
  timezone: string | null,
  isAnimating: boolean,
  animationSpeed: number,
  step: number
};

class FilterTimeline():
  view: FilterView
  time_format: str
  timezone: Optional[str]
  is_animating: bool
  animation_speed: Number
  step: Number

type FilterTimelineUpdateProps = Partial<Omit<FilterTimeline, 'step'>>;

class FilterTimelineUpdateProps():
    view: Optional[FilterView]
    time_format: Optional[str]
    timezone: Optional[str]
    is_animating: Optional[bool]
    animation_speed: Optional[Number]

type FilterType = 'range' | 'select' | 'time-range' | 'multi-select';

class FilterType(str, Enum):
    RANGE = "range"
    SELECT = "select"
    TIME_RANGE = "time-range"
    MULTI_SELECT = "multi-select"`

type FilterUpdateProps = Partial<Pick<Filter, 'value'> & {sources: PartialFilterSource[]}>;

FilterUpdateProps = _PartialFilter

Literal["side", "enlarged", "minified"]

type MultiSelectFilter = BaseFilter<'multi-select', string[]>;

class MultiSelectFilter(BaseFilter):
    type = FilterType.MULTI_SELECT
    value: List[str]

type PartialFilterSource = Optional<FilterSource, 'dataId'>;

PartialFilter = Union[
  PartialRangeFilter,
  PartialSelectFilter,
  PartialTimeRangeFilter,
  PartialMultiSelectFilter,
]

type RangeFilter = BaseFilter<'range', Range>;

class RangeFilter(BaseFilter):
    type = FilterType.RANGE
    value: Range

type SelectFilter = BaseFilter<'select', boolean>;

class SelectFilter(BaseFilter):
    type = FilterType.SELECT
    value: bool

type TimeRangeFilter = BaseFilter<'time-range', TimeRange> & {
  domain: TimeRange,
  timeline: FilterTimeline
};

class TimeRangeFilter(BaseFilter):
    type = FilterType.TIME_RANGE
    value: TimeRange
    domain: TimeRange
    timeline: FilterTimeline

type Layer = {
  id: string,
  type: LayerType | null,
  dataId: string,
  fields: Record<string, string | null>,
  label: string,
  isVisible: boolean,
  config: LayerConfig
};

class Layer(LayerCreationProps):
  id: str
  type: Optional[LayerType]
  data_id: str
  fields: Dict[str, Optional[str]]
  label: str
  is_visible: bool
  config: LayerConfig

type LayerConfig = {
  visualChannels: VisualChannels,
  visConfig: Record<string, unknown>
  columnMode?: 'points' | 'geojson' | 'table' | 'neighbors' | 'LAT_LNG' | 'H3';
};

class LayerConfig(PartialLayerConfig):
  visual_channels: VisualChannels
  vis_config: Dict[str, Any]
  column_mode: Optional[
        Literal["points", "geojson", "table", "neighbors", "LAT_LNG", "H3"]
    ]

type LayerCreationProps = Omit<
  Optional<Layer, 'id' | 'fields' | 'label' | 'isVisible'>,
  'config'
> & {
  config?: Partial<LayerConfig>
};

class LayerCreationProps(LayerUpdateProps):
  id: Optional[str]
  type: Optional[LayerType]
  data_id: Optional[str]
  fields: Dict[str, Optional[str]]
  label: Optional[str]
  is_visible: Optional[bool]
  config: Optional[PartialLayerConfig]

type LayerEventHandlers = {
  onLayerTimelineUpdate?: (layerTimeline: LayerTimeline) => void
};

class LayerEventHandlers():
  on_layer_timeline_update: Callable[[LayerTimeline], None]

type LayerTimeline = {
  currentTime: number,
  domain: TimeRange,
  isAnimating: boolean,
  isVisible: boolean,
  animationSpeed: number,
  timeFormat: string,
  timezone: string | null,
  timeSteps: number[] | null
};

class LayerTimelineUpdateProps():
  current_time: Optional[Number]
  domain: TimeRange
  is_animating: Optional[bool]
  is_visible: Optional[bool]
  animation_speed: Optional[Number]
  time_format: Optional[str]
  timezone: Optional[str]
  time_steps: Optional[List[Number]]

type LayerGroup = {
  id: string,
  label: string,
  isVisible: boolean,
  layerIds: string[]
};

class LayerGroup:
    id: StrictStr
    label: StrictStr
    is_visible: StrictBool
    layers: List[StrictStr]

type LayerTimelineUpdateProps = Partial<
  Pick<
    LayerTimeline,
    'currentTime' | 'isAnimating' | 'isVisible' | 'animationSpeed' | 'timeFormat' | 'timezone'
  >
>;

class LayerTimelineUpdateProps():
  current_time: Optional[Number]
  is_animating: Optional[bool]
  is_visible: Optional[bool]
  animation_speed: Optional[Number]
  time_format: Optional[str]
  timezone: Optional[str]

type LayerType =
  | 'point'
  | 'arc'
  | 'line'
  | 'grid'
  | 'hexagon'
  | 'geojson'
  | 'cluster'
  | 'icon'
  | 'heatmap'
  | 'h3'
  | '3d'
  | 'trip'
  | 's2'
  | 'raster-tile'
  | 'vector-tile';

class LayerType(str, Enum):
  POINT = "point"
  ARC = "arc"
  LINE = "line"
  GRID = "grid"
  HEXAGON = "hexagon"
  GEOJSON = "geojson"
  CLUSTER = "cluster"
  ICON = "icon"
  HEATMAP = "heatmap"
  H3 = "h3"
  THREE_D = "3d"
  TRIP = "trip"
  S2 = "s2"
  RASTER_TILE = "raster-tile"
  VECTOR_TILE = "vector-tile"

type LayerUpdateProps = Omit<PartialWithoutId<Layer>, 'config'> & {
  config?: Partial<LayerConfig>
};

class LayerUpdateProps():
  type: Optional[LayerType]
  data_id: str
  fields: Optional[Dict[str, Optional[str]]]
  label: Optional[str]
  is_visible: Optional[bool]
  config: Optional[PartialLayerConfig

class PartialLayerConfig():
    visual_channels: Optional[VisualChannels]
    vis_config: Optional[Dict[str, Any]]

type TileDatasetCreationProps =
  | VectorTileDatasetRemoteCreationProps
  | RasterTileDatasetRemoteCreationProps;
`}

class VisualChannel():
  name: str
  type: str

type VisualChannels = {
  [key: string]:
    | {
        name: string,
        type: string
      }
    | string
    | null
};

VisualChannels =
  Dict[str, Union[VisualChannel, str, None]]

type Bounds = {
  minLongitude: number,
  maxLongitude: number,
  minLatitude: number,
  maxLatitude: number
};

class Bounds():
  min_longitude: Number
  max_longitude: Number
  min_latitude: Number
  max_latitude: Number

type Effect = {
  id: string;
  type: EffectType;
  isEnabled: boolean;
  parameters: Record<string, number | [number, number] | [number, number, number] | string>;
};

class Effect():
    id: StrictStr
    type: EffectType
    is_enabled: StrictBool
    parameters: Optional[
        Dict[StrictStr, Union[Number, List[Number], StrictBool, StrictStr]]
    ]

EffectCreationProps = Optional<Effect, 'id' | 'isEnabled' | 'parameters'>;

_EffectCreationProps(_EffectUpdateProps):
    id: Optional[StrictStr]
    type: Optional[EffectType]
    is_enabled: Optional[StrictBool]
    parameters: Optional[
        Dict[StrictStr, Union[Number, List[Number], StrictBool, StrictStr]]
    ]

type EffectType =
  | 'ink'
  | 'brightness-contrast'
  | 'hue-saturation'
  | 'vibrance'
  | 'sepia'
  | 'dot-screen'
  | 'color-halftone'
  | 'noise'
  | 'triangle-blur'
  | 'zoom-blur'
  | 'tilt-shift'
  | 'edge-work'
  | 'vignette'
  | 'magnify'
  | 'hexagonal-pixelate'
  | 'light-and-shadow';

EffectType = [
  'ink',
  'brightness-contrast',
  'hue-saturation',
  'vibrance',
  'sepia',
  'dot-screen',
  'color-halftone',
  'noise',
  'triangle-blur',
  'zoom-blur',
  'tilt-shift',
  'edge-work',
  'vignette',
  'magnify',
  'hexagonal-pixelate',
  'light-and-shadow'
]

EffectUpdateProps = Omit<PartialWithoutId<Effect>, 'type'>;

_EffectUpdateProps(CamelCaseBaseModel):
    is_enabled: Optional[StrictBool]
    parameters: Optional[
        Dict[StrictStr, Union[Number, List[Number], StrictBool, StrictStr]]
    ]

type GeometrySelectionEvent = {
  features: Feature<Polygon>[]
};

class GeometrySelectionEvent():
  features: List[Feature[Polygon, Any]]

class HTMLMap(
    self,
    style: Optional[Dict] = None,
    basemaps: Optional[Dict] = None,
)`

type MapControlVisibility = {
  [control in MapControls]: boolean;
};

class MapControlVisibility():
  legend: bool
  toggle_3d: bool
  split_map: bool
  map_draw: bool

type MapControls = 'legend' | 'toggle-3d' | 'split-map' | 'map-draw';

type MapCreationProps = {
  container?: HTMLElement,
  style?: CSSProperties,
  eventHandlers?: MapEventHandlers,
  showPlaceholder?: boolean,
  initialState?: {
    publishedMapId: string;
  };
  basemaps?: {
    customMapStyles?: MapStyleCreationProps[],
    initialMapStyleId?: string,
    mapboxAccessToken?: string,
    transformRequest?: (opts: {url: string}) => RequestParameters
  },
  raster?: {
    serverUrls?: string[],
    stacSearchUrl?: string
    onTileLoadUpdate?: RasterTileLoadEvent
  },
  uiConfig?: {
    mapName?: string,
    sidePanel?: {
      view?: 'hidden' | 'collapsed' | 'visible',
      isAddLayerVisible?: boolean,
      addDataButton?: {
        onClick?: () => void
      }
    },
    exportEnabled?: boolean;
    sideNav?: {
      isVisible?: boolean
    }
  }
};

type MapEventHandlers = {
  onClick?: (event: MouseEvent) => void,
  onHover?: (event: MouseEvent) => void,
  onViewUpdate?: (view: View) => void,
  onGeometrySelection?: (event: GeometrySelectionEvent) => void
} & LayerEventHandlers &
  FilterEventHandlers;

class MapEventHandlers():
  on_click: Optional[OnClickHandlerType]
  on_hover: Optional[OnHoverHandlerType]
  on_view_update: Optional[OnViewUpdateType]
  on_geometry_selection: Optional[OnGeometrySelectionType]

type MapStyle = {
  id: string,
  label: string,
  url: string,
  thumbnailUrl: string,
  layerGroups: MapStyleLayerGroup[]
};

class MapStyle():
  id: str
  label: str
  url: str
  thumbnail_url: str
  layer_groups: List[MapStyleLayerGroup]

type MapStyleCreationProps = Merge<
  Optional<MapStyle, 'id' | 'thumbnailUrl'>,
  {layerGroups?: MapStyleLayerGroupCreationProps[]}
>;

class MapStyleCreationProps():
  id: Optional[str]
  thumbnail_url: Optional[str]
  layer_groups: Optional[List[MapStyleLayerGroupCreationProps]]

type MapStyleLayerGroup = {
  label: string,
  defaultVisibility: boolean
};

class MapStyleLayerGroup():
  label: str
  default_visibility: bool

type MapStyleLayerGroupCreationProps = MapStyleLayerGroup & {
  filter: string
};

class MapStyleLayerGroupCreationProps(MapStyleLayerGroup):
  filter: str

type MouseEvent = {
  coordinate: [number, number],
  position: [number, number],
  pickInfo?: {
    layerId: string,
    rowIndex: number,
    rowData: unknown[]
  }
};

class MouseEvent():
  coordinate: Tuple[Number, Number]
  position: Tuple[Number, Number]
  pick_info: Optional[PickInfo]

OnClickHandlerType = Callable[([MouseEvent], None)];

OnGeometrySelectionType = Callable[[GeometrySelectionEvent], None]

OnHoverHandlerType = Callable[[MouseEvent], None]

OnViewUpdateType = Callable[[View], None]

class PickInfo():
  layer_id: str
  row_index: Number
  row_data: List[Any]

type RequestParameters = {
  url: string;
  headers?: {[header: string]: string};
  method?: 'GET' | 'POST' | 'PUT';

type SetMapConfigOptions = {
  additionalDatasets?: DatasetCreationProps[]
};

class SetMapConfigOptions():
    additional_datasets: Optional[List[_DatasetCreationProps]]

type SetSplitModeOptions: Partial<SplitModeContext>

type SidePanelType = 'layer' | 'column' | 'filter' | 'interaction' | 'map' | 'analysis';

type SplitMode = 'single' | 'dual' | 'swipe';

SplitMode = Literal["single", "dual", "swipe"]

type SplitModeProps={
    splitMode: SplitMode
    layers: Optional[SplitLayers]
};

class SplitModeProps():
    split_mode: SplitMode
    layers: Optional[SplitLayers]

type SplitModeContext = {
  layers: string[][],
  isViewSynced: boolean,
  isZoomSynced: boolean
};

export type SplitModeDetails = {
  splitMode: SplitMode
} & SplitModeContext;

SplitLayers = List[List[str]]

type StudioLoadingProps = {
  url: string,
  namespace?: string
};

class SyncWidgetMap(
    self,
    *,
    style: Optional[Dict] = None,
    basemaps: Optional[Dict] = None,
    raster: Optional[Dict] = None,
    studio: Optional[Dict] = None,
)