@firmenakte/api-client 2.3.1 → 2.6.1

package/client.d.ts

@@ -7,6 +7,11 @@ export declare enum ChangeType {
     Scheinunternehmen = "scheinunternehmen",
     Unknown = "unknown"
 }
+/** The two files an export can produce. Same columns, same rows — only the serialiser differs. */
+export declare enum BusinessExportFormat {
+    Csv = "Csv",
+    Xlsx = "Xlsx"
+}
 /** Error body of the responses written before the request reaches an endpoint (401, 429). */
 export interface ApiError {
     /** Human-readable description of what was rejected. */
@@ -297,6 +302,29 @@ export interface BusinessDetailResponse {
     /** OENACE 2008 industry classifications assigned to the company. Filter by oenaceCode on /businesses; the catalogue is GET /oenace. */
     oenaces?: OenaceDto[];
 }
+/** The nine columns an export can carry, each on or off. Every one of them is served by the company search, so an export is a projection of rows rather than a detail request per company. */
+export interface BusinessExportColumns {
+    /** Company name as registered. */
+    firmenname?: boolean;
+    /** Firmenbuchnummer. */
+    fnr?: boolean;
+    /** Whether the company is still active. */
+    aktiv?: boolean;
+    /** First registered address as one line. */
+    adresse?: boolean;
+    /** Legal form, spelled out. */
+    rechtsform?: boolean;
+    /** Primary OENACE 2008 classification as its numeric code. */
+    oenace?: boolean;
+    /** Latest balance-sheet total. */
+    bilanzsumme?: boolean;
+    /** Whether an Ediktsdatei notice is on file. */
+    edikt?: boolean;
+    /** Whether the company is on the BMF's Scheinunternehmen list. */
+    scheinunternehmen?: boolean;
+    /** True when the export would have no columns at all, which is not a file. */
+    none?: boolean;
+}
 export interface BusinessFacetGroup {
     /** The group name, echoed back. */
     group?: string;
@@ -538,6 +566,15 @@ export interface CourtCatalogItemResponse {
     /** @format int32 */
     businessCount?: number;
 }
+/** A new Liste. Everything but the name is optional. */
+export interface CreateListRequest {
+    /** Display name. Blank or missing becomes "Neue Liste". */
+    name?: string | null;
+    /** Icon key, or null for none. */
+    icon?: string | null;
+    /** Companies to start the Liste with, in the order they should appear. */
+    fnrs?: string[] | null;
+}
 export interface DocumentChange {
     /** @format int64 */
     id?: number;
@@ -574,6 +611,10 @@ export interface Edikt {
     displayName?: string | null;
     hinweis?: string | null;
     ergaenzung?: string | null;
+    beschreibung?: string | null;
+    kategorie?: string | null;
+    transaktion?: string | null;
+    adresse?: string | null;
     /** @format date */
     bekanntmachungsDatum?: string;
     /** @format date */
@@ -602,6 +643,31 @@ export interface EdiktChange {
     /** Which register a change came from, and therefore which typed feed and payload it belongs to: "business" the Firmenbuch, "document" a newly filed document, "edikt" the Ediktsdatei, "gisa" the trade register, "scheinunternehmen" the BMF list. "unknown" is a change we could not classify. */
     changeType?: ChangeType;
 }
+export interface EntityTagHeaderValue {
+    tag?: StringSegment;
+    isWeak?: boolean;
+}
+/** Which companies to export and in which shape. Exactly one source is read, in the order below: an explicit set of companies, a Liste, or a saved Abfrage. */
+export interface ExportBusinessesRequest {
+    /** The companies to export, in the order the file should list them. At most 1000; more is refused rather than cut short. */
+    fnrs?: string[] | null;
+    /** A Liste of the calling account: its companies, in the order it holds them. Same 1000-company cap as an explicit set, over the FNRs the Liste stores. */
+    listId?: string | null;
+    /** A saved Abfrage of the calling account: the companies its filters match right now, ordered the way the search orders them. Capped at 1000 rows. */
+    queryId?: string | null;
+    /** The two files an export can produce. Same columns, same rows — only the serialiser differs. */
+    format?: BusinessExportFormat;
+    /** The nine columns an export can carry, each on or off. Every one of them is served by the company search, so an export is a projection of rows rather than a detail request per company. */
+    columns?: BusinessExportColumns | null;
+}
+export interface FileResult {
+    contentType?: string | null;
+    fileDownloadName?: string | null;
+    /** @format date-time */
+    lastModified?: string | null;
+    entityTag?: EntityTagHeaderValue | null;
+    enableRangeProcessing?: boolean;
+}
 export interface GisaChange {
     /** @format int64 */
     id?: number;
@@ -673,8 +739,22 @@ export interface GlobalChange {
 export interface GraphEdgeDto {
     source?: string;
     target?: string;
+    /** Whether the connection still holds today. An "assignment" edge is active while at least one of the person's functions at that company has no end date or ends in the future; a function that ended in the past makes it false. The other two kinds are always true, for two different reasons: an "ownership" edge whose holding has ended is not drawn at all, and an "address" carries no validity date, so a shared address cannot be dated. */
     isActive?: boolean;
+    /** "assignment" (a person holds a function in a company), "ownership" (a company holds shares in another — source is the shareholder, target the company it holds) or "address". */
     relationshipType?: string;
+    /**
+     * The shareholder's übernommene Stammeinlage. Null on any edge but "ownership", and on an ownership edge whose Firmenbuch entry carries no KAPITAL.
+     * @format double
+     */
+    capitalAmount?: number | null;
+    /** The currency of CapitalAmount — ATS occurs in this data, not only EUR. */
+    currency?: string | null;
+    /**
+     * The stake as a percentage, 0–100. Only where it is a real ownership share: a GmbH or Flexible Kapitalgesellschaft whose Gesellschafter all carry an amount in the same currency and the same Firmenbuch version. Null everywhere else, including on every non-ownership edge.
+     * @format double
+     */
+    sharePercent?: number | null;
 }
 export interface GraphNodeDto {
     id?: string;
@@ -774,12 +854,7 @@ export interface GuvDto {
     /** @format double */
     aufloesungGewinnruecklagen?: number | null;
 }
-export interface KeyFigureFilterDto {
-    /** @format double */
-    min?: number | null;
-    /** @format double */
-    max?: number | null;
-}
+export type JsonDocument = any;
 /** A company's legal form (Rechtsform), as the Firmenbuch's code and its German label. Filter by it with legalFormCode on /businesses; the full catalogue is GET /legalforms. */
 export interface LegalForm {
     /** Firmenbuch legal-form code, e.g. "AG" or "GMBH". The value legalFormCode takes. */
@@ -814,6 +889,32 @@ export interface LegalRecordDetailDto {
     changeType?: string | null;
     changes?: LegalRecordChangeDto[];
 }
+/** The companies to add to, or take off, a Liste. */
+export interface ListMembersRequest {
+    /** Company numbers. An empty array is accepted and changes nothing. */
+    fnrs?: string[] | null;
+}
+/** A Liste: the companies one account watches, as the FNRs it holds. */
+export interface ListResponse {
+    /** Stable id of the Liste. */
+    id: string;
+    /** What the account called it. */
+    name: string;
+    /** Icon key for the Liste, or null where it has none. */
+    icon?: string | null;
+    /** The companies on the Liste, in the order they were added. */
+    fnrs: string[];
+    /** Companies that were taken off again; re-adding one lifts it back out of here. */
+    removedFnrs: string[];
+    settings: JsonDocument;
+}
+/** The ranked suggestions of one term, split back into the two lists the filter renders. The two together are one ranking, not two: top caps their combined length. */
+export interface LocationSuggestionsResponse {
+    /** ZIP+city suggestions, best first. */
+    locations?: AddressLocationResponse[];
+    /** Whole-city suggestions, best first. */
+    cities?: CityResponse[];
+}
 export interface OenaceCatalogItemResponse {
     edvCode?: string;
     code?: string;
@@ -846,7 +947,7 @@ export interface PagedResponseOfAddressLocationResponse {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -871,7 +972,7 @@ export interface PagedResponseOfBusinessChange {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -896,7 +997,7 @@ export interface PagedResponseOfBusinessListResponse {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -921,7 +1022,7 @@ export interface PagedResponseOfCityResponse {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -946,7 +1047,7 @@ export interface PagedResponseOfCourtCatalogItemResponse {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -971,7 +1072,7 @@ export interface PagedResponseOfDocumentChange {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -996,7 +1097,7 @@ export interface PagedResponseOfEdiktChange {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -1021,7 +1122,7 @@ export interface PagedResponseOfGisaChange {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -1046,7 +1147,7 @@ export interface PagedResponseOfGisaLicense {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -1071,7 +1172,7 @@ export interface PagedResponseOfGlobalChange {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -1096,7 +1197,7 @@ export interface PagedResponseOfLegalFormCatalogItemResponse {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -1121,7 +1222,7 @@ export interface PagedResponseOfOenaceCatalogItemResponse {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -1146,7 +1247,7 @@ export interface PagedResponseOfPerson {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -1171,7 +1272,7 @@ export interface PagedResponseOfTradeCatalogItemResponse {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -1196,7 +1297,7 @@ export interface PagedResponseOfZipCodeResponse {
      */
     pageSize: number;
     /**
-     * Total number of rows matching the filters, across all pages — not the length of data.
+     * Total number of rows matching the filters, across all pages — not the length of data. The change feeds count it only as far as page reaches — 1000 × pageSize — where that exact value means "at least this many".
      * @format int32
      */
     totalRecords: number;
@@ -1304,6 +1405,24 @@ export interface ProblemDetails {
     /** Validation failures per field; present only on a model validation 400. */
     errors?: Record<string, string[]> | null;
 }
+/** A saved Abfrage: one filter set an account kept, to run again later. */
+export interface QueryResponse {
+    /** Stable id of the Abfrage. */
+    id: string;
+    /** Icon key for the Abfrage, or null where it has none. */
+    icon?: string | null;
+    query: JsonDocument;
+    /**
+     * How many companies matched when the Abfrage was last saved. A snapshot: it is not recomputed on read and may have drifted.
+     * @format int32
+     */
+    resultCount?: number | null;
+    /**
+     * When the Abfrage was last written, UTC. The Suchverlauf sorts on it.
+     * @format date-time
+     */
+    updatedAt: string;
+}
 /** Request to resolve company names to FNRs by exact match (1:1). Used for CSV import. */
 export interface ResolveBusinessNamesRequest {
     /** Company names to resolve (trimmed, distinct, max 500). Order is preserved in the response. */
@@ -1318,6 +1437,17 @@ export interface ResolveBusinessNamesResultItem {
     name?: string;
     fnr?: string | null;
 }
+/** An Abfrage to keep: the filters, and what they matched when they ran. */
+export interface SaveQueryRequest {
+    query?: JsonDocument | null;
+    /**
+     * How many companies the filters matched. Omit it where the count could not be determined — a missing count leaves the one the Abfrage already carries alone rather than erasing it.
+     * @format int32
+     */
+    resultCount?: number | null;
+    /** The Abfrage being edited. Sending it pins the row that is written, so an edit that changes the filters into another Abfrage's still updates this one instead of merging into that. Without it, a save that filters for the same companies as an existing Abfrage updates that one, which is what keeps throwaway searches out of the Suchverlauf. */
+    updateId?: string | null;
+}
 /** One entry from the BMF LSU (Scheinunternehmen) RSS feed. Company entries have Fnr; natural-person entries have PersonId. */
 export interface ScheinunternehmenKundmachung {
     /** @format int64 */
@@ -1362,6 +1492,28 @@ export interface ScheinunternehmenKundmachungDto {
     /** @format date-time */
     zeitpunktAlsScheinunternehmen?: string | null;
 }
+/** One suggestion: a company or a person, whichever type names. The other property is null. */
+export interface SearchItemResponse {
+    /** "business" or "person". */
+    type?: string;
+    /** One company as it appears in a list or on the map — the subset of the Firmenakte that a screening result needs. Fetch the rest with GET /businesses/{fnr}. */
+    business?: BusinessListResponse | null;
+    person?: Person | null;
+}
+/** Companies and people for one term, ranked into a single list. */
+export interface SearchResponse {
+    /** The suggestions, best first. */
+    data?: SearchItemResponse[];
+}
+export interface StringSegment {
+    buffer?: string | null;
+    /** @format int32 */
+    offset?: number;
+    /** @format int32 */
+    length?: number;
+    value?: string | null;
+    hasValue?: boolean;
+}
 export interface TradeCatalogItemResponse {
     /** @format int32 */
     licenseKey?: number;
@@ -1369,12 +1521,233 @@ export interface TradeCatalogItemResponse {
     /** @format int32 */
     companyCount?: number;
 }
+/** A partial update of a Liste: every field is optional and only the ones sent are written. "Sent" is the property being present in the body, which is not the same as it being non-null — {"icon": null} clears the icon while an omitted icon leaves it alone. System.Text.Json calls a setter only for a property the body carries, so each setter records that it was called; a nullable property alone could not tell the two apart. */
+export interface UpdateListRequest {
+    /** New display name. */
+    name?: string | null;
+    /** New icon key, or null to clear it. */
+    icon?: string | null;
+    /** The companies on the Liste, replacing the current set. */
+    fnrs?: string[] | null;
+    /** The companies taken off the Liste, replacing the current set. */
+    removedFnrs?: string[] | null;
+    settings?: JsonDocument | null;
+}
 export interface ZipCodeResponse {
     zipCode?: string;
     /** @format int32 */
     businessCount?: number;
 }
 export declare namespace Api {
+    /**
+     * @description Every saved Abfrage of the calling account, newest first.
+     * @tags Queries
+     * @name V1QueriesList
+     * @summary Your Abfragen
+     * @request GET:/api/v1/queries
+     * @secure
+     */
+    namespace V1QueriesList {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = QueryResponse[];
+    }
+    /**
+     * @description Keeps a filter set. A save whose filters match an Abfrage the account already has updates that one instead of adding a second — pass updateId to pin the row being edited.
+     * @tags Queries
+     * @name V1QueriesCreate
+     * @summary Save an Abfrage
+     * @request POST:/api/v1/queries
+     * @secure
+     */
+    namespace V1QueriesCreate {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = SaveQueryRequest;
+        type RequestHeaders = {};
+        type ResponseBody = QueryResponse;
+    }
+    /**
+     * @description The saved Abfrage with this id, when it belongs to the calling account.
+     * @tags Queries
+     * @name V1QueriesDetail
+     * @summary One Abfrage
+     * @request GET:/api/v1/queries/{id}
+     * @secure
+     */
+    namespace V1QueriesDetail {
+        type RequestParams = {
+            id: string;
+        };
+        type RequestQuery = {};
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = QueryResponse;
+    }
+    /**
+     * @description Removes one saved Abfrage from the Suchverlauf.
+     * @tags Queries
+     * @name V1QueriesDelete
+     * @summary Delete an Abfrage
+     * @request DELETE:/api/v1/queries/{id}
+     * @secure
+     */
+    namespace V1QueriesDelete {
+        type RequestParams = {
+            id: string;
+        };
+        type RequestQuery = {};
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = void;
+    }
+    /**
+     * @description Deletes every saved Abfrage of the calling account.
+     * @tags Queries
+     * @name V1QueriesAllDelete
+     * @summary Clear the Suchverlauf
+     * @request DELETE:/api/v1/queries/all
+     * @secure
+     */
+    namespace V1QueriesAllDelete {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = void;
+    }
+    /**
+     * @description Every Liste of the calling account, oldest first.
+     * @tags Lists
+     * @name V1ListsList
+     * @summary Your Listen
+     * @request GET:/api/v1/lists
+     * @secure
+     */
+    namespace V1ListsList {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = ListResponse[];
+    }
+    /**
+     * @description Creates an empty Liste, or one already holding the companies you pass.
+     * @tags Lists
+     * @name V1ListsCreate
+     * @summary Create a Liste
+     * @request POST:/api/v1/lists
+     * @secure
+     */
+    namespace V1ListsCreate {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = CreateListRequest;
+        type RequestHeaders = {};
+        type ResponseBody = ListResponse;
+    }
+    /**
+     * @description The Liste with this id, when it belongs to the calling account.
+     * @tags Lists
+     * @name V1ListsDetail
+     * @summary One Liste
+     * @request GET:/api/v1/lists/{id}
+     * @secure
+     */
+    namespace V1ListsDetail {
+        type RequestParams = {
+            id: string;
+        };
+        type RequestQuery = {};
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = ListResponse;
+    }
+    /**
+     * @description A partial update: only the fields the body carries are written, and settings are merged into the stored ones rather than replacing them.
+     * @tags Lists
+     * @name V1ListsPartialUpdate
+     * @summary Update a Liste
+     * @request PATCH:/api/v1/lists/{id}
+     * @secure
+     */
+    namespace V1ListsPartialUpdate {
+        type RequestParams = {
+            id: string;
+        };
+        type RequestQuery = {};
+        type RequestBody = UpdateListRequest;
+        type RequestHeaders = {};
+        type ResponseBody = ListResponse;
+    }
+    /**
+     * @description Deletes the Liste. The companies on it are not touched anywhere else.
+     * @tags Lists
+     * @name V1ListsDelete
+     * @summary Delete a Liste
+     * @request DELETE:/api/v1/lists/{id}
+     * @secure
+     */
+    namespace V1ListsDelete {
+        type RequestParams = {
+            id: string;
+        };
+        type RequestQuery = {};
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = void;
+    }
+    /**
+     * @description Appends the companies that are not on it yet, keeping the order of the ones that are. A company that had been taken off comes back off the removed set.
+     * @tags Lists
+     * @name V1ListsAddCreate
+     * @summary Add companies to a Liste
+     * @request POST:/api/v1/lists/{id}/add
+     * @secure
+     */
+    namespace V1ListsAddCreate {
+        type RequestParams = {
+            id: string;
+        };
+        type RequestQuery = {};
+        type RequestBody = ListMembersRequest;
+        type RequestHeaders = {};
+        type ResponseBody = ListResponse;
+    }
+    /**
+     * @description Takes the companies off the Liste and records them as removed.
+     * @tags Lists
+     * @name V1ListsRemoveCreate
+     * @summary Remove companies from a Liste
+     * @request POST:/api/v1/lists/{id}/remove
+     * @secure
+     */
+    namespace V1ListsRemoveCreate {
+        type RequestParams = {
+            id: string;
+        };
+        type RequestQuery = {};
+        type RequestBody = ListMembersRequest;
+        type RequestHeaders = {};
+        type ResponseBody = ListResponse;
+    }
+    /**
+     * @description Builds a CSV or an Excel workbook over the companies you name: an explicit set of FNRs, a Liste, or a saved Abfrage. Nothing is stored and no link is handed back: the CSV is written out as it is produced, the workbook is built in memory first. One export carries at most 1000 companies: a set of FNRs or a Liste that holds more is refused with a 400 rather than cut short, and a saved Abfrage exports its first 1000 matches. An export that would hold no rows answers 204 rather than an empty file.
+     * @tags Exports
+     * @name V1ExportsBusinessesCreate
+     * @summary Export companies
+     * @request POST:/api/v1/exports/businesses
+     * @secure
+     */
+    namespace V1ExportsBusinessesCreate {
+        type RequestParams = {};
+        type RequestQuery = {};
+        type RequestBody = ExportBusinessesRequest;
+        type RequestHeaders = {};
+        type ResponseBody = FileResult;
+    }
     /**
      * @description Downloads the signed GISA PDF extract for a license (GISA-Zahl). Language defaults to German (De).
      * @tags Trades
@@ -1500,7 +1873,7 @@ export declare namespace Api {
         type ResponseBody = GisaChange;
     }
     /**
-     * @description Feed of GISA changes — one entry per change to a company's trade licences. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
+     * @description Feed of GISA changes — one entry per change to a company's trade licences. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
      * @tags Trades
      * @name V1TradesChangesList
      * @summary GISA change feed
@@ -1541,6 +1914,31 @@ export declare namespace Api {
         type RequestHeaders = {};
         type ResponseBody = PagedResponseOfGisaChange;
     }
+    /**
+     * @description The autocomplete read: /businesses and /people for one term, ranked together, so a search field costs one request per keystroke rather than two and does not have to merge two orders itself. Each row carries either business or person, whichever type names. Ordered by where the term sits in the name, then by the shorter name, then companies before people. pageSize is per side, so the answer holds up to twice as many rows. An empty search answers an empty list; use /businesses to page through the whole dataset.
+     * @tags Search
+     * @name V1SearchList
+     * @summary Companies and people in one ranked list
+     * @request GET:/api/v1/search
+     * @secure
+     */
+    namespace V1SearchList {
+        type RequestParams = {};
+        type RequestQuery = {
+            /** The term. Empty answers an empty list — this endpoint suggests, it does not list. */
+            search?: string;
+            /**
+             * How many rows to take from each side before they are ranked together, so the answer holds at most twice this many; defaults to 10 when omitted.
+             * @format int32
+             * @min 1
+             * @max 100
+             */
+            pageSize?: number;
+        };
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = SearchResponse;
+    }
     /**
      * @description Returns (id, name) pairs for all people with at least one business assignment. For client-side name index.
      * @tags People
@@ -1695,7 +2093,7 @@ export declare namespace Api {
         type ResponseBody = PagedResponseOfLegalFormCatalogItemResponse;
     }
     /**
-     * @description Returns the graph (nodes and edges) within 2 hops of the start entity. Exactly one of personId or fnr must be provided. The network of people and companies around one starting point — who sits on which board with whom. nodes are people ("person") and companies ("business"), each carrying the id you would pass to /people/{personId} or /businesses/{fnr}; edges are source/target pairs of those ids whose relationshipType is "assignment", a person holding a function in a company. ("address", two companies registered at the same street address, is a second edge type the deployment can enable; it is off today, so expect only assignment edges.) The traversal depth is fixed at 2 hops and is not a parameter — a node with further connections outside that boundary carries hasMore=true, and isCentralNode marks the entity you started from. personId and fnr are mutually exclusive, not combinable: supplying both, or neither, is a 400, and an id that exists in neither register is a 404.
+     * @description Returns the graph (nodes and edges) within 2 hops of the start entity. Exactly one of personId or fnr must be provided. The network of people and companies around one starting point — who sits on which board with whom. nodes are people ("person") and companies ("business"), each carrying the id you would pass to /people/{personId} or /businesses/{fnr}; edges are source/target pairs of those ids whose relationshipType is "assignment", a person holding a function in a company. Two further edge types the deployment can enable: "address", two companies registered at the same street address, and "ownership", a company holding shares in another — source is the shareholder, target the company it holds, and capitalAmount, currency and sharePercent carry the stake where the register gives one. Ownership edges are drawn only for companies crawled since the shareholder mapping went live, so a company not yet re-crawled reports none rather than implying it has none. The traversal depth is fixed at 2 hops and is not a parameter — a node with further connections outside that boundary carries hasMore=true, and isCentralNode marks the entity you started from. personId and fnr are mutually exclusive, not combinable: supplying both, or neither, is a 400, and an id that exists in neither register is a 404.
      * @tags Graph
      * @name V1GraphList
      * @summary Relationship graph
@@ -1715,7 +2113,7 @@ export declare namespace Api {
         type ResponseBody = GraphResponse;
     }
     /**
-     * @description The single feed of every change across all registers — Firmenbuch, GISA, Ediktsdatei and the BMF Scheinunternehmen list — as lightweight reference rows. Each row carries only id, fnr, changeType and the dates; fetch the payload with GET /globalchanges/{id}, or poll one register's typed feed instead (/businesses/changes, /documents/changes, /edikte/changes, /trades/changes). Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id.
+     * @description The single feed of every change across all registers — Firmenbuch, GISA, Ediktsdatei and the BMF Scheinunternehmen list — as lightweight reference rows. Each row carries only id, fnr, changeType and the dates; fetch the payload with GET /globalchanges/{id}, or poll one register's typed feed instead (/businesses/changes, /documents/changes, /edikte/changes, /trades/changes). Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id.
      * @tags GlobalChanges
      * @name V1GlobalchangesList
      * @summary All-register change feed
@@ -1822,7 +2220,7 @@ export declare namespace Api {
         type ResponseBody = EdiktChange;
     }
     /**
-     * @description Feed of Ediktsdatei changes — insolvency and other court notices published about a company or a person. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on the publication date, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss an insolvency notice resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
+     * @description Feed of Ediktsdatei changes — insolvency and other court notices published about a company or a person. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on the publication date, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss an insolvency notice resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
      * @tags Edikte
      * @name V1EdikteChangesList
      * @summary Ediktsdatei change feed
@@ -1899,7 +2297,7 @@ export declare namespace Api {
         type ResponseBody = DocumentChange;
     }
     /**
-     * @description Feed of newly filed Firmenbuch documents — this is how you learn that a company has published a new Jahresabschluss. Each entry names a documentKey; fetch the file itself with GET /documents/download/{documentKey}. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on the document date, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
+     * @description Feed of newly filed Firmenbuch documents — this is how you learn that a company has published a new Jahresabschluss. Each entry names a documentKey; fetch the file itself with GET /documents/download/{documentKey}. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on the document date, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
      * @tags Documents
      * @name V1DocumentsChangesList
      * @summary Document change feed
@@ -3739,7 +4137,7 @@ export declare namespace Api {
         type ResponseBody = BusinessFacetsResponse;
     }
     /**
-     * @description The single largest company of every place in the viewport, by one metric — what a map draws as one pin per place instead of every dot in the box. groupBy picks the place: state (the nine Bundesländer, the default) or city (the towns in view). metric is one of detailViews (Aufrufe), bilanzSumme or employees (Mitarbeiter). minLat, maxLat, minLng and maxLng are required for groupBy=city and ignored for groupBy=state: the nine Bundesländer are the same nine wherever the map is looking, so that call takes no viewport at all — which is what lets one URL serve every pan and actually be cached, here and in the browser. Every /businesses filter additionally applies and means exactly what it means there; page, pageSize, orderBy, orderByDescending and countOnly are ignored. groupLabel is the place's name — "Tirol", "Innsbruck" — and is what the pin's card is headed with. A company carrying no value for the metric is skipped rather than counted as 0, so a place holding only such companies — like an empty one — returns nothing at all and the array is shorter than the number of places. Each item carries everything a popover card shows, so no second call per pin is needed. groupBy=city answers at most 16 pins, the towns holding the most companies in view; the rest is what zooming in is for. Bundesländer are derived from the PLZ of the Geschäftsanschrift, the same rule the state filter on GET /businesses uses, because the Firmenbuch carries no Land. A company that is the biggest of two places in view wins both, each pin carrying an address that is actually on screen. Cached for an hour rather than the day GET /businesses gets: view counts move.
+     * @description The single largest company of every place in the viewport, by one metric — what a map draws as one pin per place instead of every dot in the box. groupBy picks the place: state (the nine Bundesländer, the default) or city (the towns in view). metric is one of detailViews (Aufrufe), bilanzSumme or employees (Mitarbeiter). minLat, maxLat, minLng and maxLng are required for groupBy=city and ignored for groupBy=state: the nine Bundesländer are the same nine wherever the map is looking, so that call takes no viewport at all — which is what lets one URL serve every pan and actually be cached, here and in the browser. Every /businesses filter additionally applies and means exactly what it means there; page, pageSize, orderBy, orderByDescending and countOnly are ignored. groupLabel is the place's name — "Tirol", "Innsbruck" — and is what the pin's card is headed with. A company carrying no value for the metric is skipped rather than counted as 0, so a place holding only such companies — like an empty one — returns nothing at all and the array is shorter than the number of places. Each item carries everything a popover card shows, so no second call per pin is needed. groupBy=city answers at most 16 pins, the biggest of the towns in view; the rest is what zooming in is for. Bundesländer are derived from the PLZ of the Geschäftsanschrift, the same rule the state filter on GET /businesses uses, because the Firmenbuch carries no Land. A company that is the biggest of two places in view wins both, each pin carrying an address that is actually on screen and in the town it won. Cached for an hour rather than the day GET /businesses gets: view counts move.
      * @tags Businesses
      * @name V1BusinessesMapTopList
      * @summary Top company per Bundesland or city
@@ -4361,7 +4759,7 @@ export declare namespace Api {
         type ResponseBody = BusinessChange;
     }
     /**
-     * @description Feed of Firmenbuch changes — one entry per new legal record (Eintragung). Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate — so a back-dated entry is not missed — and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses. Use GET /globalchanges for the same feed across all four registers.
+     * @description Feed of Firmenbuch changes — one entry per new legal record (Eintragung). Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate — so a back-dated entry is not missed — and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses. Use GET /globalchanges for the same feed across all four registers.
      * @tags Businesses
      * @name V1BusinessesChangesList
      * @summary Firmenbuch change feed
@@ -4479,6 +4877,29 @@ export declare namespace Api {
         type RequestHeaders = {};
         type ResponseBody = PagedResponseOfCityResponse;
     }
+    /**
+     * @description Ranks cities and City+ZipCode combinations against one term and answers the best few of both, as one ranking split into two lists — what a location filter's type-ahead needs, where /addresses/locations and /addresses/cities are the paged catalogues behind it. Ordered by where the term sits in the label, then by the shorter label, then by company count, so "wien" answers Wien before Wiener Neustadt and before every 1xxx ZIP that carries it. A term shorter than two characters is ignored and the biggest groups come back instead. top caps both lists together, not each.
+     * @tags Addresses
+     * @name V1AddressesSuggestList
+     * @summary Location autocomplete
+     * @request GET:/api/v1/addresses/suggest
+     * @secure
+     */
+    namespace V1AddressesSuggestList {
+        type RequestParams = {};
+        type RequestQuery = {
+            /** The term to rank against. Shorter than two characters it is ignored entirely and the biggest groups come back instead. */
+            search?: string;
+            /**
+             * How many suggestions to answer, across both lists; defaults to 10 when omitted.
+             * @format int32
+             */
+            top?: number;
+        };
+        type RequestBody = never;
+        type RequestHeaders = {};
+        type ResponseBody = LocationSuggestionsResponse;
+    }
     /**
      * @description Returns unique zip codes from addresses with pagination and optional search.
      * @tags Addresses
@@ -4577,6 +4998,136 @@ export declare class HttpClient<SecurityDataType = unknown> {
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
     api: {
+        /**
+         * @description Every saved Abfrage of the calling account, newest first.
+         *
+         * @tags Queries
+         * @name V1QueriesList
+         * @summary Your Abfragen
+         * @request GET:/api/v1/queries
+         * @secure
+         */
+        v1QueriesList: (params?: RequestParams) => Promise<HttpResponse<QueryResponse[], ApiError | ProblemDetails>>;
+        /**
+         * @description Keeps a filter set. A save whose filters match an Abfrage the account already has updates that one instead of adding a second — pass updateId to pin the row being edited.
+         *
+         * @tags Queries
+         * @name V1QueriesCreate
+         * @summary Save an Abfrage
+         * @request POST:/api/v1/queries
+         * @secure
+         */
+        v1QueriesCreate: (data: SaveQueryRequest, params?: RequestParams) => Promise<HttpResponse<QueryResponse, ApiError | ProblemDetails>>;
+        /**
+         * @description The saved Abfrage with this id, when it belongs to the calling account.
+         *
+         * @tags Queries
+         * @name V1QueriesDetail
+         * @summary One Abfrage
+         * @request GET:/api/v1/queries/{id}
+         * @secure
+         */
+        v1QueriesDetail: (id: string, params?: RequestParams) => Promise<HttpResponse<QueryResponse, ApiError | ProblemDetails>>;
+        /**
+         * @description Removes one saved Abfrage from the Suchverlauf.
+         *
+         * @tags Queries
+         * @name V1QueriesDelete
+         * @summary Delete an Abfrage
+         * @request DELETE:/api/v1/queries/{id}
+         * @secure
+         */
+        v1QueriesDelete: (id: string, params?: RequestParams) => Promise<HttpResponse<void, ApiError | ProblemDetails>>;
+        /**
+         * @description Deletes every saved Abfrage of the calling account.
+         *
+         * @tags Queries
+         * @name V1QueriesAllDelete
+         * @summary Clear the Suchverlauf
+         * @request DELETE:/api/v1/queries/all
+         * @secure
+         */
+        v1QueriesAllDelete: (params?: RequestParams) => Promise<HttpResponse<void, ApiError | ProblemDetails>>;
+        /**
+         * @description Every Liste of the calling account, oldest first.
+         *
+         * @tags Lists
+         * @name V1ListsList
+         * @summary Your Listen
+         * @request GET:/api/v1/lists
+         * @secure
+         */
+        v1ListsList: (params?: RequestParams) => Promise<HttpResponse<ListResponse[], ApiError | ProblemDetails>>;
+        /**
+         * @description Creates an empty Liste, or one already holding the companies you pass.
+         *
+         * @tags Lists
+         * @name V1ListsCreate
+         * @summary Create a Liste
+         * @request POST:/api/v1/lists
+         * @secure
+         */
+        v1ListsCreate: (data: CreateListRequest, params?: RequestParams) => Promise<HttpResponse<ListResponse, ApiError | ProblemDetails>>;
+        /**
+         * @description The Liste with this id, when it belongs to the calling account.
+         *
+         * @tags Lists
+         * @name V1ListsDetail
+         * @summary One Liste
+         * @request GET:/api/v1/lists/{id}
+         * @secure
+         */
+        v1ListsDetail: (id: string, params?: RequestParams) => Promise<HttpResponse<ListResponse, ApiError | ProblemDetails>>;
+        /**
+         * @description A partial update: only the fields the body carries are written, and settings are merged into the stored ones rather than replacing them.
+         *
+         * @tags Lists
+         * @name V1ListsPartialUpdate
+         * @summary Update a Liste
+         * @request PATCH:/api/v1/lists/{id}
+         * @secure
+         */
+        v1ListsPartialUpdate: (id: string, data: UpdateListRequest, params?: RequestParams) => Promise<HttpResponse<ListResponse, ApiError | ProblemDetails>>;
+        /**
+         * @description Deletes the Liste. The companies on it are not touched anywhere else.
+         *
+         * @tags Lists
+         * @name V1ListsDelete
+         * @summary Delete a Liste
+         * @request DELETE:/api/v1/lists/{id}
+         * @secure
+         */
+        v1ListsDelete: (id: string, params?: RequestParams) => Promise<HttpResponse<void, ApiError | ProblemDetails>>;
+        /**
+         * @description Appends the companies that are not on it yet, keeping the order of the ones that are. A company that had been taken off comes back off the removed set.
+         *
+         * @tags Lists
+         * @name V1ListsAddCreate
+         * @summary Add companies to a Liste
+         * @request POST:/api/v1/lists/{id}/add
+         * @secure
+         */
+        v1ListsAddCreate: (id: string, data: ListMembersRequest, params?: RequestParams) => Promise<HttpResponse<ListResponse, ApiError | ProblemDetails>>;
+        /**
+         * @description Takes the companies off the Liste and records them as removed.
+         *
+         * @tags Lists
+         * @name V1ListsRemoveCreate
+         * @summary Remove companies from a Liste
+         * @request POST:/api/v1/lists/{id}/remove
+         * @secure
+         */
+        v1ListsRemoveCreate: (id: string, data: ListMembersRequest, params?: RequestParams) => Promise<HttpResponse<ListResponse, ApiError | ProblemDetails>>;
+        /**
+         * @description Builds a CSV or an Excel workbook over the companies you name: an explicit set of FNRs, a Liste, or a saved Abfrage. Nothing is stored and no link is handed back: the CSV is written out as it is produced, the workbook is built in memory first. One export carries at most 1000 companies: a set of FNRs or a Liste that holds more is refused with a 400 rather than cut short, and a saved Abfrage exports its first 1000 matches. An export that would hold no rows answers 204 rather than an empty file.
+         *
+         * @tags Exports
+         * @name V1ExportsBusinessesCreate
+         * @summary Export companies
+         * @request POST:/api/v1/exports/businesses
+         * @secure
+         */
+        v1ExportsBusinessesCreate: (data: ExportBusinessesRequest, params?: RequestParams) => Promise<HttpResponse<FileResult, ApiError | ProblemDetails>>;
         /**
          * @description Downloads the signed GISA PDF extract for a license (GISA-Zahl). Language defaults to German (De).
          *
@@ -4591,7 +5142,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
             historical?: boolean;
             /** @default "De" */
             language?: "De" | "En";
-        }, params?: RequestParams) => Promise<HttpResponse<Blob, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<Blob, ApiError | ProblemDetails>>;
         /**
          * @description Returns the global catalog of GISA Trade Definitions with pagination.
          *
@@ -4619,7 +5170,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfTradeCatalogItemResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfTradeCatalogItemResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns all company licenses for a specific trade definition with pagination.
          *
@@ -4644,7 +5195,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfGisaLicense, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfGisaLicense, ApiError | ProblemDetails>>;
         /**
          * @description Returns all licenses for a specific company (FNR).
          *
@@ -4654,7 +5205,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/trades/company/{fnr}
          * @secure
          */
-        v1TradesCompanyDetail: (fnr: string, params?: RequestParams) => Promise<HttpResponse<GisaLicense[], ProblemDetails | ApiError>>;
+        v1TradesCompanyDetail: (fnr: string, params?: RequestParams) => Promise<HttpResponse<GisaLicense[], ApiError | ProblemDetails>>;
         /**
          * @description Returns a single GISA change by id.
          *
@@ -4664,9 +5215,9 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/trades/changes/{id}
          * @secure
          */
-        v1TradesChangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<GisaChange, ProblemDetails | ApiError>>;
+        v1TradesChangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<GisaChange, ApiError | ProblemDetails>>;
         /**
-         * @description Feed of GISA changes — one entry per change to a company's trade licences. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
+         * @description Feed of GISA changes — one entry per change to a company's trade licences. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
          *
          * @tags Trades
          * @name V1TradesChangesList
@@ -4701,7 +5252,27 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfGisaChange, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfGisaChange, ApiError | ProblemDetails>>;
+        /**
+         * @description The autocomplete read: /businesses and /people for one term, ranked together, so a search field costs one request per keystroke rather than two and does not have to merge two orders itself. Each row carries either business or person, whichever type names. Ordered by where the term sits in the name, then by the shorter name, then companies before people. pageSize is per side, so the answer holds up to twice as many rows. An empty search answers an empty list; use /businesses to page through the whole dataset.
+         *
+         * @tags Search
+         * @name V1SearchList
+         * @summary Companies and people in one ranked list
+         * @request GET:/api/v1/search
+         * @secure
+         */
+        v1SearchList: (query?: {
+            /** The term. Empty answers an empty list — this endpoint suggests, it does not list. */
+            search?: string;
+            /**
+             * How many rows to take from each side before they are ranked together, so the answer holds at most twice this many; defaults to 10 when omitted.
+             * @format int32
+             * @min 1
+             * @max 100
+             */
+            pageSize?: number;
+        }, params?: RequestParams) => Promise<HttpResponse<SearchResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns (id, name) pairs for all people with at least one business assignment. For client-side name index.
          *
@@ -4711,7 +5282,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/people/names
          * @secure
          */
-        v1PeopleNamesList: (params?: RequestParams) => Promise<HttpResponse<PersonNameItem[], ProblemDetails | ApiError>>;
+        v1PeopleNamesList: (params?: RequestParams) => Promise<HttpResponse<PersonNameItem[], ApiError | ProblemDetails>>;
         /**
          * @description Lists people who hold a function in, or a GISA licence for, an Austrian company. name and search behave identically here — both split the term on spaces and keep people whose "firstName lastName" contains every token, case-insensitively — except that search wins when both are given. Ordered by last name, then first name unless orderBy says otherwise. Combine with fnr or businessName to get the officers of one company, or with functionCode for one role. fnr, functionCode, businessName, businessCity and businessRegisteredSince_gte all describe one and the same assignment: a person comes back only if a single company of theirs satisfies every one of them. So the youngest owners of this year's new Viennese companies are one page: ?businessCity=Wien&businessRegisteredSince_gte=2026-01-01&functionCode=IN&functionCode=KP&functionCode=GS&functionCode=PG&orderBy=birthDate&orderByDescending=true&pageSize=3
          *
@@ -4757,7 +5328,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfPerson, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfPerson, ApiError | ProblemDetails>>;
         /**
          * @description Returns one person with every company function, GISA licence and Edikt attached to them. personId is the synthetic id described in the glossary — "firstname-lastname-birthdate", lower case, inner spaces replaced by hyphens and "x" for a part the register does not give, e.g. "max-mustermann-1970-01-01". It is matched exactly. Take it from a list row or from an assignment on a company rather than composing it yourself.
          *
@@ -4767,7 +5338,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/people/{personId}
          * @secure
          */
-        v1PeopleDetail: (personId: string, params?: RequestParams) => Promise<HttpResponse<PersonDetailResponse, ProblemDetails | ApiError>>;
+        v1PeopleDetail: (personId: string, params?: RequestParams) => Promise<HttpResponse<PersonDetailResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns the OeNACE classification catalog with company counts. Results are ordered by company count descending — most used first.
          *
@@ -4800,7 +5371,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfOenaceCatalogItemResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfOenaceCatalogItemResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns all legal forms with pagination and optional search, sorted by business count descending.
          *
@@ -4827,9 +5398,9 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfLegalFormCatalogItemResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfLegalFormCatalogItemResponse, ApiError | ProblemDetails>>;
         /**
-         * @description Returns the graph (nodes and edges) within 2 hops of the start entity. Exactly one of personId or fnr must be provided. The network of people and companies around one starting point — who sits on which board with whom. nodes are people ("person") and companies ("business"), each carrying the id you would pass to /people/{personId} or /businesses/{fnr}; edges are source/target pairs of those ids whose relationshipType is "assignment", a person holding a function in a company. ("address", two companies registered at the same street address, is a second edge type the deployment can enable; it is off today, so expect only assignment edges.) The traversal depth is fixed at 2 hops and is not a parameter — a node with further connections outside that boundary carries hasMore=true, and isCentralNode marks the entity you started from. personId and fnr are mutually exclusive, not combinable: supplying both, or neither, is a 400, and an id that exists in neither register is a 404.
+         * @description Returns the graph (nodes and edges) within 2 hops of the start entity. Exactly one of personId or fnr must be provided. The network of people and companies around one starting point — who sits on which board with whom. nodes are people ("person") and companies ("business"), each carrying the id you would pass to /people/{personId} or /businesses/{fnr}; edges are source/target pairs of those ids whose relationshipType is "assignment", a person holding a function in a company. Two further edge types the deployment can enable: "address", two companies registered at the same street address, and "ownership", a company holding shares in another — source is the shareholder, target the company it holds, and capitalAmount, currency and sharePercent carry the stake where the register gives one. Ownership edges are drawn only for companies crawled since the shareholder mapping went live, so a company not yet re-crawled reports none rather than implying it has none. The traversal depth is fixed at 2 hops and is not a parameter — a node with further connections outside that boundary carries hasMore=true, and isCentralNode marks the entity you started from. personId and fnr are mutually exclusive, not combinable: supplying both, or neither, is a 400, and an id that exists in neither register is a 404.
          *
          * @tags Graph
          * @name V1GraphList
@@ -4842,9 +5413,9 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
             personId?: string;
             /** Start from this company. Normalised before matching — trimmed, spaces and leading zeros removed — so 034853 f and 34853f are the same company; case is not folded. Mutually exclusive with personId. */
             fnr?: string;
-        }, params?: RequestParams) => Promise<HttpResponse<GraphResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<GraphResponse, ApiError | ProblemDetails>>;
         /**
-         * @description The single feed of every change across all registers — Firmenbuch, GISA, Ediktsdatei and the BMF Scheinunternehmen list — as lightweight reference rows. Each row carries only id, fnr, changeType and the dates; fetch the payload with GET /globalchanges/{id}, or poll one register's typed feed instead (/businesses/changes, /documents/changes, /edikte/changes, /trades/changes). Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id.
+         * @description The single feed of every change across all registers — Firmenbuch, GISA, Ediktsdatei and the BMF Scheinunternehmen list — as lightweight reference rows. Each row carries only id, fnr, changeType and the dates; fetch the payload with GET /globalchanges/{id}, or poll one register's typed feed instead (/businesses/changes, /documents/changes, /edikte/changes, /trades/changes). Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id.
          *
          * @tags GlobalChanges
          * @name V1GlobalchangesList
@@ -4879,7 +5450,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfGlobalChange, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfGlobalChange, ApiError | ProblemDetails>>;
         /**
          * @description Changes for a watchlist of companies, all four change types in one unpaged response. Built for watchlist polling: pass up to 1000 fnr values (repeat the parameter) and one cursor, and get back four arrays — businessChanges, documentChanges, ediktChanges, globalChanges — each ordered by ascending id and capped at maxResultsPerType. Not paged: raise maxResultsPerType or advance sinceId instead. sinceId is exclusive and since is inclusive, exactly as on the paged feeds, but one sinceId covers all four arrays: an array that comes back full at maxResultsPerType has more behind it and bounds the cursor, so advance sinceId only to the lowest of the full arrays' highest ids, and to the highest id of all four once none comes back full. Passing no fnr returns four empty arrays, not the whole feed.
          *
@@ -4903,7 +5474,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 2000
              */
             maxResultsPerType?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<AggregatedChangesResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<AggregatedChangesResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns one change with its typed payload, whichever register it came from. The envelope is a discriminator plus the payload: changeType says which register, and data is the matching object — a BusinessChange, DocumentChange, EdiktChange, GisaChange or ScheinunternehmenChange. Since data is a union, read changeType before it.
          *
@@ -4913,7 +5484,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/globalchanges/{id}
          * @secure
          */
-        v1GlobalchangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<ChangeDetailResponse, ProblemDetails | ApiError>>;
+        v1GlobalchangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<ChangeDetailResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns one Ediktsdatei change by id. The id is the shared change id from GET /globalchanges, so an id that exists but whose changeType is not "edikt" answers 404 here.
          *
@@ -4923,9 +5494,9 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/edikte/changes/{id}
          * @secure
          */
-        v1EdikteChangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<EdiktChange, ProblemDetails | ApiError>>;
+        v1EdikteChangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<EdiktChange, ApiError | ProblemDetails>>;
         /**
-         * @description Feed of Ediktsdatei changes — insolvency and other court notices published about a company or a person. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on the publication date, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss an insolvency notice resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
+         * @description Feed of Ediktsdatei changes — insolvency and other court notices published about a company or a person. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on the publication date, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss an insolvency notice resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
          *
          * @tags Edikte
          * @name V1EdikteChangesList
@@ -4960,7 +5531,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfEdiktChange, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfEdiktChange, ApiError | ProblemDetails>>;
         /**
          * @description Downloads a Firmenbuch document (PDF/XML) by its document key.
          *
@@ -4970,7 +5541,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/documents/download/{documentKey}
          * @secure
          */
-        v1DocumentsDownloadDetail: (documentKey: string, params?: RequestParams) => Promise<HttpResponse<void, string | ProblemDetails | ApiError>>;
+        v1DocumentsDownloadDetail: (documentKey: string, params?: RequestParams) => Promise<HttpResponse<void, string | ApiError | ProblemDetails>>;
         /**
          * @description Returns one document change by id, with the document's metadata. The id is the shared change id from GET /globalchanges, so an id that exists but whose changeType is not "document" answers 404 here.
          *
@@ -4980,9 +5551,9 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/documents/changes/{id}
          * @secure
          */
-        v1DocumentsChangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<DocumentChange, ProblemDetails | ApiError>>;
+        v1DocumentsChangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<DocumentChange, ApiError | ProblemDetails>>;
         /**
-         * @description Feed of newly filed Firmenbuch documents — this is how you learn that a company has published a new Jahresabschluss. Each entry names a documentKey; fetch the file itself with GET /documents/download/{documentKey}. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on the document date, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
+         * @description Feed of newly filed Firmenbuch documents — this is how you learn that a company has published a new Jahresabschluss. Each entry names a documentKey; fetch the file itself with GET /documents/download/{documentKey}. Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on the document date, and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses.
          *
          * @tags Documents
          * @name V1DocumentsChangesList
@@ -5017,7 +5588,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfDocumentChange, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfDocumentChange, ApiError | ProblemDetails>>;
         /**
          * @description Returns all courts with pagination and optional search, sorted by business count descending.
          *
@@ -5044,7 +5615,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfCourtCatalogItemResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfCourtCatalogItemResponse, ApiError | ProblemDetails>>;
         /**
          * @description Resolve company names to FNRs by exact name match (1:1). Used for CSV import.
          *
@@ -5054,7 +5625,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request POST:/api/v1/businesses/resolve-names
          * @secure
          */
-        v1BusinessesResolveNamesCreate: (data: ResolveBusinessNamesRequest, params?: RequestParams) => Promise<HttpResponse<ResolveBusinessNamesResponse, ProblemDetails | ApiError>>;
+        v1BusinessesResolveNamesCreate: (data: ResolveBusinessNamesRequest, params?: RequestParams) => Promise<HttpResponse<ResolveBusinessNamesResponse, ApiError | ProblemDetails>>;
         /**
          * @description Lists companies matching the filters, one page of list rows per call. name and search are different tools. name is a case-insensitive substring match on the company name and nothing else. search splits the term on spaces and keeps only companies matching every token, where a token matches the name, the fnr, or — when the whole term is a number — a GISA licence key or GISA-Zahl; it additionally lifts companies whose name starts with the term to the top of the default (name) ordering. So name narrows a known name, search finds an unknown one. Inactive companies always sort after active ones, whatever orderBy says. Pass countOnly=true for totalRecords without the rows, and use /businesses/aggregate to group the same filter set instead of paging through it.
          *
@@ -5615,7 +6186,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @format decimal
              */
             "guv.ZinsenUndAehnlicheAufwendungen_lte"?: number | null;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfBusinessListResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfBusinessListResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns all business (fnr, name) pairs for client-side name index. No pagination.
          *
@@ -5625,7 +6196,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/businesses/names
          * @secure
          */
-        v1BusinessesNamesList: (params?: RequestParams) => Promise<HttpResponse<BusinessNameItem[], ProblemDetails | ApiError>>;
+        v1BusinessesNamesList: (params?: RequestParams) => Promise<HttpResponse<BusinessNameItem[], ApiError | ProblemDetails>>;
         /**
          * @description Returns the number of companies in the dataset, as a bare integer. Unfiltered — it is the size of the whole dataset, not of a search. For a count over filters, call GET /businesses with countOnly=true and read totalRecords.
          *
@@ -5635,7 +6206,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/businesses/count
          * @secure
          */
-        v1BusinessesCountList: (params?: RequestParams) => Promise<HttpResponse<number, ProblemDetails | ApiError>>;
+        v1BusinessesCountList: (params?: RequestParams) => Promise<HttpResponse<number, ApiError | ProblemDetails>>;
         /**
          * @description Counts over the same filter set as GET /businesses, grouped by one dimension — the server-side GROUP BY that a caller would otherwise page the whole result set to compute. Every /businesses filter means exactly what it means there; page, pageSize, orderBy, orderByDescending and countOnly are ignored — top and minCount cap the bucket list instead. totalRecords equals /businesses?countOnly=true for the same filter; how the buckets relate to it is documented on BusinessAggregateResponse.
          *
@@ -6210,7 +6781,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @format decimal
              */
             "guv.ZinsenUndAehnlicheAufwendungen_lte"?: number | null;
-        }, params?: RequestParams) => Promise<HttpResponse<BusinessAggregateResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<BusinessAggregateResponse, ApiError | ProblemDetails>>;
         /**
          * @description Counts for every value of every filter group at once — what a filter builder puts on its chips. Takes the same filters as GET /businesses and means them the same way; page, pageSize, orderBy, orderByDescending and countOnly are ignored. Faceted semantics: a group is counted with all *other* active filters applied but its own lifted, so a value's count answers "how many results if I also select this", and selecting one never empties its own group. totalRecords is the current result count, with every filter applied. Each group returns its top values (top, default 10) plus every value the request already filters on, marked selected — a "Mehr" expander is a second call for that one group with a larger top, e.g. ?groups=city&top=50. city and zipCode count a business once per distinct value, so those counts can sum above totalRecords. One caveat worth knowing before wiring a chip up: the city filter matches a substring, while a city facet key is a whole city name, so selecting "Wien" also keeps "Wien-Umgebung" and can return more than the chip promised. Every other group matches its key exactly. Every group costs its own count, so ask for the groups you are rendering rather than all ten; the answer is cacheable for a day and varies on the whole query string.
          *
@@ -6780,9 +7351,9 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @format decimal
              */
             "guv.ZinsenUndAehnlicheAufwendungen_lte"?: number | null;
-        }, params?: RequestParams) => Promise<HttpResponse<BusinessFacetsResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<BusinessFacetsResponse, ApiError | ProblemDetails>>;
         /**
-         * @description The single largest company of every place in the viewport, by one metric — what a map draws as one pin per place instead of every dot in the box. groupBy picks the place: state (the nine Bundesländer, the default) or city (the towns in view). metric is one of detailViews (Aufrufe), bilanzSumme or employees (Mitarbeiter). minLat, maxLat, minLng and maxLng are required for groupBy=city and ignored for groupBy=state: the nine Bundesländer are the same nine wherever the map is looking, so that call takes no viewport at all — which is what lets one URL serve every pan and actually be cached, here and in the browser. Every /businesses filter additionally applies and means exactly what it means there; page, pageSize, orderBy, orderByDescending and countOnly are ignored. groupLabel is the place's name — "Tirol", "Innsbruck" — and is what the pin's card is headed with. A company carrying no value for the metric is skipped rather than counted as 0, so a place holding only such companies — like an empty one — returns nothing at all and the array is shorter than the number of places. Each item carries everything a popover card shows, so no second call per pin is needed. groupBy=city answers at most 16 pins, the towns holding the most companies in view; the rest is what zooming in is for. Bundesländer are derived from the PLZ of the Geschäftsanschrift, the same rule the state filter on GET /businesses uses, because the Firmenbuch carries no Land. A company that is the biggest of two places in view wins both, each pin carrying an address that is actually on screen. Cached for an hour rather than the day GET /businesses gets: view counts move.
+         * @description The single largest company of every place in the viewport, by one metric — what a map draws as one pin per place instead of every dot in the box. groupBy picks the place: state (the nine Bundesländer, the default) or city (the towns in view). metric is one of detailViews (Aufrufe), bilanzSumme or employees (Mitarbeiter). minLat, maxLat, minLng and maxLng are required for groupBy=city and ignored for groupBy=state: the nine Bundesländer are the same nine wherever the map is looking, so that call takes no viewport at all — which is what lets one URL serve every pan and actually be cached, here and in the browser. Every /businesses filter additionally applies and means exactly what it means there; page, pageSize, orderBy, orderByDescending and countOnly are ignored. groupLabel is the place's name — "Tirol", "Innsbruck" — and is what the pin's card is headed with. A company carrying no value for the metric is skipped rather than counted as 0, so a place holding only such companies — like an empty one — returns nothing at all and the array is shorter than the number of places. Each item carries everything a popover card shows, so no second call per pin is needed. groupBy=city answers at most 16 pins, the biggest of the towns in view; the rest is what zooming in is for. Bundesländer are derived from the PLZ of the Geschäftsanschrift, the same rule the state filter on GET /businesses uses, because the Firmenbuch carries no Land. A company that is the biggest of two places in view wins both, each pin carrying an address that is actually on screen and in the town it won. Cached for an hour rather than the day GET /businesses gets: view counts move.
          *
          * @tags Businesses
          * @name V1BusinessesMapTopList
@@ -7345,7 +7916,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @format decimal
              */
             "guv.ZinsenUndAehnlicheAufwendungen_lte"?: number | null;
-        }, params?: RequestParams) => Promise<HttpResponse<BusinessMapTopItem[], ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<BusinessMapTopItem[], ApiError | ProblemDetails>>;
         /**
          * @description Active businesses similar to the given one (same OeNACE branch, same region preferred).
          *
@@ -7355,7 +7926,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/businesses/{fnr}/similar
          * @secure
          */
-        v1BusinessesSimilarList: (fnr: string, params?: RequestParams) => Promise<HttpResponse<BusinessListResponse[], ProblemDetails | ApiError>>;
+        v1BusinessesSimilarList: (fnr: string, params?: RequestParams) => Promise<HttpResponse<BusinessListResponse[], ApiError | ProblemDetails>>;
         /**
          * @description Returns the whole Firmenakte of one company: master data, addresses, people, GISA licences, Edikte, documents and the parsed annual accounts. fnr is matched exactly against the stored, normalised Firmenbuchnummer — lower case, no spaces, no leading zeros and no "FN" prefix, e.g. 34853f. Nothing is normalised on the way in, so "FN 34853 f" answers 404 rather than the company. 404 also means the company is not in the dataset yet.
          *
@@ -7365,7 +7936,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/businesses/{fnr}
          * @secure
          */
-        v1BusinessesDetail: (fnr: string, params?: RequestParams) => Promise<HttpResponse<BusinessDetailResponse, ProblemDetails | ApiError>>;
+        v1BusinessesDetail: (fnr: string, params?: RequestParams) => Promise<HttpResponse<BusinessDetailResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns one Firmenbuch change by id. The id is the shared change id from GET /globalchanges, so an id that exists but whose changeType is not "business" answers 404 here.
          *
@@ -7375,9 +7946,9 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/businesses/changes/{id}
          * @secure
          */
-        v1BusinessesChangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<BusinessChange, ProblemDetails | ApiError>>;
+        v1BusinessesChangesDetail: (id: number, params?: RequestParams) => Promise<HttpResponse<BusinessChange, ApiError | ProblemDetails>>;
         /**
-         * @description Feed of Firmenbuch changes — one entry per new legal record (Eintragung). Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate — so a back-dated entry is not missed — and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses. Use GET /globalchanges for the same feed across all four registers.
+         * @description Feed of Firmenbuch changes — one entry per new legal record (Eintragung). Ordered by ascending id, and that id is the cursor: request with sinceId set to the highest id you have stored, walk page=1,2,… at a fixed pageSize until a page comes back with fewer than pageSize rows, keep the highest id you saw, and start the next poll from it. sinceId is exclusive, so nothing is delivered twice, and a new change always takes a higher id than every change already in the feed, so it appends to the end and never shifts a page you have already read. since is inclusive, filters on when we recorded the change rather than on changedDate — so a back-dated entry is not missed — and applies together with sinceId when both are sent. Paging without sinceId is not a reliable feed: an offset is not a watermark, and page stops at 1000. totalRecords stops there too — it is counted only as far as page 1000 reaches, so it caps at 1000 × pageSize and means "at least this many" once it is that; stop on a short page, not on a count. Under concurrent writes a change can become visible just after a higher id, so a consumer that must not miss one resumes from the previous poll's watermark and de-duplicates by id. fnr is normalised before matching — trimmed, spaces and leading zeros removed, case left alone — so 034853 f and 34853f are the same company, exactly as on GET /businesses. Use GET /globalchanges for the same feed across all four registers.
          *
          * @tags Businesses
          * @name V1BusinessesChangesList
@@ -7412,7 +7983,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfBusinessChange, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfBusinessChange, ApiError | ProblemDetails>>;
         /**
          * @description Returns all assignment functions (code/text lookup) for display. Cached 24h.
          *
@@ -7422,7 +7993,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/api/v1/assignmentfunctions
          * @secure
          */
-        v1AssignmentfunctionsList: (params?: RequestParams) => Promise<HttpResponse<AssignmentFunctionItemResponse[], ProblemDetails | ApiError>>;
+        v1AssignmentfunctionsList: (params?: RequestParams) => Promise<HttpResponse<AssignmentFunctionItemResponse[], ApiError | ProblemDetails>>;
         /**
          * @description Returns unique City+ZipCode combinations from addresses with pagination and optional search.
          *
@@ -7448,7 +8019,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfAddressLocationResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfAddressLocationResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns unique cities from addresses with pagination and optional search.
          *
@@ -7474,7 +8045,25 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfCityResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfCityResponse, ApiError | ProblemDetails>>;
+        /**
+         * @description Ranks cities and City+ZipCode combinations against one term and answers the best few of both, as one ranking split into two lists — what a location filter's type-ahead needs, where /addresses/locations and /addresses/cities are the paged catalogues behind it. Ordered by where the term sits in the label, then by the shorter label, then by company count, so "wien" answers Wien before Wiener Neustadt and before every 1xxx ZIP that carries it. A term shorter than two characters is ignored and the biggest groups come back instead. top caps both lists together, not each.
+         *
+         * @tags Addresses
+         * @name V1AddressesSuggestList
+         * @summary Location autocomplete
+         * @request GET:/api/v1/addresses/suggest
+         * @secure
+         */
+        v1AddressesSuggestList: (query?: {
+            /** The term to rank against. Shorter than two characters it is ignored entirely and the biggest groups come back instead. */
+            search?: string;
+            /**
+             * How many suggestions to answer, across both lists; defaults to 10 when omitted.
+             * @format int32
+             */
+            top?: number;
+        }, params?: RequestParams) => Promise<HttpResponse<LocationSuggestionsResponse, ApiError | ProblemDetails>>;
         /**
          * @description Returns unique zip codes from addresses with pagination and optional search.
          *
@@ -7500,7 +8089,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              * @max 100
              */
             pageSize?: number;
-        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfZipCodeResponse, ProblemDetails | ApiError>>;
+        }, params?: RequestParams) => Promise<HttpResponse<PagedResponseOfZipCodeResponse, ApiError | ProblemDetails>>;
     };
 }
 export {};