@plusplusoneplusplus/coc 1.0.1 → 1.0.3

package/node_modules/azure-devops-node-api/SecurityRolesApi.d.ts

@@ -0,0 +1,48 @@
+import basem = require('./ClientApiBases');
+import VsoBaseInterfaces = require('./interfaces/common/VsoBaseInterfaces');
+import SecurityRolesInterfaces = require("./interfaces/SecurityRolesInterfaces");
+export interface ISecurityRolesApi extends basem.ClientApiBase {
+    getRoleAssignments(scopeId: string, resourceId: string): Promise<SecurityRolesInterfaces.RoleAssignment[]>;
+    removeRoleAssignment(scopeId: string, resourceId: string, identityId: string): Promise<void>;
+    removeRoleAssignments(identityIds: string[], scopeId: string, resourceId: string): Promise<void>;
+    setRoleAssignment(roleAssignment: SecurityRolesInterfaces.UserRoleAssignmentRef, scopeId: string, resourceId: string, identityId: string): Promise<SecurityRolesInterfaces.RoleAssignment>;
+    setRoleAssignments(roleAssignments: SecurityRolesInterfaces.UserRoleAssignmentRef[], scopeId: string, resourceId: string): Promise<SecurityRolesInterfaces.RoleAssignment[]>;
+    getRoleDefinitions(scopeId: string): Promise<SecurityRolesInterfaces.SecurityRole[]>;
+}
+export declare class SecurityRolesApi extends basem.ClientApiBase implements ISecurityRolesApi {
+    constructor(baseUrl: string, handlers: VsoBaseInterfaces.IRequestHandler[], options?: VsoBaseInterfaces.IRequestOptions);
+    /**
+     * @param {string} scopeId
+     * @param {string} resourceId
+     */
+    getRoleAssignments(scopeId: string, resourceId: string): Promise<SecurityRolesInterfaces.RoleAssignment[]>;
+    /**
+     * @param {string} scopeId
+     * @param {string} resourceId
+     * @param {string} identityId
+     */
+    removeRoleAssignment(scopeId: string, resourceId: string, identityId: string): Promise<void>;
+    /**
+     * @param {string[]} identityIds
+     * @param {string} scopeId
+     * @param {string} resourceId
+     */
+    removeRoleAssignments(identityIds: string[], scopeId: string, resourceId: string): Promise<void>;
+    /**
+     * @param {SecurityRolesInterfaces.UserRoleAssignmentRef} roleAssignment
+     * @param {string} scopeId
+     * @param {string} resourceId
+     * @param {string} identityId
+     */
+    setRoleAssignment(roleAssignment: SecurityRolesInterfaces.UserRoleAssignmentRef, scopeId: string, resourceId: string, identityId: string): Promise<SecurityRolesInterfaces.RoleAssignment>;
+    /**
+     * @param {SecurityRolesInterfaces.UserRoleAssignmentRef[]} roleAssignments
+     * @param {string} scopeId
+     * @param {string} resourceId
+     */
+    setRoleAssignments(roleAssignments: SecurityRolesInterfaces.UserRoleAssignmentRef[], scopeId: string, resourceId: string): Promise<SecurityRolesInterfaces.RoleAssignment[]>;
+    /**
+     * @param {string} scopeId
+     */
+    getRoleDefinitions(scopeId: string): Promise<SecurityRolesInterfaces.SecurityRole[]>;
+}

package/node_modules/azure-devops-node-api/SecurityRolesApi.js

@@ -0,0 +1,190 @@
+"use strict";
+/*
+ * ---------------------------------------------------------
+ * Copyright(C) Microsoft Corporation. All rights reserved.
+ * ---------------------------------------------------------
+ *
+ * ---------------------------------------------------------
+ * Generated file, DO NOT EDIT
+ * ---------------------------------------------------------
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityRolesApi = void 0;
+const basem = require("./ClientApiBases");
+const SecurityRolesInterfaces = require("./interfaces/SecurityRolesInterfaces");
+class SecurityRolesApi extends basem.ClientApiBase {
+    constructor(baseUrl, handlers, options) {
+        super(baseUrl, handlers, 'node-SecurityRoles-api', options);
+    }
+    /**
+     * @param {string} scopeId
+     * @param {string} resourceId
+     */
+    getRoleAssignments(scopeId, resourceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                let routeValues = {
+                    scopeId: scopeId,
+                    resourceId: resourceId
+                };
+                try {
+                    let verData = yield this.vsoClient.getVersioningData("3.2-preview.1", "securityroles", "9461c234-c84c-4ed2-b918-2f0f92ad0a35", routeValues);
+                    let url = verData.requestUrl;
+                    let options = this.createRequestOptions('application/json', verData.apiVersion);
+                    let res;
+                    res = yield this.rest.get(url, options);
+                    let ret = this.formatResponse(res.result, SecurityRolesInterfaces.TypeInfo.RoleAssignment, true);
+                    resolve(ret);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }));
+        });
+    }
+    /**
+     * @param {string} scopeId
+     * @param {string} resourceId
+     * @param {string} identityId
+     */
+    removeRoleAssignment(scopeId, resourceId, identityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                let routeValues = {
+                    scopeId: scopeId,
+                    resourceId: resourceId,
+                    identityId: identityId
+                };
+                try {
+                    let verData = yield this.vsoClient.getVersioningData("3.2-preview.1", "securityroles", "9461c234-c84c-4ed2-b918-2f0f92ad0a35", routeValues);
+                    let url = verData.requestUrl;
+                    let options = this.createRequestOptions('application/json', verData.apiVersion);
+                    let res;
+                    res = yield this.rest.del(url, options);
+                    let ret = this.formatResponse(res.result, null, false);
+                    resolve(ret);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }));
+        });
+    }
+    /**
+     * @param {string[]} identityIds
+     * @param {string} scopeId
+     * @param {string} resourceId
+     */
+    removeRoleAssignments(identityIds, scopeId, resourceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                let routeValues = {
+                    scopeId: scopeId,
+                    resourceId: resourceId
+                };
+                try {
+                    let verData = yield this.vsoClient.getVersioningData("3.2-preview.1", "securityroles", "9461c234-c84c-4ed2-b918-2f0f92ad0a35", routeValues);
+                    let url = verData.requestUrl;
+                    let options = this.createRequestOptions('application/json', verData.apiVersion);
+                    let res;
+                    res = yield this.rest.update(url, identityIds, options);
+                    let ret = this.formatResponse(res.result, null, false);
+                    resolve(ret);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }));
+        });
+    }
+    /**
+     * @param {SecurityRolesInterfaces.UserRoleAssignmentRef} roleAssignment
+     * @param {string} scopeId
+     * @param {string} resourceId
+     * @param {string} identityId
+     */
+    setRoleAssignment(roleAssignment, scopeId, resourceId, identityId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                let routeValues = {
+                    scopeId: scopeId,
+                    resourceId: resourceId,
+                    identityId: identityId
+                };
+                try {
+                    let verData = yield this.vsoClient.getVersioningData("3.2-preview.1", "securityroles", "9461c234-c84c-4ed2-b918-2f0f92ad0a35", routeValues);
+                    let url = verData.requestUrl;
+                    let options = this.createRequestOptions('application/json', verData.apiVersion);
+                    let res;
+                    res = yield this.rest.replace(url, roleAssignment, options);
+                    let ret = this.formatResponse(res.result, SecurityRolesInterfaces.TypeInfo.RoleAssignment, false);
+                    resolve(ret);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }));
+        });
+    }
+    /**
+     * @param {SecurityRolesInterfaces.UserRoleAssignmentRef[]} roleAssignments
+     * @param {string} scopeId
+     * @param {string} resourceId
+     */
+    setRoleAssignments(roleAssignments, scopeId, resourceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                let routeValues = {
+                    scopeId: scopeId,
+                    resourceId: resourceId
+                };
+                try {
+                    let verData = yield this.vsoClient.getVersioningData("3.2-preview.1", "securityroles", "9461c234-c84c-4ed2-b918-2f0f92ad0a35", routeValues);
+                    let url = verData.requestUrl;
+                    let options = this.createRequestOptions('application/json', verData.apiVersion);
+                    let res;
+                    res = yield this.rest.replace(url, roleAssignments, options);
+                    let ret = this.formatResponse(res.result, SecurityRolesInterfaces.TypeInfo.RoleAssignment, true);
+                    resolve(ret);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }));
+        });
+    }
+    /**
+     * @param {string} scopeId
+     */
+    getRoleDefinitions(scopeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+                let routeValues = {
+                    scopeId: scopeId
+                };
+                try {
+                    let verData = yield this.vsoClient.getVersioningData("3.2-preview.1", "securityroles", "f4cc9a86-453c-48d2-b44d-d3bd5c105f4f", routeValues);
+                    let url = verData.requestUrl;
+                    let options = this.createRequestOptions('application/json', verData.apiVersion);
+                    let res;
+                    res = yield this.rest.get(url, options);
+                    let ret = this.formatResponse(res.result, null, true);
+                    resolve(ret);
+                }
+                catch (err) {
+                    reject(err);
+                }
+            }));
+        });
+    }
+}
+exports.SecurityRolesApi = SecurityRolesApi;

package/node_modules/azure-devops-node-api/Serialization.d.ts

@@ -0,0 +1,67 @@
+/**
+* Metadata for deserializing an enum field on a contract/type
+*/
+export interface ContractEnumMetadata {
+    enumValues?: {
+        [name: string]: number;
+    };
+}
+export interface SerializationData {
+    requestTypeMetadata?: ContractMetadata;
+    responseTypeMetadata?: ContractMetadata;
+    responseIsCollection: boolean;
+}
+/**
+* Metadata for deserializing a particular field on a contract/type
+*/
+export interface ContractFieldMetadata {
+    isArray?: boolean;
+    isDate?: boolean;
+    enumType?: ContractEnumMetadata;
+    typeInfo?: ContractMetadata;
+    isDictionary?: boolean;
+    dictionaryKeyIsDate?: boolean;
+    dictionaryValueIsDate?: boolean;
+    dictionaryKeyEnumType?: ContractEnumMetadata;
+    dictionaryValueEnumType?: ContractEnumMetadata;
+    dictionaryValueTypeInfo?: ContractMetadata;
+    dictionaryValueFieldInfo?: ContractFieldMetadata;
+}
+/**
+* Metadata required for deserializing a given type
+*/
+export interface ContractMetadata {
+    fields?: {
+        [fieldName: string]: ContractFieldMetadata;
+    };
+}
+export interface IWebApiArrayResult {
+    count: number;
+    value: any[];
+}
+/**
+* Module for handling serialization and deserialization of data contracts
+* (contracts sent from the server using the VSO default REST api serialization settings)
+*/
+export declare module ContractSerializer {
+    /**
+     * Process a contract in its raw form (e.g. date fields are Dates, and Enums are numbers) and
+     * return a pure JSON object that can be posted to REST endpoint.
+     *
+     * @param data The object to serialize
+     * @param contractMetadata The type info/metadata for the contract type being serialized
+     * @param preserveOriginal If true, don't modify the original object. False modifies the original object (the return value points to the data argument).
+     */
+    function serialize(data: any, contractMetadata: ContractMetadata, preserveOriginal: boolean): any;
+    /**
+     * Process a pure JSON object (e.g. that came from a REST call) and transform it into a JS object
+     * where date strings are converted to Date objects and enum values are converted from strings into
+     * their numerical value.
+     *
+     * @param data The object to deserialize
+     * @param contractMetadata The type info/metadata for the contract type being deserialize
+     * @param preserveOriginal If true, don't modify the original object. False modifies the original object (the return value points to the data argument).
+     * @param unwrapWrappedCollections If true check for wrapped arrays (REST apis will not return arrays directly as the root result but will instead wrap them in a { values: [], count: 0 } object.
+     */
+    function deserialize(data: any, contractMetadata: ContractMetadata, preserveOriginal: boolean, unwrapWrappedCollections: boolean): any;
+}

package/node_modules/azure-devops-node-api/Serialization.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContractSerializer = void 0;
+/**
+* Module for handling serialization and deserialization of data contracts
+* (contracts sent from the server using the VSO default REST api serialization settings)
+*/
+var ContractSerializer;
+(function (ContractSerializer) {
+    var _legacyDateRegExp;
+    /**
+     * Process a contract in its raw form (e.g. date fields are Dates, and Enums are numbers) and
+     * return a pure JSON object that can be posted to REST endpoint.
+     *
+     * @param data The object to serialize
+     * @param contractMetadata The type info/metadata for the contract type being serialized
+     * @param preserveOriginal If true, don't modify the original object. False modifies the original object (the return value points to the data argument).
+     */
+    function serialize(data, contractMetadata, preserveOriginal) {
+        if (data && contractMetadata) {
+            if (Array.isArray(data)) {
+                return _getTranslatedArray(data, contractMetadata, true, preserveOriginal);
+            }
+            else {
+                return _getTranslatedObject(data, contractMetadata, true, preserveOriginal);
+            }
+        }
+        else {
+            return data;
+        }
+    }
+    ContractSerializer.serialize = serialize;
+    /**
+     * Process a pure JSON object (e.g. that came from a REST call) and transform it into a JS object
+     * where date strings are converted to Date objects and enum values are converted from strings into
+     * their numerical value.
+     *
+     * @param data The object to deserialize
+     * @param contractMetadata The type info/metadata for the contract type being deserialize
+     * @param preserveOriginal If true, don't modify the original object. False modifies the original object (the return value points to the data argument).
+     * @param unwrapWrappedCollections If true check for wrapped arrays (REST apis will not return arrays directly as the root result but will instead wrap them in a { values: [], count: 0 } object.
+     */
+    function deserialize(data, contractMetadata, preserveOriginal, unwrapWrappedCollections) {
+        if (data) {
+            if (unwrapWrappedCollections && Array.isArray(data.value)) {
+                // Wrapped json array - unwrap it and send the array as the result
+                data = data.value;
+            }
+            if (contractMetadata) {
+                if (Array.isArray(data)) {
+                    data = _getTranslatedArray(data, contractMetadata, false, preserveOriginal);
+                }
+                else {
+                    data = _getTranslatedObject(data, contractMetadata, false, preserveOriginal);
+                }
+            }
+        }
+        return data;
+    }
+    ContractSerializer.deserialize = deserialize;
+    function _getTranslatedArray(array, typeMetadata, serialize, preserveOriginal) {
+        var resultArray = array;
+        var arrayCopy = [];
+        var i;
+        for (i = 0; i < array.length; i++) {
+            var item = array[i];
+            var processedItem;
+            // handle arrays of arrays
+            if (Array.isArray(item)) {
+                processedItem = _getTranslatedArray(item, typeMetadata, serialize, preserveOriginal);
+            }
+            else {
+                processedItem = _getTranslatedObject(item, typeMetadata, serialize, preserveOriginal);
+            }
+            if (preserveOriginal) {
+                arrayCopy.push(processedItem);
+                if (processedItem !== item) {
+                    resultArray = arrayCopy;
+                }
+            }
+            else {
+                array[i] = processedItem;
+            }
+        }
+        return resultArray;
+    }
+    function _getTranslatedObject(typeObject, typeMetadata, serialize, preserveOriginal) {
+        var processedItem = typeObject, copiedItem = false;
+        if (typeObject && typeMetadata.fields) {
+            for (var fieldName in typeMetadata.fields) {
+                var fieldMetadata = typeMetadata.fields[fieldName];
+                var fieldValue = typeObject[fieldName];
+                var translatedValue = _getTranslatedField(fieldValue, fieldMetadata, serialize, preserveOriginal);
+                if (fieldValue !== translatedValue) {
+                    if (preserveOriginal && !copiedItem) {
+                        processedItem = this._extend({}, typeObject);
+                        copiedItem = true;
+                    }
+                    processedItem[fieldName] = translatedValue;
+                }
+            }
+        }
+        return processedItem;
+    }
+    function _getTranslatedField(fieldValue, fieldMetadata, serialize, preserveOriginal) {
+        if (!fieldValue) {
+            return fieldValue;
+        }
+        if (fieldMetadata.isArray) {
+            if (Array.isArray(fieldValue)) {
+                var newArray = [], processedArray = fieldValue;
+                for (var index = 0; index < fieldValue.length; index++) {
+                    var arrayValue = fieldValue[index];
+                    var processedValue = arrayValue;
+                    if (fieldMetadata.isDate) {
+                        processedValue = _getTranslatedDateValue(arrayValue, serialize);
+                    }
+                    else if (fieldMetadata.enumType) {
+                        processedValue = _getTranslatedEnumValue(fieldMetadata.enumType, arrayValue, serialize);
+                    }
+                    else if (fieldMetadata.typeInfo) {
+                        if (Array.isArray(arrayValue)) {
+                            processedValue = _getTranslatedArray(arrayValue, fieldMetadata.typeInfo, serialize, preserveOriginal);
+                        }
+                        else {
+                            processedValue = _getTranslatedObject(arrayValue, fieldMetadata.typeInfo, serialize, preserveOriginal);
+                        }
+                    }
+                    if (preserveOriginal) {
+                        newArray.push(processedValue);
+                        if (processedValue !== arrayValue) {
+                            processedArray = newArray;
+                        }
+                    }
+                    else {
+                        fieldValue[index] = processedValue;
+                    }
+                }
+                return processedArray;
+            }
+            else {
+                return fieldValue;
+            }
+        }
+        else if (fieldMetadata.isDictionary) {
+            var dictionaryModified = false;
+            var newDictionary = {};
+            for (var key in fieldValue) {
+                var dictionaryValue = fieldValue[key];
+                var newKey = key, newValue = dictionaryValue;
+                if (fieldMetadata.dictionaryKeyIsDate) {
+                    newKey = _getTranslatedDateValue(key, serialize);
+                }
+                else if (fieldMetadata.dictionaryKeyEnumType) {
+                    newKey = _getTranslatedEnumValue(fieldMetadata.dictionaryKeyEnumType, key, serialize);
+                }
+                if (fieldMetadata.dictionaryValueIsDate) {
+                    newValue = _getTranslatedDateValue(dictionaryValue, serialize);
+                }
+                else if (fieldMetadata.dictionaryValueEnumType) {
+                    newValue = _getTranslatedEnumValue(fieldMetadata.dictionaryValueEnumType, dictionaryValue, serialize);
+                }
+                else if (fieldMetadata.dictionaryValueTypeInfo) {
+                    newValue = _getTranslatedObject(newValue, fieldMetadata.dictionaryValueTypeInfo, serialize, preserveOriginal);
+                }
+                else if (fieldMetadata.dictionaryValueFieldInfo) {
+                    newValue = _getTranslatedField(dictionaryValue, fieldMetadata.dictionaryValueFieldInfo, serialize, preserveOriginal);
+                }
+                newDictionary[newKey] = newValue;
+                if (key !== newKey || dictionaryValue !== newValue) {
+                    dictionaryModified = true;
+                }
+            }
+            return dictionaryModified ? newDictionary : fieldValue;
+        }
+        else {
+            if (fieldMetadata.isDate) {
+                return _getTranslatedDateValue(fieldValue, serialize);
+            }
+            else if (fieldMetadata.enumType) {
+                return _getTranslatedEnumValue(fieldMetadata.enumType, fieldValue, serialize);
+            }
+            else if (fieldMetadata.typeInfo) {
+                return _getTranslatedObject(fieldValue, fieldMetadata.typeInfo, serialize, preserveOriginal);
+            }
+            else {
+                return fieldValue;
+            }
+        }
+    }
+    function _getTranslatedEnumValue(enumType, valueToConvert, serialize) {
+        if (serialize && typeof valueToConvert === "number") {
+            // Serialize: number --> String
+            // Because webapi handles the numerical value for enums, there is no need to convert to string.
+            // Let this fall through to return the numerical value.
+        }
+        else if (!serialize && typeof valueToConvert === "string") {
+            // Deserialize: String --> number
+            var result = 0;
+            if (valueToConvert) {
+                var splitValue = valueToConvert.split(",");
+                for (var i = 0; i < splitValue.length; i++) {
+                    var valuePart = splitValue[i];
+                    //equivalent to jquery trim
+                    //copied from https://github.com/HubSpot/youmightnotneedjquery/blob/ef987223c20e480fcbfb5924d96c11cd928e1226/comparisons/utils/trim/ie8.js
+                    var enumName = valuePart.replace(/^\s+|\s+$/g, '') || "";
+                    if (enumName) {
+                        var resultPart = enumType.enumValues[enumName];
+                        if (!resultPart) {
+                            // No matching enum value. Try again but case insensitive
+                            var lowerCaseEnumName = enumName.toLowerCase();
+                            if (lowerCaseEnumName !== enumName) {
+                                for (var name in enumType.enumValues) {
+                                    var value = enumType.enumValues[name];
+                                    if (name.toLowerCase() === lowerCaseEnumName) {
+                                        resultPart = value;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if (resultPart) {
+                            result |= resultPart;
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+        return valueToConvert;
+    }
+    function _getTranslatedDateValue(valueToConvert, serialize) {
+        if (!serialize && typeof valueToConvert === "string") {
+            // Deserialize: String --> Date
+            var dateValue = new Date(valueToConvert);
+            if (isNaN(dateValue) && navigator.userAgent && /msie/i.test(navigator.userAgent)) {
+                dateValue = _convertLegacyIEDate(valueToConvert);
+            }
+            return dateValue;
+        }
+        return valueToConvert;
+    }
+    function _convertLegacyIEDate(dateStringValue) {
+        // IE 8/9 does not handle parsing dates in ISO form like:
+        // 2013-05-13T14:26:54.397Z
+        var match;
+        if (!_legacyDateRegExp) {
+            _legacyDateRegExp = new RegExp("(\\d+)-(\\d+)-(\\d+)T(\\d+):(\\d+):(\\d+).(\\d+)Z");
+        }
+        match = _legacyDateRegExp.exec(dateStringValue);
+        if (match) {
+            return new Date(Date.UTC(parseInt(match[1]), parseInt(match[2]) - 1, parseInt(match[3]), parseInt(match[4]), parseInt(match[5]), parseInt(match[6]), parseInt(match[7])));
+        }
+        else {
+            return null;
+        }
+    }
+    // jquery extend method in native javascript (used to clone objects)
+    // copied from https://github.com/HubSpot/youmightnotneedjquery/blob/ef987223c20e480fcbfb5924d96c11cd928e1226/comparisons/utils/extend/ie8.js
+    var _extend = function (out) {
+        out = out || {};
+        for (var i = 1; i < arguments.length; i++) {
+            if (!arguments[i])
+                continue;
+            for (var key in arguments[i]) {
+                if (arguments[i].hasOwnProperty(key))
+                    out[key] = arguments[i][key];
+            }
+        }
+        return out;
+    };
+})(ContractSerializer = exports.ContractSerializer || (exports.ContractSerializer = {}));

package/node_modules/azure-devops-node-api/TaskAgentApi.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+import taskagentbasem = require('./TaskAgentApiBase');
+import TaskAgentInterfaces = require("./interfaces/TaskAgentInterfaces");
+import VsoBaseInterfaces = require('./interfaces/common/VsoBaseInterfaces');
+export interface ITaskAgentApi extends taskagentbasem.ITaskAgentApiBase {
+    uploadTaskDefinition(customHeaders: VsoBaseInterfaces.IHeaders, contentStream: NodeJS.ReadableStream, taskId: string, overwrite: boolean): Promise<void>;
+}
+export declare class TaskAgentApi extends taskagentbasem.TaskAgentApiBase implements ITaskAgentApi {
+    private _handlers;
+    private _options;
+    private _fallbackClient;
+    constructor(baseUrl: string, handlers: VsoBaseInterfaces.IRequestHandler[], options?: VsoBaseInterfaces.IRequestOptions);
+    /**
+     * @param {string} taskId
+     * @param onResult callback function
+     */
+    deleteTaskDefinition(taskId: string): Promise<void>;
+    /**
+     * @param {string} taskId
+     * @param {string} versionString
+     * @param {string[]} visibility
+     * @param {boolean} scopeLocal
+     * @param onResult callback function with the resulting ArrayBuffer
+     */
+    getTaskContentZip(taskId: string, versionString: string, visibility: string[], scopeLocal: boolean): Promise<NodeJS.ReadableStream>;
+    /**
+     * @param {string} taskId
+     * @param {string} versionString
+     * @param {string[]} visibility
+     * @param {boolean} scopeLocal
+     * @param onResult callback function with the resulting TaskAgentInterfaces.TaskDefinition
+     */
+    getTaskDefinition(taskId: string, versionString: string, visibility: string[], scopeLocal: boolean): Promise<TaskAgentInterfaces.TaskDefinition>;
+    /**
+     * @param {string} taskId
+     * @param {string[]} visibility
+     * @param {boolean} scopeLocal
+     * @param onResult callback function with the resulting TaskAgentInterfaces.TaskDefinition[]
+     */
+    getTaskDefinitions(taskId: string, visibility: string[], scopeLocal: boolean): Promise<TaskAgentInterfaces.TaskDefinition[]>;
+    /**
+     * @param {NodeJS.ReadableStream} contentStream
+     * @param {string} taskId
+     * @param {boolean} overwrite
+     * @param onResult callback function
+     */
+    uploadTaskDefinition(customHeaders: VsoBaseInterfaces.IHeaders, contentStream: NodeJS.ReadableStream, taskId: string, overwrite: boolean): Promise<void>;
+    private _getFallbackClient;
+    private _getAccountUrl;
+}