@keiser/metrics-sdk-admin-typescript 5.0.12

package/src/event.ts

@@ -0,0 +1,267 @@
+
+interface IEventManagement {
+  unsubscribe: () => void
+  stopPropagation: () => void
+}
+
+interface ISubscribable<TypedEventHandler> {
+  readonly count: number
+  subscribe: (handler: TypedEventHandler) => () => void
+  unsubscribe: (handler: TypedEventHandler) => void
+  one: (handler: TypedEventHandler) => () => void
+  has: (handler: TypedEventHandler) => boolean
+  clear: () => void
+}
+
+interface ISubscription<TypedEventHandler> {
+  readonly isExecuted: boolean
+  readonly isOnce: boolean
+  readonly handler: TypedEventHandler
+}
+
+type IEventHandler<TypedEventArgument> = (argument: TypedEventArgument, eventManager: IEventManagement) => void
+
+type TypedEventArgument = any
+type TypedEventHandler = IEventHandler<TypedEventArgument>
+
+class DispatchError extends Error { }
+
+class Subscription<TypedEventHandler> implements ISubscription<TypedEventHandler> {
+  public isExecuted = false
+  public handler: TypedEventHandler
+  public isOnce: boolean
+
+  constructor (handler: TypedEventHandler, isOnce: boolean) {
+    this.handler = handler
+    this.isOnce = isOnce
+  }
+
+  public execute (executeAsync: boolean, scope: any, argument: TypedEventArgument, eventManager: EventManagement) {
+    if (!this.isOnce || !this.isExecuted) {
+      this.isExecuted = true
+
+      if (executeAsync) {
+        setTimeout(() => (this.handler as any).apply(scope, [argument, eventManager]), 1)
+      } else {
+        (this.handler as any).apply(scope, [argument, eventManager])
+      }
+    }
+  }
+}
+
+class EventManagement implements IEventManagement {
+  public propagationStopped = false
+  public unsubscribe: () => void
+
+  constructor (unsubscribe: () => void) {
+    this.unsubscribe = unsubscribe
+  }
+
+  public stopPropagation () {
+    this.propagationStopped = true
+  }
+}
+
+class DispatcherAsEventWrapper<TypedEventHandler> implements ISubscribable<TypedEventHandler> {
+  private readonly _subscribe: (handler: TypedEventHandler) => () => void
+  private readonly _unsubscribe: (handler: TypedEventHandler) => void
+  private readonly _one: (handler: TypedEventHandler) => () => void
+  private readonly _has: (handler: TypedEventHandler) => boolean
+  private readonly _clear: () => void
+  private readonly _count: () => number
+
+  constructor (dispatcher: ISubscribable<TypedEventHandler>) {
+    this._subscribe = (handler: TypedEventHandler) => dispatcher.subscribe(handler)
+    this._unsubscribe = (handler: TypedEventHandler) => dispatcher.unsubscribe(handler)
+    this._one = (handler: TypedEventHandler) => dispatcher.one(handler)
+    this._has = (handler: TypedEventHandler) => dispatcher.has(handler)
+    this._clear = () => dispatcher.clear()
+    this._count = () => dispatcher.count
+  }
+
+  get count (): number {
+    return this._count()
+  }
+
+  public subscribe (handler: TypedEventHandler): () => void {
+    return this._subscribe(handler)
+  }
+
+  public unsubscribe (handler: TypedEventHandler): void {
+    this._unsubscribe(handler)
+  }
+
+  public one (handler: TypedEventHandler): () => void {
+    return this._one(handler)
+  }
+
+  public has (handler: TypedEventHandler): boolean {
+    return this._has(handler)
+  }
+
+  public clear (): void {
+    this._clear()
+  }
+}
+
+interface IPropagationStatus {
+  readonly propagationStopped: boolean
+}
+
+export type IEvent<TypedEventArgument> = ISubscribable<IEventHandler<TypedEventArgument>>
+
+class BaseEventDispatcher<TypedEventArgument> implements IEvent<TypedEventArgument> {
+  private _asEventWrapper?: DispatcherAsEventWrapper<TypedEventHandler>
+
+  protected _subscriptions = new Array<ISubscription<TypedEventHandler>>()
+
+  get count (): number {
+    return this._subscriptions.length
+  }
+
+  subscribe (handler: TypedEventHandler): () => void {
+    if (typeof handler !== 'undefined') {
+      this._subscriptions.push(this.createSubscription(handler, false))
+    }
+    return () => {
+      this.unsubscribe(handler)
+    }
+  }
+
+  one (handler: TypedEventHandler): () => void {
+    if (typeof handler !== 'undefined') {
+      this._subscriptions.push(this.createSubscription(handler, true))
+    }
+    return () => {
+      this.unsubscribe(handler)
+    }
+  }
+
+  has (handler: TypedEventHandler): boolean {
+    if (typeof handler === 'undefined') {
+      return false
+    }
+    return this._subscriptions.some((subscription) => subscription.handler === handler)
+  }
+
+  unsubscribe (handler: TypedEventHandler): void {
+    if (typeof handler === 'undefined') {
+      return
+    }
+
+    for (let i = 0; i < this._subscriptions.length; i++) {
+      if (this._subscriptions[i].handler === handler) {
+        this._subscriptions.splice(i, 1)
+        break
+      }
+    }
+  }
+
+  protected _dispatch (executeAsync: boolean, scope: any, argument: any): IPropagationStatus | null {
+    for (const subscription of [...this._subscriptions]) {
+      const eventManager = new EventManagement(() => this.unsubscribe(subscription.handler))
+
+      const typedSubscription = subscription as Subscription<TypedEventHandler>
+      typedSubscription.execute(executeAsync, scope, argument, eventManager)
+      this.cleanup(typedSubscription)
+
+      if (!executeAsync && eventManager.propagationStopped) {
+        return { propagationStopped: true }
+      }
+    }
+
+    if (executeAsync) {
+      return null
+    }
+
+    return { propagationStopped: false }
+  }
+
+  protected createSubscription (handler: TypedEventHandler, isOnce: boolean): ISubscription<TypedEventHandler> {
+    return new Subscription<TypedEventHandler>(handler, isOnce)
+  }
+
+  protected cleanup (subscription: ISubscription<TypedEventHandler>) {
+    if (subscription.isOnce && subscription.isExecuted) {
+      const i = this._subscriptions.indexOf(subscription)
+      if (i > -1) {
+        this._subscriptions.splice(i, 1)
+      }
+    }
+  }
+
+  clear (): void {
+    if (this._subscriptions.length !== 0) {
+      this._subscriptions.splice(0, this._subscriptions.length)
+    }
+  }
+
+  dispatch (argument: TypedEventArgument): IPropagationStatus {
+    const result = this._dispatch(false, this, argument)
+    if (result === null) {
+      throw new DispatchError('Received null in dispatch')
+    }
+    return result
+  }
+
+  dispatchAsync (argument: TypedEventArgument): void {
+    this._dispatch(true, this, argument)
+  }
+
+  public asEvent (): IEvent<TypedEventArgument> {
+    if (typeof this._asEventWrapper === 'undefined') {
+      this._asEventWrapper = new DispatcherAsEventWrapper<TypedEventHandler>(this)
+    }
+
+    return this._asEventWrapper
+  }
+}
+
+export class EventDispatcher<TypedEventArgument> extends BaseEventDispatcher<TypedEventArgument> {
+  private readonly _onSubscriptionCountChangeEvent = new BaseEventDispatcher<{ count: number}>()
+
+  get onSubscriptionCountChangeEvent () {
+    return this._onSubscriptionCountChangeEvent.asEvent()
+  }
+
+  subscribe (handler: TypedEventHandler): () => void {
+    if (typeof handler !== 'undefined') {
+      this._subscriptions.push(this.createSubscription(handler, false))
+      this._onSubscriptionCountChangeEvent.dispatch({ count: this.count })
+    }
+    return () => {
+      this.unsubscribe(handler)
+    }
+  }
+
+  one (handler: TypedEventHandler): () => void {
+    if (typeof handler !== 'undefined') {
+      this._subscriptions.push(this.createSubscription(handler, true))
+      this._onSubscriptionCountChangeEvent.dispatch({ count: this.count })
+    }
+    return () => {
+      this.unsubscribe(handler)
+    }
+  }
+
+  unsubscribe (handler: TypedEventHandler): void {
+    if (typeof handler === 'undefined') {
+      return
+    }
+
+    for (let i = 0; i < this._subscriptions.length; i++) {
+      if (this._subscriptions[i].handler === handler) {
+        this._subscriptions.splice(i, 1)
+        break
+      }
+    }
+    this._onSubscriptionCountChangeEvent.dispatch({ count: this.count })
+  }
+
+  clear (): void {
+    if (this._subscriptions.length !== 0) {
+      this._subscriptions.splice(0, this._subscriptions.length)
+      this._onSubscriptionCountChangeEvent.dispatch({ count: this.count })
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+/* tslint:disable */
+/* eslint-disable */
+export * from './runtime';
+export * from './apis';
+export * from './models';
+export * from './error';
+export * from './event';
+export * from './connection';
+export * from './jwt';

package/src/jwt.ts

@@ -0,0 +1,17 @@
+const atobImp = (str: string): string => {
+    try {
+      return atob(str)
+    } catch (err) {
+      return Buffer.from(str, 'base64').toString('binary')
+    }
+  }
+  
+export const DecodeJWT = (token: string) => {
+let bodySeg = token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/')
+bodySeg = bodySeg.padEnd(bodySeg.length + (4 - (bodySeg.length % 4)), '=').replace(/====$/, '')
+return JSON.parse(decodeURIComponent(atobImp(bodySeg).replace(/(.)/g, m => {
+    const code = m.charCodeAt(0).toString(16).toUpperCase()
+    return `%${(code.length < 2 ? '0' : '')}${code}`
+})))
+}
+  

package/src/models/A500DataSetData.ts

@@ -0,0 +1,164 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * metrics-sdk-admin
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 5.0.12
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import type { A500RepDataPointData } from './A500RepDataPointData';
+import {
+    A500RepDataPointDataFromJSON,
+    A500RepDataPointDataFromJSONTyped,
+    A500RepDataPointDataToJSON,
+} from './A500RepDataPointData';
+import type { A500TestResultData } from './A500TestResultData';
+import {
+    A500TestResultDataFromJSON,
+    A500TestResultDataFromJSONTyped,
+    A500TestResultDataToJSON,
+} from './A500TestResultData';
+import type { A500TimeSeriesPointData } from './A500TimeSeriesPointData';
+import {
+    A500TimeSeriesPointDataFromJSON,
+    A500TimeSeriesPointDataFromJSONTyped,
+    A500TimeSeriesPointDataToJSON,
+} from './A500TimeSeriesPointData';
+
+/**
+ * 
+ * @export
+ * @interface A500DataSetData
+ */
+export interface A500DataSetData {
+    /**
+     * 
+     * @type {number}
+     * @memberof A500DataSetData
+     */
+    id: number;
+    /**
+     * 
+     * @type {Date}
+     * @memberof A500DataSetData
+     */
+    epochAt: Date;
+    /**
+     * 
+     * @type {string}
+     * @memberof A500DataSetData
+     */
+    type: A500DataSetDataTypeEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof A500DataSetData
+     */
+    testSide?: A500DataSetDataTestSideEnum;
+    /**
+     * 
+     * @type {A500TestResultData}
+     * @memberof A500DataSetData
+     */
+    leftTestResult?: A500TestResultData;
+    /**
+     * 
+     * @type {A500TestResultData}
+     * @memberof A500DataSetData
+     */
+    rightTestResult?: A500TestResultData;
+    /**
+     * 
+     * @type {Array<A500RepDataPointData>}
+     * @memberof A500DataSetData
+     */
+    a500RepDataPoints?: Array<A500RepDataPointData>;
+    /**
+     * 
+     * @type {Array<A500TimeSeriesPointData>}
+     * @memberof A500DataSetData
+     */
+    a500TimeSeriesPoints?: Array<A500TimeSeriesPointData>;
+}
+
+
+/**
+ * @export
+ */
+export const A500DataSetDataTypeEnum = {
+    Normal: 'normal',
+    Test: 'test'
+} as const;
+export type A500DataSetDataTypeEnum = typeof A500DataSetDataTypeEnum[keyof typeof A500DataSetDataTypeEnum];
+
+/**
+ * @export
+ */
+export const A500DataSetDataTestSideEnum = {
+    Left: 'left',
+    Right: 'right',
+    Both: 'both'
+} as const;
+export type A500DataSetDataTestSideEnum = typeof A500DataSetDataTestSideEnum[keyof typeof A500DataSetDataTestSideEnum];
+
+
+/**
+ * Check if a given object implements the A500DataSetData interface.
+ */
+export function instanceOfA500DataSetData(value: object): boolean {
+    let isInstance = true;
+    isInstance = isInstance && "id" in value;
+    isInstance = isInstance && "epochAt" in value;
+    isInstance = isInstance && "type" in value;
+
+    return isInstance;
+}
+
+export function A500DataSetDataFromJSON(json: any): A500DataSetData {
+    return A500DataSetDataFromJSONTyped(json, false);
+}
+
+export function A500DataSetDataFromJSONTyped(json: any, ignoreDiscriminator: boolean): A500DataSetData {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'id': json['id'],
+        'epochAt': (new Date(json['epochAt'])),
+        'type': json['type'],
+        'testSide': !exists(json, 'testSide') ? undefined : json['testSide'],
+        'leftTestResult': !exists(json, 'leftTestResult') ? undefined : A500TestResultDataFromJSON(json['leftTestResult']),
+        'rightTestResult': !exists(json, 'rightTestResult') ? undefined : A500TestResultDataFromJSON(json['rightTestResult']),
+        'a500RepDataPoints': !exists(json, 'a500RepDataPoints') ? undefined : ((json['a500RepDataPoints'] as Array<any>).map(A500RepDataPointDataFromJSON)),
+        'a500TimeSeriesPoints': !exists(json, 'a500TimeSeriesPoints') ? undefined : ((json['a500TimeSeriesPoints'] as Array<any>).map(A500TimeSeriesPointDataFromJSON)),
+    };
+}
+
+export function A500DataSetDataToJSON(value?: A500DataSetData | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'id': value.id,
+        'epochAt': (value.epochAt.toISOString()),
+        'type': value.type,
+        'testSide': value.testSide,
+        'leftTestResult': A500TestResultDataToJSON(value.leftTestResult),
+        'rightTestResult': A500TestResultDataToJSON(value.rightTestResult),
+        'a500RepDataPoints': value.a500RepDataPoints === undefined ? undefined : ((value.a500RepDataPoints as Array<any>).map(A500RepDataPointDataToJSON)),
+        'a500TimeSeriesPoints': value.a500TimeSeriesPoints === undefined ? undefined : ((value.a500TimeSeriesPoints as Array<any>).map(A500TimeSeriesPointDataToJSON)),
+    };
+}
+

package/src/models/A500MachineStateData.ts

@@ -0,0 +1,150 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * metrics-sdk-admin
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 5.0.12
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { exists, mapValues } from '../runtime';
+import type { FacilityStrengthMachineData } from './FacilityStrengthMachineData';
+import {
+    FacilityStrengthMachineDataFromJSON,
+    FacilityStrengthMachineDataFromJSONTyped,
+    FacilityStrengthMachineDataToJSON,
+} from './FacilityStrengthMachineData';
+
+/**
+ * 
+ * @export
+ * @interface A500MachineStateData
+ */
+export interface A500MachineStateData {
+    /**
+     * 
+     * @type {number}
+     * @memberof A500MachineStateData
+     */
+    facilityStrengthMachineId: number;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof A500MachineStateData
+     */
+    isFacilityConfigurationOverridden: boolean;
+    /**
+     * 
+     * @type {string}
+     * @memberof A500MachineStateData
+     */
+    appType: A500MachineStateDataAppTypeEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof A500MachineStateData
+     */
+    forceUnit: A500MachineStateDataForceUnitEnum;
+    /**
+     * 
+     * @type {string}
+     * @memberof A500MachineStateData
+     */
+    primaryFocus: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof A500MachineStateData
+     */
+    secondaryFocus: string;
+    /**
+     * 
+     * @type {FacilityStrengthMachineData}
+     * @memberof A500MachineStateData
+     */
+    facilityStrengthMachine?: FacilityStrengthMachineData;
+}
+
+
+/**
+ * @export
+ */
+export const A500MachineStateDataAppTypeEnum = {
+    Performance: 'performance',
+    Elder: 'elder',
+    Medical: 'medical',
+    Commercial: 'commercial'
+} as const;
+export type A500MachineStateDataAppTypeEnum = typeof A500MachineStateDataAppTypeEnum[keyof typeof A500MachineStateDataAppTypeEnum];
+
+/**
+ * @export
+ */
+export const A500MachineStateDataForceUnitEnum = {
+    Lb: 'lb',
+    Kg: 'kg',
+    Ne: 'ne',
+    Er: 'er'
+} as const;
+export type A500MachineStateDataForceUnitEnum = typeof A500MachineStateDataForceUnitEnum[keyof typeof A500MachineStateDataForceUnitEnum];
+
+
+/**
+ * Check if a given object implements the A500MachineStateData interface.
+ */
+export function instanceOfA500MachineStateData(value: object): boolean {
+    let isInstance = true;
+    isInstance = isInstance && "facilityStrengthMachineId" in value;
+    isInstance = isInstance && "isFacilityConfigurationOverridden" in value;
+    isInstance = isInstance && "appType" in value;
+    isInstance = isInstance && "forceUnit" in value;
+    isInstance = isInstance && "primaryFocus" in value;
+    isInstance = isInstance && "secondaryFocus" in value;
+
+    return isInstance;
+}
+
+export function A500MachineStateDataFromJSON(json: any): A500MachineStateData {
+    return A500MachineStateDataFromJSONTyped(json, false);
+}
+
+export function A500MachineStateDataFromJSONTyped(json: any, ignoreDiscriminator: boolean): A500MachineStateData {
+    if ((json === undefined) || (json === null)) {
+        return json;
+    }
+    return {
+        
+        'facilityStrengthMachineId': json['facilityStrengthMachineId'],
+        'isFacilityConfigurationOverridden': json['isFacilityConfigurationOverridden'],
+        'appType': json['appType'],
+        'forceUnit': json['forceUnit'],
+        'primaryFocus': json['primaryFocus'],
+        'secondaryFocus': json['secondaryFocus'],
+        'facilityStrengthMachine': !exists(json, 'facilityStrengthMachine') ? undefined : FacilityStrengthMachineDataFromJSON(json['facilityStrengthMachine']),
+    };
+}
+
+export function A500MachineStateDataToJSON(value?: A500MachineStateData | null): any {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    return {
+        
+        'facilityStrengthMachineId': value.facilityStrengthMachineId,
+        'isFacilityConfigurationOverridden': value.isFacilityConfigurationOverridden,
+        'appType': value.appType,
+        'forceUnit': value.forceUnit,
+        'primaryFocus': value.primaryFocus,
+        'secondaryFocus': value.secondaryFocus,
+        'facilityStrengthMachine': FacilityStrengthMachineDataToJSON(value.facilityStrengthMachine),
+    };
+}
+