@jax-data-science/api-clients 0.0.1-0

package/fesm2022/jax-data-science-api-clients.mjs

@@ -0,0 +1,911 @@
+import * as i0 from '@angular/core';
+import { Injectable, inject, Inject, NgModule } from '@angular/core';
+import { throwError, map, catchError, Observable, BehaviorSubject, combineLatest, tap } from 'rxjs';
+import { fetchEventSource } from '@microsoft/fetch-event-source';
+import * as i1 from '@angular/common/http';
+import { CommonModule } from '@angular/common';
+
+class ApiBaseServiceFactory {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    create(baseUrl) {
+        return new ApiBaseService(this.http, baseUrl);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ApiBaseServiceFactory, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ApiBaseServiceFactory, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: ApiBaseServiceFactory, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+class ApiBaseService {
+    http;
+    baseUrl;
+    constructor(http, baseUrl) {
+        this.http = http;
+        this.baseUrl = baseUrl;
+    }
+    /**
+     * Handles API response errors and HTTP errors
+     * @param response The API response
+     * @private
+     */
+    handleResponse(response) {
+        if (response.errors) {
+            // TO-DO: [GIK 6/6/2025] once the API service has the capabilities to respond
+            // with meaningful validation and analytical errors, this will need to be
+            // updated to typecast these into the ErrorResponse model and rethrow the error object
+            throw new Error(response.errors.join(', '));
+        }
+        return response;
+    }
+    /**
+     * Handles HTTP errors by catching them and rethrowing a consistent
+     * error response that contains an error code, numeric code, and
+     * a user-friendly message.
+     * TO-DO: [GIK 6/10/2025] consider adding error logging capabilities to an external service
+     * @param error an error object, typically an HttpErrorResponse
+     * @returns an Observable that emits an ErrorResponse object
+     */
+    handleHttpError(error) {
+        let errorResponse;
+        // errors returned on the Observable response stream
+        // will be wrapped in an HttpErrorResponse class
+        if (error.name === 'HttpErrorResponse') {
+            errorResponse = {
+                code: error.statusText || 'HTTP_ERROR',
+                num_code: error.status,
+                message: this.getErrorMessage(error),
+            };
+        }
+        else {
+            errorResponse = {
+                code: 'UNKNOWN_ERROR',
+                num_code: 0,
+                message: error.message || 'An unknown error occurred',
+            };
+        }
+        return throwError(() => errorResponse);
+    }
+    /**
+     * Get a user-friendly error message based on the HTTP status code
+     *
+     * @param error
+     * @return a string containing the error message
+     */
+    getErrorMessage(error) {
+        switch (error.status) {
+            case 400:
+                return 'Bad request - malformed request syntax or invalid parameters';
+                break;
+            case 401:
+                return 'Unauthorized - authentication required or invalid credentials';
+                break;
+            case 403:
+                return 'Forbidden - the authenticated user does not have permission to perform the operation';
+                break;
+            case 404:
+                return 'Not found - the requested resource does not exist';
+                break;
+            case 422:
+                return 'Unprocessable content - the request is correctly formed but contained semantic errors';
+                break;
+            case 500:
+                return 'Internal Server Error - generic server-side error';
+                break;
+            default:
+                return `Unexpected error occurred - status code: ${error.status}`;
+        }
+    }
+    /**
+     * Get a single resource
+     * @param url The endpoint URL
+     * @param params Optional query parameters
+     */
+    get(url, params) {
+        return this.http.get(`${this.baseUrl}${url}`, { params }).pipe(map((response) => this.handleResponse(response)), catchError((error) => this.handleHttpError(error)));
+    }
+    /**
+     * Get a collection of resources
+     * @param url The endpoint URL
+     * @param params Optional query parameters
+     */
+    handleCollectionResponse(response) {
+        if (response.errors) {
+            throw new Error(response.errors.join(', '));
+        }
+        return response;
+    }
+    getCollection(url, params) {
+        return this.http
+            .get(`${this.baseUrl}${url}`, { params })
+            .pipe(map((response) => this.handleCollectionResponse(response)), catchError((error) => this.handleHttpError(error)));
+    }
+    /**
+     * Create a new resource
+     * @param url The endpoint URL
+     * @param body The resource to create
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    post(url, body) {
+        return this.http.post(`${this.baseUrl}${url}`, body).pipe(map((response) => this.handleResponse(response)), catchError((error) => this.handleHttpError(error)));
+    }
+    /**
+     * Update an existing resource
+     * @param url The endpoint URL
+     * @param body The resource updates
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    put(url, body) {
+        return this.http.put(`${this.baseUrl}${url}`, body).pipe(map((response) => this.handleResponse(response)), catchError((error) => this.handleHttpError(error)));
+    }
+    /**
+     * Partially update an existing resource
+     * @param url The endpoint URL
+     * @param body The partial resource updates
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    patch(url, body) {
+        return this.http.patch(`${this.baseUrl}${url}`, body).pipe(map((response) => this.handleResponse(response)), catchError((error) => this.handleHttpError(error)));
+    }
+    /**
+     * Delete a resource
+     * @param url The endpoint URL
+     */
+    delete(url) {
+        return this.http.delete(`${this.baseUrl}${url}`).pipe(map((response) => this.handleResponse(response)), catchError((error) => this.handleHttpError(error)));
+    }
+}
+
+class AsyncTaskService {
+    // TO-DO [GIK 7/9/2025]: move 'https://astra-dev.jax.org' to an environment variable
+    apiBaseUrl = '/asynctask/api';
+    apiServiceFactory = inject(ApiBaseServiceFactory);
+    apiBaseService = this.apiServiceFactory.create(this.apiBaseUrl);
+    setApiBaseUrl(baseUrl) {
+        this.apiBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+        // ensure the URL ends with '/asynctask/api'
+        if (!this.apiBaseUrl.endsWith('asynctask/api')) {
+            this.apiBaseUrl = `${this.apiBaseUrl}/asynctask/api`;
+        }
+        // recreate the apiService
+        this.apiBaseService = this.apiServiceFactory.create(this.apiBaseUrl);
+    }
+    getApiBaseUrl() {
+        return this.apiBaseUrl;
+    }
+    // INPUT
+    addInput(inputSubmission) {
+        return this.apiBaseService.post('/inputs', inputSubmission);
+    }
+    getInput(id) {
+        return this.apiBaseService.get(`/inputs/${id}`);
+    }
+    getInputs() {
+        return this.apiBaseService.getCollection('/inputs');
+    }
+    /**
+     * Updates an existing input - only 'name' and 'description' can be updated
+     * @param inputId
+     * @param name - (optional) name to update
+     * @param description - (optional) description to update
+     */
+    updateInput(inputId, name, description) {
+        let url = `/inputs/${inputId}?`;
+        if (name !== undefined) {
+            url += `name=${name}&`;
+        }
+        if (description !== undefined) {
+            url += `description=${description}`;
+        }
+        return this.apiBaseService.patch(url, null);
+    }
+    // RUN
+    createRun(inputId, inputSubmission) {
+        const url = inputId ? `/runs?input_id=${inputId}` : '/runs';
+        return this.apiBaseService.post(url, inputSubmission || null);
+    }
+    getRun(id) {
+        return this.apiBaseService.get(`/runs/${id}`);
+    }
+    /**
+     *
+     * @param workflowId - (optional) workflow identifier
+     */
+    getRuns(workflowId) {
+        const url = (workflowId ? `/runs?workflow_id=${workflowId}` : '/runs');
+        return this.apiBaseService.getCollection(url);
+    }
+    /**
+     * Gets the input associated with the specific run ID. One run is associated
+     * with only one input, so this function returns a single input object.
+     * @param runId
+     */
+    getRunInput(runId) {
+        return this.apiBaseService.get(`/runs/${runId}/inputs`);
+    }
+    /**
+     * Gets the result associated with the specific run ID. One run is associated
+     * with only one result, so this function returns a single result object.
+     * @param runId
+     */
+    getRunResult(runId) {
+        return this.apiBaseService.get(`/runs/${runId}/results`);
+    }
+    /**
+     * Calls the fetchEventSource() function, which is a wrapper around the native
+     * EventSource API. This function is used to establish connection to an API
+     * endpoint and listen to event streaming data associated with task runs.
+     * TO-DO [GIK 7/9/2025]: needs to add a reconnect logic
+     * @return an observable that emits run events
+     */
+    getRunEvents(accessToken) {
+        const api = this.apiBaseService;
+        // observable constructor argument is 'subscribe()' method implementation
+        return new Observable((subscriber) => {
+            // abort controller to cancel the request (on component destroy)
+            const abortController = new AbortController();
+            fetchEventSource(`${this.apiBaseUrl}/runs/events`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    'Authorization': `Bearer ${accessToken}`
+                },
+                async onopen(response) {
+                    // SSE media type must be 'text/event-stream'
+                    const contentType = response.headers.get('content-type');
+                    if (!contentType?.startsWith('text/event-stream')) {
+                        const errorResponse = {
+                            code: 'INVALID_CONTENT_TYPE',
+                            num_code: response.status,
+                            message: `Expected content-type to be text/event-stream, but got: ${contentType}`
+                        };
+                        throw errorResponse;
+                    }
+                    // resolve promise (without returning anything), which indicates that the connection is open
+                    if (response.ok && response.status === 200)
+                        return;
+                    // opening SSE connection failed
+                    if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+                        const errorResponse = {
+                            code: 'RESOURCE_NOT_FOUND',
+                            num_code: response.status,
+                            message: 'Resource not found or access denied'
+                        };
+                        throw errorResponse;
+                    }
+                },
+                onmessage(event) {
+                    try {
+                        const run = JSON.parse(event.data);
+                        subscriber.next(run);
+                    }
+                    catch (error) {
+                        const errorResponse = {
+                            code: 'PARSE_ERROR',
+                            num_code: 0,
+                            message: `Failed to parse event data: ${event.data}`
+                        };
+                        throw errorResponse;
+                    }
+                },
+                onclose() {
+                    subscriber.complete();
+                },
+                onerror(errorRes) {
+                    // send an error message to subscriber's error handler
+                    subscriber.error(errorRes);
+                    // rethrow the error to stop the operation
+                    throw errorRes;
+                },
+                signal: abortController.signal
+            });
+            return () => {
+                abortController.abort(); // close connection on unsubscribe
+            };
+        });
+    }
+    // RESULT
+    getResult(resId) {
+        return this.apiBaseService.get(`/results/${resId}`);
+    }
+    getResults() {
+        return this.apiBaseService.getCollection('/results');
+    }
+    /**
+     * Updates an existing result record - 'name' and 'description' can be updated
+     * @param resId
+     * @param name - (optional) result's name to update
+     * @param description - (optional) result's description to update
+     */
+    updateResult(resId, name, description) {
+        let url = `/results/${resId}?`;
+        if (name !== undefined) {
+            url += `name=${name}&`;
+        }
+        if (description !== undefined) {
+            url += `description=${description}`;
+        }
+        return this.apiBaseService.patch(url, null);
+    }
+    // HEALTH CHECK
+    // TO-DO [GIK 05/30/2025]: should be moved outside this service
+    getHealthCheck() {
+        return this.apiBaseService.get('/monitors/servers/health');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: AsyncTaskService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: AsyncTaskService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: AsyncTaskService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * AsyncTask Service Models
+ *
+ * This module contains TypeScript interfaces for the AsyncTask service API.
+ * These models are based on the OpenAPI specification and represent the
+ * core entities used in the AsyncTask workflow system.
+ */
+/**
+ * Represents the current execution status of a workflow.
+ * Based on temporalio.api.enums.v1.WorkflowExecutionStatus
+ */
+var WorkflowExecutionStatus;
+(function (WorkflowExecutionStatus) {
+    WorkflowExecutionStatus[WorkflowExecutionStatus["RUNNING"] = 1] = "RUNNING";
+    WorkflowExecutionStatus[WorkflowExecutionStatus["COMPLETED"] = 2] = "COMPLETED";
+    WorkflowExecutionStatus[WorkflowExecutionStatus["FAILED"] = 3] = "FAILED";
+    WorkflowExecutionStatus[WorkflowExecutionStatus["CANCELED"] = 4] = "CANCELED";
+    WorkflowExecutionStatus[WorkflowExecutionStatus["TERMINATED"] = 5] = "TERMINATED";
+    WorkflowExecutionStatus[WorkflowExecutionStatus["CONTINUED_AS_NEW"] = 6] = "CONTINUED_AS_NEW";
+    WorkflowExecutionStatus[WorkflowExecutionStatus["TIMED_OUT"] = 7] = "TIMED_OUT";
+})(WorkflowExecutionStatus || (WorkflowExecutionStatus = {}));
+
+var Ontology;
+(function (Ontology) {
+    Ontology["HP"] = "HP";
+    Ontology["MONDO"] = "MONDO";
+    Ontology["MP"] = "MP";
+    Ontology["CL"] = "CL";
+    Ontology["MAXO"] = "MAXO";
+})(Ontology || (Ontology = {}));
+
+class OntologyService {
+    httpClient;
+    config_location = 'https://raw.githubusercontent.com/TheJacksonLaboratory/ontology-service/refs/heads/main/config/ontologies-internal.json';
+    config;
+    /**
+     * Get the configuration file from the source for the backend api service
+     */
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.httpClient.get(this.config_location).subscribe({
+            next: (config) => this.config = config,
+            error: () => {
+                this.config = [];
+            }
+        });
+    }
+    /**
+     * Search for terms in an ontology
+     * @param query - the search query
+     * @param limit - the number of results to return
+     * @param ontology - the ontology to search
+     */
+    search(query, limit, ontology) {
+        return this.httpClient.get(`${this.ontologyBaseResolver(ontology)}/search?q=${query}&limit=${limit}`);
+    }
+    /**
+     * Get a term by its ID
+     * @param id - the term ID
+     */
+    term(id) {
+        try {
+            const url = `${this.ontologyBaseResolver(this.ontologyFromCurie(id))}/${id}`;
+            return this.httpClient.get(url);
+        }
+        catch (error) {
+            return throwError(error);
+        }
+    }
+    /**
+     * Get the parents of a term
+     * @param id - the term ID
+     */
+    parents(id) {
+        try {
+            const url = `${this.ontologyBaseResolver(this.ontologyFromCurie(id))}/${id}/parents`;
+            return this.httpClient.get(url);
+        }
+        catch (error) {
+            return throwError(error);
+        }
+    }
+    /**
+     * Get the children of a term
+     * @param id - the term ID
+     */
+    children(id) {
+        try {
+            const url = `${this.ontologyBaseResolver(this.ontologyFromCurie(id))}/${id}/children`;
+            return this.httpClient.get(url);
+        }
+        catch (error) {
+            return throwError(error);
+        }
+    }
+    /**
+     * Get the ancestors of a term
+     * @param id - the term ID
+     */
+    ancestors(id) {
+        try {
+            const url = `${this.ontologyBaseResolver(this.ontologyFromCurie(id))}/${id}/ancestors`;
+            return this.httpClient.get(url);
+        }
+        catch (error) {
+            return throwError(error);
+        }
+    }
+    /**
+     * Get the descendants of a term
+     * @param id - the term ID
+     */
+    descendants(id) {
+        try {
+            const url = `${this.ontologyBaseResolver(this.ontologyFromCurie(id))}/${id}/descendants`;
+            return this.httpClient.get(url);
+        }
+        catch (error) {
+            return throwError(error);
+        }
+    }
+    /**
+     * Get the ontology from curie
+     */
+    ontologyFromCurie(curie) {
+        return Ontology[curie.split(':')[0]];
+    }
+    /**
+     * Get the ontology api base url configuration
+     **/
+    ontologyBaseResolver(ontology) {
+        if (!this.config || this.config.length === 0) {
+            throw new Error('No ontology configuration found.');
+        }
+        const ontology_config = this.config.find((config) => config.prefix.toUpperCase() === ontology);
+        if (!ontology_config) {
+            throw new Error('Ontology not found in configuration.');
+        }
+        return ontology_config.api.base;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: OntologyService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: OntologyService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: OntologyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+
+// TODO - move to constants file/library
+const MUS_CHRS = [
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    '10',
+    '11',
+    '12',
+    '13',
+    '14',
+    '15',
+    '16',
+    '17',
+    '18',
+    '19',
+    'X',
+    'Y',
+];
+
+class MVarService {
+    http;
+    environment;
+    api;
+    sequenceOntologyMapping = {};
+    soTerms = new BehaviorSubject([]);
+    soTerms$ = this.soTerms.asObservable();
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.api = environment.unsecuredURLs.mvar;
+        // create a sequence ontology lookup
+        this.getSequenceOntologyTerms().subscribe((terms) => {
+            terms.forEach((t) => {
+                if (t.label) {
+                    this.sequenceOntologyMapping[t.label] = t;
+                }
+            });
+        });
+    }
+    /**
+     * Gets Variants from mvar for a given set snp regions
+     * @param regions Array of snp regions
+     * @param pageStart snp start location
+     * @param pageEnd snp end location
+     * @param assembly Desired assembly version. Acceptable values are 'mm10' (GRCm38) and 'mm39' (GRCm39)
+     */
+    getVariants(regions, pageStart, pageEnd, assembly) {
+        return combineLatest(this.getRegionsToRequestVariantsFor(regions, pageStart, pageEnd).map((r) => {
+            return this.http.get(`${this.api}/variant/query?chr=${r.chromosome}&startPos=${r.start_position}&endPos=${r.end_position}&max=8000&assembly=${assembly}`);
+        })).pipe(map((variants) => {
+            const allVariants = variants.map((v) => v.variants).flat();
+            allVariants.forEach((variant) => {
+                const classCodes = variant.functionalClassCode.split(',')[0];
+                // add the ontology term
+                variant.functionalClasses = classCodes.split('&').map((c) => this.sequenceOntologyMapping[c]);
+            });
+            return allVariants;
+        }));
+    }
+    /**
+     * Returns all sequence ontology terms in MVAR
+     */
+    getSequenceOntologyTerms() {
+        return this.http
+            .get(`${this.api}/sequenceOntology/query?max=3000`)
+            .pipe(tap((terms) => this.soTerms.next(terms)));
+    }
+    /**
+     * Translates the regions requested from MUSter and the regions actually displayed on the current page into
+     * regions to request from MVAR
+     * @param requestedRegions - regions included in the request to MUSter
+     * @param pageStart - first SNP from the sorted results from MUSter to display in the table
+     * @param pageEnd - last SNP from the sorted results from MUSter to display in the table
+     */
+    getRegionsToRequestVariantsFor(requestedRegions, pageStart, pageEnd) {
+        const displayStartBP = pageStart.start_position || 0;
+        const displayEndBP = pageEnd.start_position || 0;
+        const regionsByChr = {};
+        requestedRegions.forEach((r) => {
+            if (regionsByChr[r.chromosome]) {
+                regionsByChr[r.chromosome].push(r);
+            }
+            else {
+                regionsByChr[r.chromosome] = [r];
+            }
+        });
+        const displayedRegions = [];
+        if (pageStart.chr === pageEnd.chr) {
+            regionsByChr[pageStart.chr].forEach((r) => {
+                if (r.start_position <= displayEndBP && r.end_position >= displayStartBP) {
+                    displayedRegions.push({
+                        chromosome: r.chromosome,
+                        start_position: Math.max(r.start_position, displayStartBP),
+                        end_position: Math.min(r.end_position, displayEndBP),
+                    });
+                }
+            });
+        }
+        else {
+            const displayedChrs = Object.keys(regionsByChr).filter((r) => MUS_CHRS.indexOf(r) >= MUS_CHRS.indexOf(pageStart.chr) &&
+                MUS_CHRS.indexOf(r) <= MUS_CHRS.indexOf(pageEnd.chr));
+            displayedChrs.forEach((chr) => {
+                regionsByChr[chr].forEach((r) => {
+                    if (r.end_position >= displayStartBP && chr === pageStart.chr) {
+                        displayedRegions.push({
+                            chromosome: r.chromosome,
+                            start_position: Math.max(r.start_position, displayStartBP),
+                            end_position: r.end_position,
+                        });
+                    }
+                    else if (r.start_position <= displayEndBP && chr === pageEnd.chr) {
+                        displayedRegions.push({
+                            chromosome: r.chromosome,
+                            start_position: r.start_position,
+                            end_position: Math.min(r.end_position, displayEndBP),
+                        });
+                    }
+                    else if (chr !== pageStart.chr && chr !== pageEnd.chr) {
+                        displayedRegions.push({
+                            chromosome: r.chromosome,
+                            start_position: r.start_position,
+                            end_position: r.end_position,
+                        });
+                    }
+                });
+            });
+        }
+        return displayedRegions;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: MVarService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: MVarService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: MVarService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+
+class MvarClientModule {
+    static forRoot(environment) {
+        return {
+            ngModule: MvarClientModule,
+            providers: [
+                MVarService,
+                {
+                    provide: 'environment', // you can also use InjectionToken
+                    useValue: environment
+                }
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: MvarClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.1.5", ngImport: i0, type: MvarClientModule, imports: [CommonModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: MvarClientModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: MvarClientModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                }]
+        }] });
+
+class SnpGridService {
+    http;
+    environment;
+    api;
+    // default true but becomes false if any of the API calls for general information fails
+    apiAvailable = true;
+    strains = new BehaviorSubject([]);
+    strains$ = this.strains.asObservable();
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.api = environment.securedURLs.genomeMUSter;
+        this.getHealthCheck().subscribe({
+            error: () => {
+                this.apiAvailable = false;
+            },
+        });
+        this.getStrains().subscribe({
+            next: (strains) => {
+                this.apiAvailable = Boolean(strains.length);
+            },
+            error: () => {
+                this.apiAvailable = false;
+            },
+        });
+    }
+    /**
+     * Returns the result of a health check for the API
+     */
+    getHealthCheck() {
+        return this.http.get(`${this.api}/healthcheck`);
+    }
+    /**
+     * Returns the metadata on the MUSter DB
+     */
+    getMusterMetadata() {
+        return this.http.get(`${this.api}/db_info`).pipe(catchError((err) => {
+            this.apiAvailable = false;
+            throw err;
+        }));
+    }
+    /**
+     * Returns strains available in the API and takes an optional limit; by default the limit is set
+     * to 5000 to get all strains
+     * @param limit - maximum number of strains to be returned
+     */
+    getStrains(limit = 5000) {
+        return this.http
+            .get(`${this.api}/strains/?limit=${limit}`)
+            .pipe(tap((strains) => this.strains.next(strains.filter((s) => s.mpd_strainid))));
+    }
+    /**
+     * Returns a list of known genes whose symbols/coordinates start with the specified value.
+     * @param searchValue - value to use for the "starts with" filter
+     * @param limit - maximum number of genes to return, default is 20
+     */
+    getGenes(searchValue, limit = 20) {
+        return this.http.get(`${this.api}/genes/?symbol=${searchValue}%&limit=${limit}`);
+    }
+    /**
+     * Returns the gene that matches the specified gene symbol
+     * @param geneSymbol - symbol to use to get the associated gene info
+     */
+    getGene(geneSymbol) {
+        return this.http
+            .get(`${this.api}/genes/?symbol=${geneSymbol}`)
+            .pipe(map((genes) => (genes.length ? genes[0] : null)));
+    }
+    /**
+     * Returns true if the specified gene symbol is valid from the perspective of MUSter
+     * @param geneSymbol - symbol to use to check the validity of
+     */
+    isGeneSymbolValid(geneSymbol) {
+        return this.getGene(geneSymbol).pipe(map((g) => g !== null && geneSymbol.toLowerCase() === g.symbol.toLowerCase()));
+    }
+    /**
+     * Returns list of known reference SNP (RS) data which includes IDs and coordinates
+     * @param searchValue - value to use to filter the search results
+     * @param limit - maximum number of results to return, default is 20
+     */
+    getReferenceSNPs(searchValue, limit = 20) {
+        return this.http.get(`${this.api}/rsids/?rsid=${searchValue}%&limit=${limit}`);
+    }
+    /**
+     * Returns the RS info that matches the specified rsID
+     * @param rsid - the RSID to use to get the associated RS info
+     */
+    getReferenceSNP(rsid) {
+        return this.http
+            .get(`${this.api}/rsids/?rsid=${rsid}`)
+            .pipe(map((rsids) => (rsids.length ? { ...rsids[0], end_position: rsids[0].start_position } : null)));
+    }
+    /**
+     * Returns true if the specified rsID is valid from the perspective of MUSter
+     * @param rsid - rsID to use to check the validity of
+     */
+    isRSIDValid(rsid) {
+        return this.getReferenceSNP(rsid).pipe(map((rs) => rs !== null && rsid.toLowerCase() === rs.rsid.toLowerCase()));
+    }
+    /**
+     * Returns the SNP results generated from the query constructed from the specified parameters and page
+     * @param parameters - search properties (strain IDs, regions, assembly version, etc.)
+     * @param page - requested page, which is 0-indexed. The 0th page is the initial page
+     * @param pageSize - number of records to show per page. Default of 5000
+     */
+    getGenotypes(parameters, page = 0, pageSize = 5000) {
+        let constructedURL = `${this.api}/snps/?` +
+            `assembly=${parameters.assembly}&` +
+            `mpd_strain_ids=${parameters.strains.join(',')}&` +
+            `limit=${pageSize}`;
+        if (parameters.strains_b?.length) {
+            constructedURL += `&mpd_strain_ids_b=${parameters.strains_b.join(',')}&strain_limit=${parameters.strains.length + parameters.strains_b.length}`;
+        }
+        else {
+            constructedURL += `&strain_limit=${parameters.strains.length}`;
+        }
+        if (parameters.rsids?.length) {
+            constructedURL += `&rsids=${parameters.rsids.join(',')}`;
+        }
+        if (parameters.genes?.length) {
+            constructedURL += `&genes=${parameters.genes.join(',')}`;
+        }
+        if (parameters.regions?.length) {
+            constructedURL += `&regions=${parameters.regions.join(',')}`;
+        }
+        if (parameters.dataset_id) {
+            constructedURL += `&dataset_id=${parameters.dataset_id}`;
+        }
+        if (parameters.is_unique_row) {
+            constructedURL += `&is_unique_row=${parameters.is_unique_row}`;
+        }
+        if (page) {
+            constructedURL += `&offset=${pageSize * page}`;
+        }
+        return this.http.get(constructedURL);
+    }
+    /**
+     * Returns the URL that will generate a download (in file form) for the specified strain IDs and regions
+     * @param strains - list of mpd_strain_ids to query SNPs for
+     * @param regions - list of SNPSearchRegions to query SNPs for (chromosome, start and end)
+     * @param dataset_id - ID of the dataset to query SNPs for
+     * @param is_unique_row - boolean for polymorphism filtering - true for only rows with polymorphism, false for all
+     * @param limit - the limit of the number of result rows to include in the download - you're likely to
+     *                prefer to pass the total number of rows generated by the query itself, which is included
+     *                as part of the GenotypeResults returned by getGenotypes()
+     */
+    getGenotypeDownloadURLForCurrentData(strains, regions, dataset_id, is_unique_row = false, limit) {
+        if (!dataset_id) {
+            // default to the GenomeMuster dataset id
+            dataset_id = 2;
+        }
+        const stringifiedRegions = `regions=${regions
+            .map((reg) => `${reg.chromosome}:${reg.start_position}-${reg.end_position}`)
+            .join(',')}`;
+        const stringifiedStrains = `mpd_strain_ids=${strains.join(',')}`;
+        return `${this.api}/snps/download?dataset_id=${dataset_id}&${stringifiedStrains}&${stringifiedRegions}&limit=${limit}&is_unique_row=${is_unique_row}`;
+    }
+    /**
+     * Returns the dataset with the given ID
+     * @param id
+     */
+    getDataset(id) {
+        return this.http.get(`${this.api}/datasets/${id}`);
+    }
+    /**
+     * Returns a list of Datasets that match the given criteria
+     * @param status  The value of the status to be used for filtering
+     * @param limit   The maximum number of records to return
+     */
+    findDatasets(status, limit = 50) {
+        let url = `${this.api}/datasets`;
+        url += `/?limit=${limit}`;
+        if (status) {
+            url += `&status=${status}`;
+        }
+        return this.http.get(url);
+    }
+    /**
+     * Return a list of strains that match the given criteria
+     * @param datasetId  The ID of the dataset from which to fetch the strains
+     * @param limit      The maximum number of records to return
+     */
+    datasetStrains(datasetId, limit = 5000) {
+        const url = `${this.api}/dataset_strain/?dataset_id=${datasetId}&limit=${limit}`;
+        return this.http.get(url);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: SnpGridService, deps: [{ token: i1.HttpClient }, { token: 'environment' }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: SnpGridService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: SnpGridService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['environment']
+                }] }] });
+
+class SnpGridClientModule {
+    static forRoot(environment) {
+        return {
+            ngModule: SnpGridClientModule,
+            providers: [
+                SnpGridService,
+                {
+                    provide: 'environment', // you can also use InjectionToken
+                    useValue: environment
+                }
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: SnpGridClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.1.5", ngImport: i0, type: SnpGridClientModule, imports: [CommonModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: SnpGridClientModule, imports: [CommonModule] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.5", ngImport: i0, type: SnpGridClientModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                }]
+        }] });
+
+var DatasetStatus;
+(function (DatasetStatus) {
+    DatasetStatus["Queued"] = "queued";
+    DatasetStatus["Loading"] = "loading";
+    DatasetStatus["Done"] = "done";
+    DatasetStatus["Archived"] = "archived";
+})(DatasetStatus || (DatasetStatus = {}));
+
+// AsyncTask API client
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AsyncTaskService, DatasetStatus, MUS_CHRS, MVarService, MvarClientModule, OntologyService, SnpGridClientModule, SnpGridService, WorkflowExecutionStatus };
+//# sourceMappingURL=jax-data-science-api-clients.mjs.map