@folklore/ads 0.0.109 → 0.0.111

package/dist/es.js

@@ -1,9 +1,8 @@
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
-import isFunction from 'lodash/isFunction';
-import isObject from 'lodash/isObject';
-import React, { useContext, useState, useRef, useMemo, useEffect, useCallback, useId } from 'react';
+import React, { useContext, useState, useRef, useMemo, useEffect, createContext, useCallback, useId } from 'react';
 import isArray from 'lodash/isArray';
+import isObject from 'lodash/isObject';
 import sortBy from 'lodash/sortBy';
 import uniqBy from 'lodash/uniqBy';
 import debounce from 'lodash/debounce';
@@ -27,7 +26,7 @@ const adTargeting = PropTypes.shape({
   domain: PropTypes.string
 });
 
-var propTypes$4 = /*#__PURE__*/Object.freeze({
+var propTypes = /*#__PURE__*/Object.freeze({
     __proto__: null,
     adPath: adPath,
     adSize: adSize,
@@ -50,42 +49,45 @@ function normalizeAdSizes(size) {
 function getAdSizes(sizes) {
   return uniqBy(sizes, size => isArray(size) ? size.join('x') : size);
 }
-const getMinimumAdSize = sizes => getAdSizes(sizes).filter(size => size !== 'fluid').reduce((minimumSize, size) => ({
-  width: Math.min(minimumSize.width, size[0]),
-  height: Math.min(minimumSize.height, size[1])
-}), {
-  width: Infinity,
-  height: Infinity
-});
-const sizeFitsInViewport = (size, viewport) => size === 'fluid' && viewport[0] > 600 || size !== 'fluid' && (viewport[0] === 0 || size[0] <= viewport[0]) && (viewport[1] === 0 || size[1] <= viewport[1]);
-const getSortedViewports = viewports => sortBy(Object.keys(viewports).map(name => ({
-  name,
-  size: viewports[name]
-})), [viewport => viewport.size[0]]).reverse();
-const buildSizeMappingFromViewports = (sizeMapping, viewports) => isObject(sizeMapping) && !isArray(sizeMapping) ? getSortedViewports(viewports).reduce((newSizeMapping, _ref) => {
-  let {
+function getMinimumAdSize(sizes) {
+  return getAdSizes(sizes).filter(size => size !== 'fluid').reduce((minimumSize, size) => ({
+    width: Math.min(minimumSize.width, size[0]),
+    height: Math.min(minimumSize.height, size[1])
+  }), {
+    width: Infinity,
+    height: Infinity
+  });
+}
+function sizeFitsInViewport(size, viewport) {
+  return size === 'fluid' && viewport[0] > 600 || size !== 'fluid' && (viewport[0] === 0 || size[0] <= viewport[0]) && (viewport[1] === 0 || size[1] <= viewport[1]);
+}
+function getSortedViewports(viewports) {
+  return sortBy(Object.keys(viewports).map(name => ({
+    name,
+    size: viewports[name]
+  })), [viewport => viewport.size[0]]).reverse();
+}
+function buildSizeMappingFromViewports(sizeMapping, viewports) {
+  return isObject(sizeMapping) && !isArray(sizeMapping) ? getSortedViewports(viewports).reduce((newSizeMapping, {
     name,
     size: viewPortSize
-  } = _ref;
-  return typeof sizeMapping[name] !== 'undefined' ? [...newSizeMapping, [viewPortSize, sizeMapping[name]]] : newSizeMapping;
-}, []) : sizeMapping;
-const buildSizeMappingFromSizes = (sizes, viewports) => getSortedViewports(viewports).map(_ref2 => {
-  let {
+  }) => typeof sizeMapping[name] !== 'undefined' ? [...newSizeMapping, [viewPortSize, sizeMapping[name]]] : newSizeMapping, []) : sizeMapping;
+}
+function buildSizeMappingFromSizes(sizes, viewports) {
+  return getSortedViewports(viewports).map(({
     name,
     size: viewPortSize
-  } = _ref2;
-  return [viewPortSize, sizes.filter(size => sizeFitsInViewport(size, name === 'default' ? [300, 300] : viewPortSize))];
-});
-const getSizeMappingFromSlot = (_ref3, viewports) => {
-  let {
-    size: allSizes = [],
-    sizeMapping = null
-  } = _ref3;
+  }) => [viewPortSize, sizes.filter(size => sizeFitsInViewport(size, name === 'default' ? [300, 300] : viewPortSize))]);
+}
+function getSizeMappingFromSlot({
+  size: allSizes = [],
+  sizeMapping = null
+}, viewports) {
   if (sizeMapping === true) {
     return buildSizeMappingFromSizes(allSizes, viewports);
   }
   return sizeMapping !== null ? buildSizeMappingFromViewports(sizeMapping, viewports) : null;
-};
+}
 function getSizeFromSizeMapping(sizeMapping) {
   if (sizeMapping === null) {
     return null;
@@ -105,8 +107,7 @@ function getSizeFromSizeMapping(sizeMapping) {
 }
 
 class AdSlot extends EventEmitter {
-  constructor(id, path, size) {
-    let opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  constructor(id, path, size, opts = {}) {
     super();
     this.options = {
       sizeMapping: null,
@@ -334,8 +335,7 @@ class AdsManager extends EventEmitter {
       [index.id]: [item.slug]
     } : null;
   }
-  constructor() {
-    let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(opts = {}) {
     super();
     this.options = {
       disabled: false,
@@ -503,8 +503,7 @@ class AdsManager extends EventEmitter {
       googletag.pubads().setRequestNonPersonalizedAds(disablePersonnalizedAds ? 1 : 0);
     });
   }
-  createSlot(path, size) {
-    let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  createSlot(path, size, opts = {}) {
     const {
       id: providedId = null
     } = opts;
@@ -681,66 +680,26 @@ const AdsContext = /*#__PURE__*/React.createContext({
   ready: false
 });
 const useAdsContext = () => useContext(AdsContext);
-const propTypes$3 = {
-  children: PropTypes.node.isRequired,
-  defaultSlotPath: PropTypes.string,
-  slotsPath: PropTypes.objectOf(PropTypes.string),
-  disableSingleRequest: PropTypes.bool,
-  disableVideoAds: PropTypes.bool,
-  disableLazyLoad: PropTypes.bool,
-  autoInit: PropTypes.bool,
-  resizeDebounceDelay: PropTypes.number,
-  refreshOnResize: PropTypes.bool,
-  mobileScaling: PropTypes.number,
-  renderMarginPercent: PropTypes.number,
-  fetchMarginPercent: PropTypes.number,
-  viewport: PropTypes.string,
-  slots: adSlots,
-  viewports: adViewports,
-  richAdComponents: PropTypes.objectOf(PropTypes.elementType),
-  disabled: PropTypes.bool,
-  disableTracking: PropTypes.bool
-};
-const defaultProps$2 = {
-  defaultSlotPath: null,
-  slotsPath: null,
-  disableSingleRequest: false,
-  disableVideoAds: false,
-  disableLazyLoad: false,
-  autoInit: true,
-  resizeDebounceDelay: 500,
-  refreshOnResize: false,
-  mobileScaling: 1.0,
-  renderMarginPercent: 100,
-  fetchMarginPercent: 300,
-  viewport: null,
-  slots: slots,
-  viewports: viewports,
-  richAdComponents: null,
-  disabled: false,
-  disableTracking: false
-};
-function AdsProvider(_ref) {
-  let {
-    children,
-    defaultSlotPath,
-    slotsPath,
-    disableSingleRequest,
-    disableVideoAds,
-    disableLazyLoad,
-    autoInit,
-    resizeDebounceDelay,
-    refreshOnResize,
-    mobileScaling,
-    renderMarginPercent,
-    fetchMarginPercent,
-    viewport,
-    viewports,
-    slots,
-    richAdComponents,
-    disabled,
-    disableTracking
-  } = _ref;
+function AdsProvider({
+  children,
+  defaultSlotPath = null,
+  slotsPath = null,
+  disableSingleRequest = false,
+  disableVideoAds = false,
+  disableLazyLoad = false,
+  autoInit = true,
+  resizeDebounceDelay = 500,
+  refreshOnResize = false,
+  mobileScaling = 1.0,
+  renderMarginPercent = 100,
+  fetchMarginPercent = 300,
+  viewport = null,
+  viewports: viewports$1 = viewports,
+  slots: slots$1 = slots,
+  richAdComponents = null,
+  disabled = false,
+  disableTracking = false
+}) {
   const [ready, setReady] = useState(false);
   const adsRef = useRef(null);
   const ads = useMemo(() => {
@@ -791,12 +750,12 @@ function AdsProvider(_ref) {
       onResize.cancel();
     };
   }, [ads, resizeDebounceDelay, refreshOnResize]);
-  const slotsWithSizeMapping = useMemo(() => Object.keys(slots || {}).reduce((map, key) => {
-    const slot = slots[key];
+  const slotsWithSizeMapping = useMemo(() => Object.keys(slots$1 || {}).reduce((map, key) => {
+    const slot = slots$1[key];
     const {
       size
     } = slot;
-    const sizeMapping = getSizeMappingFromSlot(slot, viewports);
+    const sizeMapping = getSizeMappingFromSlot(slot, viewports$1);
     return {
       ...map,
       [key]: {
@@ -805,51 +764,44 @@ function AdsProvider(_ref) {
         sizeMapping
       }
     };
-  }, {}), []);
-  const finalSlotsPath = useMemo(() => defaultSlotPath !== null ? {
-    default: defaultSlotPath,
-    ...slotsPath
-  } : {
-    ...slotsPath
+  }, {}), [slots$1, viewports$1]);
+  const finalSlotsPath = useMemo(() => {
+    if (defaultSlotPath !== null && slotsPath) {
+      return {
+        default: defaultSlotPath,
+        ...slotsPath
+      };
+    }
+    return slotsPath ? {
+      ...slotsPath
+    } : {};
   }, [defaultSlotPath, slotsPath]);
   const value = useMemo(() => ({
     ready,
     ads,
-    viewports,
+    viewports: viewports$1,
     viewport,
     slots: slotsWithSizeMapping,
     slotsPath: finalSlotsPath,
     trackingDisabled: disableTracking,
     richAdComponents
-  }), [ready, ads, viewports, viewport, slotsWithSizeMapping, finalSlotsPath, disableTracking, richAdComponents]);
+  }), [ready, ads, viewports$1, viewport, slotsWithSizeMapping, finalSlotsPath, disableTracking, richAdComponents]);
   return /*#__PURE__*/jsx(AdsContext.Provider, {
     value: value,
     children: children
   });
 }
-AdsProvider.propTypes = propTypes$3;
-AdsProvider.defaultProps = defaultProps$2;
 
-const AdsTargetingContext = /*#__PURE__*/React.createContext(null);
-const useAdsTargeting = () => useContext(AdsTargetingContext);
-const propTypes$2 = {
-  children: PropTypes.node.isRequired,
-  // eslint-disable-next-line react/forbid-prop-types
-  targeting: PropTypes.object,
-  replace: PropTypes.bool
+const defaultTargeting = {
+  domain: typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : null
 };
-const defaultProps$1 = {
-  targeting: {
-    domain: typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : null
-  },
-  replace: false
-};
-function AdsTargetingProvider(_ref) {
-  let {
-    children,
-    targeting,
-    replace
-  } = _ref;
+const AdsTargetingContext = /*#__PURE__*/createContext(defaultTargeting);
+const useAdsTargeting = () => useContext(AdsTargetingContext);
+function AdsTargetingProvider({
+  children,
+  targeting = defaultTargeting,
+  replace = false
+}) {
   const previousTargeting = useAdsTargeting();
   const mergedTargeting = useMemo(() => replace ? targeting : {
     ...previousTargeting,
@@ -860,21 +812,12 @@ function AdsTargetingProvider(_ref) {
     children: children
   });
 }
-AdsTargetingProvider.propTypes = propTypes$2;
-AdsTargetingProvider.defaultProps = defaultProps$1;
 
 /* eslint-disable react/jsx-props-no-spreading */
-const propTypes$1 = {
-  richAd: PropTypes.shape({
-    type: PropTypes.string.isRequired
-  }).isRequired
-};
-const defaultProps = {};
-function RichAd(_ref) {
-  let {
-    richAd,
-    ...props
-  } = _ref;
+function RichAd({
+  richAd,
+  ...props
+}) {
   const {
     type = null,
     ...richAdProps
@@ -888,12 +831,10 @@ function RichAd(_ref) {
     ...richAdProps
   }) : null;
 }
-RichAd.propTypes = propTypes$1;
-RichAd.defaultProps = defaultProps;
 
 function useAdsTracking() {
   const tracking = useTracking() || null;
-  const trackEvent = useCallback((action, slot, renderEvent) => {
+  const trackEvent = useCallback((action, slot = null, renderEvent = null) => {
     if (tracking !== null && typeof tracking.trackAd !== 'undefined') {
       tracking.trackAd(action, slot, renderEvent);
     }
@@ -901,21 +842,20 @@ function useAdsTracking() {
   return trackEvent;
 }
 
-function useAd(path, size) {
-  let {
-    id,
-    sizeMapping = null,
-    viewport = null,
-    targeting = null,
-    categoryExclusions = null,
-    refreshInterval = null,
-    alwaysRender = false,
-    onRender = null,
-    onDestroy = null,
-    disabled = false,
-    disableTracking = false,
-    rootMargin = '300px'
-  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function useAd(path, size, {
+  id,
+  sizeMapping = null,
+  viewport = null,
+  targeting = null,
+  categoryExclusions = null,
+  refreshInterval = null,
+  alwaysRender = false,
+  onRender = null,
+  onDestroy = null,
+  disabled = false,
+  disableTracking = false,
+  rootMargin = '300px'
+} = {}) {
   const {
     ads: adsManager,
     viewports,
@@ -923,9 +863,9 @@ function useAd(path, size) {
     trackingDisabled: globalTrackingDisabled = false
   } = useAdsContext();
   const trackAd = useAdsTracking();
-  const track = useCallback(function () {
+  const track = useCallback((action, slot = null, renderEvent = null) => {
     if (!disableTracking && !globalTrackingDisabled) {
-      trackAd(...arguments);
+      trackAd(action, slot, renderEvent);
     }
   }, [disableTracking, globalTrackingDisabled, trackAd]);
 
@@ -933,7 +873,7 @@ function useAd(path, size) {
   const {
     ref: refObserver,
     entry: {
-      isIntersecting
+      isIntersecting = false
     }
   } = useIntersectionObserver({
     rootMargin,
@@ -963,10 +903,7 @@ function useAd(path, size) {
       adsManager.destroySlot(currentSlot);
     }
     const viewportSize = viewport !== null ? viewports[viewport] || null : null;
-    const [, viewportFixedSize = null] = sizeMapping !== null && viewportSize !== null ? sizeMapping.find(_ref => {
-      let [itViewport] = _ref;
-      return itViewport.join('x') === viewportSize.join('x');
-    }) || [] : [];
+    const [, viewportFixedSize = null] = sizeMapping !== null && viewportSize !== null ? sizeMapping.find(([itViewport]) => itViewport.join('x') === viewportSize.join('x')) || [] : [];
     const newSlot = path !== null && !disabled ? adsManager.createSlot(path, viewportFixedSize || size, {
       id,
       visible: isVisible,
@@ -1113,7 +1050,7 @@ function parseRichAd(data) {
   } catch (e) {}
   return richAd;
 }
-function useRichAd(containerRef, id, opts) {
+function useRichAd(containerRef, id, opts = {}) {
   const [richAd, setRichAd] = useState(null);
   const {
     onRichAd = null
@@ -1151,57 +1088,31 @@ function useRichAd(containerRef, id, opts) {
 }
 
 /* eslint-disable react/require-default-props */
-const propTypes = {
-  slot: PropTypes.string.isRequired,
-  path: adPath,
-  size: adSize,
-  sizeMapping: adSizeMapping,
-  viewport: PropTypes.string,
-  targeting: adTargeting,
-  refreshInterval: PropTypes.number,
-  alwaysRender: PropTypes.bool,
-  disabled: PropTypes.bool,
-  disableTracking: PropTypes.bool,
-  shouldKeepSize: PropTypes.bool,
-  withoutStyle: PropTypes.bool,
-  withoutMinimumSize: PropTypes.bool,
-  withReactId: PropTypes.bool,
-  className: PropTypes.string,
-  emptyClassName: PropTypes.string,
-  adClassName: PropTypes.string,
-  richAdClassName: PropTypes.string,
-  richAdIframeClassName: PropTypes.string,
-  onRender: PropTypes.func,
-  onDestroy: PropTypes.func,
-  onRichAd: PropTypes.func,
-  slotRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
-};
-function Ad(_ref) {
-  let {
-    slot: slotName = null,
-    path: providedPath = null,
-    size: providedSize = null,
-    sizeMapping: providedSizeMapping = null,
-    viewport: providedViewport = null,
-    targeting: providedTargeting = null,
-    refreshInterval: providedRefreshInterval = null,
-    alwaysRender = true,
-    disabled: providedDisabled = false,
-    disableTracking = false,
-    shouldKeepSize = false,
-    withoutStyle = false,
-    withoutMinimumSize = false,
-    withReactId = false,
-    className = null,
-    emptyClassName = null,
-    adClassName = null,
-    richAdClassName = null,
-    richAdIframeClassName = null,
-    onRender = null,
-    onDestroy = null,
-    onRichAd = null,
-    slotRef = null
-  } = _ref;
+function Ad({
+  slot: slotName,
+  path: providedPath = null,
+  size: providedSize = null,
+  sizeMapping: providedSizeMapping = null,
+  viewport: providedViewport = null,
+  targeting: providedTargeting = null,
+  refreshInterval: providedRefreshInterval = null,
+  alwaysRender = true,
+  disabled: providedDisabled = false,
+  disableTracking = false,
+  shouldKeepSize = false,
+  withoutStyle = false,
+  withoutMinimumSize = false,
+  withReactId = false,
+  className = null,
+  emptyClassName = null,
+  adClassName = null,
+  richAdClassName = null,
+  richAdIframeClassName = null,
+  onRender = null,
+  onDestroy = null,
+  onRichAd = null,
+  slotRef = null
+}) {
   const {
     slots = null,
     slotsPath = null,
@@ -1211,7 +1122,7 @@ function Ad(_ref) {
   const {
     default: defaultSlotPath = null
   } = slotsPath || {};
-  const slot = slotName !== null && slots !== null ? slots[slotName] || null : null;
+  const slot = slotName && slots !== null ? slots[slotName] || null : null;
   const {
     sizeMapping: slotSizeMapping = null,
     size: slotSize = null,
@@ -1310,9 +1221,9 @@ function Ad(_ref) {
   const richAd = useRichAd(adContainerRef, id, {
     onRichAd
   });
-  if (slotRef !== null && isFunction(slotRef)) {
+  if (slotRef !== null && typeof slotRef === 'function') {
     slotRef(slotObject);
-  } else if (slotRef !== null && isObject(slotRef)) {
+  } else if (slotRef !== null && typeof slotRef === 'object') {
     // eslint-disable-next-line no-param-reassign
     slotRef.current = slotObject;
   }
@@ -1374,6 +1285,5 @@ function Ad(_ref) {
     })
   });
 }
-Ad.propTypes = propTypes;
 
-export { Ad, AdSlot, AdsManager, AdsProvider, AdsTargetingProvider, propTypes$4 as PropTypes, RichAd, buildSizeMappingFromSizes, buildSizeMappingFromViewports, getAdSizes, getMinimumAdSize, getSizeFromSizeMapping, getSizeMappingFromSlot, getSortedViewports, normalizeAdSizes, sizeFitsInViewport, slots, useAd, useAdsContext, useAdsTargeting, useAdsTracking, useRichAd, viewports };
+export { Ad, AdSlot, AdsManager, AdsProvider, AdsTargetingProvider, propTypes as PropTypes, RichAd, buildSizeMappingFromSizes, buildSizeMappingFromViewports, getAdSizes, getMinimumAdSize, getSizeFromSizeMapping, getSizeMappingFromSlot, getSortedViewports, normalizeAdSizes, sizeFitsInViewport, slots, useAd, useAdsContext, useAdsTargeting, useAdsTracking, useRichAd, viewports };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@folklore/ads",
-    "version": "0.0.109",
+    "version": "0.0.111",
     "description": "Ads library",
     "keywords": [
         "javascript",
@@ -29,13 +29,16 @@
     ],
     "main": "dist/cjs.js",
     "module": "dist/es.js",
+    "types": "types/index.d.ts",
     "files": [
-        "dist"
+        "dist",
+        "types"
     ],
     "scripts": {
-        "clean": "rm -rf dist",
-        "build": "rollup --bundleConfigAsCjs --config ../../rollup.config.js",
-        "prepare": "npm run clean && npm run build"
+        "clean": "rm -rf dist && rm -rf types",
+        "build:types": "tsc --p tsconfig.json",
+        "build": "npm run build:types && rollup --bundleConfigAsCjs --config ../../rollup.config.js",
+        "prepublishOnly": "npm run clean && npm run build"
     },
     "devDependencies": {
         "prop-types": "^15.7.2",
@@ -50,11 +53,11 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "6879f02e1991265ab2248de470fbf8e1240483a9",
+    "gitHead": "a04cfaacb364f3b35307d65d8778b078dace4491",
     "dependencies": {
-        "@folklore/hooks": "^0.0.73",
-        "@folklore/tracking": "^0.0.29",
-        "@folklore/utils": "^0.1.3",
+        "@folklore/hooks": "^0.0.74",
+        "@folklore/tracking": "^0.0.30",
+        "@folklore/utils": "^0.1.4",
         "classnames": "^2.5.1",
         "debug": "^4.3.4",
         "lodash": "^4.17.21",

package/types/Ad.d.ts

@@ -0,0 +1,30 @@
+import { Ref } from 'react';
+import { AdSize, AdSizeMapping, AdsTargeting } from './types';
+import AdSlot from './AdSlot';
+export interface AdProps {
+    slot: string;
+    path?: string | null;
+    size?: AdSize[] | null;
+    sizeMapping?: AdSizeMapping[] | null;
+    viewport?: string | null;
+    targeting?: AdsTargeting | null;
+    refreshInterval?: number | null;
+    alwaysRender?: boolean;
+    disabled?: boolean;
+    disableTracking?: boolean;
+    shouldKeepSize?: boolean;
+    withoutStyle?: boolean;
+    withoutMinimumSize?: boolean;
+    withReactId?: boolean;
+    className?: string | null;
+    emptyClassName?: string | null;
+    adClassName?: string | null;
+    richAdClassName?: string | null;
+    richAdIframeClassName?: string | null;
+    onRender?: ((event: any) => void) | null;
+    onDestroy?: (() => void) | null;
+    onRichAd?: ((richAd: any) => void) | null;
+    slotRef?: Ref<AdSlot> | null;
+}
+declare function Ad({ slot: slotName, path: providedPath, size: providedSize, sizeMapping: providedSizeMapping, viewport: providedViewport, targeting: providedTargeting, refreshInterval: providedRefreshInterval, alwaysRender, disabled: providedDisabled, disableTracking, shouldKeepSize, withoutStyle, withoutMinimumSize, withReactId, className, emptyClassName, adClassName, richAdClassName, richAdIframeClassName, onRender, onDestroy, onRichAd, slotRef, }: AdProps): import("react/jsx-runtime").JSX.Element;
+export default Ad;

package/types/AdSlot.d.ts

@@ -0,0 +1,57 @@
+import EventEmitter from 'wolfy87-eventemitter';
+import { AdSizeMapping } from './types';
+export interface AdSlotOptions {
+    sizeMapping?: null | AdSizeMapping[];
+    targeting?: {
+        [key: string]: string | Array<string>;
+    };
+    categoryExclusions?: Array<string>;
+    visible?: boolean;
+}
+declare class AdSlot extends EventEmitter {
+    options: AdSlotOptions;
+    elementId: string;
+    adPath: string;
+    adSize: string | Array<string>;
+    visible: boolean;
+    wasVisible: boolean;
+    adSlot: any;
+    rendered: boolean;
+    displayed: boolean;
+    viewable: boolean;
+    renderEvent: any;
+    refreshDisabled: boolean;
+    destroyed: boolean;
+    constructor(id: any, path: any, size: any, opts?: {});
+    updateAdSlot(): void;
+    setAdSlot(slot: any): this;
+    setRenderEvent(event: any): this;
+    setViewable(viewable: any): void;
+    setDisplayed(displayed: any): this;
+    setVisible(visible: any): this;
+    setRefreshDisabled(): void;
+    setTargeting(targeting: any): void;
+    destroy(): void;
+    getElementId(): string;
+    getAdSlot(): any;
+    getAdPath(): string;
+    getAdSize(): string | string[];
+    getTargeting(): {
+        [key: string]: string | string[];
+    };
+    isVisible(): boolean;
+    isDefined(): boolean;
+    isDisplayed(): boolean;
+    isViewable(): boolean;
+    isRendered(): boolean;
+    isRefreshDisabled(): boolean;
+    isDestroyed(): boolean;
+    isEmpty(): any;
+    canBeDisplayed(): boolean;
+    getRenderedSize(): {
+        width: any;
+        height: any;
+        isFluid: boolean;
+    };
+}
+export default AdSlot;