@ms-atlas-module/datastudio-datafactory 0.1.36

package/scripts/Framework/Model/Filter.js

@@ -0,0 +1,186 @@
+define([
+  "require",
+  "exports",
+  "./Contracts/ActivityWindow",
+  "../Util/Log",
+  "../Util/Util",
+], function (require, exports, ActivityWindowModel, Log, Util) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "Framework/Model/Filter",
+  });
+  var State = (function () {
+    function State(filterState) {
+      var _this = this;
+      if (filterState === void 0) {
+        filterState = null;
+      }
+      this.extendedProperties =
+        ActivityWindowModel.ServiceColumnNames.ExtendedProperties;
+      this.filterState = filterState
+        ? ko.observable(filterState)
+        : ko.observable({
+            pipelineNames: ko.observableArray(),
+            activityNames: ko.observableArray(),
+            activityTypes: ko.observableArray(),
+            windowStates: ko.observableArray(),
+            attemptsRange: ko.observable(),
+            durationMsRange: ko.observable(),
+            percentageCompleteRange: ko.observable(),
+            windowStart: ko.observable(),
+            windowEnd: ko.observable(),
+          });
+      this.totalFilterCount = ko.pureComputed(function () {
+        return _this.filterState && _this.filterState()
+          ? _this.filterState().pipelineNames().length +
+              _this.filterState().activityNames().length +
+              _this.filterState().activityTypes().length +
+              _this.filterState().windowStates().length +
+              (_this.filterState().windowStart() ? 1 : 0) +
+              (_this.filterState().windowEnd() ? 1 : 0)
+          : 0;
+      });
+    }
+    State.prototype.mapColumnToFilterState = function (column) {
+      switch (column) {
+        case this.extendedProperties.PipelineName:
+          return this.filterState().pipelineNames;
+        case this.extendedProperties.ActivityName:
+          return this.filterState().activityNames;
+        case this.extendedProperties.WindowState:
+          return this.filterState().windowStates;
+        case this.extendedProperties.ActivityType:
+          return this.filterState().activityTypes;
+        default:
+          logger.logDebug(
+            "Filter state not found for column: {0}".format(column)
+          );
+      }
+    };
+    State.prototype.mapDateTimeColumnToFilterState = function (column) {
+      switch (column) {
+        case this.extendedProperties.WindowStart:
+          return this.filterState().windowStart;
+        case this.extendedProperties.WindowEnd:
+          return this.filterState().windowEnd;
+        default:
+          var errorMessage =
+            "Unexpected column: " +
+            column +
+            " as input to mapDateTimeColumnToFilterState.";
+          logger.logError(errorMessage);
+          throw new Error(
+            "Unexpected column: " +
+              column +
+              " as input to mapDateTimeColumnToFilterState."
+          );
+      }
+    };
+    State.prototype.stringify = function () {
+      var filter;
+      var pipelineNames = this.filterState().pipelineNames();
+      var activityNames = this.filterState().activityNames();
+      var activityTypes = this.filterState().activityTypes();
+      var windowStates = this.filterState().windowStates();
+      var attemptsRange = this.filterState().attemptsRange();
+      var durationMsRange = this.filterState().durationMsRange();
+      var percentageCompleteRange =
+        this.filterState().percentageCompleteRange();
+      var extendedProperties =
+        ActivityWindowModel.ServiceColumnNames.ExtendedProperties;
+      filter = this.joinFilterArray(pipelineNames);
+      filter += this.joinFilterArray(activityNames);
+      filter += this.joinFilterArray(activityTypes);
+      filter += this.joinFilterArray(windowStates);
+      filter += this.stringifyNumberRange(
+        extendedProperties.Attempts,
+        attemptsRange
+      );
+      filter += this.stringifyNumberRange(
+        extendedProperties.DurationMs,
+        durationMsRange
+      );
+      filter += this.stringifyNumberRange(
+        extendedProperties.PercentageComplete,
+        percentageCompleteRange
+      );
+      filter += this.stringifyDate(
+        extendedProperties.WindowStart,
+        this.filterState().windowStart()
+      );
+      filter += this.stringifyDate(
+        extendedProperties.WindowEnd,
+        this.filterState().windowEnd()
+      );
+      if (filter.match("^.* and $")) {
+        return filter.substr(0, filter.length - 5).trim();
+      } else {
+        return filter.trim();
+      }
+    };
+    State.prototype.isEmpty = function () {
+      for (var property in this.filterState()) {
+        var stateProperty = this.filterState()[property];
+        if (Util.koPropertyHasValue(stateProperty)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    State.prototype.clear = function () {
+      this.filterState({
+        pipelineNames: ko.observableArray(),
+        activityNames: ko.observableArray(),
+        activityTypes: ko.observableArray(),
+        windowStates: ko.observableArray(),
+        attemptsRange: ko.observable(),
+        durationMsRange: ko.observable(),
+        percentageCompleteRange: ko.observable(),
+        windowStart: ko.observable(),
+        windowEnd: ko.observable(),
+      });
+    };
+    State.prototype.clearColumnFilters = function (property) {
+      var stateProperty = this.mapColumnToFilterState(property);
+      if (stateProperty) {
+        stateProperty([]);
+      } else {
+        var stateDateProperty = this.mapDateTimeColumnToFilterState(property);
+        stateDateProperty(null);
+      }
+    };
+    State.prototype.joinFilterArray = function (filterArray) {
+      if (filterArray.length > 0) {
+        return "(" + filterArray.join(" or ") + ") and ";
+      } else {
+        return "";
+      }
+    };
+    State.prototype.stringifyNumberRange = function (indexName, numberRange) {
+      return Util.propertyHasValue(numberRange)
+        ? "({0} ge {1} and {0} le {2}) and ".format(
+            indexName,
+            numberRange.min,
+            numberRange.max
+          )
+        : "";
+    };
+    State.prototype.stringifyDate = function (indexName, date) {
+      if (Util.propertyHasValue(date)) {
+        switch (indexName) {
+          case this.extendedProperties.WindowStart:
+            return "({0} ge {1}) and ".format(indexName, date.toISOString());
+          case this.extendedProperties.WindowEnd:
+            return "({0} le {1}) and ".format(indexName, date.toISOString());
+          default:
+            return "";
+        }
+      } else {
+        return "";
+      }
+    };
+    return State;
+  })();
+  exports.State = State;
+});
+//# sourceMappingURL=Filter.js.map

package/scripts/Framework/Model/Helpers/ActivityWindowHelper.js

@@ -0,0 +1,185 @@
+define([
+  "require",
+  "exports",
+  "../Contracts/ActivityWindow",
+  "../../Util/Log",
+  "../../UI/StatusCalendar",
+  "../../../../_generated/Svg",
+], function (require, exports, ActivityWindowModel, Log, StatusCalendar, Svg) {
+  "use strict";
+  var logger = Log.getLogger({
+    loggerName: "ActivityWindowHelper",
+  });
+  exports.coercedActivityRunStatus = {};
+  exports.coercedActivityRunStatus[ActivityWindowModel.States.Ready.name] =
+    StatusCalendar.StatusBoxState.success;
+  exports.coercedActivityRunStatus[ActivityWindowModel.States.Failed.name] =
+    StatusCalendar.StatusBoxState.failed;
+  exports.coercedActivityRunStatus[ActivityWindowModel.States.InProgress.name] =
+    StatusCalendar.StatusBoxState.inprogress;
+  exports.coercedActivityRunStatus[ActivityWindowModel.States.Waiting.name] =
+    StatusCalendar.StatusBoxState.waiting;
+  exports.coercedActivityRunStatus[ActivityWindowModel.States.None.name] =
+    StatusCalendar.StatusBoxState.missing;
+  exports.coercedActivityRunStatus[ActivityWindowModel.States.Skipped.name] =
+    StatusCalendar.StatusBoxState.missing;
+  var ActivityWindowCopyPairs = (function () {
+    function ActivityWindowCopyPairs(activityWindow) {
+      this._rowValue = [
+        activityWindow.pipelineName,
+        activityWindow.activityName,
+        activityWindow.windowStartPair.UTC,
+        activityWindow.windowEndPair.UTC,
+        activityWindow.windowState,
+        activityWindow.activityType,
+        activityWindow.runStart,
+        activityWindow.runEnd,
+        activityWindow.duration,
+        activityWindow.runAttempts,
+      ].join("\t");
+      this.pipeline = this.createPairs(
+        ClientResources.pipelineNameCopyLabel,
+        activityWindow.pipelineName
+      );
+      this.activity = this.createPairs(
+        ClientResources.activityNameCopyLabel,
+        activityWindow.activityName
+      );
+      this.windowStart = this.createPairs(
+        ClientResources.windowStartCopyLabel,
+        activityWindow.windowStartPair.UTC
+      );
+      this.windowEnd = this.createPairs(
+        ClientResources.windowEndCopyLabel,
+        activityWindow.windowEndPair.UTC
+      );
+      this.displayState = this.createPairs(
+        ClientResources.statusCopyLabel,
+        activityWindow.displayState
+      );
+      this.activityType = this.createPairs(
+        ClientResources.typeCopyLabel,
+        activityWindow.activityType
+      );
+      this.runStart = this.createPairs(
+        ClientResources.attemptStartCopyLabel,
+        activityWindow.runStart
+      );
+      this.runEnd = this.createPairs(
+        ClientResources.attemptEndCopyLabel,
+        activityWindow.runEnd
+      );
+      this.duration = this.createPairs(
+        ClientResources.durationCopyLabel,
+        activityWindow.duration
+      );
+      this.attempts = this.createPairs(
+        ClientResources.attemptsCopyLabel,
+        activityWindow.runAttempts.toLocaleString()
+      );
+    }
+    ActivityWindowCopyPairs.prototype.createPairs = function (label, value) {
+      return [
+        { label: label, value: value },
+        { label: ClientResources.entireRowCopyLabel, value: this._rowValue },
+      ];
+    };
+    return ActivityWindowCopyPairs;
+  })();
+  exports.ActivityWindowCopyPairs = ActivityWindowCopyPairs;
+  function getStateIcon(windowState) {
+    var svg;
+    switch (windowState) {
+      case ClientResources.statusWaiting:
+        svg = Svg.progressRing;
+        break;
+      case ActivityWindowModel.States.Ready.name:
+        svg = Svg.statusReady;
+        break;
+      case ActivityWindowModel.States.Failed.name:
+        svg = Svg.statusFailed;
+        break;
+      case ActivityWindowModel.States.Waiting.name:
+        svg = Svg.statusWaiting;
+        break;
+      case ActivityWindowModel.States.InProgress.name:
+        svg = Svg.statusInProgress;
+        break;
+      case ActivityWindowModel.States.None.name:
+        svg = Svg.statusNone;
+        break;
+      case ActivityWindowModel.States.Skipped.name:
+        svg = Svg.statusSkipped;
+        break;
+      default:
+        logger.logError("Unrecognized window state: " + windowState);
+        svg = Svg.statusStarting;
+    }
+    return svg;
+  }
+  exports.getStateIcon = getStateIcon;
+  function updateStateHtml(windowState, displayState) {
+    var svg = getStateIcon(windowState);
+    return (
+      '<div class = "row">' +
+      '<div class = "adf-statusImage">' +
+      svg +
+      "</div>" +
+      "<div>" +
+      displayState +
+      "</div>" +
+      "</div>"
+    );
+  }
+  exports.updateStateHtml = updateStateHtml;
+  function updateStateHtmlWithCount(windowState, displayState, count) {
+    var svg = getStateIcon(windowState);
+    return (
+      '<div class = "row">' +
+      '<div class = "adf-statusImage">' +
+      svg +
+      "</div>" +
+      "<div>" +
+      displayState +
+      ": " +
+      count +
+      "</div>" +
+      "</div>"
+    );
+  }
+  exports.updateStateHtmlWithCount = updateStateHtmlWithCount;
+  function createStatusCalendarStatus(activityWindow) {
+    var status = exports.coercedActivityRunStatus[activityWindow.windowState];
+    if (!status) {
+      logger.logError(
+        "Unhandled window status for status calendar: " +
+          activityWindow.windowState
+      );
+    }
+    return status;
+  }
+  exports.createStatusCalendarStatus = createStatusCalendarStatus;
+  function getStateDescription(state, substate, displayState) {
+    if (substate) {
+      return substate.description;
+    } else if (state && state.description) {
+      return state.description;
+    } else {
+      return displayState;
+    }
+  }
+  exports.getStateDescription = getStateDescription;
+  function getFormattedDate(dateString, relativeFormat) {
+    var dateMoment = moment(dateString);
+    if (!dateMoment.isValid()) {
+      return dateString;
+    }
+    if (relativeFormat) {
+      return dateMoment.fromNow();
+    } else {
+      return dateMoment.format("MM/DD/YYYY hh:mm:ss A");
+    }
+  }
+  exports.getFormattedDate = getFormattedDate;
+});
+//# sourceMappingURL=ActivityWindowHelper.js.map

package/scripts/Framework/Model/MonitoringView.js

@@ -0,0 +1,40 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  (function (MonitoringViewType) {
+    MonitoringViewType[(MonitoringViewType["System"] = 0)] = "System";
+    MonitoringViewType[(MonitoringViewType["User"] = 1)] = "User";
+  })(exports.MonitoringViewType || (exports.MonitoringViewType = {}));
+  var MonitoringViewType = exports.MonitoringViewType;
+  var Sort = (function () {
+    function Sort(column, order) {
+      this.column = column;
+      this.order = order;
+    }
+    Sort.prototype.stringify = function () {
+      return "{0} {1}".format(this.column, this.order);
+    };
+    return Sort;
+  })();
+  exports.Sort = Sort;
+  var MonitoringView = (function () {
+    function MonitoringView(type, id, text, filter, sort, modified) {
+      if (modified === void 0) {
+        modified = false;
+      }
+      this.type = type;
+      this.id = id;
+      this.text = text;
+      this.filter = filter;
+      this.sort = sort;
+      this.modified = modified;
+    }
+    return MonitoringView;
+  })();
+  exports.MonitoringView = MonitoringView;
+  exports.equalityFilterTemplate = "{0} eq '{1}'";
+  exports.dualEqualityFilterTemplate = "({0} eq '{1}' and {2} eq '{3}')";
+  exports.extractFilterFromTemplateRegex = /eq(?:\s*)'(.*)'/;
+  exports.extractDualFilterFromTemplateRegex =
+    /eq(?:\s*)'(.*)'(?:\s*)and(?:\s*)(?:.*)(?:\s*)eq(?:\s*)'(.*)'/;
+});
+//# sourceMappingURL=MonitoringView.js.map

package/scripts/Framework/Shared/Constants.js

@@ -0,0 +1,27 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  exports.locale = "en";
+  exports.moduleName = "datafactory";
+  exports.viewNames = {
+    authoring: "authoring",
+    home: "home",
+    monitoring: "edit",
+    powercopytool: "powercopytool",
+    copyactivitymonitor: "copyactivitymonitor",
+    dataloading: "dataloading",
+  };
+  exports.CSS = {
+    hoveredClass: "adf-hovered",
+    copyClass: "adf-copy",
+    hasMenuClass: "adf-hasMenuButton",
+    menuButtonClass: "adf-menuButton",
+    dropdownMenuClass: "atlas-menu",
+    overflowMessageClass: "overflowMessage",
+    highlightedClass: "adf-highlighted",
+  };
+  exports.HTML = {
+    activityRunDetailAccordionId: "#activityRunDetailAccordion",
+    emptyRunDetailsMessageId: "#emptyRunDetailsMessage",
+  };
+});
+//# sourceMappingURL=Constants.js.map

package/scripts/Framework/Shared/DataConstants.js

@@ -0,0 +1,61 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  var EntityType;
+  (function (EntityType) {
+    EntityType.table = "table";
+    EntityType.pipeline = "datapipeline";
+    EntityType.linkedService = "linkedservice";
+    EntityType.gateway = "gateway";
+  })((EntityType = exports.EntityType || (exports.EntityType = {})));
+  exports.AuthoringModuleName = "Authoring";
+  exports.HomeModuleName = "Home";
+  exports.MonitoringModuleName = "edit";
+  exports.MonitoringModuleTelemetryName = "Monitoring";
+  exports.PowerCopyToolModuleName = "powercopytool";
+  exports.PowerCopyToolModuleTelemetryName = "CodeFreeCopy";
+  exports.CopyActivityMonitorModuleName = "CopyActivityMonitor";
+  exports.ApiUri = "/api";
+  exports.ActivityRunsUri = exports.ApiUri + "/ActivityRuns";
+  exports.FactoryUri = exports.ApiUri + "/DataFactory";
+  exports.DataArtifactUri = exports.ApiUri + "/" + EntityType.table;
+  exports.DataSlicesUri = exports.ApiUri + "/DataSlice";
+  exports.DefaultSubscriptionId = "68BB21FC-7AF0-4126-BE17-76F2942DEEDF";
+  exports.DefaultResourceGroupName = "ResourceGroup";
+  exports.RunRecordUri = exports.ApiUri + "/RunRecord";
+  exports.RunLogUri = exports.ApiUri + "/RunLog";
+  exports.PipelineUri = exports.ApiUri + "/" + EntityType.pipeline;
+  exports.LinkedServiceUri = exports.ApiUri + "/" + EntityType.linkedService;
+  exports.GatewayUri = exports.ApiUri + "/" + EntityType.gateway;
+  exports.ResourceUri = exports.ApiUri + "/Resource";
+  exports.RegionUri = exports.ApiUri + "/Region";
+  exports.DataFactoryResourceId = "Microsoft.DataFactory/dataFactories";
+  exports.DataFactoryProvider = "Microsoft.DataFactory";
+  exports.LayoutUri = exports.ApiUri + "/Layout";
+  exports.LayoutGraphUri = exports.LayoutUri + "/LayoutGraph";
+  exports.RemoveOverlapsUri = exports.LayoutUri + "/RemoveOverlaps";
+  exports.IsFactoryNameAvailableUri =
+    exports.ApiUri + "/FactoryNameAvailability";
+  exports.GetBlobAsStringUri = exports.ApiUri + "/MdpBase/GetBlobAsString";
+  exports.dateColumnWidth = ko.observable("170px");
+  exports.fileBytesLoadLimit = 256000;
+  exports.getMLSwaggerUri = exports.ApiUri + "/AzureML/GetSwaggerDoc";
+  exports.ActivityRunsMonitoringUri = "/activitywindows";
+  exports.DataSlicesMonitoringUri = "/dataslices";
+  exports.GraphNodeStatusBindingHandler = "graphNodeStatus";
+  exports.ActivityWindowListViewModel = "ActivityWindowListViewModel";
+  exports.PipelineWindowListViewModel = "PipelineWindowListViewModel";
+  exports.activityRunsListFilterViewModel = "ActivityRunsListFilterViewModel";
+  exports.dateTimeFilterViewModel = "DateTimeFilterViewModel";
+  exports.ActivityWindowDetailsViewModel = "ActivityWindowDetailsViewModel";
+  exports.alertExplorerViewModel = "AlertExplorerViewModel";
+  exports.datasetNodeCommands = "DatasetNodeCommands";
+  var ObsArrayChangeStatus;
+  (function (ObsArrayChangeStatus) {
+    ObsArrayChangeStatus.added = "added";
+    ObsArrayChangeStatus.deleted = "deleted";
+  })(
+    (ObsArrayChangeStatus =
+      exports.ObsArrayChangeStatus || (exports.ObsArrayChangeStatus = {}))
+  );
+});
+//# sourceMappingURL=DataConstants.js.map

package/scripts/Framework/Shared/Disposable.js

@@ -0,0 +1,53 @@
+var __extends =
+  (this && this.__extends) ||
+  function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype =
+      b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
+  };
+define([
+  "require",
+  "exports",
+  "Viva.Controls/Base/Base.TriggerableLifetimeManager",
+], function (require, exports, VivaGraphLifetimeManager) {
+  "use strict";
+  var DisposableLifetimeManager = (function (_super) {
+    __extends(DisposableLifetimeManager, _super);
+    function DisposableLifetimeManager() {
+      _super.apply(this, arguments);
+    }
+    return DisposableLifetimeManager;
+  })(VivaGraphLifetimeManager.TriggerableLifetimeManager);
+  exports.DisposableLifetimeManager = DisposableLifetimeManager;
+  var DisposableBase = (function () {
+    function DisposableBase(lifetimeManager) {
+      this._lifetimeManager = lifetimeManager;
+      this._lifetimeManager.registerForDispose(this);
+    }
+    DisposableBase.prototype.dispose = function () {
+      this._lifetimeManager.dispose();
+    };
+    return DisposableBase;
+  })();
+  exports.DisposableBase = DisposableBase;
+  var RootDisposable = (function (_super) {
+    __extends(RootDisposable, _super);
+    function RootDisposable() {
+      _super.call(this, new DisposableLifetimeManager());
+    }
+    return RootDisposable;
+  })(DisposableBase);
+  exports.RootDisposable = RootDisposable;
+  var ChildDisposable = (function (_super) {
+    __extends(ChildDisposable, _super);
+    function ChildDisposable(lifetimeManager) {
+      _super.call(this, lifetimeManager.createChildLifetime());
+    }
+    return ChildDisposable;
+  })(DisposableBase);
+  exports.ChildDisposable = ChildDisposable;
+});
+//# sourceMappingURL=Disposable.js.map

package/scripts/Framework/Shared/IconResources.js

@@ -0,0 +1,59 @@
+define(["require", "exports", "./Resources/IbizaSvgs"], function (
+  require,
+  exports,
+  SVG
+) {
+  "use strict";
+  exports.Icons = {
+    activityIcon: SVG.Content.Images.activity,
+    activityScriptIcon: SVG.Content.Images.activityScript,
+    adlStore: SVG.Content.Images.adlStore,
+    azureDbTable: SVG.Content.Images.azureDBTable,
+    blobTable: SVG.Content.Images.blobTable,
+    dataFactoryIcon: SVG.Content.Images.aDF,
+    diagramIcon: SVG.Content.Images.diagram,
+    loading: SVG.Content.Images.ellipsisSquare,
+    linkedService: SVG.Content.Images.linkedService,
+    tableIcon: SVG.Content.Images.table,
+    tableSchemaIcon: SVG.Content.Images.tableSchema,
+    sqlDwTable: SVG.Content.Images.sqlDwTable,
+    sqlTable: SVG.Content.Images.sqlTable,
+    dataPipelineIcon: SVG.Content.Images.pipeline,
+    dataSliceIcon: SVG.Content.Images.slice,
+    activityRunIcon: SVG.Content.Images.job,
+    graphPipelineIcon: SVG.Content.Images.graphPipeline,
+    graphActivityIcon: SVG.Content.Images.graphActivity,
+    zoomOneHundredPercentIcon:
+      SVG.Content.Images.FloorplanToolbar.zoomOneHundredPercent,
+    zoomInIcon: SVG.Content.Images.FloorplanToolbar.zoomIn,
+    zoomOutIcon: SVG.Content.Images.FloorplanToolbar.zoomOut,
+    zoomToFitIcon: SVG.Content.Images.FloorplanToolbar.zoomToFit,
+    lockIcon: SVG.Content.Images.FloorplanToolbar.lock,
+    selectionModeIcon: SVG.Content.Images.FloorplanToolbar.selectionMode,
+    lineageDisplayIcon: SVG.Content.Images.FloorplanToolbar.lineageDisplay,
+    autolayoutIcon: SVG.Content.Images.FloorplanToolbar.autolayout,
+    resumePipelineIcon: SVG.Content.Images.ActionToolbar.resume,
+    cancelPipelineIcon: SVG.Content.Images.ActionToolbar.stop,
+    pausePipelineIcon: SVG.Content.Images.ActionToolbar.pause,
+    dropdownIcon: SVG.Content.Images.ActionToolbar.dropdown,
+    rerunDropdownIcon: SVG.Content.Images.ActionToolbar.rerunDropdown,
+    rerunSlicesIcon: SVG.Content.Images.ActionToolbar.rerunSlices,
+    inProgressIcon: SVG.Content.Images.StatusIcons.inProgress,
+    retryIcon: SVG.Content.Images.StatusIcons.retry,
+    viewSourceIcon: SVG.Content.Images.viewSource,
+    pipelineSourceIcon: SVG.Content.Images.pipelineSource,
+    book: SVG.Content.Images.book,
+    quickstart: SVG.Content.Images.quickstart,
+    tools: SVG.Content.Images.tools,
+    onPremisesHDFS: SVG.Content.Images.onPremisesHDFS,
+    sampleIcon: SVG.Content.Images.SampleDeployment.sample,
+    sampleCustomerProfilingIcon:
+      SVG.Content.Images.SampleDeployment.customerProfilingSample,
+    sampleCustomerChurnIcon:
+      SVG.Content.Images.SampleDeployment.customerChurnSample,
+    sampleProductRecommendationIcon:
+      SVG.Content.Images.SampleDeployment.productRecommendationSample,
+    suggestSampleIcon: SVG.Content.Images.SampleDeployment.suggestSample,
+  };
+});
+//# sourceMappingURL=IconResources.js.map