@oiz/stzh-components 2.11.0-beta1 → 2.11.1

package/dist/types/components/stzh-timepicker/stzh-timepicker.d.ts

@@ -0,0 +1,62 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import { StzhTimepickerChangeEvent } from "../../index";
+import { StzhTimepickerLocalizedText } from "./stzh-timepicker.localization";
+/**
+ */
+export declare class StzhTimepicker {
+  /** Initial open state */
+  open: boolean;
+  /**
+   * Minimum time allowed to be picked in minutes. Can not be lower than 0.
+   * This setting can be used alone or together with the max property.
+   */
+  min: number;
+  /**
+   * Maximum time allowed to be picked in minutes. Can not be higher than 1440 (24h * 60).
+   * This setting can be used alone or together with the min property.
+   */
+  max: number;
+  /** Time added for each step in minutes. */
+  step: number;
+  /** Name of the hidden date picker input. */
+  name: string;
+  /** Value of dropdown (current selected time in format HH:MM). */
+  value: string;
+  /** Popover placement for the dropdown (if applicable) */
+  popoverPlacement: "bottom" | "bottom-end" | "bottom-center" | "top" | "top-end" | "top-center";
+  /** Label for dropdown */
+  label: string;
+  /** Whether the element is readonly or not */
+  readonly: boolean;
+  /** Whether the element is disabled or not */
+  disabled: boolean;
+  /** Description message (use description slot as alternative) */
+  description: string;
+  /** Long description message appearing in a popover (use description-long slot as alternative) */
+  descriptionLong: string;
+  /** One or multiple error message (use error slot as alternative) */
+  error: string | string[];
+  /** Invalid status */
+  invalid: boolean;
+  /** Required status */
+  required: boolean;
+  /** Append text to label depending if field is optional/required. true -> show "(optional)", false -> show nothing */
+  showMarker: boolean;
+  /** Size variant */
+  size: "default" | "small";
+  /** Id of the element which describes the input */
+  a11yDescribedby: string;
+  /**  Translation strings. */
+  localization: StzhTimepickerLocalizedText;
+  /** Timepicker change event */
+  stzhChange: EventEmitter<StzhTimepickerChangeEvent>;
+  element: HTMLStzhTimepickerElement;
+  minMaxWatcher(): void;
+  private input;
+  private _dropdownOptions;
+  private onRootFocus;
+  private onDropdownChange;
+  private updateDropdownOptions;
+  componentWillLoad(): Promise<void>;
+  render(): any;
+}

package/dist/types/components/stzh-toast/stzh-toast.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import { StzhToastOpenEvent, StzhToastOpenedEvent, StzhToastCloseEvent, StzhToastClosedEvent, StzhToastType } from "../../index";
+import { StzhToastLocalizedText } from "./stzh-toast.localization";
+/**
+ * @slot link - Slot for optional stzh-link element
+ */
+export declare class StzhToast {
+  /** Label */
+  label: string;
+  /** Type */
+  type: StzhToastType;
+  /** Whether to hide close button */
+  hideClose: boolean;
+  /** Open state */
+  open: boolean;
+  /** Whether open animation should be played initially. */
+  initialOpenAnimation: boolean;
+  /** Translation strings. */
+  localization: StzhToastLocalizedText;
+  /** Toast open event */
+  stzhOpen: EventEmitter<StzhToastOpenEvent>;
+  /** Toast opened event (after animation)  */
+  stzhOpened: EventEmitter<StzhToastOpenedEvent>;
+  /** Toast close event */
+  stzhClose: EventEmitter<StzhToastCloseEvent>;
+  /** Toast closed event (after animation)  */
+  stzhClosed: EventEmitter<StzhToastClosedEvent>;
+  element: HTMLStzhToastElement;
+  openWatcher(newValue: boolean): Promise<void>;
+  show(): Promise<void>;
+  hide(): Promise<void>;
+  private toggledByMethod;
+  private rootElement;
+  private handleLinkSlotchange;
+  private onCloseButtonClick;
+  componentWillLoad(): Promise<void>;
+  componentDidLoad(): void;
+  render(): any;
+}

package/dist/types/components/stzh-toastbar/stzh-toastbar.d.ts

@@ -0,0 +1,41 @@
+import { StzhToastbarInitialToast, StzhToastType } from "../../index";
+/**
+ * @slot - Slot for stzh-toast elements
+ */
+export declare class StzhToastbar {
+  /**
+   * Time after toasts are hidden (in seconds).
+   * Toasts with type `error` will stay, until the user closes them manually.
+   */
+  hideAfter: number;
+  /**
+   * Maximum of toasts allowed to be shown.
+   * If more are created, oldest will be hidden, even if timeout not ended yet or toast type is `error`.
+   */
+  max: number;
+  /**
+   * Initial toasts.
+   *
+   * Array of objects that at least includes `label` and optionally `type`, `link` (object with `href` and `label`) `cookie` and `cookieExpires`:
+   * `[{"label": "Lorem ipsum", "link": { "label": "More info", "href": "https://example.com" }, "cookie": "cookie-banner", "cookieExpires": 365 }]`
+   *
+   * If `cookie` exists in an object, it will check for that cookie name first (prefixed with `stzh-components-toastbar-closed-`) and only show if cookie doesn't exist.
+   * `cookieExpires` sets the cookie lifetime (default 365 days, set 0 for session cookie).
+   */
+  initialToasts: StzhToastbarInitialToast[] | string;
+  private _initialToasts;
+  element: HTMLStzhToastbarElement;
+  /** Create new toast. */
+  toast(label: string, { type, link }?: {
+    type?: StzhToastType;
+    link?: HTMLStzhLinkElement;
+  }): Promise<HTMLStzhToastElement>;
+  initialToastsWatcher(newValue: any[] | string): void;
+  private toastAppended;
+  private toastsAppended;
+  private hideOverflowingItems;
+  private handleSlotchange;
+  componentWillLoad(): void;
+  componentDidLoad(): void;
+  render(): any;
+}

package/dist/types/components/stzh-toggle/stzh-toggle.d.ts

@@ -0,0 +1,59 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import { StzhToggleChangeEvent, StzhToggleFocusEvent, StzhToggleBlurEvent } from "../../index";
+import { StzhLocaleComponent } from "../../utils/translation-utils";
+/**
+ * @slot - Slot for label content
+ * @slot description - Slot for description
+ * @slot description-long - Slot for long description (in popover)
+ * @slot error - Slot for error
+ */
+export declare class StzhToggle {
+  /** Translation strings */
+  localization: StzhLocaleComponent;
+  /** Whether the toggle is disabled */
+  disabled: boolean;
+  /** Name of the input element */
+  name: string;
+  /** Value of the input element */
+  value: string;
+  /** Invalid status */
+  invalid: boolean;
+  /** Required status */
+  required: boolean;
+  /** Append text to label depending if field is optional/required. true -> show "(optional)", false -> show nothing */
+  showMarker: boolean;
+  /** Checked status */
+  checked: boolean;
+  /** Label */
+  label: string;
+  /** Position of label */
+  labelPosition: "right" | "left";
+  /** Description message (use description slot as alternative) */
+  description: string;
+  /** Long description message appearing in a popover (use description-long slot as alternative) */
+  descriptionLong: string;
+  /** One or multiple error message (use error slot as alternative) */
+  error: string | string[];
+  private _error;
+  /** Id for element which describes the input (this will be overwritten if description prop or slot is used) */
+  a11yDescribedby: string;
+  /** Focus input field */
+  setFocus(): Promise<void>;
+  /** Change event */
+  stzhChange: EventEmitter<StzhToggleChangeEvent>;
+  /** Focus event */
+  stzhFocus: EventEmitter<StzhToggleFocusEvent>;
+  /** Input blur event */
+  stzhBlur: EventEmitter<StzhToggleBlurEvent>;
+  errorWatcher(newValue: string | string[]): void;
+  element: HTMLStzhRadioElement;
+  private input;
+  private inputId;
+  private focusedByInput;
+  private onInput;
+  private onRootFocus;
+  private onFocus;
+  private onBlur;
+  componentWillLoad(): Promise<void>;
+  render(): any;
+}

package/dist/types/components/stzh-tooltip/stzh-tooltip.d.ts

@@ -0,0 +1,80 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import { StzhTooltipOpenEvent, StzhTooltipOpenedEvent, StzhTooltipCloseEvent, StzhTooltipClosedEvent } from "../../index";
+import { Placement } from "@floating-ui/dom";
+import { StzhTooltipLocalizedText } from "./stzh-tooltip.localization";
+/**
+ * @slot Trigger element inside
+ * @slot content - Content of tooltip
+ */
+export declare class StzhTooltip {
+  /** Whether tooltip should be open */
+  open: boolean;
+  /** Label of tooltip (used for screenreaders) */
+  label: string;
+  /** Content of tooltip (use instead of content slot) */
+  content: string;
+  /** Default placement of tooltip relative to trigger element */
+  placement: Placement;
+  /** Position strategy */
+  strategy: "absolute" | "fixed";
+  /** Shifting of tooltip content */
+  skidding: number;
+  /** Distance from tooltip content to trigger (default: arrow height + 8px = 16) */
+  distance: number;
+  /** Whether tooltip is interactive */
+  interactive: boolean;
+  /**
+   * Controls how the tooltip is activated. Possible options include `click`, `hover`, `focus`, and `manual`. Multiple
+   * options can be passed by separating them with a space. When manual is used, the tooltip must be activated
+   * programmatically.
+   */
+  trigger: string;
+  private _trigger;
+  /** Translation strings */
+  localization: StzhTooltipLocalizedText;
+  element: HTMLStzhTooltipElement;
+  /** Tooltip open event */
+  stzhOpen: EventEmitter<StzhTooltipOpenEvent>;
+  /** Tooltip opened event (after animation) */
+  stzhOpened: EventEmitter<StzhTooltipOpenedEvent>;
+  /** Tooltip close event */
+  stzhClose: EventEmitter<StzhTooltipCloseEvent>;
+  /** Tooltip closed event (after animation) */
+  stzhClosed: EventEmitter<StzhTooltipClosedEvent>;
+  /** Show tooltip content */
+  show(): Promise<void>;
+  /** Hide tooltip content */
+  hide(): Promise<void>;
+  /** Toggle tooltip content */
+  toggle(): Promise<void>;
+  update(): Promise<void>;
+  openWatcher(newValue: boolean): Promise<void>;
+  triggerWatcher(newValue: string): void;
+  handleDocumentClick(event: MouseEvent): void;
+  computedPlacement: Placement;
+  private toggledByMethod;
+  private middlewareData;
+  private triggerElement;
+  private contentElement;
+  private arrowElement;
+  private autoUpdateCleanup;
+  private id;
+  private trap;
+  private isHovering;
+  private hasTrigger;
+  private onEscKey;
+  private computePosition;
+  private onClickTrigger;
+  private onMouseEnterTrigger;
+  private onMouseLeaveTrigger;
+  private onFocusTrigger;
+  private onBlurTrigger;
+  private onMouseMoveDocument;
+  componentWillLoad(): Promise<void>;
+  componentDidRender(): void;
+  componentDidUpdate(): void;
+  componentDidLoad(): void;
+  connectedCallback(): void;
+  disconnectedCallback(): void;
+  render(): any;
+}

package/dist/types/components/stzh-upload/stzh-upload.d.ts

@@ -0,0 +1,236 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import { StzhUploadFilesItem, StzhUploadFileAddedEvent, StzhUploadFilesAddedEvent, StzhUploadFileRemoveEvent, StzhUploadFileRemovedEvent, StzhUploadSendingEvent, StzhUploadSendingMultipleEvent, StzhUploadProcessingEvent, StzhUploadProcessingMultipleEvent, StzhUploadProgressEvent, StzhUploadProgressTotalEvent, StzhUploadErrorEvent, StzhUploadErrorMultipleEvent, StzhUploadSuccessEvent, StzhUploadSuccessMultipleEvent, StzhUploadCanceledEvent, StzhUploadCanceledMultipleEvent, StzhUploadCompleteEvent, StzhUploadCompleteMultipleEvent } from "../../index";
+import { StzhUploadLocalizedText } from './stzh-upload.localization';
+import "../../libraries/dropzone/dropzone";
+/**
+ * @slot error - Slot for error
+ */
+export declare class StzhUpload {
+  /**
+   * Initially pre existing files (e.g. already uploaded by the user).
+   * Array of objects that must at least include `name` and `size` attribute:
+   * `[{"name":"file1.txt", "size": 12345}, {"name":"file2.txt", "size": 12345}]`
+   */
+  existingFiles: StzhUploadFilesItem[] | string;
+  private _existingFiles;
+  /** Label */
+  label: string;
+  /** Description */
+  description: string;
+  /** Button text */
+  button: string;
+  /**
+   * URL the files are processed to.
+   *
+   * You can also provide a function that will be called with `files` and
+   * `dataBlocks`  and must return the url as string.
+   */
+  url: string | Function;
+  /**
+   * Can be changed to `"put"` if necessary. You can also provide a function
+   * that will be called with `files` and must return the method.
+   */
+  method: "post" | "put" | Function;
+  /**
+   * Will be set on the XHRequest.
+   */
+  withCredentials: boolean;
+  /**
+   * Whether the upload is disabled or not.
+   */
+  disabled: boolean;
+  /**
+   * Whether the upload is marked as invalid.
+   */
+  invalid: boolean;
+  /** Whether download functionality should be disabled. */
+  downloadDisabled: boolean;
+  /** Whether download functionality should only be shown to completed files. */
+  downloadDisabledWhileProcessing: boolean;
+  /** One or multiple error message (use error slot as alternative) */
+  error: string | string[];
+  private _error;
+  /**
+   * The default implementation of `accept` checks the file's mime type or
+   * extension against this list. This is a comma separated list of mime
+   * types or file extensions.
+   *
+   * Eg.: `image/*,application/pdf,.psd`
+   *
+   * This option will also be used as
+   * [`accept`](https://developer.mozilla.org/en-US/docs/HTML/Element/input#attr-accept)
+   * parameter on the hidden file input as well.
+   */
+  acceptedFiles: string | null;
+  /**
+   * If false, files will be added to the queue but the queue will not be
+   * processed automatically.
+   * This can be useful if you need some additional user input before sending
+   * files (or if you want want all files sent at once).
+   * If you're ready to send the file simply call `element.processQueue()`.
+   */
+  autoProcessQueue: boolean;
+  /**
+   * Hide progress (bars and text).
+   */
+  hideProgress: boolean;
+  /**
+   * Hide progress (bars) only while idle (will show them as soon as upload starts).
+   * Can be used together with `autoProcessQueue`, e.g. if files are uploaded at form submit to prevent showing empty progressbar.
+   */
+  hideProgressWhileIdle: boolean;
+  /**
+   * If not `null` defines how many files this dropzone handles. If it exceeds,
+   * the event `stzhMaxfilesexceeded` will be called.
+   */
+  maxFiles: number | null;
+  /**
+   * The maximum filesize (in MiB) that is allowed to be uploaded.
+   */
+  maxFilesize: number;
+  /**
+   * How many file uploads to process in parallel.
+   */
+  parallelUploads: number;
+  /**
+   * Whether to send multiple files in one request. If
+   * this it set to true, then the fallback file input element will
+   * have the `multiple` attribute as well. This option will
+   * also trigger additional events (like `stzhSuccessMultiple`). See the events
+   * documentation section for more information.
+   */
+  uploadMultiple: boolean;
+  /**
+   * Whether you want files to be uploaded in chunks to your server. This can't be
+   * used in combination with `uploadMultiple`.
+   *
+   * See `chunksUploaded` prop for the callback to finalise an upload.
+   */
+  chunking: boolean;
+  /**
+   * If `chunking` is enabled, this defines whether **every** file should be chunked,
+   * even if the file size is below chunkSize. This means, that the additional chunk
+   * form data will be submitted and the `chunksUploaded` callback will be invoked.
+   */
+  forceChunking: boolean;
+  /**
+   * If `chunking` is `true`, then this defines the chunk size in bytes.
+   */
+  chunkSize: number;
+  /**
+   * If `true`, the individual chunks of a file are being uploaded simultaneously.
+   */
+  parallelChunkUploads: boolean;
+  /**
+   * Whether a chunk should be retried if it fails.
+   */
+  retryChunks: boolean;
+  /**
+   * If `retryChunks` is true, how many times should it be retried.
+   */
+  retryChunksLimit: number;
+  /**
+   * The base that is used to calculate the **displayed** filesize. You can
+   * change this to 1024 if you would rather display kibibytes, mebibytes,
+   * etc... 1024 is technically incorrect, because `1024 bytes` are `1 kibibyte`
+   * not `1 kilobyte`. You can change this to `1024` if you don't care about
+   * validity.
+   */
+  filesizeBase: number;
+  /**
+   * An optional object to send additional headers to the server. Eg:
+   * `{ "My-Awesome-Header": "header value" }`
+   */
+  headers: object | null;
+  /**
+   * Should the default headers be set or not?
+   * Accept: application/json <- for requesting json response
+   * Cache-Control: no-cache <- Request shouldnt be cached
+   * X-Requested-With: XMLHttpRequest <- We sent the request via XMLHttpRequest
+   */
+  defaultHeaders: boolean;
+  /**
+   * A function that gets a [file](https://developer.mozilla.org/en-US/docs/DOM/File)
+   * and a `done` function as parameters.
+   *
+   * If the done function is invoked without arguments, the file is "accepted" and will
+   * be processed. If you pass an error message, the file is rejected, and the error
+   * message will be displayed.
+   * This function will not be called if the file is too big or doesn't match the mime types.
+   */
+  accept: Function;
+  /**
+   * The callback that will be invoked when all chunks have been uploaded for a file.
+   * It gets the file for which the chunks have been uploaded as the first parameter,
+   * and the `done` function as second. `done()` needs to be invoked when everything
+   * needed to finish the upload process is done.
+   */
+  chunksUploaded: Function;
+  /**
+   * This is the element the hidden input field (which is used when clicking on the
+   * dropzone to trigger file selection) will be appended to. This might
+   * be important in case you use frameworks to switch the content of your page.
+   *
+   * Can be a selector string, or an element directly. Will be rendered into element by default.
+   */
+  hiddenInputContainer: string | HTMLElement;
+  /** Translation strings. */
+  localization: StzhUploadLocalizedText;
+  element: HTMLStzhUploadElement;
+  existingFilesWatcher(newValue: StzhUploadFilesItem[] | string): void;
+  disabledWatcher(): void;
+  errorWatcher(newValue: string | string[]): void;
+  /** File added */
+  stzhFileAdded: EventEmitter<StzhUploadFileAddedEvent>;
+  /** Files added (multiple) */
+  stzhFilesAdded: EventEmitter<StzhUploadFilesAddedEvent>;
+  /** File remove (before, cancelable) */
+  stzhFileRemove: EventEmitter<StzhUploadFileRemoveEvent>;
+  /** File removed */
+  stzhFileRemoved: EventEmitter<StzhUploadFileRemovedEvent>;
+  /** Before sending file (add additional data before request if necessary) */
+  stzhSending: EventEmitter<StzhUploadSendingEvent>;
+  /** Before sending multiple files (add additional data before request if necessary) */
+  stzhSendingMultiple: EventEmitter<StzhUploadSendingMultipleEvent>;
+  /** Files starting to get processed */
+  stzhProcessing: EventEmitter<StzhUploadProcessingEvent>;
+  /** Files starting to get processed (multiple) */
+  stzhProcessingMultiple: EventEmitter<StzhUploadProcessingMultipleEvent>;
+  /** Upload file progress during upload */
+  stzhProgress: EventEmitter<StzhUploadProgressEvent>;
+  /** Upload total file progress during upload */
+  stzhProgressTotal: EventEmitter<StzhUploadProgressTotalEvent>;
+  /** File error */
+  stzhError: EventEmitter<StzhUploadErrorEvent>;
+  /** Files error (multiple files) */
+  stzhErrorMultiple: EventEmitter<StzhUploadErrorMultipleEvent>;
+  /** File successfully uploaded */
+  stzhSuccess: EventEmitter<StzhUploadSuccessEvent>;
+  /** Files successfully uploaded (multiple files) */
+  stzhSuccessMultiple: EventEmitter<StzhUploadSuccessMultipleEvent>;
+  /** Canceled file upload */
+  stzhCanceled: EventEmitter<StzhUploadCanceledEvent>;
+  /** Canceled file upload (multiple files) */
+  stzhCanceledMultiple: EventEmitter<StzhUploadCanceledMultipleEvent>;
+  /** Completed upload (successfully or with error) */
+  stzhComplete: EventEmitter<StzhUploadCompleteEvent>;
+  /** Completed upload (successfully or with error, multiple files) */
+  stzhCompleteMultiple: EventEmitter<StzhUploadCompleteMultipleEvent>;
+  processQueue(): Promise<any>;
+  removeFile(file: any, force?: boolean): Promise<any>;
+  removeAllFiles(onlyCancelCurrentlyUploadingFiles?: boolean, force?: boolean): Promise<any>;
+  private dropzone;
+  private dropzoneElement;
+  private buttonElement;
+  private clickareaElement;
+  private previewsElement;
+  private errorsElement;
+  private hiddenInputContainerElement;
+  private uploadId;
+  private filesize;
+  private filePreviewId;
+  componentWillLoad(): Promise<void>;
+  componentDidRender(): void;
+  disconnectedCallback(): void;
+  render(): any;
+}

package/dist/types/components/stzh-vbz-carousel/stzh-vbz-carousel.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @slot - Slot any element
+ */
+export declare class StzhVbzCarousel {
+  /** Timeout delay in milliseconds used for autoplay */
+  autoplayTimeout: number;
+  element: HTMLStzhFigureElement;
+  private majorTicker;
+  private hideElement;
+  private onDisturbanceFetched;
+  connectedCallback(): Promise<void>;
+  disconnectedCallback(): void;
+  render(): any;
+}

package/dist/types/components/stzh-vbz-linechip/stzh-vbz-linechip.d.ts

@@ -0,0 +1,37 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import { StzhVbzLinechipFocusEvent, StzhVbzLinechipBlurEvent } from "../../index";
+import { VBZ } from "../../index";
+/**
+ *
+ */
+export declare class StzhVbzLinechip {
+  /** Line */
+  line: VBZ.Lines;
+  /** Active */
+  active: boolean;
+  /** Show alert icon */
+  alert: boolean;
+  /** Whether it is a global disturbance */
+  global: boolean;
+  /** Whether fold disabled */
+  disabled: boolean;
+  /**
+   * For Adobe Analytics.
+   * Will be rendered as value of `s-object-id` attribute to the button element.
+   * Default value will be taken from `line` prop or "Global" if global is true.
+   */
+  analyticsId: string;
+  element: HTMLStzhVbzLinechipElement;
+  /** Focus menu item */
+  setFocus(): Promise<void>;
+  /** Focus event */
+  stzhFocus: EventEmitter<StzhVbzLinechipFocusEvent>;
+  /** Input blur event */
+  stzhBlur: EventEmitter<StzhVbzLinechipBlurEvent>;
+  private chip;
+  private focusedByInput;
+  private onRootFocus;
+  private onFocus;
+  private onBlur;
+  render(): any;
+}

package/dist/types/components/stzh-vbz-majorticker/stzh-vbz-majorticker.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+import { StzhLocaleAdapter } from "../../utils/date-adapter";
+import { StzhVbzMajortickerLocalizedText } from "./stzh-vbz-majorticker.localization";
+import { StzhVbzMajortickerDisturbanceFetchedEvent, StzhVbzMajortickerDisturbance } from "../../index";
+/**
+ */
+export declare class StzhVbzMajorticker {
+  /** API URL (`{lang}` is replaced in the URL)  */
+  api: string;
+  /** Data to pass in directly (alternative for API call) */
+  data: any;
+  private _data;
+  /** More info link (`{lang}` and `{id}` are replaced in the URL) */
+  moreInfoLink: string;
+  /**
+   * Date adapter, for custom parsing/formatting.
+   * Must be object with a `parse` function which accepts a `string` and returns a `Date`,
+   * and a `format` function which accepts a `Date` and returns a `string`.
+   */
+  dateAdapter: StzhLocaleAdapter;
+  /** Translation strings. */
+  localization: StzhVbzMajortickerLocalizedText;
+  /** Overwrite ghettobox close time cookie option if needed */
+  ghettoboxCloseTimeKey: string;
+  /** Whether ghettobox is shown (if has not been closed before) */
+  ghettoboxShown: boolean;
+  element: HTMLStzhVbzMajortickerElement;
+  /** Event when major disturbance was fetched */
+  stzhDisturbanceFetched: EventEmitter<StzhVbzMajortickerDisturbanceFetchedEvent>;
+  /** Return whether ghettobox is shown (if has not been closed before) */
+  getGhettoboxShown(): Promise<boolean>;
+  /** Return fetched disturbance */
+  getDisturbance(): Promise<StzhVbzMajortickerDisturbance>;
+  apiWatcher(newValue: string): Promise<void>;
+  dataWatcher(newValue: any): Promise<void>;
+  private disturbance;
+  private onGhettoboxOpen;
+  private onGhettoboxClose;
+  componentWillLoad(): Promise<void>;
+  render(): any;
+}

package/dist/types/components/stzh-vbz-ticker/stzh-vbz-ticker.d.ts

@@ -0,0 +1,34 @@
+import { StzhLocaleAdapter } from "../../utils/date-adapter";
+import { VbzTickerDisturbance } from "../../index";
+import { StzhVbzTickerLocalizedText } from "./stzh-vbz-ticker.localization";
+/**
+ * @slot link - Optional link to traffic situation
+ */
+export declare class StzhVbzTicker {
+  /** API URL (`{lang}` is replaced in the URL)  */
+  api: string;
+  /** Data to pass in directly (alternative for API call) */
+  data: any;
+  private _data;
+  /** More info link (`{lang}` and `{id}` are replaced in the URL) */
+  moreInfoLink: string;
+  /**
+   * Date adapter, for custom parsing/formatting.
+   * Must be object with a `parse` function which accepts a `string` and returns a `Date`,
+   * and a `format` function which accepts a `Date` and returns a `string`.
+   */
+  dateAdapter: StzhLocaleAdapter;
+  /** Translation strings. */
+  localization: StzhVbzTickerLocalizedText;
+  element: HTMLStzhVbzTickerElement;
+  private globalDisturbances;
+  private lines;
+  private collator;
+  private counter;
+  localizationWatcher(): void;
+  apiWatcher(newValue: string): Promise<void>;
+  dataWatcher(newValue: any): Promise<void>;
+  componentWillLoad(): Promise<void>;
+  renderDisturbance(disturbance: VbzTickerDisturbance): any;
+  render(): any;
+}

package/dist/types/components/stzh-youtube/stzh-youtube.d.ts

@@ -0,0 +1,30 @@
+import { StzhYoutubeLocalizedText } from './stzh-youtube.localization';
+/**
+ *
+ */
+export declare class StzhYoutube {
+  /** Translation strings */
+  localization: StzhYoutubeLocalizedText;
+  /** URL to youtube video */
+  url: string;
+  /**
+   * Cookie name (used for showing/hiding cookie wall)
+   * Will be prefixed with `stzh-components-iframe-confirm-`.
+   */
+  cookie: string;
+  /**
+   * Number of days the cookie is valid for.
+   * If omitted or set to null or 0, the cookie expires when browser is closed.
+   * Maximum is on year (365 days, is default).
+   */
+  cookieExpires: number | null;
+  /** Whether preview should be skipped, if user passed the cookiewall before */
+  skipPreviewIfCookieAccepted: boolean;
+  /** Whether preview should always be skipped */
+  skipPreview: boolean;
+  element: HTMLStzhYoutubeElement;
+  previewSkipped: boolean;
+  private handlePreviewSkipped;
+  componentWillLoad(): Promise<void>;
+  render(): any;
+}