@ms-atlas-module/datastudio-datafactory 0.1.36

package/scripts/Framework/Model/ArmDataFactoryCache.js

@@ -0,0 +1,77 @@
+define(["require", "exports", "./DataCache"], function (
+  require,
+  exports,
+  DataCache
+) {
+  "use strict";
+  var DataFactoryCache = (function () {
+    function DataFactoryCache(service) {
+      this.pipelineListCacheObject = null;
+      this.tableListCacheObject = null;
+      this.runRecordListCacheObject = null;
+      this.linkedServiceListCacheObject = null;
+      this.gatewayListCacheObject = null;
+      this.dataFactoryCacheObject = null;
+      this.pipelineCacheObject = null;
+      this.tableCacheObject = null;
+      this.runRecordCacheObject = null;
+      this.linkedServiceCacheObject = null;
+      this.gatewayCacheObject = null;
+      this.dataSliceCacheObject = null;
+      this.pipelineListCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.listPipelines,
+      });
+      this.pipelineCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.getPipeline,
+      });
+      this.dataFactoryCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.getDataFactory,
+      });
+      this.linkedServiceCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.getLinkedService,
+      });
+      this.linkedServiceListCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.listLinkedServices,
+      });
+      this.tableListCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.listDatasets,
+      });
+      this.tableCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.getDataset,
+      });
+      this.dataSliceCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.listSlices,
+      });
+      this.runRecordListCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.listRunRecords,
+      });
+      this.runRecordCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.getRunRecord,
+      });
+      this.gatewayCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.getGateway,
+      });
+      this.gatewayListCacheObject = new DataCache.DataCache({
+        serviceObject: service,
+        serviceMethod: service.listGateways,
+      });
+    }
+    DataFactoryCache.prototype.stripValue = function (data) {
+      return data.value;
+    };
+    return DataFactoryCache;
+  })();
+  exports.DataFactoryCache = DataFactoryCache;
+});
+//# sourceMappingURL=ArmDataFactoryCache.js.map

package/scripts/Framework/Model/Contracts/Activity.js

@@ -0,0 +1,83 @@
+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", "./BaseEncodable"], function (
+  require,
+  exports,
+  BaseEncodable
+) {
+  "use strict";
+  var DefaultValues = (function () {
+    function DefaultValues() {}
+    DefaultValues.retry = 0;
+    DefaultValues.concurrency = 1;
+    DefaultValues.delay = "00:00:00";
+    DefaultValues.timeout = "00:00:00";
+    DefaultValues.executionPriorityOrder = "OldestFirst";
+    DefaultValues.longRetry = 1;
+    DefaultValues.longRetryInterval = "00:00:00";
+    return DefaultValues;
+  })();
+  exports.DefaultValues = DefaultValues;
+  var ActivityType = (function () {
+    function ActivityType() {}
+    ActivityType.copyActivity = "Copy";
+    ActivityType.dotNetActivity = "DotNetActivity";
+    ActivityType.storedProcedureActivity = "SqlServerStoredProcedure";
+    ActivityType.azureMLBatchExecutionActivity = "AzureMLBatchExecution";
+    ActivityType.hdInsightHiveActivity = "HDInsightHive";
+    ActivityType.hdInsightPigActivity = "HDInsightPig";
+    ActivityType.hdInsightMapReduceActivity = "HDInsightMapReduce";
+    ActivityType.hdInsightStreamingActivity = "HDInsightStreaming";
+    return ActivityType;
+  })();
+  exports.ActivityType = ActivityType;
+  exports.activityTypeToResourceMap = {};
+  exports.activityTypeToResourceMap[ActivityType.copyActivity] =
+    ClientResources.copyActivity;
+  exports.activityTypeToResourceMap[ActivityType.dotNetActivity] =
+    ClientResources.dotNet;
+  exports.activityTypeToResourceMap[ActivityType.storedProcedureActivity] =
+    ClientResources.storedProcedure;
+  exports.activityTypeToResourceMap[
+    ActivityType.azureMLBatchExecutionActivity
+  ] = ClientResources.azureML;
+  exports.activityTypeToResourceMap[ActivityType.hdInsightHiveActivity] =
+    ClientResources.hive;
+  exports.activityTypeToResourceMap[ActivityType.hdInsightPigActivity] =
+    ClientResources.pig;
+  exports.activityTypeToResourceMap[ActivityType.hdInsightMapReduceActivity] =
+    ClientResources.mapReduce;
+  exports.activityTypeToNameInfoResourceMap = {};
+  exports.activityTypeToNameInfoResourceMap[ActivityType.copyActivity] =
+    "Name of the copy activity that will copy data from a source data store to a destination data store.";
+  function getActivityKey(activityName, pipelineId) {
+    return new Encodable(pipelineId.substr(1), activityName).getLegacyKey();
+  }
+  exports.getActivityKey = getActivityKey;
+  var Encodable = (function (_super) {
+    __extends(Encodable, _super);
+    function Encodable(pipelineName, name) {
+      _super.call(
+        this,
+        BaseEncodable.EncodableType.ACTIVITY,
+        name.toUpperCase() + " " + pipelineName.toUpperCase()
+      );
+      this.name = name;
+      this.pipelineName = pipelineName;
+    }
+    Encodable.prototype.getLegacyKey = function () {
+      return "A" + this.id;
+    };
+    return Encodable;
+  })(BaseEncodable.BaseEncodable);
+  exports.Encodable = Encodable;
+});
+//# sourceMappingURL=Activity.js.map

package/scripts/Framework/Model/Contracts/ActivityWindow.js

@@ -0,0 +1,185 @@
+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", "./BaseEncodable"], function (
+  require,
+  exports,
+  BaseEncodable
+) {
+  "use strict";
+  var Encodable = (function (_super) {
+    __extends(Encodable, _super);
+    function Encodable(activityWindow) {
+      _super.call(
+        this,
+        BaseEncodable.EncodableType.ACTIVITY_RUN,
+        activityWindow().reservedId
+      );
+      this.observable = activityWindow;
+    }
+    return Encodable;
+  })(BaseEncodable.BaseEncodable);
+  exports.Encodable = Encodable;
+  var ServiceColumnNames;
+  (function (ServiceColumnNames) {
+    ServiceColumnNames.EventNamespave = "EventNamespace";
+    ServiceColumnNames.Key = "Key";
+    ServiceColumnNames.Scope = "Scope";
+    ServiceColumnNames.Tenant = "Tenant";
+    ServiceColumnNames.Timestamp = "Timestamp";
+    var ExtendedProperties;
+    (function (ExtendedProperties) {
+      ExtendedProperties.ActivityId = "ActivityId";
+      ExtendedProperties.ActivityName = "ActivityName";
+      ExtendedProperties.ActivityType = "ActivityType";
+      ExtendedProperties.Attempts = "Attempts";
+      ExtendedProperties.DataFactoryId = "DataFactoryId";
+      ExtendedProperties.DataFactoryName = "DataFactoryName";
+      ExtendedProperties.DurationMs = "DurationMs";
+      ExtendedProperties.InputTables = "InputTables";
+      ExtendedProperties.OutputTables = "OutputTables";
+      ExtendedProperties.PercentageComplete = "PercentageComplete";
+      ExtendedProperties.PipelineId = "PipelineId";
+      ExtendedProperties.PipelineName = "PipelineName";
+      ExtendedProperties.ResourceGroup = "ResourceGroup";
+      ExtendedProperties.WindowStart = "WindowStart";
+      ExtendedProperties.WindowEnd = "WindowEnd";
+      ExtendedProperties.LastRunStart = "LastRunStart";
+      ExtendedProperties.LastRunEnd = "LastRunEnd";
+      ExtendedProperties.LastRunStatus = "LastRunStatus";
+      ExtendedProperties.WindowState = "WindowState";
+      ExtendedProperties.WindowStatus = "WindowStatus";
+      ExtendedProperties.WindowSubstate = "WindowSubstate";
+    })(
+      (ExtendedProperties =
+        ServiceColumnNames.ExtendedProperties ||
+        (ServiceColumnNames.ExtendedProperties = {}))
+    );
+  })(
+    (ServiceColumnNames =
+      exports.ServiceColumnNames || (exports.ServiceColumnNames = {}))
+  );
+  var Status;
+  (function (Status) {
+    Status.Succeeded = "Succeeded";
+    Status.Failed = "FailedExecution";
+    Status.TimedOut = "TimedOut";
+    Status.Starting = "Starting";
+    Status.AllocatingResources = "AllocatingResources";
+    Status.Configuring = "Configuring";
+    Status.Retry = "Retry";
+    Status.Running = "Running";
+  })((Status = exports.Status || (exports.Status = {})));
+  exports.StatusLabel = {
+    LongRetry: "Long retry",
+    TimedOut: "Timed out",
+    AllocatingResources: "Allocating resources",
+    FailedExecution: "Failed",
+  };
+  var States;
+  (function (States) {
+    States.Ready = {
+      name: "Ready",
+      displayName: ClientResources.ReadyDisplayName,
+      description: ClientResources.ReadyDescription,
+    };
+    States.Waiting = {
+      name: "Waiting",
+      displayName: ClientResources.WaitingDisplayName,
+      substates: {
+        ScheduledTime: {
+          name: "ScheduledTime",
+          displayName: ClientResources.ScheduledTimeDisplayName,
+          description: ClientResources.ScheduledTimeDescription,
+        },
+        DatasetDependencies: {
+          name: "DatasetDependencies",
+          displayName: ClientResources.DatasetDependenciesDisplayName,
+          description: ClientResources.DatasetDependenciesDescription,
+        },
+        ComputeResources: {
+          name: "ComputeResources",
+          displayName: ClientResources.ComputeResourcesDisplayName,
+          description: ClientResources.ComputeResourcesDescription,
+        },
+        ConcurrencyLimit: {
+          name: "ConcurrencyLimit",
+          displayName: ClientResources.ConcurrencyLimitDisplayName,
+          description: ClientResources.ConcurrencyLimitDescription,
+        },
+        ActivityResume: {
+          name: "ActivityResume",
+          displayName: ClientResources.ActivityResumeDisplayName,
+          description: ClientResources.ActivityResumeDescription,
+        },
+        Retry: {
+          name: "Retry",
+          displayName: ClientResources.RetryDisplayName,
+          description: ClientResources.RetryDescription,
+        },
+        Validation: {
+          name: "Validation",
+          displayName: ClientResources.ValidationDisplayName,
+          description: ClientResources.WaitingValidationDescription,
+        },
+        ValidationRetry: {
+          name: "ValidationRetry",
+          displayName: ClientResources.ValidationRetryDisplayName,
+          description: ClientResources.ValidationRetryDescription,
+        },
+      },
+    };
+    States.InProgress = {
+      name: "InProgress",
+      displayName: ClientResources.InProgressDisplayName,
+      description: ClientResources.InProgressDescription,
+      substates: {
+        Validating: {
+          name: "Validating",
+          displayName: ClientResources.ValidatingDisplayName,
+          description: ClientResources.ValidatingDescription,
+        },
+      },
+    };
+    States.Failed = {
+      name: "Failed",
+      displayName: ClientResources.FailedDisplayName,
+      description: ClientResources.FailedDescription,
+      substates: {
+        TimedOut: {
+          name: "TimedOut",
+          displayName: ClientResources.TimedOutDisplayName,
+          description: ClientResources.TimedOutDescription,
+        },
+        Canceled: {
+          name: "Canceled",
+          displayName: ClientResources.CanceledDisplayName,
+          description: ClientResources.CanceledDescription,
+        },
+        Validation: {
+          name: "Validation",
+          displayName: ClientResources.ValidationDisplayName,
+          description: ClientResources.FailedValidationDescription,
+        },
+      },
+    };
+    States.Skipped = {
+      name: "Skipped",
+      displayName: ClientResources.SkippedDisplayName,
+      description: ClientResources.SkippedDescription,
+    };
+    States.None = {
+      name: "None",
+      displayName: ClientResources.NoneDisplayName,
+      description: ClientResources.NoneDescription,
+    };
+  })((States = exports.States || (exports.States = {})));
+});
+//# sourceMappingURL=ActivityWindow.js.map

package/scripts/Framework/Model/Contracts/BaseEncodable.js

@@ -0,0 +1,106 @@
+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"], function (require, exports) {
+  "use strict";
+  (function (EncodableType) {
+    EncodableType[(EncodableType["PIPELINE"] = 0)] = "PIPELINE";
+    EncodableType[(EncodableType["ACTIVITY"] = 1)] = "ACTIVITY";
+    EncodableType[(EncodableType["TABLE"] = 2)] = "TABLE";
+    EncodableType[(EncodableType["ACTIVITY_RUN"] = 3)] = "ACTIVITY_RUN";
+    EncodableType[(EncodableType["STRING"] = 4)] = "STRING";
+    EncodableType[(EncodableType["LINKED_SERVICE"] = 5)] = "LINKED_SERVICE";
+    EncodableType[(EncodableType["GATEWAY"] = 6)] = "GATEWAY";
+    EncodableType[(EncodableType["DATAFACTORY"] = 7)] = "DATAFACTORY";
+    EncodableType[(EncodableType["PIPELINE_ONETIME"] = 8)] = "PIPELINE_ONETIME";
+    EncodableType[(EncodableType["PIPELINE_SCHEDULED"] = 9)] =
+      "PIPELINE_SCHEDULED";
+  })(exports.EncodableType || (exports.EncodableType = {}));
+  var EncodableType = exports.EncodableType;
+  var BaseEncodable = (function () {
+    function BaseEncodable(newType, id) {
+      this.type = newType;
+      this.id = id;
+    }
+    BaseEncodable.prototype.equals = function (other) {
+      return other.type === this.type && other.id === this.id;
+    };
+    return BaseEncodable;
+  })();
+  exports.BaseEncodable = BaseEncodable;
+  var StringEncodable = (function (_super) {
+    __extends(StringEncodable, _super);
+    function StringEncodable(idString) {
+      _super.call(this, EncodableType.STRING, idString);
+    }
+    return StringEncodable;
+  })(BaseEncodable);
+  exports.StringEncodable = StringEncodable;
+  var EncodableSet = (function () {
+    function EncodableSet(encodables) {
+      if (encodables === void 0) {
+        encodables = [];
+      }
+      this._typeMap = {};
+      encodables.forEach(this.add);
+    }
+    EncodableSet.prototype.add = function (encodable) {
+      var index = encodable.type;
+      if (!(index in this._typeMap)) {
+        this._typeMap[index] = {};
+      }
+      this._typeMap[index][encodable.id] = encodable;
+    };
+    EncodableSet.prototype.remove = function (encodable) {
+      var index = encodable.type;
+      if (this._typeMap[index]) {
+        delete this._typeMap[index][encodable.id];
+      }
+    };
+    EncodableSet.prototype.clear = function () {
+      this._typeMap = {};
+    };
+    EncodableSet.prototype.length = function () {
+      var length = 0;
+      for (var i in this._typeMap) {
+        length += Object.keys(this._typeMap[i]).length;
+      }
+      return length;
+    };
+    EncodableSet.prototype.filterEncodables = function (typeToKeep) {
+      var copy = this._typeMap[typeToKeep];
+      this._typeMap = {};
+      this._typeMap[typeToKeep] = copy;
+    };
+    EncodableSet.prototype.clearByType = function (typeToClear) {
+      var clearedEncodable = this._typeMap[typeToClear];
+      delete this._typeMap[typeToClear];
+      return clearedEncodable;
+    };
+    EncodableSet.prototype.toTypeMap = function (type) {
+      return this._typeMap[type];
+    };
+    EncodableSet.prototype.contains = function (encodable) {
+      var index = encodable.type;
+      return index in this._typeMap && encodable.id in this._typeMap[index];
+    };
+    EncodableSet.prototype.forEach = function (callback) {
+      for (var i in this._typeMap) {
+        var idMap = this._typeMap[i];
+        for (var id in idMap) {
+          callback(idMap[id]);
+        }
+      }
+    };
+    return EncodableSet;
+  })();
+  exports.EncodableSet = EncodableSet;
+});
+//# sourceMappingURL=BaseEncodable.js.map

package/scripts/Framework/Model/Contracts/Common.js

@@ -0,0 +1,19 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  var ProvisioningState;
+  (function (ProvisioningState) {
+    ProvisioningState.NotSpecified = "NotSpecified";
+    ProvisioningState.PendingCreation = "PendingCreation";
+    ProvisioningState.Succeeded = "Succeeded";
+    ProvisioningState.PendingUpdate = "PendingUpdate";
+    ProvisioningState.PendingDeletion = "PendingDeletion";
+    ProvisioningState.Failed = "Failed";
+    ProvisioningState.PendingRecreation = "PendingRecreation";
+    ProvisioningState.Disabled = "Disabled";
+    ProvisioningState.Running = "Running";
+  })(
+    (ProvisioningState =
+      exports.ProvisioningState || (exports.ProvisioningState = {}))
+  );
+});
+//# sourceMappingURL=Common.js.map

package/scripts/Framework/Model/Contracts/DataArtifact.js

@@ -0,0 +1,100 @@
+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",
+  "../../Shared/IconResources",
+  "./BaseEncodable",
+], function (require, exports, IconResources, BaseEncodable) {
+  "use strict";
+  var TableType;
+  (function (TableType) {
+    TableType.AzureBlobLocation = "AzureBlob";
+    TableType.AzureSqlDwTableLocation = "AzureSqlDWTable";
+    TableType.AzureSqlTableLocation = "AzureSqlTable";
+    TableType.AzureTableLocation = "AzureTable";
+    TableType.CustomLocation = "CustomDataset";
+    TableType.OnPremisesSqlServerTableLocation = "SqlServerTable";
+    TableType.AzureDataLakeStore = "AzureDataLakeStore";
+    TableType.OracleTable = "OracleTable";
+    TableType.RelationalTable = "RelationalTable";
+  })((TableType = exports.TableType || (exports.TableType = {})));
+  var CustomTableType;
+  (function (CustomTableType) {
+    CustomTableType.OnPremHDFS = "OnpremisesHDFS";
+  })(
+    (CustomTableType =
+      exports.CustomTableType || (exports.CustomTableType = {}))
+  );
+  exports.tableTypeToResourceMap = {};
+  exports.tableTypeToResourceMap[TableType.AzureBlobLocation] =
+    ClientResources.linkedServiceAzureBlobLocation;
+  exports.tableTypeToResourceMap[TableType.AzureSqlDwTableLocation] =
+    ClientResources.linkedServiceAzureSqlDwTableLocation;
+  exports.tableTypeToResourceMap[TableType.AzureSqlTableLocation] =
+    ClientResources.linkedServiceAzureSqlTableLocation;
+  exports.tableTypeToResourceMap[TableType.AzureTableLocation] =
+    ClientResources.linkedServiceAzureTableLocation;
+  exports.tableTypeToResourceMap[TableType.CustomLocation] =
+    ClientResources.linkedServiceCustomLocation;
+  exports.tableTypeToResourceMap[TableType.OnPremisesSqlServerTableLocation] =
+    ClientResources.linkedServiceOnPremisesSqlServerTableLocation;
+  exports.tableTypeToResourceMap[TableType.AzureDataLakeStore] =
+    ClientResources.linkedServiceAzureDataLakeStore;
+  exports.tableTypeToSvgMap = {};
+  exports.tableTypeToSvgMap[TableType.AzureBlobLocation] =
+    IconResources.Icons.blobTable;
+  exports.tableTypeToSvgMap[TableType.AzureSqlDwTableLocation] =
+    IconResources.Icons.sqlDwTable;
+  exports.tableTypeToSvgMap[TableType.AzureSqlTableLocation] =
+    IconResources.Icons.sqlTable;
+  exports.tableTypeToSvgMap[TableType.AzureTableLocation] =
+    IconResources.Icons.azureDbTable;
+  exports.tableTypeToSvgMap[TableType.CustomLocation] =
+    IconResources.Icons.tableIcon;
+  exports.tableTypeToSvgMap[TableType.OnPremisesSqlServerTableLocation] =
+    IconResources.Icons.sqlTable;
+  exports.tableTypeToSvgMap[TableType.AzureDataLakeStore] =
+    IconResources.Icons.adlStore;
+  function getTableKey(tableName) {
+    return "T" + tableName.toUpperCase();
+  }
+  exports.getTableKey = getTableKey;
+  var Encodable = (function (_super) {
+    __extends(Encodable, _super);
+    function Encodable(name) {
+      _super.call(this, BaseEncodable.EncodableType.TABLE, name.toUpperCase());
+      this.name = name;
+    }
+    Encodable.prototype.getLegacyKey = function () {
+      return getTableKey(this.name);
+    };
+    return Encodable;
+  })(BaseEncodable.BaseEncodable);
+  exports.Encodable = Encodable;
+  var Availability;
+  (function (Availability) {
+    Availability.Frequency = {
+      Minute: "Minute",
+      Hour: "Hour",
+      Day: "Day",
+      Week: "Week",
+      Month: "Month",
+      Year: "Year",
+    };
+  })((Availability = exports.Availability || (exports.Availability = {})));
+  exports.Default = {
+    properties: {
+      type: TableType.AzureBlobLocation,
+    },
+  };
+});
+//# sourceMappingURL=DataArtifact.js.map

package/scripts/Framework/Model/Contracts/Diagram.js

@@ -0,0 +1,9 @@
+define(["require", "exports"], function (require, exports) {
+  "use strict";
+  (function (DiagramMode) {
+    DiagramMode[(DiagramMode["Factory"] = 0)] = "Factory";
+    DiagramMode[(DiagramMode["OpenPipeline"] = 1)] = "OpenPipeline";
+  })(exports.DiagramMode || (exports.DiagramMode = {}));
+  var DiagramMode = exports.DiagramMode;
+});
+//# sourceMappingURL=Diagram.js.map

package/scripts/Framework/Model/Contracts/Encodable.js

@@ -0,0 +1,113 @@
+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",
+  "./Activity",
+  "./ActivityWindow",
+  "./LinkedService",
+  "./Gateway",
+  "./DataArtifact",
+  "./Pipeline",
+  "./BaseEncodable",
+], function (
+  require,
+  exports,
+  Activity,
+  ActivityWindow,
+  LinkedService,
+  Gateway,
+  DataArtifact,
+  Pipeline,
+  BaseEncodable
+) {
+  "use strict";
+  exports.EncodableType = BaseEncodable.EncodableType;
+  exports.Encodable = BaseEncodable.BaseEncodable;
+  exports.EncodableSet = BaseEncodable.EncodableSet;
+  exports.ActivityEncodable = Activity.Encodable;
+  exports.TableEncodable = DataArtifact.Encodable;
+  exports.PipelineEncodable = Pipeline.Encodable;
+  exports.StringEncodable = BaseEncodable.StringEncodable;
+  exports.ActivityRunEncodable = ActivityWindow.Encodable;
+  exports.LinkedServiceEncodable = LinkedService.Encodable;
+  exports.GatewayEncodable = Gateway.Encodable;
+  function createLegacyKeyFromEncodable(encodable) {
+    switch (encodable.type) {
+      case exports.EncodableType.PIPELINE:
+        return encodable.getLegacyKey();
+      case exports.EncodableType.TABLE:
+        return encodable.getLegacyKey();
+      case exports.EncodableType.ACTIVITY:
+        return encodable.getLegacyKey();
+      default:
+        return encodable.id;
+    }
+  }
+  exports.createLegacyKeyFromEncodable = createLegacyKeyFromEncodable;
+  function createEncodableFromLegacyKey(key) {
+    var name = key.substring(1);
+    switch (key[0]) {
+      case "P":
+        return new exports.PipelineEncodable(name);
+      case "T":
+        return new exports.TableEncodable(name);
+      case "A":
+        var lastSpace = name.lastIndexOf(" ");
+        var pipelineName = name.substring(lastSpace + 1);
+        var activityName = name.substring(0, lastSpace);
+        return new exports.ActivityEncodable(pipelineName, activityName);
+      default:
+        return new exports.StringEncodable(name);
+    }
+  }
+  exports.createEncodableFromLegacyKey = createEncodableFromLegacyKey;
+  var DataFactoryEncodable = (function (_super) {
+    __extends(DataFactoryEncodable, _super);
+    function DataFactoryEncodable(name) {
+      _super.call(
+        this,
+        BaseEncodable.EncodableType.DATAFACTORY,
+        name.toUpperCase()
+      );
+      this.name = name;
+    }
+    return DataFactoryEncodable;
+  })(BaseEncodable.BaseEncodable);
+  exports.DataFactoryEncodable = DataFactoryEncodable;
+  var OnetimePipelineEncodable = (function (_super) {
+    __extends(OnetimePipelineEncodable, _super);
+    function OnetimePipelineEncodable(name) {
+      _super.call(
+        this,
+        BaseEncodable.EncodableType.PIPELINE_ONETIME,
+        name.toUpperCase()
+      );
+      this.name = name;
+    }
+    return OnetimePipelineEncodable;
+  })(BaseEncodable.BaseEncodable);
+  exports.OnetimePipelineEncodable = OnetimePipelineEncodable;
+  var ScheduledPipelineEncodable = (function (_super) {
+    __extends(ScheduledPipelineEncodable, _super);
+    function ScheduledPipelineEncodable(name) {
+      _super.call(
+        this,
+        BaseEncodable.EncodableType.PIPELINE_SCHEDULED,
+        name.toUpperCase()
+      );
+      this.name = name;
+    }
+    return ScheduledPipelineEncodable;
+  })(BaseEncodable.BaseEncodable);
+  exports.ScheduledPipelineEncodable = ScheduledPipelineEncodable;
+});
+//# sourceMappingURL=Encodable.js.map