@firmenakte/api-client 2.1.1 → 2.6.1

package/client.js

@@ -11,7 +11,7 @@
  * ---------------------------------------------------------------
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Api = exports.HttpClient = exports.ContentType = exports.ChangeType = void 0;
+exports.Api = exports.HttpClient = exports.ContentType = exports.BusinessExportFormat = exports.ChangeType = void 0;
 /** 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. */
 var ChangeType;
 (function (ChangeType) {
@@ -22,6 +22,12 @@ var ChangeType;
     ChangeType["Scheinunternehmen"] = "scheinunternehmen";
     ChangeType["Unknown"] = "unknown";
 })(ChangeType || (exports.ChangeType = ChangeType = {}));
+/** The two files an export can produce. Same columns, same rows — only the serialiser differs. */
+var BusinessExportFormat;
+(function (BusinessExportFormat) {
+    BusinessExportFormat["Csv"] = "Csv";
+    BusinessExportFormat["Xlsx"] = "Xlsx";
+})(BusinessExportFormat || (exports.BusinessExportFormat = BusinessExportFormat = {}));
 var ContentType;
 (function (ContentType) {
     ContentType["Json"] = "application/json";
@@ -191,6 +197,222 @@ class Api extends HttpClient {
     constructor() {
         super(...arguments);
         this.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 = {}) => this.request({
+                path: `/api/v1/queries`,
+                method: "GET",
+                secure: true,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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, params = {}) => this.request({
+                path: `/api/v1/queries`,
+                method: "POST",
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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, params = {}) => this.request({
+                path: `/api/v1/queries/${id}`,
+                method: "GET",
+                secure: true,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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, params = {}) => this.request({
+                path: `/api/v1/queries/${id}`,
+                method: "DELETE",
+                secure: true,
+                ...params,
+            }),
+            /**
+             * @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 = {}) => this.request({
+                path: `/api/v1/queries/all`,
+                method: "DELETE",
+                secure: true,
+                ...params,
+            }),
+            /**
+             * @description Every Liste of the calling account, oldest first.
+             *
+             * @tags Lists
+             * @name V1ListsList
+             * @summary Your Listen
+             * @request GET:/api/v1/lists
+             * @secure
+             */
+            v1ListsList: (params = {}) => this.request({
+                path: `/api/v1/lists`,
+                method: "GET",
+                secure: true,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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, params = {}) => this.request({
+                path: `/api/v1/lists`,
+                method: "POST",
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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, params = {}) => this.request({
+                path: `/api/v1/lists/${id}`,
+                method: "GET",
+                secure: true,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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, data, params = {}) => this.request({
+                path: `/api/v1/lists/${id}`,
+                method: "PATCH",
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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, params = {}) => this.request({
+                path: `/api/v1/lists/${id}`,
+                method: "DELETE",
+                secure: true,
+                ...params,
+            }),
+            /**
+             * @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, data, params = {}) => this.request({
+                path: `/api/v1/lists/${id}/add`,
+                method: "POST",
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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, data, params = {}) => this.request({
+                path: `/api/v1/lists/${id}/remove`,
+                method: "POST",
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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, params = {}) => this.request({
+                path: `/api/v1/exports/businesses`,
+                method: "POST",
+                body: data,
+                secure: true,
+                type: ContentType.Json,
+                ...params,
+            }),
             /**
              * @description Downloads the signed GISA PDF extract for a license (GISA-Zahl). Language defaults to German (De).
              *
@@ -274,7 +496,7 @@ class Api extends HttpClient {
                 ...params,
             }),
             /**
-             * @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
@@ -290,6 +512,23 @@ class Api extends HttpClient {
                 format: "json",
                 ...params,
             }),
+            /**
+             * @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, params = {}) => this.request({
+                path: `/api/v1/search`,
+                method: "GET",
+                query: query,
+                secure: true,
+                format: "json",
+                ...params,
+            }),
             /**
              * @description Returns (id, name) pairs for all people with at least one business assignment. For client-side name index.
              *
@@ -374,7 +613,7 @@ class Api extends HttpClient {
                 ...params,
             }),
             /**
-             * @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
@@ -391,7 +630,7 @@ class Api extends HttpClient {
                 ...params,
             }),
             /**
-             * @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
@@ -457,7 +696,7 @@ class Api extends HttpClient {
                 ...params,
             }),
             /**
-             * @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
@@ -505,7 +744,7 @@ class Api extends HttpClient {
                 ...params,
             }),
             /**
-             * @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
@@ -622,6 +861,40 @@ class Api extends HttpClient {
                 format: "json",
                 ...params,
             }),
+            /**
+             * @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.
+             *
+             * @tags Businesses
+             * @name V1BusinessesFacetsList
+             * @summary Filter-builder facet counts
+             * @request GET:/api/v1/businesses/facets
+             * @secure
+             */
+            v1BusinessesFacetsList: (query, params = {}) => this.request({
+                path: `/api/v1/businesses/facets`,
+                method: "GET",
+                query: query,
+                secure: true,
+                format: "json",
+                ...params,
+            }),
+            /**
+             * @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
+             * @request GET:/api/v1/businesses/map-top
+             * @secure
+             */
+            v1BusinessesMapTopList: (query, params = {}) => this.request({
+                path: `/api/v1/businesses/map-top`,
+                method: "GET",
+                query: query,
+                secure: true,
+                format: "json",
+                ...params,
+            }),
             /**
              * @description Active businesses similar to the given one (same OeNACE branch, same region preferred).
              *
@@ -671,7 +944,7 @@ class Api extends HttpClient {
                 ...params,
             }),
             /**
-             * @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
@@ -737,6 +1010,23 @@ class Api extends HttpClient {
                 format: "json",
                 ...params,
             }),
+            /**
+             * @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, params = {}) => this.request({
+                path: `/api/v1/addresses/suggest`,
+                method: "GET",
+                query: query,
+                secure: true,
+                format: "json",
+                ...params,
+            }),
             /**
              * @description Returns unique zip codes from addresses with pagination and optional search.
              *