public async queryTestRuns()

in api/TestApi.ts [2935:3011]
69 lines of code
11 McCabe index (conditional complexity)

    public async queryTestRuns(
        project: string,
        minLastUpdatedDate: Date,
        maxLastUpdatedDate: Date,
        state?: TestInterfaces.TestRunState,
        planIds?: number[],
        isAutomated?: boolean,
        publishContext?: TestInterfaces.TestRunPublishContext,
        buildIds?: number[],
        buildDefIds?: number[],
        branchName?: string,
        releaseIds?: number[],
        releaseDefIds?: number[],
        releaseEnvIds?: number[],
        releaseEnvDefIds?: number[],
        runTitle?: string,
        top?: number,
        continuationToken?: string
        ): Promise<TestInterfaces.TestRun[]> {
        if (minLastUpdatedDate == null) {
            throw new TypeError('minLastUpdatedDate can not be null or undefined');
        }
        if (maxLastUpdatedDate == null) {
            throw new TypeError('maxLastUpdatedDate can not be null or undefined');
        }

        return new Promise<TestInterfaces.TestRun[]>(async (resolve, reject) => {
            let routeValues: any = {
                project: project
            };

            let queryValues: any = {
                minLastUpdatedDate: minLastUpdatedDate,
                maxLastUpdatedDate: maxLastUpdatedDate,
                state: state,
                planIds: planIds && planIds.join(","),
                isAutomated: isAutomated,
                publishContext: publishContext,
                buildIds: buildIds && buildIds.join(","),
                buildDefIds: buildDefIds && buildDefIds.join(","),
                branchName: branchName,
                releaseIds: releaseIds && releaseIds.join(","),
                releaseDefIds: releaseDefIds && releaseDefIds.join(","),
                releaseEnvIds: releaseEnvIds && releaseEnvIds.join(","),
                releaseEnvDefIds: releaseEnvDefIds && releaseEnvDefIds.join(","),
                runTitle: runTitle,
                '$top': top,
                continuationToken: continuationToken,
            };
            
            try {
                let verData: vsom.ClientVersioningData = await this.vsoClient.getVersioningData(
                    "6.1-preview.3",
                    "Test",
                    "cadb3810-d47d-4a3c-a234-fe5f3be50138",
                    routeValues,
                    queryValues);

                let url: string = verData.requestUrl!;
                let options: restm.IRequestOptions = this.createRequestOptions('application/json', 
                                                                                verData.apiVersion);

                let res: restm.IRestResponse<TestInterfaces.TestRun[]>;
                res = await this.rest.get<TestInterfaces.TestRun[]>(url, options);

                let ret = this.formatResponse(res.result,
                                              TestInterfaces.TypeInfo.TestRun,
                                              true);

                resolve(ret);
                
            }
            catch (err) {
                reject(err);
            }
        });
    }