Server API Interface

/**
 * Gws Server API.
 * Version 5.2.20
 */

type _int = number;
type _float = number;
type _bytes = any;
type _dict = {[k: string]: any};

/// Data object.
export interface Data {

}

/// 
export interface Params extends Data {
    /// locale for this request
    locale?: string;
    /// project uid
    projectUid?: string;
}

/// 
export interface GekosGetFsParams extends Params {
    /// 
    alkisAd?: string;
    /// 
    alkisFs?: string;
}

/// 
export interface ResponseError extends Data {
    /// 
    info: string;
    /// 
    status: _int;
}

/// 
export interface Response extends Data {
    /// 
    error?: ResponseError;
}

export enum AttributeType {
    bool = "bool",
    bytes = "bytes",
    date = "date",
    datetime = "datetime",
    float = "float",
    geometry = "geometry",
    int = "int",
    list = "list",
    str = "str",
    text = "text",
    time = "time",
};

/// 
export interface Attribute extends Data {
    /// 
    editable?: boolean;
    /// 
    name: string;
    /// 
    title?: string;
    /// 
    type?: AttributeType;
    /// 
    value: any;
}

export type AttributeList = Array<Attribute>;

/// Properties base type
export interface Props extends Data {

}

/// 
export interface ShapeProps extends Props {
    /// 
    crs: string;
    /// 
    geometry: _dict;
}

export enum StyleType {
    css = "css",
    cssSelector = "cssSelector",
};

export type Color = string;

export enum StyleLabelAlign {
    center = "center",
    left = "left",
    right = "right",
};

export enum StyleLabelFontStyle {
    italic = "italic",
    normal = "normal",
};

export enum StyleLabelFontWeight {
    bold = "bold",
    normal = "normal",
};

export type intList = Array<_int>;

export enum StyleLabelPlacement {
    end = "end",
    middle = "middle",
    start = "start",
};

export enum StyleStrokeLineCap {
    butt = "butt",
    round = "round",
    square = "square",
};

export enum StyleStrokeLineJoin {
    bevel = "bevel",
    miter = "miter",
    round = "round",
};

export enum StyleMarker {
    arrow = "arrow",
    circle = "circle",
    cross = "cross",
    square = "square",
};

export enum StyleGeometryOption {
    all = "all",
    none = "none",
};

export enum StyleLabelOption {
    all = "all",
    none = "none",
};

/// 
export interface StyleValues extends Data {
    /// 
    fill?: Color;
    /// 
    icon?: string;
    /// 
    label_align?: StyleLabelAlign;
    /// 
    label_background?: Color;
    /// 
    label_fill?: Color;
    /// 
    label_font_family?: string;
    /// 
    label_font_size?: _int;
    /// 
    label_font_style?: StyleLabelFontStyle;
    /// 
    label_font_weight?: StyleLabelFontWeight;
    /// 
    label_line_height?: _int;
    /// 
    label_max_scale?: _int;
    /// 
    label_min_scale?: _int;
    /// 
    label_offset_x?: _int;
    /// 
    label_offset_y?: _int;
    /// 
    label_padding?: intList;
    /// 
    label_placement?: StyleLabelPlacement;
    /// 
    label_stroke?: Color;
    /// 
    label_stroke_dasharray?: intList;
    /// 
    label_stroke_dashoffset?: _int;
    /// 
    label_stroke_linecap?: StyleStrokeLineCap;
    /// 
    label_stroke_linejoin?: StyleStrokeLineJoin;
    /// 
    label_stroke_miterlimit?: _int;
    /// 
    label_stroke_width?: _int;
    /// 
    marker?: StyleMarker;
    /// 
    marker_fill?: Color;
    /// 
    marker_size?: _int;
    /// 
    marker_stroke?: Color;
    /// 
    marker_stroke_dasharray?: intList;
    /// 
    marker_stroke_dashoffset?: _int;
    /// 
    marker_stroke_linecap?: StyleStrokeLineCap;
    /// 
    marker_stroke_linejoin?: StyleStrokeLineJoin;
    /// 
    marker_stroke_miterlimit?: _int;
    /// 
    marker_stroke_width?: _int;
    /// 
    offset_x?: _int;
    /// 
    offset_y?: _int;
    /// 
    point_size?: _int;
    /// 
    stroke?: Color;
    /// 
    stroke_dasharray?: intList;
    /// 
    stroke_dashoffset?: _int;
    /// 
    stroke_linecap?: StyleStrokeLineCap;
    /// 
    stroke_linejoin?: StyleStrokeLineJoin;
    /// 
    stroke_miterlimit?: _int;
    /// 
    stroke_width?: _int;
    /// 
    with_geometry?: StyleGeometryOption;
    /// 
    with_label?: StyleLabelOption;
}

/// 
export interface StyleProps extends Props {
    /// 
    text?: string;
    /// 
    type: StyleType;
    /// 
    values?: StyleValues;
}

/// 
export interface FeatureProps extends Data {
    /// 
    attributes?: AttributeList;
    /// 
    elements?: _dict;
    /// 
    layerUid?: string;
    /// 
    shape?: ShapeProps;
    /// 
    style?: StyleProps;
    /// 
    uid?: string;
}

/// 
export interface GekosGetFsResponse extends Response {
    /// 
    feature: FeatureProps;
}

/// 
export interface UserProps extends Data {
    /// 
    displayName: string;
}

/// 
export interface AuthResponse extends Response {
    /// 
    user: UserProps;
}

/// 
export interface AuthLoginParams extends Params {
    /// 
    password: string;
    /// 
    username: string;
}

/// 
export interface ProjectInfoParams extends Params {

}

export type strList = Array<string>;

/// 
export interface IntlLocaleData extends Data {
    /// 
    dateFormatLong: string;
    /// 
    dateFormatMedium: string;
    /// 
    dateFormatShort: string;
    /// date unit names, e.g. 'YMD' for 'en', 'JMT' for 'de'
    dateUnits: string;
    /// 
    daysLong: strList;
    /// 
    daysShort: strList;
    /// 
    firstWeekDay: _int;
    /// 
    id: string;
    /// 
    language: string;
    /// 
    languageName: string;
    /// 
    monthsLong: strList;
    /// 
    monthsShort: strList;
    /// 
    numberDecimal: string;
    /// 
    numberGroup: string;
}

/// 
export interface GeorisksProps extends Props {
    /// 
    privacyPolicyLink: string;
}

/// Gemarkung (Administrative Unit) object
export interface AlkisGemarkung extends Data {
    /// Gemarkung name
    gemarkung: string;
    /// Gemarkung uid
    gemarkungUid: string;
    /// Gemeinde name
    gemeinde: string;
    /// Gemeinde uid
    gemeindeUid: string;
}

export type AlkisGemarkungList = Array<AlkisGemarkung>;

export type FormatStr = string;

/// 
export interface ModelRule extends Data {
    /// 
    editable: boolean;
    /// 
    expression: string;
    /// 
    format: FormatStr;
    /// 
    name: string;
    /// 
    source: string;
    /// 
    title: string;
    /// 
    type: AttributeType;
    /// 
    value?: string;
}

export type ModelRuleList = Array<ModelRule>;

/// 
export interface ModelProps extends Props {
    /// 
    rules: ModelRuleList;
}

/// 
export interface TemplateQualityLevel extends Data {
    /// 
    dpi: _int;
    /// 
    name: string;
}

export type TemplateQualityLevelList = Array<TemplateQualityLevel>;

/// 
export interface TemplateProps extends Props {
    /// 
    dataModel: ModelProps;
    /// 
    mapHeight: _int;
    /// 
    mapWidth: _int;
    /// 
    qualityLevels: TemplateQualityLevelList;
    /// 
    title: string;
    /// 
    uid: string;
}

/// Configuration base type
export interface Config extends Data {
    /// unique ID
    uid?: string;
}

/// Flurstückssuche UI configuration.
export interface AlkissearchUiConfig extends Config {
    /// activate spatial search after submit
    autoSpatialSearch?: boolean;
    /// plain = only "gemarkung", combined = "gemarkung(gemeinde)", tree = "gemeinde", then "gemarkung"
    gemarkungListMode?: string;
    /// search in selection enabled
    searchSelection?: boolean;
    /// spatial search enabled
    searchSpatial?: boolean;
    /// export function enabled
    useExport?: boolean;
    /// pick mode enabled
    usePick?: boolean;
    /// select mode enabled
    useSelect?: boolean;
}

/// 
export interface AlkissearchProps extends Props {
    /// 
    exportGroups: _dict;
    /// 
    gemarkungen: AlkisGemarkungList;
    /// 
    limit: _int;
    /// 
    printTemplate: TemplateProps;
    /// 
    type: 'alkissearch';
    /// 
    ui: AlkissearchUiConfig;
    /// 
    withBuchung: boolean;
    /// 
    withControl: boolean;
    /// 
    withEigentuemer: boolean;
    /// 
    withFlurnummer: boolean;
}

/// 
export interface DimensionProps extends Props {
    /// 
    layerUids?: strList;
    /// 
    pixelTolerance: _int;
    /// 
    type: 'dimensions';
}

export type ActionProps = AlkissearchProps | DimensionProps | GeorisksProps;

export type ActionPropsList = Array<ActionProps>;

/// 
export interface ClientElementProps extends Data {
    /// 
    tag: string;
}

export type ClientElementPropsList = Array<ClientElementProps>;

/// 
export interface ClientProps extends Data {
    /// 
    elements?: ClientElementPropsList;
    /// 
    options?: _dict;
}

export type Point = [_float, _float];

export type Extent = [_float, _float, _float, _float];

export enum GeometryType {
    curve = "CURVE",
    geomcollection = "GEOMCOLLECTION",
    geometry = "GEOMETRY",
    linestring = "LINESTRING",
    multicurve = "MULTICURVE",
    multilinestring = "MULTILINESTRING",
    multipoint = "MULTIPOINT",
    multipolygon = "MULTIPOLYGON",
    multisurface = "MULTISURFACE",
    point = "POINT",
    polygon = "POLYGON",
    polyhedralsurface = "POLYHEDRALSURFACE",
    surface = "SURFACE",
};

/// 
export interface MetaContact extends Data {
    /// 
    address: string;
    /// 
    area: string;
    /// 
    city: string;
    /// 
    country: string;
    /// 
    email: string;
    /// 
    fax: string;
    /// 
    organization: string;
    /// 
    person: string;
    /// 
    phone: string;
    /// 
    position: string;
    /// 
    url: string;
    /// 
    zip: string;
}

export type Url = string;

/// 
export interface MetaLink extends Data {
    /// 
    function: string;
    /// 
    scheme: string;
    /// 
    url: Url;
}

export type MetaLinkList = Array<MetaLink>;

/// 
export interface MetaData extends Data {
    /// 
    abstract: string;
    /// 
    accessConstraints: string;
    /// 
    attribution: string;
    /// 
    contact: MetaContact;
    /// 
    fees: string;
    /// 
    image: Url;
    /// 
    images: _dict;
    /// 
    inspire: _dict;
    /// 
    iso: _dict;
    /// 
    keywords: strList;
    /// 
    language: string;
    /// 
    links: MetaLinkList;
    /// 
    modDate: string;
    /// 
    name: string;
    /// 
    pubDate: string;
    /// 
    serviceUrl: Url;
    /// 
    title: string;
    /// 
    uid: string;
    /// 
    url: Url;
}

/// Client options for a layer
export interface ClientOptions extends Data {
    /// only one of this layer's children is visible at a time
    exclusive?: boolean;
    /// the layer is expanded in the list view
    expanded?: boolean;
    /// the layer is displayed in this list view
    listed?: boolean;
    /// the layer is intially selected
    selected?: boolean;
    /// the layer is not listed, but its children are
    unfolded?: boolean;
    /// the layer is intially visible
    visible?: boolean;
}

export type floatList = Array<_float>;

/// 
export interface LayerProps extends Data {
    /// 
    editAccess?: strList;
    /// 
    editStyle?: StyleProps;
    /// 
    extent?: Extent;
    /// 
    geometryType?: GeometryType;
    /// 
    layers?: LayerPropsList;
    /// 
    loadingStrategy?: string;
    /// 
    meta: MetaData;
    /// 
    opacity?: _float;
    /// 
    options: ClientOptions;
    /// 
    resolutions?: floatList;
    /// 
    style?: StyleProps;
    /// 
    tileSize?: _int;
    /// 
    title?: string;
    /// 
    type: string;
    /// 
    uid: string;
    /// 
    url?: string;
}

export type LayerPropsList = Array<LayerProps>;

/// 
export interface MapProps extends Data {
    /// 
    center: Point;
    /// 
    coordinatePrecision: _int;
    /// 
    crs: string;
    /// 
    crsDef?: string;
    /// 
    extent: Extent;
    /// 
    initResolution: _float;
    /// 
    layers: LayerPropsList;
    /// 
    resolutions: floatList;
    /// 
    title?: string;
}

export type TemplatePropsList = Array<TemplateProps>;

/// 
export interface PrinterProps extends Data {
    /// 
    templates: TemplatePropsList;
}

/// 
export interface ProjectProps extends Data {
    /// 
    actions: ActionPropsList;
    /// 
    client?: ClientProps;
    /// 
    description: string;
    /// 
    locales: strList;
    /// 
    map: MapProps;
    /// 
    meta: MetaData;
    /// 
    overviewMap: MapProps;
    /// 
    printer: PrinterProps;
    /// 
    title: string;
    /// 
    uid: string;
}

/// 
export interface ProjectInfoResponse extends Response {
    /// 
    localeData: IntlLocaleData;
    /// 
    project: ProjectProps;
    /// 
    user?: UserProps;
}

export type Crs = string;

/// 
export interface MapRenderBoxParams extends Params {
    /// 
    bbox: Extent;
    /// 
    crs?: Crs;
    /// 
    dpi?: _int;
    /// 
    height: _int;
    /// 
    layerUid: string;
    /// 
    layers?: strList;
    /// 
    width: _int;
}

/// 
export interface HttpResponse extends Response {
    /// 
    content: string;
    /// 
    mime: string;
    /// 
    status: _int;
}

/// 
export interface MapRenderXyzParams extends Params {
    /// 
    layerUid: string;
    /// 
    x: _int;
    /// 
    y: _int;
    /// 
    z: _int;
}

/// 
export interface MapRenderLegendParams extends Params {
    /// 
    layerUid: string;
}

/// 
export interface MapDescribeLayerParams extends Params {
    /// 
    layerUid: string;
}

/// 
export interface MapDescribeLayerResponse extends Params {
    /// 
    description: string;
}

/// 
export interface MapGetFeaturesParams extends Params {
    /// 
    bbox?: Extent;
    /// 
    crs?: Crs;
    /// 
    layerUid: string;
    /// 
    limit?: _int;
    /// 
    resolution?: _float;
}

export type FeaturePropsList = Array<FeatureProps>;

/// 
export interface MapGetFeaturesResponse extends Response {
    /// 
    features: FeaturePropsList;
}

export type ShapePropsList = Array<ShapeProps>;

/// 
export interface DproconConnectParams extends Params {
    /// 
    shapes: ShapePropsList;
}

/// 
export interface DproconConnectResponse extends Response {
    /// 
    url: string;
}

/// 
export interface DproconGetDataParams extends Params {
    /// 
    requestId: string;
}

/// 
export interface DproconGetDataResponse extends Data {
    /// 
    feature: FeatureProps;
}

/// 
export interface PrintItemBase extends Data {
    /// 
    opacity?: _float;
    /// 
    style?: StyleProps;
}

/// 
export interface PrintItemBitmap extends PrintItemBase {
    /// 
    data: _bytes;
    /// 
    height: _int;
    /// 
    mode: string;
    /// 
    type: 'bitmap';
    /// 
    width: _int;
}

/// 
export interface PrintItemUrl extends PrintItemBase {
    /// 
    type: 'url';
    /// 
    url: string;
}

/// 
export interface PrintItemFeatures extends PrintItemBase {
    /// 
    features: FeaturePropsList;
    /// 
    type: 'features';
}

/// 
export interface PrintItemRaster extends PrintItemBase {
    /// 
    layerUid: string;
    /// 
    subLayers?: strList;
    /// 
    type: 'raster';
}

/// 
export interface PrintItemVector extends PrintItemBase {
    /// 
    layerUid: string;
    /// 
    type: 'vector';
}

export type PointList = Array<Point>;

/// 
export interface SvgFragment {
    /// 
    points: PointList;
    /// 
    svg: string;
}

/// 
export interface PrintItemFragment extends PrintItemBase {
    /// 
    fragment: SvgFragment;
    /// 
    type: 'fragment';
}

export type PrintItem = PrintItemBitmap | PrintItemFeatures | PrintItemFragment | PrintItemRaster | PrintItemUrl | PrintItemVector;

export type PrintItemList = Array<PrintItem>;

/// 
export interface PrintSection extends Data {
    /// 
    center: Point;
    /// 
    context?: _dict;
    /// 
    items?: PrintItemList;
}

export type PrintSectionList = Array<PrintSection>;

/// 
export interface PrintParamsBase extends Params {
    /// 
    crs?: Crs;
    /// 
    format?: string;
    /// 
    items: PrintItemList;
    /// 
    rotation?: _int;
    /// 
    scale: _int;
    /// 
    sections?: PrintSectionList;
}

/// 
export interface PrintParamsWithTemplate extends PrintParamsBase {
    /// 
    quality: _int;
    /// 
    templateUid: string;
    /// 
    type: 'template';
}

/// 
export interface PrintParamsWithMap extends PrintParamsBase {
    /// 
    dpi: _int;
    /// 
    mapHeight: _int;
    /// 
    mapWidth: _int;
    /// 
    type: 'map';
}

export type PrintParams = PrintParamsWithMap | PrintParamsWithTemplate;

export enum JobState {
    cancel = "cancel",
    complete = "complete",
    error = "error",
    init = "init",
    open = "open",
    running = "running",
};

/// 
export interface PrinterResponse extends Response {
    /// 
    jobUid?: string;
    /// 
    progress?: _int;
    /// 
    state: JobState;
    /// 
    stepname?: string;
    /// 
    steptype?: string;
    /// 
    url?: string;
}

/// 
export interface PrinterQueryParams extends Params {
    /// 
    jobUid: string;
}

/// 
export interface SearchParams extends Params {
    /// 
    bbox?: Extent;
    /// 
    crs?: Crs;
    /// 
    keyword?: string;
    /// 
    layerUids: strList;
    /// 
    limit?: _int;
    /// 
    resolution: _float;
    /// 
    shapes?: ShapePropsList;
    /// 
    tolerance?: string;
    /// 
    withAttributes?: boolean;
    /// 
    withDescription?: boolean;
    /// 
    withGeometry?: boolean;
}

/// 
export interface SearchResponse extends Response {
    /// 
    features: FeaturePropsList;
}

/// 
export interface AlkisgeocoderGeocoderAddress extends Data {
    /// 
    gemarkung?: string;
    /// 
    gemeinde?: string;
    /// 
    hausnummer?: string;
    /// 
    strasse?: string;
}

export type AlkisgeocoderGeocoderAddressList = Array<AlkisgeocoderGeocoderAddress>;

/// 
export interface AlkisgeocoderGeocoderParams extends Data {
    /// 
    adressen: AlkisgeocoderGeocoderAddressList;
    /// 
    crs: Crs;
}

/// 
export interface AlkisgeocoderGeocoderResponse extends Response {
    /// 
    coordinates: PointList;
}

/// 
export interface CloudSource extends Data {
    /// binary content
    content?: _bytes;
    /// text content
    text?: string;
}

export enum CloudAssetType {
    svg = "svg",
};

/// Media asset for the map
export interface CloudAsset extends Data {
    /// file name, as used in the map source
    name: string;
    /// file source
    source: CloudSource;
    /// type, e.g. "svg"
    type: CloudAssetType;
}

export type CloudAssetList = Array<CloudAsset>;

export type dictList = Array<_dict>;

/// Data set for a cloud project.
export interface CloudDataSet extends Data {
    /// list of data records
    records: dictList;
    /// data set uid as used in the map
    uid: string;
}

export type CloudDataSetList = Array<CloudDataSet>;

export enum CloudMapType {
    qgis = "qgis",
};

/// Cloud project map
export interface CloudMap extends Data {
    /// map assets
    assets?: CloudAssetList;
    /// data for the map
    data?: CloudDataSetList;
    /// layer ids to use in the cloud
    layerUids?: strList;
    /// map source code (e.g. a QGIS project)
    source: CloudSource;
    /// map type
    type: CloudMapType;
}

/// Parameters for the CreateProject command
export interface CloudCreateProjectParams extends Params {
    /// project map
    map: CloudMap;
    /// project name
    projectName: string;
    /// API user key
    userKey: string;
    /// API user ID
    userUid: string;
}

/// 
export interface CloudCreateProjectResponse extends Response {

}

/// A file attached to a report.
export interface GeorisksReportFile {
    /// file content as a byte array
    content: _bytes;
}

export type GeorisksReportFileList = Array<GeorisksReportFile>;

/// Params for the createReport action
export interface GeorisksCreateReportParams extends Params {
    /// 
    category: string;
    /// 
    dangers: strList;
    /// event date
    date: string;
    /// attached files
    files?: GeorisksReportFileList;
    /// 
    height?: string;
    /// 
    kind?: string;
    /// user message
    message?: string;
    /// spatial shape of the report
    shape: ShapeProps;
    /// 
    volume?: string;
}

/// Response of the createReport action.
export interface GeorisksCreateReportResponse extends Response {
    /// id of the created report
    reportUid: _int;
}

/// Params for the reportStatus action
export interface GeorisksReportStatusParams extends Params {
    /// uids to query
    reportUids: intList;
}

export enum GeorisksReportStatus {
    approved = 2,
    error = 99,
    open = 0,
    process = 1,
    rejected = 3,
};

/// Status of a single report.
export interface GeorisksReportStatusItem {
    /// ISO-formatted change date
    date: string;
    /// report status reason
    reason: string;
    /// report id
    reportUid: _int;
    /// status value
    status: GeorisksReportStatus;
}

export type GeorisksReportStatusItemList = Array<GeorisksReportStatusItem>;

/// 
export interface GeorisksReportStatusResponse extends Response {
    /// 
    items: GeorisksReportStatusItemList;
}

/// 
export interface NoParams extends Data {

}

/// Details of a single report.
export interface GeorisksReportListItem {
    /// 
    category: string;
    /// 
    dangers: strList;
    /// ISO-formatted change date
    date: string;
    /// 
    height: string;
    /// 
    images: strList;
    /// 
    kind: string;
    /// 
    message: string;
    /// report id
    reportUid: _int;
    /// spatial shape of the report
    shape: ShapeProps;
    /// spatial shape of the report in the EPSG:4326 crs
    shape4326: ShapeProps;
    /// 
    volume: string;
}

export type GeorisksReportListItemList = Array<GeorisksReportListItem>;

/// 
export interface GeorisksReportListResponse extends Response {
    /// 
    items: GeorisksReportListItemList;
}

/// 
export interface AlkissearchFindParams extends Params {
    /// 
    gemarkung?: string;
    /// 
    gemarkungOrGemeindeUid?: string;
    /// 
    gemarkungUid?: string;
    /// 
    gemeinde?: string;
    /// 
    gemeindeUid?: string;
}

/// 
export interface AlkissearchFindStrasseParams extends AlkissearchFindParams {

}

/// 
export interface AlkissearchFindStrasseResponse extends Response {
    /// 
    strassen: strList;
}

/// 
export interface AlkissearchFindFlurstueckParams extends AlkissearchFindParams {
    /// 
    bblatt?: string;
    /// 
    controlInput?: string;
    /// 
    crs?: Crs;
    /// 
    flaecheBis?: string;
    /// 
    flaecheVon?: string;
    /// 
    flurnummer?: string;
    /// 
    flurstuecksfolge?: string;
    /// 
    fsUids?: strList;
    /// 
    hausnummer?: string;
    /// 
    name?: string;
    /// 
    nenner?: string;
    /// 
    shapes?: ShapePropsList;
    /// 
    strasse?: string;
    /// 
    vnum?: string;
    /// 
    vorname?: string;
    /// 
    wantEigentuemer?: boolean;
    /// 
    zaehler?: string;
}

/// 
export interface AlkissearchFindFlurstueckResponse extends Response {
    /// 
    features: FeaturePropsList;
    /// 
    total: _int;
}

/// 
export interface AlkissearchGetDetailsParams extends AlkissearchFindFlurstueckParams {

}

/// 
export interface AlkissearchGetDetailsResponse extends Response {
    /// 
    feature: FeatureProps;
}

/// 
export interface AlkissearchExportParams extends Params {
    /// 
    findParams: AlkissearchFindFlurstueckParams;
    /// 
    groups: strList;
}

/// 
export interface AlkissearchExportResponse extends Response {
    /// 
    content: string;
    /// 
    mime: string;
}

/// 
export interface AlkissearchPrintParams extends Params {
    /// 
    findParams: AlkissearchFindFlurstueckParams;
    /// 
    highlightStyle: StyleProps;
    /// 
    printParams: PrintParamsWithTemplate;
}

/// 
export interface StorageEntry extends Data {
    /// 
    category: string;
    /// 
    name: string;
}

/// 
export interface StorageWriteParams extends Params {
    /// 
    data: _dict;
    /// 
    entry: StorageEntry;
}

/// 
export interface StorageWriteResponse extends Response {
    /// 
    entry: StorageEntry;
}

/// 
export interface StorageDeleteParams extends Params {
    /// 
    entry: StorageEntry;
}

/// 
export interface StorageDeleteResponse extends Params {

}

/// 
export interface StorageReadParams extends Params {
    /// 
    entry: StorageEntry;
}

/// 
export interface StorageReadResponse extends Response {
    /// 
    data: _dict;
    /// 
    entry: StorageEntry;
}

/// 
export interface StorageDirParams extends Params {
    /// 
    category: string;
}

export type StorageEntryList = Array<StorageEntry>;

/// 
export interface StorageDirResponse extends Response {
    /// 
    entries: StorageEntryList;
    /// 
    readable: boolean;
    /// 
    writable: boolean;
}

/// 
export interface EditParams extends Params {
    /// 
    features: FeaturePropsList;
    /// 
    layerUid: string;
}

/// 
export interface EditResponse extends Response {
    /// 
    features: FeaturePropsList;
}

/// 
export interface AssetGetPathParams extends Params {
    /// 
    path: string;
}

/// 
export interface TabeditLoadParams extends Params {
    /// 
    table?: string;
}

/// 
export interface TabeditLoadResponse extends Response {
    /// 
    features: FeaturePropsList;
}

/// 
export interface TabeditSaveParams extends Params {
    /// 
    date: string;
    /// 
    features: FeaturePropsList;
}

/// 
export interface TabeditSaveResponse extends Response {

}

export interface GwsServerApi {
    /// 
    gekosFindFs(p: GekosGetFsParams, options?: any): Promise<GekosGetFsResponse>;
    /// Check the authorization status
    authCheck(p: Params, options?: any): Promise<AuthResponse>;
    /// Perform a login
    authLogin(p: AuthLoginParams, options?: any): Promise<AuthResponse>;
    /// Perform a logout
    authLogout(p: Params, options?: any): Promise<AuthResponse>;
    /// Return the project configuration
    projectInfo(p: ProjectInfoParams, options?: any): Promise<ProjectInfoResponse>;
    /// Render a part of the map inside a bounding box
    mapRenderBox(p: MapRenderBoxParams, options?: any): Promise<HttpResponse>;
    /// Render an XYZ tile
    mapRenderXyz(p: MapRenderXyzParams, options?: any): Promise<HttpResponse>;
    /// Render a legend for a layer
    mapRenderLegend(p: MapRenderLegendParams, options?: any): Promise<HttpResponse>;
    /// 
    mapDescribeLayer(p: MapDescribeLayerParams, options?: any): Promise<MapDescribeLayerResponse>;
    /// Get a list of features in a bounding box
    mapGetFeatures(p: MapGetFeaturesParams, options?: any): Promise<MapGetFeaturesResponse>;
    /// 
    dproconConnect(p: DproconConnectParams, options?: any): Promise<DproconConnectResponse>;
    /// 
    dproconGetData(p: DproconGetDataParams, options?: any): Promise<DproconGetDataResponse>;
    /// Start a backround print job
    printerPrint(p: PrintParams, options?: any): Promise<PrinterResponse>;
    /// Start a backround snapshot job
    printerSnapshot(p: PrintParams, options?: any): Promise<PrinterResponse>;
    /// Query the print job status
    printerQuery(p: PrinterQueryParams, options?: any): Promise<PrinterResponse>;
    /// Cancel a print job
    printerCancel(p: PrinterQueryParams, options?: any): Promise<PrinterResponse>;
    /// Perform a search
    searchFindFeatures(p: SearchParams, options?: any): Promise<SearchResponse>;
    /// 
    alkisgeocoderDecode(p: AlkisgeocoderGeocoderParams, options?: any): Promise<AlkisgeocoderGeocoderResponse>;
    /// 
    cloudCreateProject(p: CloudCreateProjectParams, options?: any): Promise<CloudCreateProjectResponse>;
    /// Upload a new report
    georisksCreateReport(p: GeorisksCreateReportParams, options?: any): Promise<GeorisksCreateReportResponse>;
    /// Query the status of the reports
    georisksReportStatus(p: GeorisksReportStatusParams, options?: any): Promise<GeorisksReportStatusResponse>;
    /// Return all approved reports
    georisksReportList(p: NoParams, options?: any): Promise<GeorisksReportListResponse>;
    /// Return a list of Strassen for the given Gemarkung
    alkissearchFindStrasse(p: AlkissearchFindStrasseParams, options?: any): Promise<AlkissearchFindStrasseResponse>;
    /// Perform a Flurstueck search
    alkissearchFindFlurstueck(p: AlkissearchFindFlurstueckParams, options?: any): Promise<AlkissearchFindFlurstueckResponse>;
    /// Return a Flurstueck feature with details
    alkissearchGetDetails(p: AlkissearchGetDetailsParams, options?: any): Promise<AlkissearchGetDetailsResponse>;
    /// Export Flurstueck features
    alkissearchExport(p: AlkissearchExportParams, options?: any): Promise<AlkissearchExportResponse>;
    /// Print Flurstueck features
    alkissearchPrint(p: AlkissearchPrintParams, options?: any): Promise<PrinterResponse>;
    /// 
    storageWrite(p: StorageWriteParams, options?: any): Promise<StorageWriteResponse>;
    /// 
    storageDelete(p: StorageDeleteParams, options?: any): Promise<StorageDeleteResponse>;
    /// 
    storageRead(p: StorageReadParams, options?: any): Promise<StorageReadResponse>;
    /// 
    storageDir(p: StorageDirParams, options?: any): Promise<StorageDirResponse>;
    /// Add features to the layer
    editAddFeatures(p: EditParams, options?: any): Promise<EditResponse>;
    /// Delete features from the layer
    editDeleteFeatures(p: EditParams, options?: any): Promise<EditResponse>;
    /// Update features on the layer
    editUpdateFeatures(p: EditParams, options?: any): Promise<EditResponse>;
    /// Return an asset under the given path and project
    assetGet(p: AssetGetPathParams, options?: any): Promise<HttpResponse>;
    /// 
    tabeditLoad(p: TabeditLoadParams, options?: any): Promise<TabeditLoadResponse>;
    /// 
    tabeditSave(p: TabeditSaveParams, options?: any): Promise<TabeditSaveResponse>;
}