Server API Interface

/**
 * Gws Server API.
 * Version 4.1.12
 */

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

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

export type strList = Array<string>;

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

export type ShapePropsList = Array<ShapeProps>;

/// 
export interface AlkisFsQueryParams extends Params {
    /// 
    alkisAd?: string;
    /// 
    alkisFs?: string;
    /// 
    bblatt?: string;
    /// 
    controlInput?: string;
    /// 
    flaecheBis?: string;
    /// 
    flaecheVon?: string;
    /// 
    flurnummer?: string;
    /// 
    flurstuecksfolge?: string;
    /// 
    fsUids?: strList;
    /// 
    gemarkungOrGemeindeUid?: string;
    /// 
    gemarkungUid?: string;
    /// 
    gemeindeUid?: string;
    /// 
    hausnummer?: string;
    /// 
    name?: string;
    /// 
    nenner?: string;
    /// 
    shapes?: ShapePropsList;
    /// 
    strasse?: string;
    /// 
    vnum?: string;
    /// 
    vorname?: string;
    /// 
    wantEigentuemer?: boolean;
    /// 
    zaehler?: string;
}

/// 
export interface AlkisFsDetailsParams extends AlkisFsQueryParams {

}

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

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

/// Feature style
export interface StyleProps {
    /// css rules
    content?: _dict;
    /// raw style content
    text?: string;
    /// style type ("css")
    type: string;
}

/// 
export interface FeatureProps {
    /// 
    attributes?: _dict;
    /// 
    category?: string;
    /// 
    description?: string;
    /// 
    label?: string;
    /// 
    shape?: ShapeProps;
    /// 
    style?: StyleProps;
    /// 
    teaser?: string;
    /// 
    title?: string;
    /// 
    uid?: string;
}

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

/// 
export interface AlkisFsExportParams extends AlkisFsQueryParams {
    /// 
    groups: strList;
}

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

/// 
export interface PrintBitmapItem {
    /// 
    data?: _bytes;
    /// 
    height?: _int;
    /// 
    mode?: string;
    /// 
    url?: string;
    /// 
    width?: _int;
}

/// 
export interface PrintFeatureProps {
    /// 
    label?: string;
    /// 
    shape?: ShapeProps;
    /// 
    style?: StyleProps;
}

export type PrintFeaturePropsList = Array<PrintFeatureProps>;

export type Point = [_float, _float];

export type PointList = Array<Point>;

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

/// 
export interface PrintItem {
    /// 
    bitmap?: PrintBitmapItem;
    /// 
    features?: PrintFeaturePropsList;
    /// 
    layerUid?: string;
    /// 
    opacity?: _float;
    /// 
    printAsVector?: boolean;
    /// 
    style?: StyleProps;
    /// 
    subLayers?: strList;
    /// 
    svgFragment?: SvgFragment;
}

export type PrintItemList = Array<PrintItem>;

/// 
export interface PrintSection {
    /// 
    center: Point;
    /// 
    data?: _dict;
    /// 
    items?: PrintItemList;
}

export type PrintSectionList = Array<PrintSection>;

/// 
export interface PrintParams extends Params {
    /// 
    format?: string;
    /// 
    items: PrintItemList;
    /// 
    mapHeight?: _int;
    /// 
    mapWidth?: _int;
    /// 
    quality: _int;
    /// 
    rotation: _int;
    /// 
    scale: _int;
    /// 
    sections?: PrintSectionList;
    /// 
    templateUid: string;
}

/// 
export interface AlkisFsPrintParams extends AlkisFsQueryParams {
    /// 
    highlightStyle: StyleProps;
    /// 
    printParams?: PrintParams;
}

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

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

export type FeaturePropsList = Array<FeatureProps>;

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

/// 
export interface AlkisFsSetupParams extends Params {

}

/// Gemarkung (Administative Unit) object
export interface AlkisFsGemarkung {
    /// Gemarkung name
    gemarkung: string;
    /// Gemarkung uid
    gemarkungUid: string;
    /// Gemeinde name
    gemeinde: string;
    /// Gemeinde uid
    gemeindeUid: string;
}

export type AlkisFsGemarkungList = Array<AlkisFsGemarkung>;

/// 
export interface Attribute {
    /// 
    name?: string;
    /// 
    title?: string;
    /// 
    type?: string;
}

export type AttributeList = Array<Attribute>;

/// Quality level for a template
export interface TemplateQualityLevel {
    /// dpi value
    dpi: _int;
    /// level name
    name?: string;
}

export type TemplateQualityLevelList = Array<TemplateQualityLevel>;

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

/// Flurstückssuche UI configuration.
export interface AlkisUiConfig {
    /// 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 AlkisFsSetupResponse extends Response {
    /// 
    gemarkungen: AlkisFsGemarkungList;
    /// 
    limit: _int;
    /// 
    printTemplate: TemplateProps;
    /// 
    ui: AlkisUiConfig;
    /// 
    withBuchung: boolean;
    /// 
    withControl: boolean;
    /// 
    withEigentuemer: boolean;
    /// 
    withFlurnummer: boolean;
}

/// 
export interface AlkisFsStrassenParams extends Params {
    /// 
    gemarkungOrGemeindeUid?: string;
    /// 
    gemarkungUid?: string;
    /// 
    gemeindeUid?: string;
}

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

/// 
export interface AlkisGeocoderAddress {
    /// 
    gemarkung?: string;
    /// 
    gemeinde?: string;
    /// 
    hausnummer?: string;
    /// 
    strasse?: string;
}

export type AlkisGeocoderAddressList = Array<AlkisGeocoderAddress>;

/// CRS code like "EPSG:3857"
export interface crsref {

}

/// 
export interface AlkisGeocoderParams {
    /// 
    adressen: AlkisGeocoderAddressList;
    /// 
    crs: crsref;
}

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

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

/// An http or https URL
export interface url {

}

/// 
export interface HttpResponse {
    /// 
    content: string;
    /// 
    location?: url;
    /// 
    mimeType: string;
    /// 
    status: _int;
}

/// 
export interface AuthCheckParams extends Params {

}

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

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

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

/// 
export interface AuthLogoutParams extends Params {

}

/// 
export interface DimensionOptionsParams extends Params {

}

/// 
export interface DimensionOptionsResponse extends Response {
    /// 
    layerUids?: strList;
    /// 
    pixelTolerance?: _int;
}

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

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

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

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

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

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

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

/// 
export interface NoParams {

}

/// 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 type intList = Array<_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 MapDescribeLayerParams extends Params {
    /// 
    layerUid: string;
}

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

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

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

/// 
export interface MapRenderBboxParams extends Params {
    /// 
    bbox: Extent;
    /// 
    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 PrinterQueryParams extends Params {
    /// 
    jobUid: string;
}

/// 
export interface ProjectInfoParams extends Params {

}

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

export type ClientElementPropsList = Array<ClientElementProps>;

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

/// 
export interface Config {

}

/// Attribute configuration
export interface AttributeConfig extends Config {
    /// internal name
    name?: string;
    /// title
    title?: string;
    /// type
    type?: string;
}

export type AttributeConfigList = Array<AttributeConfig>;

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

/// 
export interface MetaData {
    /// 
    abstract?: string;
    /// 
    access_constraints?: string;
    /// 
    attribution?: string;
    /// 
    contact?: MetaContact;
    /// 
    fees?: string;
    /// 
    image?: url;
    /// 
    keywords?: strList;
    /// 
    name?: string;
    /// 
    title?: string;
    /// 
    url?: url;
}

/// Client options for a layer
export interface LayerClientOptions {
    /// 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 {
    /// 
    dataModel?: AttributeConfigList;
    /// 
    description?: string;
    /// 
    editAccess?: strList;
    /// 
    editStyle?: StyleProps;
    /// 
    extent?: Extent;
    /// 
    geometryType?: string;
    /// 
    layers?: LayerPropsList;
    /// 
    loadingStrategy?: string;
    /// 
    meta: MetaData;
    /// 
    opacity?: _float;
    /// 
    options: LayerClientOptions;
    /// 
    resolutions?: floatList;
    /// 
    style?: StyleProps;
    /// 
    tileSize?: _int;
    /// 
    title?: string;
    /// 
    type: string;
    /// 
    uid: string;
    /// 
    url?: string;
}

export type LayerPropsList = Array<LayerProps>;

/// 
export interface MapProps {
    /// 
    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 {
    /// 
    templates: TemplatePropsList;
}

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

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

/// 
export interface RemoteadminGetSpecParams extends Params {
    /// 
    lang: string;
    /// 
    password: string;
}

/// 
export interface RemoteadminValidateParams extends Params {
    /// 
    config: _dict;
    /// 
    password: string;
}

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

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

/// 
export interface StorageDirParams extends Params {

}

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

export type StorageEntryList = Array<StorageEntry>;

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

/// 
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 GwsServerApi {
    /// Return a Flurstueck feature with details
    alkisFsDetails(p: AlkisFsDetailsParams, options?: any): Promise<AlkisFsDetailsResponse>;

    /// Export Flurstueck features
    alkisFsExport(p: AlkisFsExportParams, options?: any): Promise<AlkisFsExportResponse>;

    /// Print Flurstueck features
    alkisFsPrint(p: AlkisFsPrintParams, options?: any): Promise<PrinterResponse>;

    /// Perform a Flurstueck search
    alkisFsSearch(p: AlkisFsQueryParams, options?: any): Promise<AlkisFsSearchResponse>;

    /// Return project-specific Flurstueck-Search settings
    alkisFsSetup(p: AlkisFsSetupParams, options?: any): Promise<AlkisFsSetupResponse>;

    /// Return a list of Strassen for the given Gemarkung
    alkisFsStrassen(p: AlkisFsStrassenParams, options?: any): Promise<AlkisFsStrassenResponse>;

    /// 
    alkisGeocoder(p: AlkisGeocoderParams, options?: any): Promise<AlkisGeocoderResponse>;

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

    /// Check the authorization status
    authCheck(p: AuthCheckParams, options?: any): Promise<AuthResponse>;

    /// Perform a login
    authLogin(p: AuthLoginParams, options?: any): Promise<AuthResponse>;

    /// Perform a logout
    authLogout(p: AuthLogoutParams, options?: any): Promise<AuthResponse>;

    /// 
    dimensionOptions(p: DimensionOptionsParams, options?: any): Promise<DimensionOptionsResponse>;

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

    /// Upload a new report
    georisksCreateReport(p: GeorisksCreateReportParams, options?: any): Promise<GeorisksCreateReportResponse>;

    /// Return all approved reports
    georisksReportList(p: NoParams, options?: any): Promise<GeorisksReportListResponse>;

    /// Query the status of the reports
    georisksReportStatus(p: GeorisksReportStatusParams, options?: any): Promise<GeorisksReportStatusResponse>;

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

    /// 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
    mapRenderBbox(p: MapRenderBboxParams, 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: PrinterQueryParams, options?: any): Promise<PrinterResponse>;

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

    /// Query the print job status
    printerQuery(p: PrinterQueryParams, options?: any): Promise<PrinterResponse>;

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

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

    /// Get the config spec
    remoteadminGetSpec(p: RemoteadminGetSpecParams, options?: any): Promise<Response>;

    /// Validate configuration
    remoteadminValidate(p: RemoteadminValidateParams, options?: any): Promise<Response>;

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

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

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

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