Add new model definitions for various APIs in generated Swagger files

generated/swagger/cat-search-api/project.json

@@ -4,7 +4,7 @@
   "sourceRoot": "generated/swagger/cat-search-api/src",
   "prefix": "lib",
   "projectType": "library",
-  "tags": [],
+  "tags": ["generated","swagger", "cat-search", "api"],
   "targets": {
     "generate": {
       "command": "ng-swagger-gen --config {projectRoot}/ng-swagger-gen.json --output {projectRoot}/src",

generated/swagger/cat-search-api/src/base-service.ts

@@ -0,0 +1,62 @@
+/* tslint:disable */
+import { HttpClient, HttpParameterCodec, HttpParams } from '@angular/common/http';
+import { CatConfiguration } from './cat-configuration';
+
+/**
+ * Custom parameter codec to correctly handle the plus sign in parameter
+ * values. See https://github.com/angular/angular/issues/18261
+ */
+class ParameterCodec implements HttpParameterCodec {
+  encodeKey(key: string): string {
+    return encodeURIComponent(key);
+  }
+
+  encodeValue(value: string): string {
+    return encodeURIComponent(value);
+  }
+
+  decodeKey(key: string): string {
+    return decodeURIComponent(key);
+  }
+
+  decodeValue(value: string): string {
+    return decodeURIComponent(value);
+  }
+}
+const PARAMETER_CODEC = new ParameterCodec();
+
+/**
+ * Base class for API services
+ */
+export class BaseService {
+  constructor(
+    protected config: CatConfiguration,
+    protected http: HttpClient,
+  ) {}
+
+  private _rootUrl: string = '';
+
+  /**
+   * Returns the root url for API operations. If not set directly in this
+   * service, will fallback to ApiConfiguration.rootUrl.
+   */
+  get rootUrl(): string {
+    return this._rootUrl || this.config.rootUrl;
+  }
+
+  /**
+   * Sets the root URL for API operations in this service.
+   */
+  set rootUrl(rootUrl: string) {
+    this._rootUrl = rootUrl;
+  }
+
+  /**
+   * Creates a new `HttpParams` with the correct codec
+   */
+  protected newParams(): HttpParams {
+    return new HttpParams({
+      encoder: PARAMETER_CODEC,
+    });
+  }
+}

generated/swagger/cat-search-api/src/cat-configuration.ts

@@ -0,0 +1,16 @@
+/* tslint:disable */
+import { Injectable } from '@angular/core';
+
+/**
+ * Global configuration for Cat services
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class CatConfiguration {
+  rootUrl: string = 'https://isa-test.paragon-data.net/cat/v6';
+}
+
+export interface CatConfigurationInterface {
+  rootUrl?: string;
+}

generated/swagger/cat-search-api/src/models.ts

@@ -0,0 +1,56 @@
+export { ResponseArgsOfIDictionaryOfLongAndNullableInteger } from './models/response-args-of-idictionary-of-long-and-nullable-integer';
+export { ResponseArgs } from './models/response-args';
+export { DialogOfString } from './models/dialog-of-string';
+export { DialogSettings } from './models/dialog-settings';
+export { DialogContentType } from './models/dialog-content-type';
+export { KeyValueDTOOfStringAndString } from './models/key-value-dtoof-string-and-string';
+export { ProblemDetails } from './models/problem-details';
+export { LesepunkteRequest } from './models/lesepunkte-request';
+export { ListResponseArgsOfItemDTO } from './models/list-response-args-of-item-dto';
+export { ResponseArgsOfIEnumerableOfItemDTO } from './models/response-args-of-ienumerable-of-item-dto';
+export { ItemDTO } from './models/item-dto';
+export { ItemType } from './models/item-type';
+export { ProductDTO } from './models/product-dto';
+export { SizeOfString } from './models/size-of-string';
+export { WeightOfAvoirdupois } from './models/weight-of-avoirdupois';
+export { Avoirdupois } from './models/avoirdupois';
+export { TouchedBase } from './models/touched-base';
+export { SpecDTO } from './models/spec-dto';
+export { TextDTO } from './models/text-dto';
+export { ImageDTO } from './models/image-dto';
+export { AvailabilityDTO } from './models/availability-dto';
+export { ShopDTO } from './models/shop-dto';
+export { PriceDTO } from './models/price-dto';
+export { PriceValueDTO } from './models/price-value-dto';
+export { VATValueDTO } from './models/vatvalue-dto';
+export { VATType } from './models/vattype';
+export { AvailabilityType } from './models/availability-type';
+export { StockInfoDTO } from './models/stock-info-dto';
+export { StockStatus } from './models/stock-status';
+export { ShelfInfoDTO } from './models/shelf-info-dto';
+export { Successor } from './models/successor';
+export { ReviewDTO } from './models/review-dto';
+export { EntityDTO } from './models/entity-dto';
+export { EntityStatus } from './models/entity-status';
+export { CRUDA } from './models/cruda';
+export { QueryTokenDTO } from './models/query-token-dto';
+export { CatalogType } from './models/catalog-type';
+export { QueryTokenDTO2 } from './models/query-token-dto2';
+export { OrderByDTO } from './models/order-by-dto';
+export { ListResponseArgsOfAutocompleteDTO } from './models/list-response-args-of-autocomplete-dto';
+export { ResponseArgsOfIEnumerableOfAutocompleteDTO } from './models/response-args-of-ienumerable-of-autocomplete-dto';
+export { AutocompleteDTO } from './models/autocomplete-dto';
+export { AutocompleteTokenDTO } from './models/autocomplete-token-dto';
+export { ResponseArgsOfItemDTO } from './models/response-args-of-item-dto';
+export { ResponseArgsOfUISettingsDTO } from './models/response-args-of-uisettings-dto';
+export { UISettingsDTO } from './models/uisettings-dto';
+export { TranslationDTO } from './models/translation-dto';
+export { QuerySettingsDTO } from './models/query-settings-dto';
+export { InputGroupDTO } from './models/input-group-dto';
+export { InputDTO } from './models/input-dto';
+export { InputType } from './models/input-type';
+export { InputOptionsDTO } from './models/input-options-dto';
+export { OptionDTO } from './models/option-dto';
+export { ResponseArgsOfIEnumerableOfInputGroupDTO } from './models/response-args-of-ienumerable-of-input-group-dto';
+export { ResponseArgsOfIEnumerableOfOrderByDTO } from './models/response-args-of-ienumerable-of-order-by-dto';
+export { ResponseArgsOfIEnumerableOfQueryTokenDTO } from './models/response-args-of-ienumerable-of-query-token-dto';

generated/swagger/cat-search-api/src/models/autocomplete-dto.ts

@@ -0,0 +1,26 @@
+/* tslint:disable */
+
+/**
+ * Auocomplete-Ergebnis
+ */
+export interface AutocompleteDTO {
+  /**
+   * Anzeige / Bezeichner
+   */
+  display?: string;
+
+  /**
+   * Id
+   */
+  id?: string;
+
+  /**
+   * Abfragewert
+   */
+  query?: string;
+
+  /**
+   * Art (z.B. Titel, Autor, Verlag, ...)
+   */
+  type?: string;
+}

generated/swagger/cat-search-api/src/models/autocomplete-token-dto.ts

@@ -0,0 +1,32 @@
+/* tslint:disable */
+import { CatalogType } from './catalog-type';
+
+/**
+ * Suchabfrage
+ */
+export interface AutocompleteTokenDTO {
+  /**
+   * Katalogbereich
+   */
+  catalogType: CatalogType;
+
+  /**
+   * Filter
+   */
+  filter?: { [key: string]: string };
+
+  /**
+   * Eingabe
+   */
+  input?: string;
+
+  /**
+   * Menge angezigter Treffer
+   */
+  take?: number;
+
+  /**
+   * Typ (z.B. qs, author, title, publisher)
+   */
+  type?: string;
+}

generated/swagger/cat-search-api/src/models/availability-dto.ts

@@ -0,0 +1,74 @@
+/* tslint:disable */
+import { PriceDTO } from './price-dto';
+import { ShopDTO } from './shop-dto';
+import { AvailabilityType } from './availability-type';
+
+/**
+ * Verfügbarkeit
+ */
+export interface AvailabilityDTO {
+  /**
+   * Voraussichtliches Lieferdatum
+   */
+  at?: string;
+
+  /**
+   * EVT
+   */
+  firstDayOfSale?: string;
+
+  /**
+   * Produkt / Artikel PK
+   */
+  itemId?: number;
+
+  /**
+   * Preis (VK)
+   */
+  price?: PriceDTO;
+
+  /**
+   * Preisgebunden
+   */
+  priceMaintained?: boolean;
+
+  /**
+   * Verfügbare Menge
+   */
+  qty?: number;
+
+  /**
+   * Rang
+   */
+  rank?: number;
+
+  /**
+   * Zeitstempel der Anfrage
+   */
+  requested?: string;
+
+  /**
+   * Shop
+   */
+  shop?: ShopDTO;
+
+  /**
+   * Stock Status Code / Meldeschlüssel
+   */
+  ssc?: string;
+
+  /**
+   * Stock Status Code / Beschreibung
+   */
+  sscText?: string;
+
+  /**
+   * Verfügbarkeitsstatus
+   */
+  status: AvailabilityType;
+
+  /**
+   * Lieferant
+   */
+  supplier?: string;
+}

generated/swagger/cat-search-api/src/models/availability-type.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+export type AvailabilityType = 0 | 1 | 2 | 32 | 256 | 512 | 1024 | 2048 | 4096 | 8192 | 16384;

generated/swagger/cat-search-api/src/models/avoirdupois.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+export type Avoirdupois = 0 | 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096;

generated/swagger/cat-search-api/src/models/catalog-type.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+
+/**
+ * Katalogbereich
+ */
+export type CatalogType = 0 | 1 | 2 | 4;

generated/swagger/cat-search-api/src/models/cruda.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+export type CRUDA = 0 | 1 | 2 | 4 | 8 | 16;

generated/swagger/cat-search-api/src/models/dialog-content-type.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+export type DialogContentType = 0 | 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128;

generated/swagger/cat-search-api/src/models/dialog-of-string.ts

@@ -0,0 +1,16 @@
+/* tslint:disable */
+import { KeyValueDTOOfStringAndString } from './key-value-dtoof-string-and-string';
+import { DialogContentType } from './dialog-content-type';
+import { DialogSettings } from './dialog-settings';
+export interface DialogOfString {
+  actions?: Array<KeyValueDTOOfStringAndString>;
+  actionsRequired?: number;
+  area?: string;
+  content?: string;
+  contentType: DialogContentType;
+  description?: string;
+  displayTimeout?: number;
+  settings: DialogSettings;
+  subtitle?: string;
+  title?: string;
+}

generated/swagger/cat-search-api/src/models/dialog-settings.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+export type DialogSettings = 0 | 1 | 2 | 4;

generated/swagger/cat-search-api/src/models/entity-dto.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+import { TouchedBase } from './touched-base';
+import { CRUDA } from './cruda';
+import { EntityStatus } from './entity-status';
+export interface EntityDTO extends TouchedBase {
+  changed?: string;
+  created?: string;
+  cruda?: CRUDA;
+  id?: number;
+  pId?: string;
+  status?: EntityStatus;
+  uId?: string;
+  version?: number;
+}

generated/swagger/cat-search-api/src/models/entity-status.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+export type EntityStatus = 0 | 1 | 2 | 4 | 8;

generated/swagger/cat-search-api/src/models/image-dto.ts

@@ -0,0 +1,41 @@
+/* tslint:disable */
+
+/**
+ * Bild
+ */
+export interface ImageDTO {
+  /**
+   * Copyright
+   */
+  copyright?: string;
+
+  /**
+   * PK
+   */
+  id?: number;
+
+  /**
+   * Bildquelle
+   */
+  source?: string;
+
+  /**
+   * Bildunterschrift
+   */
+  subtitle?: string;
+
+  /**
+   * Thumbnail-Url
+   */
+  thumbUrl?: string;
+
+  /**
+   * Art des Bildes
+   */
+  type?: string;
+
+  /**
+   * Url
+   */
+  url?: string;
+}

generated/swagger/cat-search-api/src/models/input-dto.ts

@@ -0,0 +1,16 @@
+/* tslint:disable */
+import { InputOptionsDTO } from './input-options-dto';
+import { InputType } from './input-type';
+export interface InputDTO {
+  constraint?: string;
+  description?: string;
+  key?: string;
+  label?: string;
+  maxValue?: string;
+  minValue?: string;
+  options?: InputOptionsDTO;
+  placeholder?: string;
+  target?: string;
+  type: InputType;
+  value?: string;
+}

generated/swagger/cat-search-api/src/models/input-group-dto.ts

@@ -0,0 +1,8 @@
+/* tslint:disable */
+import { InputDTO } from './input-dto';
+export interface InputGroupDTO {
+  description?: string;
+  group?: string;
+  input?: Array<InputDTO>;
+  label?: string;
+}

generated/swagger/cat-search-api/src/models/input-options-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { OptionDTO } from './option-dto';
+export interface InputOptionsDTO {
+  max?: number;
+  values?: Array<OptionDTO>;
+}

generated/swagger/cat-search-api/src/models/input-type.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+export type InputType = 0 | 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 3072 | 4096 | 8192 | 12288;

generated/swagger/cat-search-api/src/models/item-dto.ts

@@ -0,0 +1,114 @@
+/* tslint:disable */
+import { EntityDTO } from './entity-dto';
+import { AvailabilityDTO } from './availability-dto';
+import { KeyValueDTOOfStringAndString } from './key-value-dtoof-string-and-string';
+import { ImageDTO } from './image-dto';
+import { ProductDTO } from './product-dto';
+import { ReviewDTO } from './review-dto';
+import { ShelfInfoDTO } from './shelf-info-dto';
+import { SpecDTO } from './spec-dto';
+import { StockInfoDTO } from './stock-info-dto';
+import { Successor } from './successor';
+import { TextDTO } from './text-dto';
+import { ItemType } from './item-type';
+export interface ItemDTO extends EntityDTO {
+  /**
+   * Verfügbarkeit laut Katalog
+   */
+  catalogAvailability?: AvailabilityDTO;
+
+  /**
+   * Produktfamilie
+   */
+  family?: Array<ItemDTO>;
+
+  /**
+   * Besondere Merkmale
+   */
+  features?: Array<KeyValueDTOOfStringAndString>;
+
+  /**
+   * Weitere Artikel-IDs
+   */
+  ids?: { [key: string]: number };
+
+  /**
+   * Primary image / Id des Hauptbilds
+   */
+  imageId?: string;
+
+  /**
+   * Images / Zusätzliche Bilder
+   */
+  images?: Array<ImageDTO>;
+
+  /**
+   * Markierungen (Lesezeichen) wie (BOD, Prämie)
+   */
+  labels?: { [key: string]: string };
+
+  /**
+   * Produkt-Stammdaten
+   */
+  product?: ProductDTO;
+
+  /**
+   * Lesepunkte
+   */
+  promoPoints?: number;
+
+  /**
+   * Einlöse-Prämienpunkte
+   */
+  redemptionPoints?: number;
+
+  /**
+   * Rezensionen
+   */
+  reviews?: Array<ReviewDTO>;
+
+  /**
+   * Rang
+   */
+  scoring?: number;
+
+  /**
+   * Platzierungs-/Regalinformationen
+   */
+  shelfInfos?: Array<ShelfInfoDTO>;
+
+  /**
+   * Verfügbarkeit zur Bestellung zum Versand
+   */
+  shippingAvailabilities?: Array<AvailabilityDTO>;
+
+  /**
+   * Specs / Technische Daten / Werte
+   */
+  specs?: Array<SpecDTO>;
+
+  /**
+   * Bestandsinformationen
+   */
+  stockInfos?: Array<StockInfoDTO>;
+
+  /**
+   * Verfügbarkeit zur Bestellung in die Filiale
+   */
+  storeAvailabilities?: Array<AvailabilityDTO>;
+
+  /**
+   * Nachfolgeartikel
+   */
+  successor?: Successor;
+
+  /**
+   * Texte
+   */
+  texts?: Array<TextDTO>;
+
+  /**
+   * Artikel / Produkttyp
+   */
+  type?: ItemType;
+}

generated/swagger/cat-search-api/src/models/item-type.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+
+/**
+ * Artikel-/Produkttyp
+ */
+export type ItemType = 0 | 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096 | 8192 | 16384 | 32768 | 65536;

generated/swagger/cat-search-api/src/models/key-value-dtoof-string-and-string.ts

@@ -0,0 +1,12 @@
+/* tslint:disable */
+export interface KeyValueDTOOfStringAndString {
+  command?: string;
+  description?: string;
+  enabled?: boolean;
+  group?: string;
+  key?: string;
+  label?: string;
+  selected?: boolean;
+  sort?: number;
+  value?: string;
+}

generated/swagger/cat-search-api/src/models/lesepunkte-request.ts

@@ -0,0 +1,17 @@
+/* tslint:disable */
+export interface LesepunkteRequest {
+  /**
+   * Artikel ID
+   */
+  id: number;
+
+  /**
+   * Preis (fallback)
+   */
+  price?: number;
+
+  /**
+   * Menge
+   */
+  quantity: number;
+}

generated/swagger/cat-search-api/src/models/list-response-args-of-autocomplete-dto.ts

@@ -0,0 +1,8 @@
+/* tslint:disable */
+import { ResponseArgsOfIEnumerableOfAutocompleteDTO } from './response-args-of-ienumerable-of-autocomplete-dto';
+export interface ListResponseArgsOfAutocompleteDTO extends ResponseArgsOfIEnumerableOfAutocompleteDTO {
+  completed?: boolean;
+  hits?: number;
+  skip?: number;
+  take?: number;
+}

generated/swagger/cat-search-api/src/models/list-response-args-of-item-dto.ts

@@ -0,0 +1,8 @@
+/* tslint:disable */
+import { ResponseArgsOfIEnumerableOfItemDTO } from './response-args-of-ienumerable-of-item-dto';
+export interface ListResponseArgsOfItemDTO extends ResponseArgsOfIEnumerableOfItemDTO {
+  completed?: boolean;
+  hits?: number;
+  skip?: number;
+  take?: number;
+}

generated/swagger/cat-search-api/src/models/option-dto.ts

@@ -0,0 +1,13 @@
+/* tslint:disable */
+export interface OptionDTO {
+  description?: string;
+  enabled?: boolean;
+  key?: string;
+  label?: string;
+  maxValue?: string;
+  minValue?: string;
+  placeholder?: string;
+  selected?: boolean;
+  value?: string;
+  values?: Array<OptionDTO>;
+}

generated/swagger/cat-search-api/src/models/order-by-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+export interface OrderByDTO {
+  by?: string;
+  desc?: boolean;
+  label?: string;
+}

generated/swagger/cat-search-api/src/models/price-dto.ts

@@ -0,0 +1,8 @@
+/* tslint:disable */
+import { TouchedBase } from './touched-base';
+import { PriceValueDTO } from './price-value-dto';
+import { VATValueDTO } from './vatvalue-dto';
+export interface PriceDTO extends TouchedBase {
+  value?: PriceValueDTO;
+  vat?: VATValueDTO;
+}

generated/swagger/cat-search-api/src/models/price-value-dto.ts

@@ -0,0 +1,7 @@
+/* tslint:disable */
+import { TouchedBase } from './touched-base';
+export interface PriceValueDTO extends TouchedBase {
+  currency?: string;
+  currencySymbol?: string;
+  value?: number;
+}

generated/swagger/cat-search-api/src/models/problem-details.ts

@@ -0,0 +1,10 @@
+/* tslint:disable */
+export interface ProblemDetails {
+  detail?: string;
+  extensions: { [key: string]: any };
+  instance?: string;
+  status?: number;
+  title?: string;
+  type?: string;
+  [prop: string]: any;
+}

generated/swagger/cat-search-api/src/models/product-dto.ts

@@ -0,0 +1,24 @@
+/* tslint:disable */
+import { TouchedBase } from './touched-base';
+import { SizeOfString } from './size-of-string';
+import { WeightOfAvoirdupois } from './weight-of-avoirdupois';
+export interface ProductDTO extends TouchedBase {
+  additionalName?: string;
+  catalogProductNumber?: string;
+  contributors?: string;
+  ean?: string;
+  edition?: string;
+  format?: string;
+  formatDetail?: string;
+  locale?: string;
+  manufacturer?: string;
+  name?: string;
+  productGroup?: string;
+  productGroupDetails?: string;
+  publicationDate?: string;
+  serial?: string;
+  size?: SizeOfString;
+  supplierProductNumber?: string;
+  volume?: string;
+  weight?: WeightOfAvoirdupois;
+}

generated/swagger/cat-search-api/src/models/query-settings-dto.ts

@@ -0,0 +1,8 @@
+/* tslint:disable */
+import { InputGroupDTO } from './input-group-dto';
+import { OrderByDTO } from './order-by-dto';
+export interface QuerySettingsDTO {
+  filter?: Array<InputGroupDTO>;
+  input?: Array<InputGroupDTO>;
+  orderBy?: Array<OrderByDTO>;
+}

generated/swagger/cat-search-api/src/models/query-token-dto.ts

@@ -0,0 +1,24 @@
+/* tslint:disable */
+import { QueryTokenDTO2 } from './query-token-dto2';
+import { CatalogType } from './catalog-type';
+export interface QueryTokenDTO extends QueryTokenDTO2 {
+  /**
+   * Katalogbereich
+   */
+  catalogType?: CatalogType;
+
+  /**
+   * Anfragen werden nicht getrackt
+   */
+  doNotTrack?: boolean;
+
+  /**
+   * Lagerdaten
+   */
+  returnStockData?: boolean;
+
+  /**
+   * Lager PK
+   */
+  stockId?: number;
+}

generated/swagger/cat-search-api/src/models/query-token-dto2.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+import { OrderByDTO } from './order-by-dto';
+export interface QueryTokenDTO2 {
+  filter?: { [key: string]: string };
+  friendlyName?: string;
+  fuzzy?: number;
+  hitsOnly?: boolean;
+  ids?: Array<number>;
+  input?: { [key: string]: string };
+  options?: { [key: string]: string };
+  orderBy?: Array<OrderByDTO>;
+  skip?: number;
+  take?: number;
+}

generated/swagger/cat-search-api/src/models/response-args-of-idictionary-of-long-and-nullable-integer.ts

@@ -0,0 +1,5 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+export interface ResponseArgsOfIDictionaryOfLongAndNullableInteger extends ResponseArgs {
+  result?: { [key: string]: number };
+}

generated/swagger/cat-search-api/src/models/response-args-of-ienumerable-of-autocomplete-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { AutocompleteDTO } from './autocomplete-dto';
+export interface ResponseArgsOfIEnumerableOfAutocompleteDTO extends ResponseArgs {
+  result?: Array<AutocompleteDTO>;
+}

generated/swagger/cat-search-api/src/models/response-args-of-ienumerable-of-input-group-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { InputGroupDTO } from './input-group-dto';
+export interface ResponseArgsOfIEnumerableOfInputGroupDTO extends ResponseArgs {
+  result?: Array<InputGroupDTO>;
+}

generated/swagger/cat-search-api/src/models/response-args-of-ienumerable-of-item-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { ItemDTO } from './item-dto';
+export interface ResponseArgsOfIEnumerableOfItemDTO extends ResponseArgs {
+  result?: Array<ItemDTO>;
+}

generated/swagger/cat-search-api/src/models/response-args-of-ienumerable-of-order-by-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { OrderByDTO } from './order-by-dto';
+export interface ResponseArgsOfIEnumerableOfOrderByDTO extends ResponseArgs {
+  result?: Array<OrderByDTO>;
+}

generated/swagger/cat-search-api/src/models/response-args-of-ienumerable-of-query-token-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { QueryTokenDTO } from './query-token-dto';
+export interface ResponseArgsOfIEnumerableOfQueryTokenDTO extends ResponseArgs {
+  result?: Array<QueryTokenDTO>;
+}

generated/swagger/cat-search-api/src/models/response-args-of-item-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { ItemDTO } from './item-dto';
+export interface ResponseArgsOfItemDTO extends ResponseArgs {
+  result?: ItemDTO;
+}

generated/swagger/cat-search-api/src/models/response-args-of-uisettings-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { ResponseArgs } from './response-args';
+import { UISettingsDTO } from './uisettings-dto';
+export interface ResponseArgsOfUISettingsDTO extends ResponseArgs {
+  result?: UISettingsDTO;
+}

generated/swagger/cat-search-api/src/models/response-args.ts

@@ -0,0 +1,9 @@
+/* tslint:disable */
+import { DialogOfString } from './dialog-of-string';
+export interface ResponseArgs {
+  dialog?: DialogOfString;
+  error: boolean;
+  invalidProperties?: { [key: string]: string };
+  message?: string;
+  requestId?: number;
+}

generated/swagger/cat-search-api/src/models/review-dto.ts

@@ -0,0 +1,37 @@
+/* tslint:disable */
+export interface ReviewDTO {
+  /**
+   * Autor
+   */
+  author?: string;
+
+  /**
+   * Filiale
+   */
+  branch?: string;
+
+  /**
+   * Erstellungsdatum
+   */
+  created: string;
+
+  /**
+   * Externe Id
+   */
+  id?: string;
+
+  /**
+   * Rating
+   */
+  rating: number;
+
+  /**
+   * Text
+   */
+  text?: string;
+
+  /**
+   * Titel
+   */
+  title?: string;
+}

generated/swagger/cat-search-api/src/models/shelf-info-dto.ts

@@ -0,0 +1,16 @@
+/* tslint:disable */
+
+/**
+ * Regalinfo
+ */
+export interface ShelfInfoDTO {
+  /**
+   * Sortiment
+   */
+  assortment?: string;
+
+  /**
+   * Bezeichner
+   */
+  label?: string;
+}

generated/swagger/cat-search-api/src/models/shop-dto.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+
+/**
+ * Shop
+ */
+export interface ShopDTO {}

generated/swagger/cat-search-api/src/models/size-of-string.ts

@@ -0,0 +1,7 @@
+/* tslint:disable */
+export interface SizeOfString {
+  height: number;
+  length: number;
+  unit?: string;
+  width: number;
+}

generated/swagger/cat-search-api/src/models/spec-dto.ts

@@ -0,0 +1,26 @@
+/* tslint:disable */
+
+/**
+ * Eigenchaften
+ */
+export interface SpecDTO {
+  /**
+   * PK
+   */
+  id?: number;
+
+  /**
+   * Key
+   */
+  key?: string;
+
+  /**
+   * Label
+   */
+  label?: string;
+
+  /**
+   * Wert
+   */
+  value?: string;
+}

generated/swagger/cat-search-api/src/models/stock-info-dto.ts

@@ -0,0 +1,78 @@
+/* tslint:disable */
+import { StockStatus } from './stock-status';
+
+/**
+ * Bestandsinformation
+ */
+export interface StockInfoDTO {
+  /**
+   * Filiale PK
+   */
+  branchId?: number;
+
+  /**
+   * Fach / Kammer
+   */
+  compartment?: string;
+
+  /**
+   * Erstmals bestellt
+   */
+  firstOrderDate?: string;
+
+  /**
+   * FKZ
+   */
+  fkz?: number;
+
+  /**
+   * Lagerbestand
+   */
+  inStock?: number;
+
+  /**
+   * Artikel PK
+   */
+  itemId?: number;
+
+  /**
+   * Zuletzt bestellt am
+   */
+  lastOrderDate?: string;
+
+  /**
+   * Zuletzt bestellte Menge
+   */
+  lastOrderedQuantity?: number;
+
+  /**
+   * Letzter Verkauf
+   */
+  lastSold?: string;
+
+  /**
+   * ZOB - Optischer Bestand - Zentrale
+   */
+  minStockCategoryManagement?: number;
+
+  /**
+   * FOB - Optischer Bestand - Filiale
+   */
+  minStockLocal?: number;
+
+  /**
+   * Bestellte Menge
+   */
+  openOrderedQuantity?: number;
+
+  /**
+   * Dispositionsstatus
+   * 1:rot = nicht bewirtschaftet (Sortiment inaktiv, Dispo aus); 2:gelb = Abverkauf (Sortiment aktiv, Dispo aus); 3:grün = Autodispo, (Sortiment aktiv, Dispo aktiv); 4:schwarz = "gesperrt" (Dispo gesperrt)
+   */
+  status?: StockStatus;
+
+  /**
+   * Lager PK
+   */
+  stockId?: number;
+}

generated/swagger/cat-search-api/src/models/stock-status.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+
+/**
+ * Dispositionsstatus
+ */
+export type StockStatus = 0 | 1 | 2 | 3 | 4;

generated/swagger/cat-search-api/src/models/successor.ts

@@ -0,0 +1,13 @@
+/* tslint:disable */
+import { ProductDTO } from './product-dto';
+export interface Successor extends ProductDTO {
+  /**
+   * PK
+   */
+  id?: number;
+
+  /**
+   * Ab
+   */
+  start?: string;
+}

generated/swagger/cat-search-api/src/models/text-dto.ts

@@ -0,0 +1,22 @@
+/* tslint:disable */
+export interface TextDTO {
+  /**
+   * PK
+   */
+  id?: number;
+
+  /**
+   * Key
+   */
+  key?: string;
+
+  /**
+   * Label
+   */
+  label?: string;
+
+  /**
+   * Wert
+   */
+  value?: string;
+}

generated/swagger/cat-search-api/src/models/touched-base.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+export interface TouchedBase {}

generated/swagger/cat-search-api/src/models/translation-dto.ts

@@ -0,0 +1,5 @@
+/* tslint:disable */
+export interface TranslationDTO {
+  target?: string;
+  values?: { [key: string]: string };
+}

generated/swagger/cat-search-api/src/models/uisettings-dto.ts

@@ -0,0 +1,19 @@
+/* tslint:disable */
+import { QuerySettingsDTO } from './query-settings-dto';
+import { TranslationDTO } from './translation-dto';
+export interface UISettingsDTO extends QuerySettingsDTO {
+  /**
+   * Url Template für Detail-Bild
+   */
+  imageUrl?: string;
+
+  /**
+   * Url Template für Teaser-Bild
+   */
+  thumbnailImageUrl?: string;
+
+  /**
+   * Übersetzungen
+   */
+  translations?: Array<TranslationDTO>;
+}

generated/swagger/cat-search-api/src/models/vattype.ts

@@ -0,0 +1,2 @@
+/* tslint:disable */
+export type VATType = 0 | 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128;

generated/swagger/cat-search-api/src/models/vatvalue-dto.ts

@@ -0,0 +1,9 @@
+/* tslint:disable */
+import { TouchedBase } from './touched-base';
+import { VATType } from './vattype';
+export interface VATValueDTO extends TouchedBase {
+  inPercent?: number;
+  label?: string;
+  value?: number;
+  vatType?: VATType;
+}

generated/swagger/cat-search-api/src/models/weight-of-avoirdupois.ts

@@ -0,0 +1,6 @@
+/* tslint:disable */
+import { Avoirdupois } from './avoirdupois';
+export interface WeightOfAvoirdupois {
+  unit: Avoirdupois;
+  value: number;
+}

generated/swagger/cat-search-api/src/services.ts

@@ -0,0 +1,2 @@
+export { PromotionService } from './services/promotion.service';
+export { SearchService } from './services/search.service';

generated/swagger/cat-search-api/src/services/promotion.service.ts

@@ -0,0 +1,121 @@
+/* tslint:disable */
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpRequest, HttpResponse, HttpHeaders } from '@angular/common/http';
+import { BaseService as __BaseService } from '../base-service';
+import { CatConfiguration as __Configuration } from '../cat-configuration';
+import { StrictHttpResponse as __StrictHttpResponse } from '../strict-http-response';
+import { Observable as __Observable } from 'rxjs';
+import { map as __map, filter as __filter } from 'rxjs/operators';
+
+import { ResponseArgsOfIDictionaryOfLongAndNullableInteger } from '../models/response-args-of-idictionary-of-long-and-nullable-integer';
+import { LesepunkteRequest } from '../models/lesepunkte-request';
+@Injectable({
+  providedIn: 'root',
+})
+class PromotionService extends __BaseService {
+  static readonly PromotionLesepunktePath = '/promotion/lesepunkte';
+  static readonly PromotionLesepunkte2Path = '/stock/{stockId}/promotion/lesepunkte';
+
+  constructor(config: __Configuration, http: HttpClient) {
+    super(config, http);
+  }
+
+  /**
+   * Lesepunkte
+   * @param items Ids und Mengen
+   */
+  PromotionLesepunkteResponse(
+    items: Array<LesepunkteRequest>,
+  ): __Observable<__StrictHttpResponse<ResponseArgsOfIDictionaryOfLongAndNullableInteger>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    __body = items;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/promotion/lesepunkte`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfIDictionaryOfLongAndNullableInteger>;
+      }),
+    );
+  }
+  /**
+   * Lesepunkte
+   * @param items Ids und Mengen
+   */
+  PromotionLesepunkte(items: Array<LesepunkteRequest>): __Observable<ResponseArgsOfIDictionaryOfLongAndNullableInteger> {
+    return this.PromotionLesepunkteResponse(items).pipe(__map((_r) => _r.body as ResponseArgsOfIDictionaryOfLongAndNullableInteger));
+  }
+
+  /**
+   * Lesepunkte
+   * @param params The `PromotionService.PromotionLesepunkte2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `items`: Ids und Mengen
+   */
+  PromotionLesepunkte2Response(
+    params: PromotionService.PromotionLesepunkte2Params,
+  ): __Observable<__StrictHttpResponse<ResponseArgsOfIDictionaryOfLongAndNullableInteger>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    __body = params.items;
+    let req = new HttpRequest<any>(
+      'POST',
+      this.rootUrl + `/stock/${encodeURIComponent(String(params.stockId))}/promotion/lesepunkte`,
+      __body,
+      {
+        headers: __headers,
+        params: __params,
+        responseType: 'json',
+      },
+    );
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfIDictionaryOfLongAndNullableInteger>;
+      }),
+    );
+  }
+  /**
+   * Lesepunkte
+   * @param params The `PromotionService.PromotionLesepunkte2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `items`: Ids und Mengen
+   */
+  PromotionLesepunkte2(
+    params: PromotionService.PromotionLesepunkte2Params,
+  ): __Observable<ResponseArgsOfIDictionaryOfLongAndNullableInteger> {
+    return this.PromotionLesepunkte2Response(params).pipe(__map((_r) => _r.body as ResponseArgsOfIDictionaryOfLongAndNullableInteger));
+  }
+}
+
+module PromotionService {
+  /**
+   * Parameters for PromotionLesepunkte2
+   */
+  export interface PromotionLesepunkte2Params {
+    /**
+     * Lager PK (optional)
+     */
+    stockId: number;
+
+    /**
+     * Ids und Mengen
+     */
+    items: Array<LesepunkteRequest>;
+  }
+}
+
+export { PromotionService };

generated/swagger/cat-search-api/src/services/search.service.ts

@@ -0,0 +1,898 @@
+/* tslint:disable */
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpRequest, HttpResponse, HttpHeaders } from '@angular/common/http';
+import { BaseService as __BaseService } from '../base-service';
+import { CatConfiguration as __Configuration } from '../cat-configuration';
+import { StrictHttpResponse as __StrictHttpResponse } from '../strict-http-response';
+import { Observable as __Observable } from 'rxjs';
+import { map as __map, filter as __filter } from 'rxjs/operators';
+
+import { ListResponseArgsOfItemDTO } from '../models/list-response-args-of-item-dto';
+import { QueryTokenDTO } from '../models/query-token-dto';
+import { ListResponseArgsOfAutocompleteDTO } from '../models/list-response-args-of-autocomplete-dto';
+import { AutocompleteTokenDTO } from '../models/autocomplete-token-dto';
+import { ResponseArgsOfItemDTO } from '../models/response-args-of-item-dto';
+import { ResponseArgsOfUISettingsDTO } from '../models/response-args-of-uisettings-dto';
+import { ResponseArgsOfIEnumerableOfInputGroupDTO } from '../models/response-args-of-ienumerable-of-input-group-dto';
+import { ResponseArgsOfIEnumerableOfOrderByDTO } from '../models/response-args-of-ienumerable-of-order-by-dto';
+import { ResponseArgsOfIEnumerableOfQueryTokenDTO } from '../models/response-args-of-ienumerable-of-query-token-dto';
+import { ResponseArgsOfIEnumerableOfItemDTO } from '../models/response-args-of-ienumerable-of-item-dto';
+@Injectable({
+  providedIn: 'root',
+})
+class SearchService extends __BaseService {
+  static readonly SearchTopPath = '/s/top';
+  static readonly SearchTop2Path = '/stock/{stockId}/s/top';
+  static readonly SearchSearchPath = '/s';
+  static readonly SearchSearch2Path = '/stock/{stockId}/s';
+  static readonly SearchAutocompletePath = '/s/complete';
+  static readonly SearchAutocomplete2Path = '/stock/{stockId}/s/complete';
+  static readonly SearchByIdPath = '/s/byid';
+  static readonly SearchById2Path = '/stock/{stockId}/s/byid';
+  static readonly SearchByEANPath = '/s/byean';
+  static readonly SearchByEAN2Path = '/stock/{stockId}/s/byean';
+  static readonly SearchByEAN3Path = '/branch/{branchNumber}/s/byean';
+  static readonly SearchDetailPath = '/s/{id}';
+  static readonly SearchDetail2Path = '/stock/{stockId}/s/{id}';
+  static readonly SearchDetailByEANPath = '/s/ean/{ean}';
+  static readonly SearchDetailByEAN2Path = '/stock/{stockId}/ean/{ean}';
+  static readonly SearchSettingsPath = '/s/settings';
+  static readonly SearchSearchFilterPath = '/s/filter';
+  static readonly SearchSearchSortPath = '/s/sort';
+  static readonly SearchHistoryPath = '/s/history';
+  static readonly SearchGetRecommendationsPath = '/s/recommendations/{digId}';
+
+  constructor(config: __Configuration, http: HttpClient) {
+    super(config, http);
+  }
+
+  /**
+   * TOP-Suche
+   * @param queryToken Suchkriterien
+   */
+  SearchTopResponse(queryToken: QueryTokenDTO): __Observable<__StrictHttpResponse<ListResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    __body = queryToken;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/s/top`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * TOP-Suche
+   * @param queryToken Suchkriterien
+   */
+  SearchTop(queryToken: QueryTokenDTO): __Observable<ListResponseArgsOfItemDTO> {
+    return this.SearchTopResponse(queryToken).pipe(__map((_r) => _r.body as ListResponseArgsOfItemDTO));
+  }
+
+  /**
+   * TOP-Suche
+   * @param params The `SearchService.SearchTop2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `queryToken`: Suchkriterien
+   */
+  SearchTop2Response(params: SearchService.SearchTop2Params): __Observable<__StrictHttpResponse<ListResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    __body = params.queryToken;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/stock/${encodeURIComponent(String(params.stockId))}/s/top`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * TOP-Suche
+   * @param params The `SearchService.SearchTop2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `queryToken`: Suchkriterien
+   */
+  SearchTop2(params: SearchService.SearchTop2Params): __Observable<ListResponseArgsOfItemDTO> {
+    return this.SearchTop2Response(params).pipe(__map((_r) => _r.body as ListResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Suche
+   * @param queryToken Suchkriterien
+   */
+  SearchSearchResponse(queryToken: QueryTokenDTO): __Observable<__StrictHttpResponse<ListResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    __body = queryToken;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/s`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Suche
+   * @param queryToken Suchkriterien
+   */
+  SearchSearch(queryToken: QueryTokenDTO): __Observable<ListResponseArgsOfItemDTO> {
+    return this.SearchSearchResponse(queryToken).pipe(__map((_r) => _r.body as ListResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Suche
+   * @param params The `SearchService.SearchSearch2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `queryToken`: Suchkriterien
+   */
+  SearchSearch2Response(params: SearchService.SearchSearch2Params): __Observable<__StrictHttpResponse<ListResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    __body = params.queryToken;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/stock/${encodeURIComponent(String(params.stockId))}/s`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Suche
+   * @param params The `SearchService.SearchSearch2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `queryToken`: Suchkriterien
+   */
+  SearchSearch2(params: SearchService.SearchSearch2Params): __Observable<ListResponseArgsOfItemDTO> {
+    return this.SearchSearch2Response(params).pipe(__map((_r) => _r.body as ListResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Autocomplete
+   * @param queryToken Suchbegriff
+   */
+  SearchAutocompleteResponse(queryToken: AutocompleteTokenDTO): __Observable<__StrictHttpResponse<ListResponseArgsOfAutocompleteDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    __body = queryToken;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/s/complete`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfAutocompleteDTO>;
+      }),
+    );
+  }
+  /**
+   * Autocomplete
+   * @param queryToken Suchbegriff
+   */
+  SearchAutocomplete(queryToken: AutocompleteTokenDTO): __Observable<ListResponseArgsOfAutocompleteDTO> {
+    return this.SearchAutocompleteResponse(queryToken).pipe(__map((_r) => _r.body as ListResponseArgsOfAutocompleteDTO));
+  }
+
+  /**
+   * Autocomplete
+   * @param params The `SearchService.SearchAutocomplete2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `queryToken`: Suchbegriff
+   */
+  SearchAutocomplete2Response(
+    params: SearchService.SearchAutocomplete2Params,
+  ): __Observable<__StrictHttpResponse<ListResponseArgsOfAutocompleteDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    __body = params.queryToken;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/stock/${encodeURIComponent(String(params.stockId))}/s/complete`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfAutocompleteDTO>;
+      }),
+    );
+  }
+  /**
+   * Autocomplete
+   * @param params The `SearchService.SearchAutocomplete2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `queryToken`: Suchbegriff
+   */
+  SearchAutocomplete2(params: SearchService.SearchAutocomplete2Params): __Observable<ListResponseArgsOfAutocompleteDTO> {
+    return this.SearchAutocomplete2Response(params).pipe(__map((_r) => _r.body as ListResponseArgsOfAutocompleteDTO));
+  }
+
+  /**
+   * Suche nach IDs
+   * @param ids PKs
+   */
+  SearchByIdResponse(ids: Array<number>): __Observable<__StrictHttpResponse<ListResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    __body = ids;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/s/byid`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Suche nach IDs
+   * @param ids PKs
+   */
+  SearchById(ids: Array<number>): __Observable<ListResponseArgsOfItemDTO> {
+    return this.SearchByIdResponse(ids).pipe(__map((_r) => _r.body as ListResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Suche nach IDs
+   * @param params The `SearchService.SearchById2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `ids`: PKs
+   */
+  SearchById2Response(params: SearchService.SearchById2Params): __Observable<__StrictHttpResponse<ListResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    __body = params.ids;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/stock/${encodeURIComponent(String(params.stockId))}/s/byid`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Suche nach IDs
+   * @param params The `SearchService.SearchById2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `ids`: PKs
+   */
+  SearchById2(params: SearchService.SearchById2Params): __Observable<ListResponseArgsOfItemDTO> {
+    return this.SearchById2Response(params).pipe(__map((_r) => _r.body as ListResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Suche nach EAN
+   * @param eans EANs
+   */
+  SearchByEANResponse(eans: Array<string>): __Observable<__StrictHttpResponse<ListResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    __body = eans;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/s/byean`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Suche nach EAN
+   * @param eans EANs
+   */
+  SearchByEAN(eans: Array<string>): __Observable<ListResponseArgsOfItemDTO> {
+    return this.SearchByEANResponse(eans).pipe(__map((_r) => _r.body as ListResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Suche nach EAN
+   * @param params The `SearchService.SearchByEAN2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `eans`: EANs
+   */
+  SearchByEAN2Response(params: SearchService.SearchByEAN2Params): __Observable<__StrictHttpResponse<ListResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    __body = params.eans;
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/stock/${encodeURIComponent(String(params.stockId))}/s/byean`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Suche nach EAN
+   * @param params The `SearchService.SearchByEAN2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `eans`: EANs
+   */
+  SearchByEAN2(params: SearchService.SearchByEAN2Params): __Observable<ListResponseArgsOfItemDTO> {
+    return this.SearchByEAN2Response(params).pipe(__map((_r) => _r.body as ListResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Suche nach EAN
+   * @param params The `SearchService.SearchByEAN3Params` containing the following parameters:
+   *
+   * - `eans`: EANs
+   *
+   * - `branchNumber`: Filiale-Nr (optional)
+   */
+  SearchByEAN3Response(params: SearchService.SearchByEAN3Params): __Observable<__StrictHttpResponse<ListResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    __body = params.eans;
+
+    let req = new HttpRequest<any>('POST', this.rootUrl + `/branch/${encodeURIComponent(String(params.branchNumber))}/s/byean`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ListResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Suche nach EAN
+   * @param params The `SearchService.SearchByEAN3Params` containing the following parameters:
+   *
+   * - `eans`: EANs
+   *
+   * - `branchNumber`: Filiale-Nr (optional)
+   */
+  SearchByEAN3(params: SearchService.SearchByEAN3Params): __Observable<ListResponseArgsOfItemDTO> {
+    return this.SearchByEAN3Response(params).pipe(__map((_r) => _r.body as ListResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Detail
+   * @param params The `SearchService.SearchDetailParams` containing the following parameters:
+   *
+   * - `id`: PK
+   *
+   * - `doNotTrack`:
+   */
+  SearchDetailResponse(params: SearchService.SearchDetailParams): __Observable<__StrictHttpResponse<ResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    if (params.doNotTrack != null) __params = __params.set('doNotTrack', params.doNotTrack.toString());
+    let req = new HttpRequest<any>('GET', this.rootUrl + `/s/${encodeURIComponent(String(params.id))}`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Detail
+   * @param params The `SearchService.SearchDetailParams` containing the following parameters:
+   *
+   * - `id`: PK
+   *
+   * - `doNotTrack`:
+   */
+  SearchDetail(params: SearchService.SearchDetailParams): __Observable<ResponseArgsOfItemDTO> {
+    return this.SearchDetailResponse(params).pipe(__map((_r) => _r.body as ResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Detail
+   * @param params The `SearchService.SearchDetail2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `id`: PK
+   *
+   * - `doNotTrack`:
+   */
+  SearchDetail2Response(params: SearchService.SearchDetail2Params): __Observable<__StrictHttpResponse<ResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    if (params.doNotTrack != null) __params = __params.set('doNotTrack', params.doNotTrack.toString());
+    let req = new HttpRequest<any>(
+      'GET',
+      this.rootUrl + `/stock/${encodeURIComponent(String(params.stockId))}/s/${encodeURIComponent(String(params.id))}`,
+      __body,
+      {
+        headers: __headers,
+        params: __params,
+        responseType: 'json',
+      },
+    );
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Detail
+   * @param params The `SearchService.SearchDetail2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `id`: PK
+   *
+   * - `doNotTrack`:
+   */
+  SearchDetail2(params: SearchService.SearchDetail2Params): __Observable<ResponseArgsOfItemDTO> {
+    return this.SearchDetail2Response(params).pipe(__map((_r) => _r.body as ResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Detail by EAN
+   * @param ean EAN
+   */
+  SearchDetailByEANResponse(ean: string): __Observable<__StrictHttpResponse<ResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    let req = new HttpRequest<any>('GET', this.rootUrl + `/s/ean/${encodeURIComponent(String(ean))}`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Detail by EAN
+   * @param ean EAN
+   */
+  SearchDetailByEAN(ean: string): __Observable<ResponseArgsOfItemDTO> {
+    return this.SearchDetailByEANResponse(ean).pipe(__map((_r) => _r.body as ResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Detail by EAN
+   * @param params The `SearchService.SearchDetailByEAN2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `ean`: EAN
+   */
+  SearchDetailByEAN2Response(params: SearchService.SearchDetailByEAN2Params): __Observable<__StrictHttpResponse<ResponseArgsOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    let req = new HttpRequest<any>(
+      'GET',
+      this.rootUrl + `/stock/${encodeURIComponent(String(params.stockId))}/ean/${encodeURIComponent(String(params.ean))}`,
+      __body,
+      {
+        headers: __headers,
+        params: __params,
+        responseType: 'json',
+      },
+    );
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Detail by EAN
+   * @param params The `SearchService.SearchDetailByEAN2Params` containing the following parameters:
+   *
+   * - `stockId`: Lager PK (optional)
+   *
+   * - `ean`: EAN
+   */
+  SearchDetailByEAN2(params: SearchService.SearchDetailByEAN2Params): __Observable<ResponseArgsOfItemDTO> {
+    return this.SearchDetailByEAN2Response(params).pipe(__map((_r) => _r.body as ResponseArgsOfItemDTO));
+  }
+
+  /**
+   * Settings
+   */
+  SearchSettingsResponse(): __Observable<__StrictHttpResponse<ResponseArgsOfUISettingsDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    let req = new HttpRequest<any>('GET', this.rootUrl + `/s/settings`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfUISettingsDTO>;
+      }),
+    );
+  }
+  /**
+   * Settings
+   */
+  SearchSettings(): __Observable<ResponseArgsOfUISettingsDTO> {
+    return this.SearchSettingsResponse().pipe(__map((_r) => _r.body as ResponseArgsOfUISettingsDTO));
+  }
+
+  /**
+   * Filter
+   */
+  SearchSearchFilterResponse(): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfInputGroupDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    let req = new HttpRequest<any>('GET', this.rootUrl + `/s/filter`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfInputGroupDTO>;
+      }),
+    );
+  }
+  /**
+   * Filter
+   */
+  SearchSearchFilter(): __Observable<ResponseArgsOfIEnumerableOfInputGroupDTO> {
+    return this.SearchSearchFilterResponse().pipe(__map((_r) => _r.body as ResponseArgsOfIEnumerableOfInputGroupDTO));
+  }
+
+  /**
+   * Filter
+   */
+  SearchSearchSortResponse(): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfOrderByDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    let req = new HttpRequest<any>('GET', this.rootUrl + `/s/sort`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfOrderByDTO>;
+      }),
+    );
+  }
+  /**
+   * Filter
+   */
+  SearchSearchSort(): __Observable<ResponseArgsOfIEnumerableOfOrderByDTO> {
+    return this.SearchSearchSortResponse().pipe(__map((_r) => _r.body as ResponseArgsOfIEnumerableOfOrderByDTO));
+  }
+
+  /**
+   * Suchhistorie
+   * @param take Take
+   */
+  SearchHistoryResponse(take?: null | number): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfQueryTokenDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+    if (take != null) __params = __params.set('take', take.toString());
+    let req = new HttpRequest<any>('GET', this.rootUrl + `/s/history`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfQueryTokenDTO>;
+      }),
+    );
+  }
+  /**
+   * Suchhistorie
+   * @param take Take
+   */
+  SearchHistory(take?: null | number): __Observable<ResponseArgsOfIEnumerableOfQueryTokenDTO> {
+    return this.SearchHistoryResponse(take).pipe(__map((_r) => _r.body as ResponseArgsOfIEnumerableOfQueryTokenDTO));
+  }
+
+  /**
+   * Get Recommendation
+   * @param params The `SearchService.SearchGetRecommendationsParams` containing the following parameters:
+   *
+   * - `digId`:
+   *
+   * - `sessionId`: Process Id
+   *
+   * @return ResponseArgs of Recomendations
+   */
+  SearchGetRecommendationsResponse(
+    params: SearchService.SearchGetRecommendationsParams,
+  ): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfItemDTO>> {
+    let __params = this.newParams();
+    let __headers = new HttpHeaders();
+    let __body: any = null;
+
+    if (params.sessionId != null) __params = __params.set('sessionId', params.sessionId.toString());
+    let req = new HttpRequest<any>('GET', this.rootUrl + `/s/recommendations/${encodeURIComponent(String(params.digId))}`, __body, {
+      headers: __headers,
+      params: __params,
+      responseType: 'json',
+    });
+
+    return this.http.request<any>(req).pipe(
+      __filter((_r) => _r instanceof HttpResponse),
+      __map((_r) => {
+        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfItemDTO>;
+      }),
+    );
+  }
+  /**
+   * Get Recommendation
+   * @param params The `SearchService.SearchGetRecommendationsParams` containing the following parameters:
+   *
+   * - `digId`:
+   *
+   * - `sessionId`: Process Id
+   *
+   * @return ResponseArgs of Recomendations
+   */
+  SearchGetRecommendations(params: SearchService.SearchGetRecommendationsParams): __Observable<ResponseArgsOfIEnumerableOfItemDTO> {
+    return this.SearchGetRecommendationsResponse(params).pipe(__map((_r) => _r.body as ResponseArgsOfIEnumerableOfItemDTO));
+  }
+}
+
+module SearchService {
+  /**
+   * Parameters for SearchTop2
+   */
+  export interface SearchTop2Params {
+    /**
+     * Lager PK (optional)
+     */
+    stockId: number;
+
+    /**
+     * Suchkriterien
+     */
+    queryToken: QueryTokenDTO;
+  }
+
+  /**
+   * Parameters for SearchSearch2
+   */
+  export interface SearchSearch2Params {
+    /**
+     * Lager PK (optional)
+     */
+    stockId: number;
+
+    /**
+     * Suchkriterien
+     */
+    queryToken: QueryTokenDTO;
+  }
+
+  /**
+   * Parameters for SearchAutocomplete2
+   */
+  export interface SearchAutocomplete2Params {
+    /**
+     * Lager PK (optional)
+     */
+    stockId: number;
+
+    /**
+     * Suchbegriff
+     */
+    queryToken: AutocompleteTokenDTO;
+  }
+
+  /**
+   * Parameters for SearchById2
+   */
+  export interface SearchById2Params {
+    /**
+     * Lager PK (optional)
+     */
+    stockId: number;
+
+    /**
+     * PKs
+     */
+    ids: Array<number>;
+  }
+
+  /**
+   * Parameters for SearchByEAN2
+   */
+  export interface SearchByEAN2Params {
+    /**
+     * Lager PK (optional)
+     */
+    stockId: number;
+
+    /**
+     * EANs
+     */
+    eans: Array<string>;
+  }
+
+  /**
+   * Parameters for SearchByEAN3
+   */
+  export interface SearchByEAN3Params {
+    /**
+     * EANs
+     */
+    eans: Array<string>;
+
+    /**
+     * Filiale-Nr (optional)
+     */
+    branchNumber: string;
+  }
+
+  /**
+   * Parameters for SearchDetail
+   */
+  export interface SearchDetailParams {
+    /**
+     * PK
+     */
+    id: number;
+    doNotTrack?: boolean;
+  }
+
+  /**
+   * Parameters for SearchDetail2
+   */
+  export interface SearchDetail2Params {
+    /**
+     * Lager PK (optional)
+     */
+    stockId: number;
+
+    /**
+     * PK
+     */
+    id: number;
+    doNotTrack?: boolean;
+  }
+
+  /**
+   * Parameters for SearchDetailByEAN2
+   */
+  export interface SearchDetailByEAN2Params {
+    /**
+     * Lager PK (optional)
+     */
+    stockId: number;
+
+    /**
+     * EAN
+     */
+    ean: string;
+  }
+
+  /**
+   * Parameters for SearchGetRecommendations
+   */
+  export interface SearchGetRecommendationsParams {
+    digId: string;
+
+    /**
+     * Process Id
+     */
+    sessionId?: null | string;
+  }
+}
+
+export { SearchService };

generated/swagger/cat-search-api/src/strict-http-response.ts

@@ -0,0 +1,9 @@
+/* tslint:disable */
+import { HttpResponse } from '@angular/common/http';
+
+/**
+ * Constrains the http to not expand the response type with `| null`
+ */
+export type StrictHttpResponse<T> = HttpResponse<T> & {
+  readonly body: T;
+};