Server API Interface

/**
 * Gws Server API.
 * Version 6.1.8
 */

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

/// Basic data object.
export interface Data {

}

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

export type AlkisgeocoderGeocoderAddressList = Array<AlkisgeocoderGeocoderAddress>;

export type Crs = string;

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

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

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

export type Point = [_float, _float];

export type PointList = Array<Point>;

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

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

export enum AlkisStrasseQueryMode {
    exact = "exact",
    start = "start",
    substring = "substring",
};

/// 
export interface AlkissearchBaseFindParams extends Params {
    /// 
    gemarkung?: string;
    /// 
    gemarkungUid?: string;
    /// 
    gemeinde?: string;
    /// 
    gemeindeUid?: string;
    /// 
    strasse?: string;
    /// 
    strasseMode?: AlkisStrasseQueryMode;
}

export type strList = Array<string>;

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

}

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

export type ShapePropsList = Array<ShapeProps>;

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

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

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

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>;

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 {
    /// 
    name?: string;
    /// 
    text?: string;
    /// 
    type: StyleType;
    /// 
    values?: StyleValues;
}

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

export type FeaturePropsList = Array<FeatureProps>;

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

/// 
export interface AlkissearchGetDetailsParams extends AlkissearchFindFlurstueckParams {

}

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

/// 
export interface AlkissearchGetToponymsParams extends Params {

}

/// 
export interface AlkissearchToponymGemarkung extends Data {
    /// 
    gemeindeUid: string;
    /// 
    name: string;
    /// 
    uid: string;
}

export type AlkissearchToponymGemarkungList = Array<AlkissearchToponymGemarkung>;

/// 
export interface AlkissearchToponymGemeinde extends Data {
    /// 
    name: string;
    /// 
    uid: string;
}

export type AlkissearchToponymGemeindeList = Array<AlkissearchToponymGemeinde>;

/// 
export interface AlkissearchGetToponymsResponse extends Response {
    /// 
    gemarkungen: AlkissearchToponymGemarkungList;
    /// 
    gemeinden: AlkissearchToponymGemeindeList;
    /// 
    strasseGemarkungUids: strList;
    /// 
    strasseNames: strList;
}

/// 
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 StylePropsList = Array<StyleProps>;

export type AnyList = Array<any>;

/// 
export interface PrintItemFragment extends PrintItemBase {
    /// 
    points: PointList;
    /// 
    styles?: StylePropsList;
    /// 
    tags: AnyList;
    /// 
    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;
    /// 
    legendLayers?: strList;
    /// 
    rotation?: _int;
    /// 
    scale: _int;
    /// 
    sections?: PrintSectionList;
}

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

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

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

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

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

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

/// 
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 BplanDeleteFeatureParams extends Params {
    /// 
    uid: string;
}

/// 
export interface BplanDeleteFeatureResponse extends Response {

}

/// 
export interface BplanGetFeaturesParams extends Params {
    /// 
    auUid: string;
}

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

/// 
export interface BplanImportParams extends Params {
    /// 
    auUid: string;
    /// 
    replace: boolean;
    /// 
    uploadUid: string;
}

/// 
export interface ImporterStats extends Data {
    /// 
    numPdfs: _int;
    /// 
    numPngs: _int;
    /// 
    numRecords: _int;
}

/// 
export interface BplanStatusResponse extends Response {
    /// 
    jobUid: string;
    /// 
    progress: _int;
    /// 
    state: JobState;
    /// 
    stats: ImporterStats;
}

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

/// 
export interface BplanLoadInfoParams extends Params {
    /// 
    auUid: string;
}

/// 
export interface BplanLoadInfoResponse extends Response {
    /// 
    info: string;
}

/// 
export interface BplanLoadUserMetaParams extends Params {
    /// 
    auUid: string;
}

/// 
export interface BplanLoadUserMetaResponse extends Response {
    /// 
    meta: _dict;
}

/// 
export interface BplanSaveUserMetaParams extends Params {
    /// 
    auUid: string;
    /// 
    meta: _dict;
}

/// 
export interface BplanSaveUserMetaResponse extends Response {

}

/// 
export interface UploadChunkParams extends Params {
    /// 
    chunkCount: _int;
    /// 
    chunkNumber: _int;
    /// 
    content: _bytes;
    /// 
    name: string;
    /// 
    totalSize: _int;
    /// 
    uid: string;
}

/// 
export interface UploadChunkResponse extends Response {
    /// 
    uid: string;
}

/// 
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 EditParams extends Params {
    /// 
    features: FeaturePropsList;
    /// 
    layerUid: string;
}

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

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

/// 
export interface FsDeleteResponse extends Response {

}

/// 
export interface FsEmptyTrashParams extends Params {

}

/// 
export interface FsEmptyTrashResponse extends Response {

}

/// 
export interface FsListParams extends Params {

}

/// 
export interface FsListEntry extends Data {
    /// 
    path: string;
}

export type FsListEntryList = Array<FsListEntry>;

/// 
export interface FsListResponse extends Response {
    /// 
    entries: FsListEntryList;
}

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

/// 
export interface FsReadResponse extends Response {
    /// 
    data: _bytes;
}

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

/// 
export interface FsUndeleteResponse extends Response {

}

/// 
export interface FsWriteParams extends Params {
    /// 
    data: _bytes;
    /// 
    path: string;
}

/// 
export interface FsWriteResponse extends Response {

}

/// 
export interface FsinfoCheckUploadParams extends Params {
    /// 
    names: strList;
    /// 
    personUid: string;
}

/// 
export interface FsinfoCheckUploadResponse extends Params {
    /// 
    existingNames: strList;
}

/// 
export interface FsinfoDeleteDocumentParams extends Params {
    /// 
    documentUid: string;
}

/// 
export interface FsinfoDeleteDocumentResponse extends Params {
    /// 
    documentUid: string;
}

/// 
export interface FsinfoFindFlurstueckParams extends Params {
    /// 
    flur?: string;
    /// 
    flurstueck?: string;
    /// 
    gemarkung?: string;
    /// 
    nachname?: string;
    /// 
    pn?: string;
    /// 
    vorname?: string;
}

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

/// 
export interface FsinfoGetDetailsParams extends Params {
    /// 
    fsUid: string;
}

/// 
export interface FsinfoDocumentProps extends Props {
    /// 
    created: string;
    /// 
    filename: string;
    /// 
    personUid: string;
    /// 
    size: _int;
    /// 
    title: string;
    /// 
    uid: string;
}

export type FsinfoDocumentPropsList = Array<FsinfoDocumentProps>;

/// 
export interface FsinfoPersonProps extends Props {
    /// 
    description: string;
    /// 
    documents: FsinfoDocumentPropsList;
    /// 
    title: string;
    /// 
    uid: string;
}

export type FsinfoPersonPropsList = Array<FsinfoPersonProps>;

/// 
export interface FsinfoGetDetailsResponse extends Response {
    /// 
    feature: FeatureProps;
    /// 
    persons: FsinfoPersonPropsList;
}

/// 
export interface FsinfoGetDocumentsResponse extends Response {
    /// 
    persons: FsinfoPersonPropsList;
}

/// 
export interface FsinfoGetGemarkungenResponse extends Response {
    /// 
    names: strList;
}

/// 
export interface FsinfoUploadFile extends Data {
    /// 
    data: _bytes;
    /// 
    filename: string;
    /// 
    mimeType: string;
    /// 
    title: string;
}

export type FsinfoUploadFileList = Array<FsinfoUploadFile>;

/// 
export interface FsinfoUploadParams extends Params {
    /// 
    files: FsinfoUploadFileList;
    /// 
    personUid: string;
}

/// 
export interface FsinfoUploadResponse extends Response {
    /// 
    documentUids: strList;
}

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

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

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

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

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

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

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

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

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

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

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

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

export type PrintParams = PrintParamsWithMap | PrintParamsWithTemplate;

/// 
export interface ProjectInfoParams extends Params {

}

/// 
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 BplanAdministrativeUnit extends Data {
    /// 
    name: string;
    /// 
    uid: string;
}

export type BplanAdministrativeUnitList = Array<BplanAdministrativeUnit>;

/// 
export interface BplanProps extends Props {
    /// 
    auList: BplanAdministrativeUnitList;
    /// 
    type: 'bplan';
    /// 
    uploadChunkSize: _int;
}

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

/// 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;
}

export enum AlkissearchUiGemarkungListMode {
    combined = "combined",
    none = "none",
    plain = "plain",
    tree = "tree",
};

export enum AlkissearchUiStrasseListMode {
    plain = "plain",
    withGemarkung = "withGemarkung",
    withGemarkungIfRepeated = "withGemarkungIfRepeated",
    withGemeinde = "withGemeinde",
    withGemeindeIfRepeated = "withGemeindeIfRepeated",
};

export enum AlkissearchUiStrasseSearchMode {
    any = "any",
    start = "start",
};

/// Flurstückssuche UI configuration.
export interface AlkissearchUiConfig extends Config {
    /// activate spatial search after submit
    autoSpatialSearch?: boolean;
    /// gemarkung list mode
    gemarkungListMode?: AlkissearchUiGemarkungListMode;
    /// search in selection enabled
    searchSelection?: boolean;
    /// spatial search enabled
    searchSpatial?: boolean;
    /// strasse list entry format
    strasseListMode?: AlkissearchUiStrasseListMode;
    /// strasse search mode
    strasseSearchMode?: AlkissearchUiStrasseSearchMode;
    /// 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 type ActionProps = AlkissearchProps | BplanProps | DimensionProps;

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 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 MetadataProps extends Props {
    /// 
    abstract: string;
    /// 
    attribution: string;
    /// 
    dateCreated: string;
    /// 
    dateUpdated: string;
    /// 
    keywords: strList;
    /// 
    language: string;
    /// 
    title: string;
}

/// 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: MetadataProps;
    /// 
    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: MetadataProps;
    /// 
    overviewMap: MapProps;
    /// 
    printer: PrinterProps;
    /// 
    title: string;
    /// 
    uid: string;
}

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

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

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

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

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

/// 
export interface StorageDeleteResponse extends Params {

}

/// 
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 StorageReadParams extends Params {
    /// 
    entry: StorageEntry;
}

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

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

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

/// 
export interface TabeditTableProps extends Props {
    /// 
    title: string;
    /// 
    uid: string;
}

export type TabeditTablePropsList = Array<TabeditTableProps>;

/// 
export interface TabeditGetTablesRepsponse extends Response {
    /// 
    tables: TabeditTablePropsList;
}

/// 
export interface TabeditLoadDataParams extends Params {
    /// 
    tableUid: string;
}

/// 
export interface TabeditLoadDataResponse extends Response {
    /// 
    attributes: AttributeList;
    /// 
    key: string;
    /// 
    records: AnyList;
    /// 
    tableUid: string;
    /// 
    widths?: intList;
    /// 
    withFilter: boolean;
}

/// 
export interface TabeditSaveDataParams extends Params {
    /// 
    attributes: AttributeList;
    /// 
    records: AnyList;
    /// 
    tableUid: string;
}

/// 
export interface TabeditSaveDataResponse extends Response {

}

export interface GwsServerApi {

    /// 
    alkisgeocoderDecode(p: AlkisgeocoderGeocoderParams, options?: any): Promise<AlkisgeocoderGeocoderResponse>;

    /// Export Flurstueck features
    alkissearchExport(p: AlkissearchExportParams, options?: any): Promise<AlkissearchExportResponse>;

    /// Perform a Flurstueck search
    alkissearchFindFlurstueck(p: AlkissearchFindFlurstueckParams, options?: any): Promise<AlkissearchFindFlurstueckResponse>;

    /// Return a Flurstueck feature with details
    alkissearchGetDetails(p: AlkissearchGetDetailsParams, options?: any): Promise<AlkissearchGetDetailsResponse>;

    /// Return all Toponyms (Gemeinde/Gemarkung/Strasse) in the area
    alkissearchGetToponyms(p: AlkissearchGetToponymsParams, options?: any): Promise<AlkissearchGetToponymsResponse>;

    /// Print Flurstueck features
    alkissearchPrint(p: AlkissearchPrintParams, options?: any): Promise<JobStatusResponse>;

    /// Return an asset under the given path and project
    assetGet(p: AssetGetPathParams, options?: any): Promise<HttpResponse>;

    /// 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>;

    /// 
    bplanDeleteFeature(p: BplanDeleteFeatureParams, options?: any): Promise<BplanDeleteFeatureResponse>;

    /// 
    bplanGetFeatures(p: BplanGetFeaturesParams, options?: any): Promise<BplanGetFeaturesResponse>;

    /// 
    bplanImport(p: BplanImportParams, options?: any): Promise<BplanStatusResponse>;

    /// Cancel a print job
    bplanImportCancel(p: BplanStatusParams, options?: any): Promise<BplanStatusResponse>;

    /// 
    bplanImportStatus(p: BplanStatusParams, options?: any): Promise<BplanStatusResponse>;

    /// 
    bplanLoadInfo(p: BplanLoadInfoParams, options?: any): Promise<BplanLoadInfoResponse>;

    /// Return the user metadata
    bplanLoadUserMeta(p: BplanLoadUserMetaParams, options?: any): Promise<BplanLoadUserMetaResponse>;

    /// 
    bplanSaveUserMeta(p: BplanSaveUserMetaParams, options?: any): Promise<BplanSaveUserMetaResponse>;

    /// 
    bplanUploadChunk(p: UploadChunkParams, options?: any): Promise<UploadChunkResponse>;

    /// 
    dproconConnect(p: DproconConnectParams, options?: any): Promise<DproconConnectResponse>;

    /// 
    dproconGetData(p: DproconGetDataParams, options?: any): Promise<DproconGetDataResponse>;

    /// 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>;

    /// Move a file to trash.
    fsDelete(p: FsDeleteParams, options?: any): Promise<FsDeleteResponse>;

    /// Empty the trash.
    fsEmptyTrash(p: FsEmptyTrashParams, options?: any): Promise<FsEmptyTrashResponse>;

    /// Return a list of all server files.
    fsList(p: FsListParams, options?: any): Promise<FsListResponse>;

    /// List paths currently in the trash.
    fsListTrash(p: FsListParams, options?: any): Promise<FsListResponse>;

    /// Read from an existing file.
    fsRead(p: FsReadParams, options?: any): Promise<FsReadResponse>;

    /// Restore a file from the trash.
    fsUndelete(p: FsUndeleteParams, options?: any): Promise<FsUndeleteResponse>;

    /// Write data to a new or existing file.
    fsWrite(p: FsWriteParams, options?: any): Promise<FsWriteResponse>;

    /// 
    fsinfoCheckUpload(p: FsinfoCheckUploadParams, options?: any): Promise<FsinfoCheckUploadResponse>;

    /// 
    fsinfoDeleteDocument(p: FsinfoDeleteDocumentParams, options?: any): Promise<FsinfoDeleteDocumentResponse>;

    /// Perform a Flurstueck search
    fsinfoFindFlurstueck(p: FsinfoFindFlurstueckParams, options?: any): Promise<FsinfoFindFlurstueckResponse>;

    /// 
    fsinfoGetDetails(p: FsinfoGetDetailsParams, options?: any): Promise<FsinfoGetDetailsResponse>;

    /// 
    fsinfoGetDocuments(p: Params, options?: any): Promise<FsinfoGetDocumentsResponse>;

    /// Return a list of Gemarkung names
    fsinfoGetGemarkungen(p: Params, options?: any): Promise<FsinfoGetGemarkungenResponse>;

    /// 
    fsinfoUpload(p: FsinfoUploadParams, options?: any): Promise<FsinfoUploadResponse>;

    /// 
    gekosFindFs(p: GekosGetFsParams, options?: any): Promise<GekosGetFsResponse>;

    /// 
    mapDescribeLayer(p: MapDescribeLayerParams, options?: any): Promise<MapDescribeLayerResponse>;

    /// Get a list of features in a bounding box
    mapGetFeatures(p: MapGetFeaturesParams, options?: any): Promise<MapGetFeaturesResponse>;

    /// Render a part of the map inside a bounding box
    mapRenderBox(p: MapRenderBoxParams, options?: any): Promise<HttpResponse>;

    /// Render a legend for a layer
    mapRenderLegend(p: MapRenderLegendParams, options?: any): Promise<HttpResponse>;

    /// Render an XYZ tile
    mapRenderXyz(p: MapRenderXyzParams, options?: any): Promise<HttpResponse>;

    /// Cancel a print job
    printerCancel(p: JobStatusParams, options?: any): Promise<JobStatusResponse>;

    /// Start a backround print job
    printerPrint(p: PrintParams, options?: any): Promise<JobStatusResponse>;

    /// Start a backround snapshot job
    printerSnapshot(p: PrintParams, options?: any): Promise<JobStatusResponse>;

    /// Query the print job status
    printerStatus(p: JobStatusParams, options?: any): Promise<JobStatusResponse>;

    /// Return the project configuration
    projectInfo(p: ProjectInfoParams, options?: any): Promise<ProjectInfoResponse>;

    /// Perform a search
    searchFindFeatures(p: SearchParams, options?: any): Promise<SearchResponse>;

    /// 
    storageDelete(p: StorageDeleteParams, options?: any): Promise<StorageDeleteResponse>;

    /// 
    storageDir(p: StorageDirParams, options?: any): Promise<StorageDirResponse>;

    /// 
    storageRead(p: StorageReadParams, options?: any): Promise<StorageReadResponse>;

    /// 
    storageWrite(p: StorageWriteParams, options?: any): Promise<StorageWriteResponse>;

    /// 
    tabeditGetTables(p: Params, options?: any): Promise<TabeditGetTablesRepsponse>;

    /// 
    tabeditLoadData(p: TabeditLoadDataParams, options?: any): Promise<TabeditLoadDataResponse>;

    /// 
    tabeditSaveData(p: TabeditSaveDataParams, options?: any): Promise<TabeditSaveDataResponse>;
}