kylebouchard
/
Aquadash-backend-client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update

This commit is contained in:
Kyle Bouchard 2024-02-12 09:19:10 -05:00
parent a04c913c23
commit c7fa94fb28
20 changed files with 213 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.openapi-generator/FILES
View File

@ -21,6 +21,7 @@ model/sensor.ts
model/sensorType.ts model/sensorType.ts
model/token.ts model/token.ts
model/validationError.ts model/validationError.ts
model/validationErrorLocInner.ts
ng-package.json ng-package.json
package.json package.json
param.ts param.ts

2
.openapi-generator/VERSION
View File

@ -1 +1 @@
7.3.0-SNAPSHOT 7.3.0

28
api/actuators.service.ts
View File

@ -99,10 +99,10 @@ export class ActuatorsService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public actuators(prototypeId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Array<Actuator>>; public actuators(prototypeId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<Actuator>>;
public actuators(prototypeId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Array<Actuator>>>; public actuators(prototypeId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<Actuator>>>;
public actuators(prototypeId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Array<Actuator>>>; public actuators(prototypeId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<Actuator>>>;
public actuators(prototypeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public actuators(prototypeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (prototypeId === null || prototypeId === undefined) { if (prototypeId === null || prototypeId === undefined) {
throw new Error('Required parameter prototypeId was null or undefined when calling actuators.'); throw new Error('Required parameter prototypeId was null or undefined when calling actuators.');
} }
@ -126,6 +126,11 @@ export class ActuatorsService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -146,6 +151,7 @@ export class ActuatorsService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -157,10 +163,10 @@ export class ActuatorsService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public putActuators(actuator: Array<Actuator>, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Actuator>; public putActuators(actuator: Array<Actuator>, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Actuator>;
public putActuators(actuator: Array<Actuator>, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Actuator>>; public putActuators(actuator: Array<Actuator>, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Actuator>>;
public putActuators(actuator: Array<Actuator>, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Actuator>>; public putActuators(actuator: Array<Actuator>, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Actuator>>;
public putActuators(actuator: Array<Actuator>, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public putActuators(actuator: Array<Actuator>, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (actuator === null || actuator === undefined) { if (actuator === null || actuator === undefined) {
throw new Error('Required parameter actuator was null or undefined when calling putActuators.'); throw new Error('Required parameter actuator was null or undefined when calling putActuators.');
} }
@ -184,6 +190,11 @@ export class ActuatorsService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
// to determine the Content-Type header // to determine the Content-Type header
const consumes: string[] = [ const consumes: string[] = [
@ -214,6 +225,7 @@ export class ActuatorsService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );

70
api/default.service.ts
View File

@ -119,10 +119,10 @@ export class DefaultService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public createUserAccessToken(username: any, password: any, grantType?: any, scope?: any, clientId?: any, clientSecret?: any, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Token>; public createUserAccessToken(username: string, password: string, grantType?: string, scope?: string, clientId?: string, clientSecret?: string, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Token>;
public createUserAccessToken(username: any, password: any, grantType?: any, scope?: any, clientId?: any, clientSecret?: any, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Token>>; public createUserAccessToken(username: string, password: string, grantType?: string, scope?: string, clientId?: string, clientSecret?: string, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Token>>;
public createUserAccessToken(username: any, password: any, grantType?: any, scope?: any, clientId?: any, clientSecret?: any, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Token>>; public createUserAccessToken(username: string, password: string, grantType?: string, scope?: string, clientId?: string, clientSecret?: string, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Token>>;
public createUserAccessToken(username: any, password: any, grantType?: any, scope?: any, clientId?: any, clientSecret?: any, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public createUserAccessToken(username: string, password: string, grantType?: string, scope?: string, clientId?: string, clientSecret?: string, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (username === null || username === undefined) { if (username === null || username === undefined) {
throw new Error('Required parameter username was null or undefined when calling createUserAccessToken.'); throw new Error('Required parameter username was null or undefined when calling createUserAccessToken.');
} }
@ -149,6 +149,11 @@ export class DefaultService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
// to determine the Content-Type header // to determine the Content-Type header
const consumes: string[] = [ const consumes: string[] = [
'application/x-www-form-urlencoded' 'application/x-www-form-urlencoded'
@ -204,6 +209,7 @@ export class DefaultService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -220,10 +226,10 @@ export class DefaultService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public loginForAccessToken(username: any, password: any, grantType?: any, scope?: any, clientId?: any, clientSecret?: any, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Token>; public loginForAccessToken(username: string, password: string, grantType?: string, scope?: string, clientId?: string, clientSecret?: string, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Token>;
public loginForAccessToken(username: any, password: any, grantType?: any, scope?: any, clientId?: any, clientSecret?: any, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Token>>; public loginForAccessToken(username: string, password: string, grantType?: string, scope?: string, clientId?: string, clientSecret?: string, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Token>>;
public loginForAccessToken(username: any, password: any, grantType?: any, scope?: any, clientId?: any, clientSecret?: any, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Token>>; public loginForAccessToken(username: string, password: string, grantType?: string, scope?: string, clientId?: string, clientSecret?: string, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Token>>;
public loginForAccessToken(username: any, password: any, grantType?: any, scope?: any, clientId?: any, clientSecret?: any, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public loginForAccessToken(username: string, password: string, grantType?: string, scope?: string, clientId?: string, clientSecret?: string, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (username === null || username === undefined) { if (username === null || username === undefined) {
throw new Error('Required parameter username was null or undefined when calling loginForAccessToken.'); throw new Error('Required parameter username was null or undefined when calling loginForAccessToken.');
} }
@ -250,6 +256,11 @@ export class DefaultService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
// to determine the Content-Type header // to determine the Content-Type header
const consumes: string[] = [ const consumes: string[] = [
'application/x-www-form-urlencoded' 'application/x-www-form-urlencoded'
@ -305,6 +316,7 @@ export class DefaultService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -315,10 +327,10 @@ export class DefaultService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public picture(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Picture>; public picture(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Picture>;
public picture(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Picture>>; public picture(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Picture>>;
public picture(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Picture>>; public picture(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Picture>>;
public picture(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public picture(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
let localVarHeaders = this.defaultHeaders; let localVarHeaders = this.defaultHeaders;
@ -339,6 +351,11 @@ export class DefaultService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -359,6 +376,7 @@ export class DefaultService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -369,10 +387,10 @@ export class DefaultService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public readItems(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any>; public readItems(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
public readItems(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<any>>; public readItems(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
public readItems(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<any>>; public readItems(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
public readItems(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public readItems(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
let localVarHeaders = this.defaultHeaders; let localVarHeaders = this.defaultHeaders;
@ -400,6 +418,11 @@ export class DefaultService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -420,6 +443,7 @@ export class DefaultService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -430,10 +454,10 @@ export class DefaultService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public userLogOut(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any>; public userLogOut(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any>;
public userLogOut(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<any>>; public userLogOut(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<any>>;
public userLogOut(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<any>>; public userLogOut(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<any>>;
public userLogOut(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public userLogOut(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
let localVarHeaders = this.defaultHeaders; let localVarHeaders = this.defaultHeaders;
@ -461,6 +485,11 @@ export class DefaultService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -481,6 +510,7 @@ export class DefaultService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );

28
api/measurements.service.ts
View File

@ -102,10 +102,10 @@ export class MeasurementsService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public measurements(prototypeId: number, sensorType: SensorType, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Array<Measurement>>; public measurements(prototypeId: number, sensorType: SensorType, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<Measurement>>;
public measurements(prototypeId: number, sensorType: SensorType, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Array<Measurement>>>; public measurements(prototypeId: number, sensorType: SensorType, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<Measurement>>>;
public measurements(prototypeId: number, sensorType: SensorType, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Array<Measurement>>>; public measurements(prototypeId: number, sensorType: SensorType, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<Measurement>>>;
public measurements(prototypeId: number, sensorType: SensorType, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public measurements(prototypeId: number, sensorType: SensorType, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (prototypeId === null || prototypeId === undefined) { if (prototypeId === null || prototypeId === undefined) {
throw new Error('Required parameter prototypeId was null or undefined when calling measurements.'); throw new Error('Required parameter prototypeId was null or undefined when calling measurements.');
} }
@ -132,6 +132,11 @@ export class MeasurementsService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -152,6 +157,7 @@ export class MeasurementsService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -165,10 +171,10 @@ export class MeasurementsService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public postMeasurement(prototypeId: number, sensorType: SensorType, value: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Measurement>; public postMeasurement(prototypeId: number, sensorType: SensorType, value: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Measurement>;
public postMeasurement(prototypeId: number, sensorType: SensorType, value: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Measurement>>; public postMeasurement(prototypeId: number, sensorType: SensorType, value: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Measurement>>;
public postMeasurement(prototypeId: number, sensorType: SensorType, value: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Measurement>>; public postMeasurement(prototypeId: number, sensorType: SensorType, value: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Measurement>>;
public postMeasurement(prototypeId: number, sensorType: SensorType, value: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public postMeasurement(prototypeId: number, sensorType: SensorType, value: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (prototypeId === null || prototypeId === undefined) { if (prototypeId === null || prototypeId === undefined) {
throw new Error('Required parameter prototypeId was null or undefined when calling postMeasurement.'); throw new Error('Required parameter prototypeId was null or undefined when calling postMeasurement.');
} }
@ -211,6 +217,11 @@ export class MeasurementsService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -232,6 +243,7 @@ export class MeasurementsService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );

42
api/prototypes.service.ts
View File

@ -99,10 +99,10 @@ export class PrototypesService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public postPrototype(prototype: Prototype, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Prototype>; public postPrototype(prototype: Prototype, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Prototype>;
public postPrototype(prototype: Prototype, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Prototype>>; public postPrototype(prototype: Prototype, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Prototype>>;
public postPrototype(prototype: Prototype, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Prototype>>; public postPrototype(prototype: Prototype, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Prototype>>;
public postPrototype(prototype: Prototype, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public postPrototype(prototype: Prototype, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (prototype === null || prototype === undefined) { if (prototype === null || prototype === undefined) {
throw new Error('Required parameter prototype was null or undefined when calling postPrototype.'); throw new Error('Required parameter prototype was null or undefined when calling postPrototype.');
} }
@ -133,6 +133,11 @@ export class PrototypesService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
// to determine the Content-Type header // to determine the Content-Type header
const consumes: string[] = [ const consumes: string[] = [
@ -163,6 +168,7 @@ export class PrototypesService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -174,10 +180,10 @@ export class PrototypesService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public prototype(prototypeId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Prototype>; public prototype(prototypeId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Prototype>;
public prototype(prototypeId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Prototype>>; public prototype(prototypeId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Prototype>>;
public prototype(prototypeId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Prototype>>; public prototype(prototypeId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Prototype>>;
public prototype(prototypeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public prototype(prototypeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (prototypeId === null || prototypeId === undefined) { if (prototypeId === null || prototypeId === undefined) {
throw new Error('Required parameter prototypeId was null or undefined when calling prototype.'); throw new Error('Required parameter prototypeId was null or undefined when calling prototype.');
} }
@ -201,6 +207,11 @@ export class PrototypesService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -221,6 +232,7 @@ export class PrototypesService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -231,10 +243,10 @@ export class PrototypesService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public prototypes(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Array<Prototype>>; public prototypes(observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<Prototype>>;
public prototypes(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Array<Prototype>>>; public prototypes(observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<Prototype>>>;
public prototypes(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Array<Prototype>>>; public prototypes(observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<Prototype>>>;
public prototypes(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public prototypes(observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
let localVarHeaders = this.defaultHeaders; let localVarHeaders = this.defaultHeaders;
@ -255,6 +267,11 @@ export class PrototypesService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -275,6 +292,7 @@ export class PrototypesService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );

42
api/sensors.service.ts
View File

@ -102,10 +102,10 @@ export class SensorsService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public postSensor(prototypeId: number, sensorType: SensorType, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Sensor>; public postSensor(prototypeId: number, sensorType: SensorType, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Sensor>;
public postSensor(prototypeId: number, sensorType: SensorType, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Sensor>>; public postSensor(prototypeId: number, sensorType: SensorType, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Sensor>>;
public postSensor(prototypeId: number, sensorType: SensorType, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Sensor>>; public postSensor(prototypeId: number, sensorType: SensorType, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Sensor>>;
public postSensor(prototypeId: number, sensorType: SensorType, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public postSensor(prototypeId: number, sensorType: SensorType, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (prototypeId === null || prototypeId === undefined) { if (prototypeId === null || prototypeId === undefined) {
throw new Error('Required parameter prototypeId was null or undefined when calling postSensor.'); throw new Error('Required parameter prototypeId was null or undefined when calling postSensor.');
} }
@ -138,6 +138,11 @@ export class SensorsService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -159,6 +164,7 @@ export class SensorsService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -170,10 +176,10 @@ export class SensorsService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public sensor(prototypeId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Array<Sensor>>; public sensor(prototypeId: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<Sensor>>;
public sensor(prototypeId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Array<Sensor>>>; public sensor(prototypeId: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<Sensor>>>;
public sensor(prototypeId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Array<Sensor>>>; public sensor(prototypeId: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<Sensor>>>;
public sensor(prototypeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public sensor(prototypeId: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
if (prototypeId === null || prototypeId === undefined) { if (prototypeId === null || prototypeId === undefined) {
throw new Error('Required parameter prototypeId was null or undefined when calling sensor.'); throw new Error('Required parameter prototypeId was null or undefined when calling sensor.');
} }
@ -197,6 +203,11 @@ export class SensorsService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -217,6 +228,7 @@ export class SensorsService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );
@ -229,10 +241,10 @@ export class SensorsService {
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
* @param reportProgress flag to report request and response progress. * @param reportProgress flag to report request and response progress.
*/ */
public sensors(sensorType?: string, prototypeId?: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Array<Sensor>>; public sensors(sensorType?: string, prototypeId?: number, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<Array<Sensor>>;
public sensors(sensorType?: string, prototypeId?: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Array<Sensor>>>; public sensors(sensorType?: string, prototypeId?: number, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpResponse<Array<Sensor>>>;
public sensors(sensorType?: string, prototypeId?: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Array<Sensor>>>; public sensors(sensorType?: string, prototypeId?: number, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<HttpEvent<Array<Sensor>>>;
public sensors(sensorType?: string, prototypeId?: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> { public sensors(sensorType?: string, prototypeId?: number, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext, transferCache?: boolean}): Observable<any> {
let localVarQueryParameters = new HttpParams({encoder: this.encoder}); let localVarQueryParameters = new HttpParams({encoder: this.encoder});
if (sensorType !== undefined && sensorType !== null) { if (sensorType !== undefined && sensorType !== null) {
@ -263,6 +275,11 @@ export class SensorsService {
localVarHttpContext = new HttpContext(); localVarHttpContext = new HttpContext();
} }
let localVarTransferCache: boolean | undefined = options && options.transferCache;
if (localVarTransferCache === undefined) {
localVarTransferCache = true;
}
let responseType_: 'text' | 'json' | 'blob' = 'json'; let responseType_: 'text' | 'json' | 'blob' = 'json';
if (localVarHttpHeaderAcceptSelected) { if (localVarHttpHeaderAcceptSelected) {
@ -284,6 +301,7 @@ export class SensorsService {
withCredentials: this.configuration.withCredentials, withCredentials: this.configuration.withCredentials,
headers: localVarHeaders, headers: localVarHeaders,
observe: observe, observe: observe,
transferCache: localVarTransferCache,
reportProgress: reportProgress reportProgress: reportProgress
} }
); );

12
model/actuator.ts
View File

@ -12,11 +12,11 @@
export interface Actuator { export interface Actuator {
actuator_name: any | null; actuator_name: string;
prototype_id: any | null; prototype_id: number;
low: any | null; low: number;
high: any | null; high: number;
actuator_id: any | null; actuator_id: number;
enabled: any | null; enabled: boolean;
} }

3
model/hTTPValidationError.ts
View File

@ -9,9 +9,10 @@
* https://openapi-generator.tech * https://openapi-generator.tech
* Do not edit the class manually. * Do not edit the class manually.
*/ */
import { ValidationError } from './validationError';
export interface HTTPValidationError { export interface HTTPValidationError {
detail?: any | null; detail?: Array<ValidationError>;
} }

8
model/measurement.ts
View File

@ -12,9 +12,9 @@
export interface Measurement { export interface Measurement {
value: any | null; value: number;
sensor_id: any | null; sensor_id: number;
measurement_id: any | null; measurement_id: number;
timestamp: any | null; timestamp: string;
} }

1
model/models.ts
View File

@ -7,3 +7,4 @@ export * from './sensor';
export * from './sensorType'; export * from './sensorType';
export * from './token'; export * from './token';
export * from './validationError'; export * from './validationError';
export * from './validationErrorLocInner';

2
model/picture.ts
View File

@ -12,6 +12,6 @@
export interface Picture { export interface Picture {
data: any | null; data: string;
} }

4
model/prototype.ts
View File

@ -12,7 +12,7 @@
export interface Prototype { export interface Prototype {
prototype_id: any | null; prototype_id: number;
prototype_name: any | null; prototype_name: string;
} }

4
model/sensor.ts
View File

@ -14,8 +14,8 @@ import { SensorType } from './sensorType';
export interface Sensor { export interface Sensor {
sensor_type: SensorType; sensor_type: SensorType;
prototype_id: any | null; prototype_id: number;
sensor_id: any | null; sensor_id: number;
} }
export namespace Sensor { export namespace Sensor {
} }

13
model/sensorType.ts
View File

@ -14,6 +14,15 @@
/** /**
* An enumeration. * An enumeration.
*/ */
export interface SensorType { export type SensorType = 'temperature' | 'humidity' | 'ec' | 'ph' | 'water_level' | 'boolean_water_level' | 'oxygen';
}
export const SensorType = {
Temperature: 'temperature' as SensorType,
Humidity: 'humidity' as SensorType,
Ec: 'ec' as SensorType,
Ph: 'ph' as SensorType,
WaterLevel: 'water_level' as SensorType,
BooleanWaterLevel: 'boolean_water_level' as SensorType,
Oxygen: 'oxygen' as SensorType
};

4
model/token.ts
View File

@ -12,7 +12,7 @@
export interface Token { export interface Token {
access_token: any | null; access_token: string;
token_type: any | null; token_type: string;
} }

7
model/validationError.ts
View File

@ -9,11 +9,12 @@
* https://openapi-generator.tech * https://openapi-generator.tech
* Do not edit the class manually. * Do not edit the class manually.
*/ */
import { ValidationErrorLocInner } from './validationErrorLocInner';
export interface ValidationError { export interface ValidationError {
loc: any | null; loc: Array<ValidationErrorLocInner>;
msg: any | null; msg: string;
type: any | null; type: string;
} }

16
model/validationErrorLocInner.ts Normal file
View File

@ -0,0 +1,16 @@
/**
* FastAPI
* No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
*
* The version of the OpenAPI document: 0.1.0
*
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
export interface ValidationErrorLocInner {
}

7
openapitools.json Normal file
View File

@ -0,0 +1,7 @@
{
"$schema": "./node_modules/@openapitools/openapi-generator-cli/config.schema.json",
"spaces": 2,
"generator-cli": {
"version": "7.3.0"
}
}

6
package.json
View File

@ -25,11 +25,11 @@
"@angular/compiler-cli": "^17.1.0", "@angular/compiler-cli": "^17.1.0",
"@angular/core": "^17.1.0", "@angular/core": "^17.1.0",
"@angular/platform-browser": "^17.1.0", "@angular/platform-browser": "^17.1.0",
"ng-packagr": "^16.0.0", "ng-packagr": "^17.0.3",
"reflect-metadata": "^0.1.3", "reflect-metadata": "^0.1.3",
"rxjs": "^7.4.0", "rxjs": "^7.4.0",
"typescript": ">=4.9.3 <5.2.0", "typescript": ">=4.9.3 <5.3.0",
"zone.js": "^0.13.0" "zone.js": "^0.14.0"
}, },
"publishConfig": { "publishConfig": {
"registry": "https://git.aquapoly.ca/kylebouchard/Aquadash-backend-client" "registry": "https://git.aquapoly.ca/kylebouchard/Aquadash-backend-client"