quantum-component-library 0.0.1 → 1.0.0-qa

package/dist/generated/graphql.d.ts

@@ -0,0 +1,2326 @@
+import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    Date: {
+        input: any;
+        output: any;
+    };
+    /** An ISO-8601 encoded date string (YYYY-MM-DD) */
+    DateString: {
+        input: any;
+        output: any;
+    };
+    /** Long custom scalar type */
+    Long: {
+        input: any;
+        output: any;
+    };
+    /** Unit custom scalar type */
+    Unit: {
+        input: any;
+        output: any;
+    };
+};
+export type Action = {
+    __typename?: 'Action';
+    activityKind: ActionActivityKind;
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    instructionsMovementReport?: Maybe<Scalars['String']['output']>;
+    instructionsPointOfInterest?: Maybe<Scalars['String']['output']>;
+    laterality: ActionLaterality;
+    name: Scalars['String']['output'];
+    quantumOwned?: Maybe<Scalars['Boolean']['output']>;
+    sensorLocations: Array<SensorLocation>;
+    thresholds: Array<Threshold>;
+    useCases: Array<UseCase>;
+};
+export declare enum ActionActivityKind {
+    Action = "Action",
+    Movement = "Movement"
+}
+export declare enum ActionLaterality {
+    Bilateral = "Bilateral",
+    Either = "Either",
+    Unilateral = "Unilateral"
+}
+export type ActionModule = {
+    __typename?: 'ActionModule';
+    actions: Array<Action>;
+    categories: Array<ModuleCategory>;
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    moduleActions: Array<ModuleAction>;
+    name: Scalars['String']['output'];
+    quantumOwned?: Maybe<Scalars['Boolean']['output']>;
+};
+export type AnalysisAction = {
+    __typename?: 'AnalysisAction';
+    id: Scalars['ID']['output'];
+    laterality: AnalysisActionLaterality;
+    name: Scalars['String']['output'];
+    subClassification: AnalysisSubClassification;
+};
+export declare enum AnalysisActionLaterality {
+    Bilateral = "Bilateral",
+    Either = "Either",
+    Unilateral = "Unilateral"
+}
+export declare enum AnalysisActionSide {
+    Bilateral = "Bilateral",
+    Left = "Left",
+    Right = "Right"
+}
+export type AnalysisClassification = {
+    __typename?: 'AnalysisClassification';
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    subClassifications: Array<AnalysisSubClassification>;
+};
+export type AnalysisMetric = {
+    __typename?: 'AnalysisMetric';
+    analysis: TestAnalysis;
+    createdAt: Scalars['Date']['output'];
+    description?: Maybe<Scalars['String']['output']>;
+    discriminator?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    key: AnalysisMetricKey;
+    metric: Metric;
+    name?: Maybe<Scalars['String']['output']>;
+    poiMetrics?: Maybe<Array<PoiMetric>>;
+    threshold?: Maybe<TestAnalysisThreshold>;
+};
+export type AnalysisMetricKey = {
+    __typename?: 'AnalysisMetricKey';
+    id: Scalars['ID']['output'];
+    name?: Maybe<Scalars['String']['output']>;
+};
+export declare enum AnalysisMetricKeyId {
+    AverageAngularVelocity = "average_angular_velocity",
+    LeftVsRightTarget = "left_vs_right_target",
+    Mass = "mass",
+    MaxAngle = "max_angle",
+    MaxHorizontalAccel = "max_horizontal_accel",
+    MaxRom = "max_rom",
+    MaxVerticalAccel = "max_vertical_accel",
+    MaxVerticalGrf = "max_vertical_grf",
+    MaxVerticalLf = "max_vertical_lf",
+    MinHorizontalAccel = "min_horizontal_accel",
+    MinVerticalAccel = "min_vertical_accel",
+    NewPointsOfInterest = "new_points_of_interest",
+    ParameterScore = "parameter_score",
+    PeakAngleScreenshot = "peak_angle_screenshot",
+    PercentInsideLimits = "percent_inside_limits",
+    PercentOutsideLimits = "percent_outside_limits",
+    PoiScreenshot = "poi_screenshot",
+    PointsOfInterest = "points_of_interest",
+    StartTimestamp = "start_timestamp",
+    ThresholdException = "threshold_exception",
+    TotalParameterScore = "total_parameter_score"
+}
+export type AnalysisSubClassification = {
+    __typename?: 'AnalysisSubClassification';
+    actions: Array<AnalysisAction>;
+    classification: AnalysisClassification;
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+};
+export type AuthSession = {
+    __typename?: 'AuthSession';
+    accessToken: Scalars['String']['output'];
+};
+export type ChangePasswordInput = {
+    newPassword: Scalars['String']['input'];
+    userId: Scalars['ID']['input'];
+};
+export type ComparativeMetric = {
+    __typename?: 'ComparativeMetric';
+    labelA: Scalars['String']['output'];
+    labelB: Scalars['String']['output'];
+    unitA: Scalars['Unit']['output'];
+    unitB: Scalars['Unit']['output'];
+    valueA: Scalars['Float']['output'];
+    valueB: Scalars['Float']['output'];
+};
+export type ComparativeMetricInput = {
+    labelA: Scalars['String']['input'];
+    labelB: Scalars['String']['input'];
+    unitA: Scalars['Unit']['input'];
+    unitB: Scalars['Unit']['input'];
+    valueA: Scalars['Float']['input'];
+    valueB: Scalars['Float']['input'];
+};
+export type CopyActionsInput = {
+    actionIds: Array<Scalars['ID']['input']>;
+    sourceGroupId: Scalars['ID']['input'];
+    targetGroupId: Scalars['ID']['input'];
+};
+export type CopyModulesInput = {
+    moduleIds: Array<Scalars['ID']['input']>;
+    sourceGroupId: Scalars['ID']['input'];
+    targetGroupId: Scalars['ID']['input'];
+};
+export type CreateAccountInput = {
+    email: Scalars['String']['input'];
+    firstName: Scalars['String']['input'];
+    groupId?: InputMaybe<Scalars['ID']['input']>;
+    lastName: Scalars['String']['input'];
+    password: Scalars['String']['input'];
+    username: Scalars['String']['input'];
+};
+export type CreateAccountResult = {
+    __typename?: 'CreateAccountResult';
+    session: AuthSession;
+    user: CurrentUser;
+};
+export type CreateActionInput = {
+    activityKind?: InputMaybe<ActionActivityKind>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    instructionsMovementReport?: InputMaybe<Scalars['String']['input']>;
+    instructionsPointOfInterest?: InputMaybe<Scalars['String']['input']>;
+    laterality: ActionLaterality;
+    name: Scalars['String']['input'];
+    quantumOwned?: InputMaybe<Scalars['Boolean']['input']>;
+    sensorLocations?: InputMaybe<Array<SensorLocation>>;
+    thresholds: Array<ThresholdInput>;
+    useCases?: InputMaybe<Array<UseCaseInput>>;
+};
+export type CreateAnalysisMetricInput = {
+    description?: InputMaybe<Scalars['String']['input']>;
+    discriminator?: InputMaybe<Scalars['String']['input']>;
+    keyId: AnalysisMetricKeyId;
+    metric: MetricInput;
+    name?: InputMaybe<Scalars['String']['input']>;
+    thresholdId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type CreateGroupInput = {
+    name: Scalars['String']['input'];
+};
+export type CreateKeypointGroupInput = {
+    activity?: InputMaybe<Scalars['String']['input']>;
+    keypoints: Array<KeypointInput>;
+    name: Scalars['String']['input'];
+    testId: Scalars['ID']['input'];
+};
+export type CreateModuleInput = {
+    actions: Array<Scalars['ID']['input']>;
+    categories?: InputMaybe<Array<Scalars['ID']['input']>>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+    quantumOwned?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type CreateSessionInput = {
+    createdForId: Scalars['ID']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+    startedAt?: InputMaybe<Scalars['DateString']['input']>;
+};
+export type CreateTestAnalysisInput = {
+    actionId?: InputMaybe<Scalars['ID']['input']>;
+    actionSide?: InputMaybe<AnalysisActionSide>;
+    classification?: InputMaybe<Scalars['String']['input']>;
+    endFrame: Scalars['Int']['input'];
+    kind: TestAnalysisKind;
+    name: Scalars['String']['input'];
+    startFrame: Scalars['Int']['input'];
+    startedAt?: InputMaybe<Scalars['Date']['input']>;
+    testId: Scalars['ID']['input'];
+    thresholds: Array<TestAnalysisThresholdInput>;
+};
+export type CreateTestInfoInput = {
+    athleteWeight: Scalars['Float']['input'];
+};
+export type CreateTestInput = {
+    actionId?: InputMaybe<Scalars['ID']['input']>;
+    comment?: InputMaybe<Scalars['String']['input']>;
+    endedAt?: InputMaybe<Scalars['Date']['input']>;
+    info: CreateTestInfoInput;
+    kind: Scalars['ID']['input'];
+    name: Scalars['String']['input'];
+    sessionId: Scalars['ID']['input'];
+    startedAt: Scalars['Date']['input'];
+    timezone?: InputMaybe<Scalars['String']['input']>;
+};
+export type CreateTrialInput = {
+    endFrame: Scalars['Int']['input'];
+    excludeFromAverage?: InputMaybe<Scalars['Boolean']['input']>;
+    label?: InputMaybe<Scalars['String']['input']>;
+    startFrame: Scalars['Int']['input'];
+};
+export type CreateTrialParameterInput = {
+    data?: InputMaybe<TrialParameterDataInput>;
+    kind: ParameterKind;
+    max: Scalars['Float']['input'];
+    metrics?: InputMaybe<TrialParameterMetricsInput>;
+    min: Scalars['Float']['input'];
+    partDimension: Scalars['String']['input'];
+    partId: Scalars['String']['input'];
+    partKind: Scalars['String']['input'];
+};
+export type CreateUserProfileInput = {
+    age?: InputMaybe<Scalars['Int']['input']>;
+    date_of_birth: Scalars['Date']['input'];
+    firstName: Scalars['String']['input'];
+    gender: Scalars['String']['input'];
+    groupId?: InputMaybe<Scalars['ID']['input']>;
+    height: Scalars['Float']['input'];
+    lastName: Scalars['String']['input'];
+    userId?: InputMaybe<Scalars['ID']['input']>;
+    weight: Scalars['Float']['input'];
+};
+export type CurrentUser = {
+    __typename?: 'CurrentUser';
+    createdAt: Scalars['String']['output'];
+    email: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    profile?: Maybe<UserProfile>;
+    roles: Array<Scalars['String']['output']>;
+    unitSystem: UnitSystem;
+    updatedAt: Scalars['String']['output'];
+    username: Scalars['String']['output'];
+};
+export type DiscreteMetric = {
+    __typename?: 'DiscreteMetric';
+    unit: Scalars['Unit']['output'];
+    value: Scalars['Float']['output'];
+};
+export type DiscreteMetricInput = {
+    unit: Scalars['Unit']['input'];
+    value: Scalars['Float']['input'];
+};
+export type GeneralActivityReport = {
+    __typename?: 'GeneralActivityReport';
+    averageParameterScores: Array<TestAverageParameterScore>;
+    id: Scalars['ID']['output'];
+    report: TestReport;
+    trials: Array<Trial>;
+};
+export type Group = {
+    __typename?: 'Group';
+    createdAt: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    imageUrl?: Maybe<Scalars['String']['output']>;
+    name: Scalars['String']['output'];
+    profiles: Array<UserProfile>;
+    quantumOwned?: Maybe<Scalars['Boolean']['output']>;
+    updatedAt: Scalars['String']['output'];
+    users: Array<User>;
+};
+export type GroupInfo = {
+    __typename?: 'GroupInfo';
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+};
+export type ImageMetric = {
+    __typename?: 'ImageMetric';
+    path: Scalars['String']['output'];
+};
+export type Keypoint = {
+    __typename?: 'Keypoint';
+    activityStep?: Maybe<Scalars['String']['output']>;
+    frameNumber: Scalars['Int']['output'];
+    keypointGroupId: Scalars['ID']['output'];
+    name?: Maybe<Scalars['String']['output']>;
+};
+export type KeypointGroup = {
+    __typename?: 'KeypointGroup';
+    activity?: Maybe<Scalars['String']['output']>;
+    createdAt: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    keypoints: Array<Keypoint>;
+    name: Scalars['String']['output'];
+    testId: Scalars['ID']['output'];
+    updatedAt: Scalars['String']['output'];
+};
+export type KeypointInput = {
+    activityStep?: InputMaybe<Scalars['String']['input']>;
+    frameNumber: Scalars['Int']['input'];
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type KeypointsMetric = {
+    __typename?: 'KeypointsMetric';
+    keypoints: Array<KeypointsMetricItem>;
+};
+export type KeypointsMetricInput = {
+    keypoints: Array<KeypointsMetricItemInput>;
+};
+export type KeypointsMetricItem = {
+    __typename?: 'KeypointsMetricItem';
+    frame: Scalars['Int']['output'];
+    id: Scalars['ID']['output'];
+    timeSeries: Array<KeypointsMetricTimeSeries>;
+    timestamp: Scalars['Long']['output'];
+    unit: Scalars['Unit']['output'];
+    value: Scalars['Float']['output'];
+};
+export type KeypointsMetricItemInput = {
+    frame: Scalars['Int']['input'];
+    timeSeries: Array<KeypointsMetricTimeSeriesInput>;
+    timestamp: Scalars['Long']['input'];
+    unit: Scalars['Unit']['input'];
+    value: Scalars['Float']['input'];
+};
+export type KeypointsMetricTimeSeries = {
+    __typename?: 'KeypointsMetricTimeSeries';
+    id: Scalars['ID']['output'];
+    label: Scalars['String']['output'];
+    timeSeriesJson: Scalars['String']['output'];
+    unit: Scalars['Unit']['output'];
+};
+export type KeypointsMetricTimeSeriesInput = {
+    label: Scalars['String']['input'];
+    timeSeriesJson: Scalars['String']['input'];
+    unit: Scalars['Unit']['input'];
+};
+export type LoginInput = {
+    password: Scalars['String']['input'];
+    username: Scalars['String']['input'];
+};
+export type LoginResult = {
+    __typename?: 'LoginResult';
+    session: AuthSession;
+    user: CurrentUser;
+};
+export type Metric = ComparativeMetric | DiscreteMetric | ImageMetric | KeypointsMetric | PoiMetricInUnion | TableMetric;
+export type MetricInput = {
+    comparative?: InputMaybe<ComparativeMetricInput>;
+    discrete?: InputMaybe<DiscreteMetricInput>;
+    image?: InputMaybe<Scalars['Boolean']['input']>;
+    keypoints?: InputMaybe<KeypointsMetricInput>;
+    poiMetrics?: InputMaybe<Array<PoiMetricInput>>;
+    table?: InputMaybe<TableMetricInput>;
+};
+export type ModuleAction = {
+    __typename?: 'ModuleAction';
+    action: Action;
+    actionId: Scalars['ID']['output'];
+    moduleId: Scalars['ID']['output'];
+    sortOrder: Scalars['Int']['output'];
+};
+export type ModuleCategory = {
+    __typename?: 'ModuleCategory';
+    description?: Maybe<Scalars['String']['output']>;
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    sortOrder: Scalars['Int']['output'];
+};
+export type MovementCoordinationReport = {
+    __typename?: 'MovementCoordinationReport';
+    averageParameterScores: Array<TestAverageParameterScore>;
+    id: Scalars['ID']['output'];
+    report: TestReport;
+    trials: Array<Trial>;
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    addActionToModule: ActionModule;
+    /** @deprecated Use archiveUser instead */
+    archiveUser: Scalars['Boolean']['output'];
+    changePassword: Scalars['Boolean']['output'];
+    copyActions: Scalars['Boolean']['output'];
+    copyModules: Scalars['Boolean']['output'];
+    createAccount?: Maybe<CreateAccountResult>;
+    createAction: Action;
+    createAnalysisMetrics: TestAnalysis;
+    createGeneralActivityReport: GeneralActivityReport;
+    createGeneralActivityTrial: Trial;
+    createGroup: Group;
+    createKeypointGroup: KeypointGroup;
+    createModule: ActionModule;
+    createMovementCoordinationReport: MovementCoordinationReport;
+    createMovementCoordinationTrial: Trial;
+    createOrUpdateManyTrialParameterMetrics: Array<TrialParameterMetrics>;
+    createOrUpdateTrialParameterMetrics: TrialParameterMetrics;
+    createRangeReport: RangeReport;
+    createRangeTrial: Trial;
+    createSession: Session;
+    createStabilityBalanceReport: StabilityBalanceReport;
+    createStabilityBalanceTrial: Trial;
+    createTest: Test;
+    createTestAnalysis: TestAnalysis;
+    /** @deprecated This defaults to a report within a test, use the report-specific mutations instead. */
+    createTrial: Trial;
+    createTrialParameter: TrialParameter;
+    createUserProfile: UserProfile;
+    deleteAction: Scalars['Boolean']['output'];
+    deleteModule: Scalars['Boolean']['output'];
+    deleteTest: Scalars['Boolean']['output'];
+    deleteTestAnalysis: Scalars['Boolean']['output'];
+    deleteTestReport: Scalars['Boolean']['output'];
+    deleteTrial: Scalars['Boolean']['output'];
+    deleteTrialParameter: Scalars['Boolean']['output'];
+    deleteUserProfile: Scalars['Boolean']['output'];
+    duplicateAction: Scalars['Boolean']['output'];
+    login?: Maybe<LoginResult>;
+    removeActionFromModule: ActionModule;
+    replaceTrialParameters: Array<TrialParameter>;
+    requestPoseProcessing: Scalars['Boolean']['output'];
+    unarchiveUserProfile: UserProfile;
+    updateAction: Action;
+    updateGroup: Group;
+    updateModule: ActionModule;
+    updateTest: Test;
+    updateTestReport: TestReportUnion;
+    updateTrial: Trial;
+    updateTrialData: Trial;
+    updateUserProfile: UserProfile;
+    updateVideoDataOffset: TestFile;
+};
+export type MutationAddActionToModuleArgs = {
+    actionId: Scalars['ID']['input'];
+    moduleId: Scalars['ID']['input'];
+};
+export type MutationArchiveUserArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationChangePasswordArgs = {
+    input: ChangePasswordInput;
+};
+export type MutationCopyActionsArgs = {
+    input: CopyActionsInput;
+};
+export type MutationCopyModulesArgs = {
+    input: CopyModulesInput;
+};
+export type MutationCreateAccountArgs = {
+    input: CreateAccountInput;
+};
+export type MutationCreateActionArgs = {
+    input: CreateActionInput;
+};
+export type MutationCreateAnalysisMetricsArgs = {
+    analysisId: Scalars['ID']['input'];
+    input: Array<CreateAnalysisMetricInput>;
+};
+export type MutationCreateGeneralActivityReportArgs = {
+    testId: Scalars['ID']['input'];
+    testReportInput?: InputMaybe<TestReportInput>;
+};
+export type MutationCreateGeneralActivityTrialArgs = {
+    input: CreateTrialInput;
+    reportId: Scalars['ID']['input'];
+};
+export type MutationCreateGroupArgs = {
+    input: CreateGroupInput;
+};
+export type MutationCreateKeypointGroupArgs = {
+    input: CreateKeypointGroupInput;
+};
+export type MutationCreateModuleArgs = {
+    input: CreateModuleInput;
+};
+export type MutationCreateMovementCoordinationReportArgs = {
+    testId: Scalars['ID']['input'];
+    testReportInput?: InputMaybe<TestReportInput>;
+};
+export type MutationCreateMovementCoordinationTrialArgs = {
+    input: CreateTrialInput;
+    reportId: Scalars['ID']['input'];
+};
+export type MutationCreateOrUpdateManyTrialParameterMetricsArgs = {
+    input: Array<TrialParameterMetricsItemInput>;
+};
+export type MutationCreateOrUpdateTrialParameterMetricsArgs = {
+    input: TrialParameterMetricsInput;
+    trialParameterId: Scalars['ID']['input'];
+};
+export type MutationCreateRangeReportArgs = {
+    testId: Scalars['ID']['input'];
+    testReportInput?: InputMaybe<TestReportInput>;
+};
+export type MutationCreateRangeTrialArgs = {
+    input: CreateTrialInput;
+    reportId: Scalars['ID']['input'];
+};
+export type MutationCreateSessionArgs = {
+    input: CreateSessionInput;
+};
+export type MutationCreateStabilityBalanceReportArgs = {
+    testId: Scalars['ID']['input'];
+    testReportInput?: InputMaybe<TestReportInput>;
+};
+export type MutationCreateStabilityBalanceTrialArgs = {
+    input: CreateTrialInput;
+    reportId: Scalars['ID']['input'];
+};
+export type MutationCreateTestArgs = {
+    input: CreateTestInput;
+};
+export type MutationCreateTestAnalysisArgs = {
+    input: CreateTestAnalysisInput;
+};
+export type MutationCreateTrialArgs = {
+    input: CreateTrialInput;
+    testId: Scalars['ID']['input'];
+};
+export type MutationCreateTrialParameterArgs = {
+    input: CreateTrialParameterInput;
+    trialId: Scalars['ID']['input'];
+};
+export type MutationCreateUserProfileArgs = {
+    input: CreateUserProfileInput;
+};
+export type MutationDeleteActionArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteModuleArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteTestArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteTestAnalysisArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteTestReportArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteTrialArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteTrialParameterArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDeleteUserProfileArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationDuplicateActionArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationLoginArgs = {
+    input: LoginInput;
+};
+export type MutationRemoveActionFromModuleArgs = {
+    actionId: Scalars['ID']['input'];
+    moduleId: Scalars['ID']['input'];
+};
+export type MutationReplaceTrialParametersArgs = {
+    input: Array<ReplaceTrialParameterInput>;
+    trialId: Scalars['ID']['input'];
+};
+export type MutationRequestPoseProcessingArgs = {
+    testFileId: Scalars['ID']['input'];
+};
+export type MutationUnarchiveUserProfileArgs = {
+    id: Scalars['ID']['input'];
+};
+export type MutationUpdateActionArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateActionInput;
+};
+export type MutationUpdateGroupArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateGroupInput;
+};
+export type MutationUpdateModuleArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateModuleInput;
+};
+export type MutationUpdateTestArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateTestInput;
+};
+export type MutationUpdateTestReportArgs = {
+    id: Scalars['ID']['input'];
+    input: TestReportInput;
+};
+export type MutationUpdateTrialArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateTrialInput;
+};
+export type MutationUpdateTrialDataArgs = {
+    id: Scalars['ID']['input'];
+    input: UpdateTrialDataInput;
+};
+export type MutationUpdateUserProfileArgs = {
+    input: UpdateUserProfileInput;
+};
+export type MutationUpdateVideoDataOffsetArgs = {
+    offset: Scalars['Int']['input'];
+    testFileId: Scalars['ID']['input'];
+};
+export type Parameter = {
+    __typename?: 'Parameter';
+    id: Scalars['ID']['output'];
+    kind: ParameterKind;
+    partDimension: Scalars['String']['output'];
+    partId: Scalars['String']['output'];
+    partKind: Scalars['String']['output'];
+};
+export declare enum ParameterKind {
+    Limit = "Limit",
+    Target = "Target"
+}
+export type PoiMetric = {
+    __typename?: 'PoiMetric';
+    frame: Scalars['Int']['output'];
+    name: Scalars['String']['output'];
+};
+export type PoiMetricInUnion = {
+    __typename?: 'PoiMetricInUnion';
+    poiMetrics?: Maybe<Array<PoiMetric>>;
+};
+export type PoiMetricInput = {
+    frame: Scalars['Int']['input'];
+    name: Scalars['String']['input'];
+};
+export type PoseTask = {
+    __typename?: 'PoseTask';
+    attempts: Scalars['Int']['output'];
+    id: Scalars['ID']['output'];
+    maxAttempts: Scalars['Int']['output'];
+    status: TaskStatus;
+    taskId: Scalars['ID']['output'];
+};
+export type QuantumOwnedData = {
+    __typename?: 'QuantumOwnedData';
+    moduleCategories: Array<ModuleCategory>;
+    quantumOwnedActions: Array<Action>;
+    quantumOwnedModules: Array<ActionModule>;
+};
+export type Query = {
+    __typename?: 'Query';
+    actions: Array<Action>;
+    analysisClassifications: Array<AnalysisClassification>;
+    currentGroup?: Maybe<Group>;
+    generalActivityReport?: Maybe<GeneralActivityReport>;
+    getActionById?: Maybe<Action>;
+    getQuantumOwnedData: QuantumOwnedData;
+    getSessionById?: Maybe<Session>;
+    getTest?: Maybe<Test>;
+    getTestAnalysis?: Maybe<TestAnalysis>;
+    getTestFile?: Maybe<TestFile>;
+    getTestsForSession: Array<Test>;
+    group?: Maybe<Group>;
+    groups: Array<Group>;
+    historicalMetrics: Array<AnalysisMetric>;
+    keypoints: Array<Keypoint>;
+    me?: Maybe<CurrentUser>;
+    module?: Maybe<ActionModule>;
+    moduleCategories: Array<ModuleCategory>;
+    modules: Array<ActionModule>;
+    movementCoordinationReport?: Maybe<MovementCoordinationReport>;
+    profileSessionForToday: Session;
+    quantumOwnedActions: Array<Action>;
+    quantumOwnedModules: Array<ActionModule>;
+    quantumOwnedUseCases: Array<UseCase>;
+    rangeReport?: Maybe<RangeReport>;
+    sessionsCreatedByProfile: Array<Session>;
+    sessionsForProfile: Array<Session>;
+    stabilityBalanceReport?: Maybe<StabilityBalanceReport>;
+    testReport?: Maybe<TestReportUnion>;
+    trial?: Maybe<Trial>;
+    /** @deprecated This defaults to a report within a test, use the report-specific queries instead. */
+    trialsForTest: Array<Trial>;
+    useCases: Array<UseCase>;
+    userProfile?: Maybe<UserProfile>;
+};
+export type QueryActionsArgs = {
+    groupId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type QueryGeneralActivityReportArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryGetActionByIdArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryGetSessionByIdArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryGetTestArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryGetTestAnalysisArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryGetTestFileArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryGetTestsForSessionArgs = {
+    sessionId: Scalars['ID']['input'];
+};
+export type QueryGroupArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryHistoricalMetricsArgs = {
+    actionId?: InputMaybe<Scalars['ID']['input']>;
+    actionSide?: InputMaybe<AnalysisActionSide>;
+    end?: InputMaybe<Scalars['Date']['input']>;
+    keyId: Scalars['ID']['input'];
+    profileId?: InputMaybe<Scalars['ID']['input']>;
+    start?: InputMaybe<Scalars['Date']['input']>;
+    thresholdFilter?: InputMaybe<ThresholdFilter>;
+};
+export type QueryKeypointsArgs = {
+    keypointGroupId: Scalars['ID']['input'];
+};
+export type QueryModuleArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryModulesArgs = {
+    groupId?: InputMaybe<Scalars['ID']['input']>;
+};
+export type QueryMovementCoordinationReportArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryProfileSessionForTodayArgs = {
+    now?: InputMaybe<Scalars['Date']['input']>;
+    profileId: Scalars['ID']['input'];
+    timezone?: InputMaybe<Scalars['String']['input']>;
+};
+export type QueryQuantumOwnedUseCasesArgs = {
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    search?: InputMaybe<Scalars['String']['input']>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+};
+export type QueryRangeReportArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QuerySessionsCreatedByProfileArgs = {
+    filter?: InputMaybe<SessionFilter>;
+    profileId: Scalars['ID']['input'];
+};
+export type QuerySessionsForProfileArgs = {
+    filter?: InputMaybe<SessionFilter>;
+    profileId: Scalars['ID']['input'];
+};
+export type QueryStabilityBalanceReportArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryTestReportArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryTrialArgs = {
+    id: Scalars['ID']['input'];
+};
+export type QueryTrialsForTestArgs = {
+    testId: Scalars['ID']['input'];
+};
+export type QueryUseCasesArgs = {
+    limit?: InputMaybe<Scalars['Int']['input']>;
+    search?: InputMaybe<Scalars['String']['input']>;
+    skip?: InputMaybe<Scalars['Int']['input']>;
+};
+export type QueryUserProfileArgs = {
+    id: Scalars['ID']['input'];
+};
+export type RangeReport = {
+    __typename?: 'RangeReport';
+    averageParameterScores: Array<TestAverageParameterScore>;
+    id: Scalars['ID']['output'];
+    report: TestReport;
+    trial?: Maybe<Trial>;
+};
+export type ReplaceTrialParameterInput = {
+    id?: InputMaybe<Scalars['ID']['input']>;
+    input: CreateTrialParameterInput;
+};
+export declare enum SensorLocation {
+    CenterBack = "CenterBack",
+    Head = "Head",
+    LeftFoot = "LeftFoot",
+    LeftForearm = "LeftForearm",
+    LeftShank = "LeftShank",
+    LeftThigh = "LeftThigh",
+    LeftUpperArm = "LeftUpperArm",
+    Pelvis = "Pelvis",
+    RightFoot = "RightFoot",
+    RightForearm = "RightForearm",
+    RightShank = "RightShank",
+    RightThigh = "RightThigh",
+    RightUpperArm = "RightUpperArm",
+    Thorax = "Thorax"
+}
+export type Session = {
+    __typename?: 'Session';
+    createdAt: Scalars['String']['output'];
+    createdById: Scalars['ID']['output'];
+    createdForId: Scalars['ID']['output'];
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+    startedAt: Scalars['DateString']['output'];
+    tests: Array<Test>;
+    updatedAt: Scalars['String']['output'];
+};
+export type SessionFilter = {
+    after?: InputMaybe<Scalars['Date']['input']>;
+    before?: InputMaybe<Scalars['Date']['input']>;
+};
+export type StabilityBalanceReport = {
+    __typename?: 'StabilityBalanceReport';
+    averageParameterScores: Array<TestAverageParameterScore>;
+    id: Scalars['ID']['output'];
+    report: TestReport;
+    trial?: Maybe<Trial>;
+};
+export type TableMetric = {
+    __typename?: 'TableMetric';
+    rows: Array<TableMetricRow>;
+};
+export type TableMetricCell = {
+    __typename?: 'TableMetricCell';
+    colSpan: Scalars['Int']['output'];
+    id: Scalars['ID']['output'];
+    isLabel?: Maybe<Scalars['Boolean']['output']>;
+    isNumeric?: Maybe<Scalars['Boolean']['output']>;
+    order: Scalars['Int']['output'];
+    rowSpan: Scalars['Int']['output'];
+    unit?: Maybe<Scalars['Unit']['output']>;
+    value: Scalars['String']['output'];
+};
+export type TableMetricCellInput = {
+    colSpan?: InputMaybe<Scalars['Int']['input']>;
+    isLabel?: InputMaybe<Scalars['Boolean']['input']>;
+    isNumeric?: InputMaybe<Scalars['Boolean']['input']>;
+    order: Scalars['Int']['input'];
+    rowSpan?: InputMaybe<Scalars['Int']['input']>;
+    unit?: InputMaybe<Scalars['Unit']['input']>;
+    value: Scalars['String']['input'];
+};
+export type TableMetricInput = {
+    rows: Array<TableMetricRowInput>;
+};
+export type TableMetricRow = {
+    __typename?: 'TableMetricRow';
+    cells: Array<TableMetricCell>;
+    id: Scalars['ID']['output'];
+    order: Scalars['Int']['output'];
+};
+export type TableMetricRowInput = {
+    cells: Array<TableMetricCellInput>;
+    order: Scalars['Int']['input'];
+};
+export declare enum TaskStatus {
+    Complete = "Complete",
+    Error = "Error",
+    Pending = "Pending",
+    Working = "Working"
+}
+export type Test = {
+    __typename?: 'Test';
+    action?: Maybe<Action>;
+    analysis: Array<TestAnalysisSummary>;
+    /** @deprecated This defaults to a report within a test, use the report-specific queries instead. */
+    averageParameterScores: Array<TestAverageParameterScore>;
+    comment?: Maybe<Scalars['String']['output']>;
+    createdAt: Scalars['String']['output'];
+    endedAt?: Maybe<Scalars['Date']['output']>;
+    file?: Maybe<TestFile>;
+    id: Scalars['ID']['output'];
+    info?: Maybe<TestInfo>;
+    kindId?: Maybe<Scalars['ID']['output']>;
+    name: Scalars['String']['output'];
+    reports: Array<TestReportUnion>;
+    session: Session;
+    sessionId: Scalars['ID']['output'];
+    startedAt: Scalars['Date']['output'];
+    timezone: Scalars['String']['output'];
+    updatedAt: Scalars['String']['output'];
+};
+export type TestAnalysis = {
+    __typename?: 'TestAnalysis';
+    action?: Maybe<AnalysisAction>;
+    actionSide?: Maybe<AnalysisActionSide>;
+    classification?: Maybe<Scalars['String']['output']>;
+    createdAt: Scalars['Date']['output'];
+    endFrame: Scalars['Int']['output'];
+    id: Scalars['ID']['output'];
+    kind: TestAnalysisKind;
+    metrics: Array<AnalysisMetric>;
+    /** @deprecated Use action instead */
+    name?: Maybe<Scalars['String']['output']>;
+    startFrame: Scalars['Int']['output'];
+    startedAt?: Maybe<Scalars['Date']['output']>;
+    test: Test;
+    testId: Scalars['ID']['output'];
+    thresholds: Array<TestAnalysisThreshold>;
+    updatedAt: Scalars['Date']['output'];
+};
+export declare enum TestAnalysisKind {
+    General = "General",
+    PointOfInterest = "PointOfInterest"
+}
+export type TestAnalysisSummary = {
+    __typename?: 'TestAnalysisSummary';
+    action?: Maybe<AnalysisAction>;
+    actionSide?: Maybe<AnalysisActionSide>;
+    classification?: Maybe<Scalars['String']['output']>;
+    createdAt: Scalars['Date']['output'];
+    hasBeenGenerated: Scalars['Boolean']['output'];
+    id: Scalars['ID']['output'];
+    kind: TestAnalysisKind;
+    name?: Maybe<Scalars['String']['output']>;
+    startedAt?: Maybe<Scalars['Date']['output']>;
+    testId: Scalars['ID']['output'];
+    updatedAt: Scalars['Date']['output'];
+};
+export type TestAnalysisThreshold = {
+    __typename?: 'TestAnalysisThreshold';
+    id: Scalars['ID']['output'];
+    kind?: Maybe<TestAnalysisThresholdKind>;
+    max: Scalars['Float']['output'];
+    min: Scalars['Float']['output'];
+    partDimension: Scalars['String']['output'];
+    partId: Scalars['String']['output'];
+    partKind: Scalars['String']['output'];
+    testAnalysisId: Scalars['ID']['output'];
+};
+export type TestAnalysisThresholdInput = {
+    kind?: InputMaybe<TestAnalysisThresholdKind>;
+    max: Scalars['Float']['input'];
+    min: Scalars['Float']['input'];
+    partDimension: Scalars['String']['input'];
+    partId: Scalars['String']['input'];
+    partKind: Scalars['String']['input'];
+};
+export declare enum TestAnalysisThresholdKind {
+    Limit = "Limit",
+    Target = "Target"
+}
+export type TestAverageParameterScore = {
+    __typename?: 'TestAverageParameterScore';
+    averagePercentInside: Scalars['Float']['output'];
+    averageScore: Scalars['Float']['output'];
+    parameter: Parameter;
+    parameterId: Scalars['ID']['output'];
+    stdDev: Scalars['Float']['output'];
+    stdDevPercentInside: Scalars['Float']['output'];
+    trialCount: Scalars['Int']['output'];
+    variance: Scalars['Float']['output'];
+    variancePercentInside: Scalars['Float']['output'];
+};
+export declare enum TestDataSource {
+    Pose = "Pose",
+    Sensor = "Sensor"
+}
+export type TestFile = {
+    __typename?: 'TestFile';
+    createdAt: Scalars['Date']['output'];
+    dataFile?: Maybe<Scalars['String']['output']>;
+    dataSources: Array<TestDataSource>;
+    id: Scalars['ID']['output'];
+    poseTask?: Maybe<PoseTask>;
+    poseTaskStatus?: Maybe<TaskStatus>;
+    postProcessingStatus?: Maybe<TaskStatus>;
+    transcodeTask?: Maybe<TranscodeTask>;
+    updatedAt: Scalars['Date']['output'];
+    videoDataOffset: Scalars['Int']['output'];
+    videoFile?: Maybe<Scalars['String']['output']>;
+    videoFileFormat?: Maybe<Scalars['String']['output']>;
+};
+export type TestInfo = {
+    __typename?: 'TestInfo';
+    athleteWeight: Scalars['Float']['output'];
+};
+export type TestReport = {
+    __typename?: 'TestReport';
+    createdAt: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    name?: Maybe<Scalars['String']['output']>;
+    testId: Scalars['ID']['output'];
+    updatedAt: Scalars['String']['output'];
+};
+export type TestReportInput = {
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type TestReportUnion = GeneralActivityReport | MovementCoordinationReport | RangeReport | StabilityBalanceReport;
+export type Threshold = {
+    __typename?: 'Threshold';
+    id: Scalars['ID']['output'];
+    kind: ThresholdKind;
+    max: Scalars['Float']['output'];
+    min: Scalars['Float']['output'];
+    partDimension: Scalars['String']['output'];
+    partId: Scalars['String']['output'];
+    partKind: Scalars['String']['output'];
+};
+export type ThresholdFilter = {
+    kind?: InputMaybe<TestAnalysisThresholdKind>;
+    max?: InputMaybe<Scalars['Float']['input']>;
+    min?: InputMaybe<Scalars['Float']['input']>;
+    partDimension?: InputMaybe<Scalars['String']['input']>;
+    partId?: InputMaybe<Scalars['String']['input']>;
+    partKind?: InputMaybe<Scalars['String']['input']>;
+};
+export type ThresholdInput = {
+    kind: ThresholdKind;
+    max: Scalars['Float']['input'];
+    min: Scalars['Float']['input'];
+    partDimension: Scalars['String']['input'];
+    partId: Scalars['String']['input'];
+    partKind: Scalars['String']['input'];
+};
+export declare enum ThresholdKind {
+    Limit = "Limit",
+    Target = "Target"
+}
+export type TranscodeTask = {
+    __typename?: 'TranscodeTask';
+    attempts: Scalars['Int']['output'];
+    id: Scalars['ID']['output'];
+    maxAttempts: Scalars['Int']['output'];
+    status: TaskStatus;
+    taskId: Scalars['ID']['output'];
+};
+export type Trial = {
+    __typename?: 'Trial';
+    createdAt: Scalars['String']['output'];
+    endFrame: Scalars['Int']['output'];
+    excludeFromAverage: Scalars['Boolean']['output'];
+    id: Scalars['ID']['output'];
+    label?: Maybe<Scalars['String']['output']>;
+    parameters: Array<TrialParameter>;
+    startFrame: Scalars['Int']['output'];
+    updatedAt: Scalars['String']['output'];
+};
+export type TrialParameter = {
+    __typename?: 'TrialParameter';
+    data?: Maybe<TrialParameterData>;
+    id: Scalars['ID']['output'];
+    max: Scalars['Float']['output'];
+    metrics?: Maybe<TrialParameterMetrics>;
+    min: Scalars['Float']['output'];
+    parameter: Parameter;
+    parameterId: Scalars['ID']['output'];
+    trialId: Scalars['ID']['output'];
+};
+export type TrialParameterData = {
+    __typename?: 'TrialParameterData';
+    id: Scalars['ID']['output'];
+    timestamps: Array<Scalars['Long']['output']>;
+    trialParameterId: Scalars['ID']['output'];
+    values: Array<Scalars['Float']['output']>;
+};
+export type TrialParameterDataInput = {
+    timestamps: Array<Scalars['Long']['input']>;
+    values: Array<Scalars['Float']['input']>;
+};
+export type TrialParameterMetrics = {
+    __typename?: 'TrialParameterMetrics';
+    id: Scalars['ID']['output'];
+    max: Scalars['Float']['output'];
+    maxTimestamp: Scalars['Int']['output'];
+    min: Scalars['Float']['output'];
+    minTimestamp: Scalars['Int']['output'];
+    percentInside: Scalars['Float']['output'];
+    trialParameterId: Scalars['ID']['output'];
+    volumeInside: Scalars['Float']['output'];
+    volumeOutside: Scalars['Float']['output'];
+};
+export type TrialParameterMetricsInput = {
+    max: Scalars['Float']['input'];
+    maxTimestamp: Scalars['Int']['input'];
+    min: Scalars['Float']['input'];
+    minTimestamp: Scalars['Int']['input'];
+    percentInside: Scalars['Float']['input'];
+    volumeInside: Scalars['Float']['input'];
+    volumeOutside: Scalars['Float']['input'];
+};
+export type TrialParameterMetricsItemInput = {
+    input: TrialParameterMetricsInput;
+    trialParameterId: Scalars['ID']['input'];
+};
+export declare enum UnitSystem {
+    Imperial = "IMPERIAL",
+    Metric = "METRIC"
+}
+export type UpdateActionInput = {
+    activityKind?: InputMaybe<ActionActivityKind>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    instructionsMovementReport?: InputMaybe<Scalars['String']['input']>;
+    instructionsPointOfInterest?: InputMaybe<Scalars['String']['input']>;
+    laterality?: InputMaybe<ActionLaterality>;
+    name?: InputMaybe<Scalars['String']['input']>;
+    quantumOwned?: InputMaybe<Scalars['Boolean']['input']>;
+    sensorLocations?: InputMaybe<Array<SensorLocation>>;
+    thresholds?: InputMaybe<Array<ThresholdInput>>;
+    useCases?: InputMaybe<Array<UseCaseInput>>;
+};
+export type UpdateGroupInput = {
+    name?: InputMaybe<Scalars['String']['input']>;
+    quantumOwned?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type UpdateModuleInput = {
+    actions: Array<Scalars['ID']['input']>;
+    categories?: InputMaybe<Array<Scalars['ID']['input']>>;
+    description?: InputMaybe<Scalars['String']['input']>;
+    name: Scalars['String']['input'];
+    quantumOwned?: InputMaybe<Scalars['Boolean']['input']>;
+};
+export type UpdateTestInput = {
+    comment?: InputMaybe<Scalars['String']['input']>;
+    endedAt?: InputMaybe<Scalars['Date']['input']>;
+    name?: InputMaybe<Scalars['String']['input']>;
+};
+export type UpdateTrialDataInput = {
+    endFrame?: InputMaybe<Scalars['Int']['input']>;
+    excludeFromAverage?: InputMaybe<Scalars['Boolean']['input']>;
+    label?: InputMaybe<Scalars['String']['input']>;
+    parameters: Array<ReplaceTrialParameterInput>;
+    startFrame?: InputMaybe<Scalars['Int']['input']>;
+};
+export type UpdateTrialInput = {
+    endFrame?: InputMaybe<Scalars['Int']['input']>;
+    excludeFromAverage?: InputMaybe<Scalars['Boolean']['input']>;
+    label?: InputMaybe<Scalars['String']['input']>;
+    startFrame?: InputMaybe<Scalars['Int']['input']>;
+};
+export type UpdateTrialParameterInput = {
+    kind?: InputMaybe<ParameterKind>;
+    max?: InputMaybe<Scalars['Float']['input']>;
+    min?: InputMaybe<Scalars['Float']['input']>;
+};
+export type UpdateUserProfileInput = {
+    age?: InputMaybe<Scalars['Int']['input']>;
+    date_of_birth?: InputMaybe<Scalars['Date']['input']>;
+    firstName?: InputMaybe<Scalars['String']['input']>;
+    gender?: InputMaybe<Scalars['String']['input']>;
+    height?: InputMaybe<Scalars['Float']['input']>;
+    id: Scalars['ID']['input'];
+    lastName?: InputMaybe<Scalars['String']['input']>;
+    weight?: InputMaybe<Scalars['Float']['input']>;
+};
+export type UseCase = {
+    __typename?: 'UseCase';
+    id: Scalars['ID']['output'];
+    name: Scalars['String']['output'];
+};
+export type UseCaseInput = {
+    id?: InputMaybe<Scalars['ID']['input']>;
+    name: Scalars['String']['input'];
+};
+export type User = {
+    __typename?: 'User';
+    createdAt: Scalars['Date']['output'];
+    deletedAt?: Maybe<Scalars['Date']['output']>;
+    email: Scalars['String']['output'];
+    id: Scalars['ID']['output'];
+    profile?: Maybe<UserProfile>;
+    roles: Array<Scalars['String']['output']>;
+    unitSystem: UnitSystem;
+    updatedAt: Scalars['Date']['output'];
+    username: Scalars['String']['output'];
+};
+export type UserProfile = {
+    __typename?: 'UserProfile';
+    age?: Maybe<Scalars['Int']['output']>;
+    createdAt: Scalars['Date']['output'];
+    date_of_birth?: Maybe<Scalars['Date']['output']>;
+    deletedAt?: Maybe<Scalars['Date']['output']>;
+    firstName: Scalars['String']['output'];
+    gender?: Maybe<Scalars['String']['output']>;
+    group?: Maybe<GroupInfo>;
+    height?: Maybe<Scalars['Float']['output']>;
+    id: Scalars['ID']['output'];
+    lastName: Scalars['String']['output'];
+    updatedAt: Scalars['Date']['output'];
+    weight?: Maybe<Scalars['Float']['output']>;
+};
+export type AssessmentActionFragment = {
+    __typename?: 'Action';
+    id: string;
+    name: string;
+    activityKind: ActionActivityKind;
+    description?: string | null;
+    instructionsPointOfInterest?: string | null;
+    instructionsMovementReport?: string | null;
+    laterality: ActionLaterality;
+    sensorLocations: Array<SensorLocation>;
+    quantumOwned?: boolean | null;
+    thresholds: Array<{
+        __typename?: 'Threshold';
+        id: string;
+        kind: ThresholdKind;
+        min: number;
+        max: number;
+        partKind: string;
+        partId: string;
+        partDimension: string;
+    }>;
+    useCases: Array<{
+        __typename?: 'UseCase';
+        id: string;
+        name: string;
+    }>;
+} & {
+    ' $fragmentName'?: 'AssessmentActionFragment';
+};
+export type AnalysisThresholdFragment = {
+    __typename?: 'TestAnalysisThreshold';
+    testAnalysisId: string;
+    id: string;
+    kind?: TestAnalysisThresholdKind | null;
+    min: number;
+    max: number;
+    partKind: string;
+    partId: string;
+    partDimension: string;
+} & {
+    ' $fragmentName'?: 'AnalysisThresholdFragment';
+};
+export type AnalysisMetricFragment = {
+    __typename?: 'AnalysisMetric';
+    id: string;
+    createdAt: any;
+    name?: string | null;
+    description?: string | null;
+    discriminator?: string | null;
+    key: {
+        __typename?: 'AnalysisMetricKey';
+        id: string;
+        name?: string | null;
+    };
+    analysis: {
+        __typename?: 'TestAnalysis';
+        id: string;
+        startedAt?: any | null;
+    };
+    threshold?: {
+        __typename?: 'TestAnalysisThreshold';
+        id: string;
+        testAnalysisId: string;
+        kind?: TestAnalysisThresholdKind | null;
+        min: number;
+        max: number;
+        partKind: string;
+        partId: string;
+        partDimension: string;
+    } | null;
+    metric: ({
+        __typename: 'ComparativeMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisComparativeMetricFragment': AnalysisComparativeMetricFragment;
+        };
+    }) | ({
+        __typename: 'DiscreteMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisDiscreteMetricFragment': AnalysisDiscreteMetricFragment;
+        };
+    }) | ({
+        __typename: 'ImageMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisImageMetricFragment': AnalysisImageMetricFragment;
+        };
+    }) | ({
+        __typename: 'KeypointsMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisKeypointsMetricFragment': AnalysisKeypointsMetricFragment;
+        };
+    }) | {
+        __typename?: 'PoiMetricInUnion';
+    } | ({
+        __typename: 'TableMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisTableMetricFragment': AnalysisTableMetricFragment;
+        };
+    });
+} & {
+    ' $fragmentName'?: 'AnalysisMetricFragment';
+};
+export type HistoricalAnalysisMetricFragment = {
+    __typename?: 'AnalysisMetric';
+    id: string;
+    createdAt: any;
+    name?: string | null;
+    description?: string | null;
+    key: {
+        __typename?: 'AnalysisMetricKey';
+        id: string;
+        name?: string | null;
+    };
+    analysis: {
+        __typename?: 'TestAnalysis';
+        id: string;
+        startedAt?: any | null;
+    };
+    metric: ({
+        __typename: 'ComparativeMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisComparativeMetricFragment': AnalysisComparativeMetricFragment;
+        };
+    }) | ({
+        __typename: 'DiscreteMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisDiscreteMetricFragment': AnalysisDiscreteMetricFragment;
+        };
+    }) | ({
+        __typename: 'ImageMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisImageMetricFragment': AnalysisImageMetricFragment;
+        };
+    }) | ({
+        __typename: 'KeypointsMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisKeypointsMetricFragment': AnalysisKeypointsMetricFragment;
+        };
+    }) | {
+        __typename?: 'PoiMetricInUnion';
+    } | ({
+        __typename: 'TableMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisTableMetricFragment': AnalysisTableMetricFragment;
+        };
+    });
+} & {
+    ' $fragmentName'?: 'HistoricalAnalysisMetricFragment';
+};
+export type AnalysisDiscreteMetricFragment = {
+    __typename?: 'DiscreteMetric';
+    unit: any;
+    value: number;
+} & {
+    ' $fragmentName'?: 'AnalysisDiscreteMetricFragment';
+};
+export type AnalysisComparativeMetricFragment = {
+    __typename?: 'ComparativeMetric';
+    unitA: any;
+    unitB: any;
+    valueA: number;
+    valueB: number;
+    labelA: string;
+    labelB: string;
+} & {
+    ' $fragmentName'?: 'AnalysisComparativeMetricFragment';
+};
+export type AnalysisKeypointsMetricFragment = {
+    __typename?: 'KeypointsMetric';
+    keypoints: Array<{
+        __typename?: 'KeypointsMetricItem';
+        unit: any;
+        value: number;
+        frame: number;
+        timestamp: any;
+        timeSeries: Array<{
+            __typename?: 'KeypointsMetricTimeSeries';
+            label: string;
+            unit: any;
+            timeSeriesJson: string;
+        }>;
+    }>;
+} & {
+    ' $fragmentName'?: 'AnalysisKeypointsMetricFragment';
+};
+export type AnalysisTableMetricFragment = {
+    __typename?: 'TableMetric';
+    rows: Array<{
+        __typename?: 'TableMetricRow';
+        id: string;
+        order: number;
+        cells: Array<{
+            __typename?: 'TableMetricCell';
+            id: string;
+            order: number;
+            value: string;
+            unit?: any | null;
+            colSpan: number;
+            rowSpan: number;
+            isLabel?: boolean | null;
+            isNumeric?: boolean | null;
+        }>;
+    }>;
+} & {
+    ' $fragmentName'?: 'AnalysisTableMetricFragment';
+};
+export type AnalysisImageMetricFragment = {
+    __typename?: 'ImageMetric';
+    path: string;
+} & {
+    ' $fragmentName'?: 'AnalysisImageMetricFragment';
+};
+export type AnalysisTestActionFragment = {
+    __typename?: 'Action';
+    id: string;
+    name: string;
+    description?: string | null;
+    instructionsPointOfInterest?: string | null;
+    instructionsMovementReport?: string | null;
+    laterality: ActionLaterality;
+    sensorLocations: Array<SensorLocation>;
+    thresholds: Array<{
+        __typename?: 'Threshold';
+        id: string;
+        kind: ThresholdKind;
+        min: number;
+        max: number;
+        partKind: string;
+        partId: string;
+        partDimension: string;
+    }>;
+} & {
+    ' $fragmentName'?: 'AnalysisTestActionFragment';
+};
+export type FullTestAnalysisFragment = {
+    __typename?: 'TestAnalysis';
+    id: string;
+    testId: string;
+    name?: string | null;
+    kind: TestAnalysisKind;
+    createdAt: any;
+    updatedAt: any;
+    startedAt?: any | null;
+    startFrame: number;
+    endFrame: number;
+    actionSide?: AnalysisActionSide | null;
+    thresholds: Array<({
+        __typename?: 'TestAnalysisThreshold';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisThresholdFragment': AnalysisThresholdFragment;
+        };
+    })>;
+    metrics: Array<({
+        __typename?: 'AnalysisMetric';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisMetricFragment': AnalysisMetricFragment;
+        };
+    })>;
+    test: {
+        __typename?: 'Test';
+        id: string;
+        name: string;
+        createdAt: string;
+        updatedAt: string;
+        startedAt: any;
+        endedAt?: any | null;
+        sessionId: string;
+        kindId?: string | null;
+        file?: ({
+            __typename?: 'TestFile';
+        } & {
+            ' $fragmentRefs'?: {
+                'TestFileFragment': TestFileFragment;
+            };
+        }) | null;
+        info?: {
+            __typename?: 'TestInfo';
+            athleteWeight: number;
+        } | null;
+        action?: ({
+            __typename?: 'Action';
+        } & {
+            ' $fragmentRefs'?: {
+                'AnalysisTestActionFragment': AnalysisTestActionFragment;
+            };
+        }) | null;
+    };
+    action?: {
+        __typename?: 'AnalysisAction';
+        id: string;
+        name: string;
+    } | null;
+} & {
+    ' $fragmentName'?: 'FullTestAnalysisFragment';
+};
+export type BasicTestAnalysisFragment = {
+    __typename?: 'TestAnalysis';
+    id: string;
+    testId: string;
+    name?: string | null;
+    kind: TestAnalysisKind;
+    createdAt: any;
+    updatedAt: any;
+    startedAt?: any | null;
+    startFrame: number;
+    endFrame: number;
+    actionSide?: AnalysisActionSide | null;
+    thresholds: Array<({
+        __typename?: 'TestAnalysisThreshold';
+    } & {
+        ' $fragmentRefs'?: {
+            'AnalysisThresholdFragment': AnalysisThresholdFragment;
+        };
+    })>;
+} & {
+    ' $fragmentName'?: 'BasicTestAnalysisFragment';
+};
+export type ReviewTestReportFragment = {
+    __typename?: 'TestReport';
+    id: string;
+    createdAt: string;
+    name?: string | null;
+} & {
+    ' $fragmentName'?: 'ReviewTestReportFragment';
+};
+export type UserGroupFragment = {
+    __typename?: 'Group';
+    id: string;
+    name: string;
+    imageUrl?: string | null;
+    quantumOwned?: boolean | null;
+} & {
+    ' $fragmentName'?: 'UserGroupFragment';
+};
+export type LibraryModuleActionFragment = {
+    __typename?: 'ModuleAction';
+    moduleId: string;
+    actionId: string;
+    sortOrder: number;
+    action: ({
+        __typename?: 'Action';
+    } & {
+        ' $fragmentRefs'?: {
+            'AssessmentActionFragment': AssessmentActionFragment;
+        };
+    });
+} & {
+    ' $fragmentName'?: 'LibraryModuleActionFragment';
+};
+export type LibraryActionModuleFragment = {
+    __typename?: 'ActionModule';
+    id: string;
+    name: string;
+    description?: string | null;
+    quantumOwned?: boolean | null;
+    moduleActions: Array<({
+        __typename?: 'ModuleAction';
+    } & {
+        ' $fragmentRefs'?: {
+            'LibraryModuleActionFragment': LibraryModuleActionFragment;
+        };
+    })>;
+    categories: Array<({
+        __typename?: 'ModuleCategory';
+    } & {
+        ' $fragmentRefs'?: {
+            'LibraryModuleCategoryFragment': LibraryModuleCategoryFragment;
+        };
+    })>;
+} & {
+    ' $fragmentName'?: 'LibraryActionModuleFragment';
+};
+export type LibraryModuleCategoryFragment = {
+    __typename?: 'ModuleCategory';
+    id: string;
+    name: string;
+    description?: string | null;
+    sortOrder: number;
+} & {
+    ' $fragmentName'?: 'LibraryModuleCategoryFragment';
+};
+export type PoseTaskFragment = {
+    __typename?: 'PoseTask';
+    id: string;
+    taskId: string;
+    status: TaskStatus;
+    attempts: number;
+    maxAttempts: number;
+} & {
+    ' $fragmentName'?: 'PoseTaskFragment';
+};
+export type TranscodeTaskFragment = {
+    __typename?: 'TranscodeTask';
+    id: string;
+    taskId: string;
+    status: TaskStatus;
+    attempts: number;
+    maxAttempts: number;
+} & {
+    ' $fragmentName'?: 'TranscodeTaskFragment';
+};
+export type TestFileFragment = {
+    __typename?: 'TestFile';
+    id: string;
+    videoFile?: string | null;
+    dataFile?: string | null;
+    videoFileFormat?: string | null;
+    videoDataOffset: number;
+    poseTaskStatus?: TaskStatus | null;
+    postProcessingStatus?: TaskStatus | null;
+    dataSources: Array<TestDataSource>;
+    poseTask?: ({
+        __typename?: 'PoseTask';
+    } & {
+        ' $fragmentRefs'?: {
+            'PoseTaskFragment': PoseTaskFragment;
+        };
+    }) | null;
+    transcodeTask?: ({
+        __typename?: 'TranscodeTask';
+    } & {
+        ' $fragmentRefs'?: {
+            'TranscodeTaskFragment': TranscodeTaskFragment;
+        };
+    }) | null;
+} & {
+    ' $fragmentName'?: 'TestFileFragment';
+};
+export type ReviewParameterFragment = {
+    __typename?: 'Parameter';
+    id: string;
+    kind: ParameterKind;
+    partKind: string;
+    partId: string;
+    partDimension: string;
+} & {
+    ' $fragmentName'?: 'ReviewParameterFragment';
+};
+export type ReviewTrialParameterMetricsFragment = {
+    __typename?: 'TrialParameterMetrics';
+    trialParameterId: string;
+    min: number;
+    max: number;
+    minTimestamp: number;
+    maxTimestamp: number;
+    percentInside: number;
+    volumeInside: number;
+    volumeOutside: number;
+} & {
+    ' $fragmentName'?: 'ReviewTrialParameterMetricsFragment';
+};
+export type ReviewTrialParameterDataFragment = {
+    __typename?: 'TrialParameterData';
+    trialParameterId: string;
+    timestamps: Array<any>;
+    values: Array<number>;
+} & {
+    ' $fragmentName'?: 'ReviewTrialParameterDataFragment';
+};
+export type ReviewTrialParameterFragment = {
+    __typename?: 'TrialParameter';
+    trialId: string;
+    id: string;
+    min: number;
+    max: number;
+    parameter: ({
+        __typename?: 'Parameter';
+    } & {
+        ' $fragmentRefs'?: {
+            'ReviewParameterFragment': ReviewParameterFragment;
+        };
+    });
+    metrics?: ({
+        __typename?: 'TrialParameterMetrics';
+    } & {
+        ' $fragmentRefs'?: {
+            'ReviewTrialParameterMetricsFragment': ReviewTrialParameterMetricsFragment;
+        };
+    }) | null;
+    data?: ({
+        __typename?: 'TrialParameterData';
+    } & {
+        ' $fragmentRefs'?: {
+            'ReviewTrialParameterDataFragment': ReviewTrialParameterDataFragment;
+        };
+    }) | null;
+} & {
+    ' $fragmentName'?: 'ReviewTrialParameterFragment';
+};
+export type ReviewTrialFragment = {
+    __typename?: 'Trial';
+    id: string;
+    createdAt: string;
+    label?: string | null;
+    startFrame: number;
+    endFrame: number;
+    excludeFromAverage: boolean;
+    parameters: Array<({
+        __typename?: 'TrialParameter';
+    } & {
+        ' $fragmentRefs'?: {
+            'ReviewTrialParameterFragment': ReviewTrialParameterFragment;
+        };
+    })>;
+} & {
+    ' $fragmentName'?: 'ReviewTrialFragment';
+};
+export type TestParameterScoreOverviewFragment = {
+    __typename?: 'TestAverageParameterScore';
+    averageScore: number;
+    trialCount: number;
+    variance: number;
+    stdDev: number;
+    averagePercentInside: number;
+    variancePercentInside: number;
+    stdDevPercentInside: number;
+    parameter: ({
+        __typename?: 'Parameter';
+    } & {
+        ' $fragmentRefs'?: {
+            'ReviewParameterFragment': ReviewParameterFragment;
+        };
+    });
+} & {
+    ' $fragmentName'?: 'TestParameterScoreOverviewFragment';
+};
+type TestReportOverview_GeneralActivityReport_Fragment = {
+    __typename: 'GeneralActivityReport';
+    id: string;
+    report: {
+        __typename?: 'TestReport';
+        id: string;
+        createdAt: string;
+        name?: string | null;
+    };
+    averageParameterScores: Array<({
+        __typename?: 'TestAverageParameterScore';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestParameterScoreOverviewFragment': TestParameterScoreOverviewFragment;
+        };
+    })>;
+} & {
+    ' $fragmentName'?: 'TestReportOverview_GeneralActivityReport_Fragment';
+};
+type TestReportOverview_MovementCoordinationReport_Fragment = {
+    __typename: 'MovementCoordinationReport';
+    id: string;
+    report: {
+        __typename?: 'TestReport';
+        id: string;
+        createdAt: string;
+        name?: string | null;
+    };
+    averageParameterScores: Array<({
+        __typename?: 'TestAverageParameterScore';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestParameterScoreOverviewFragment': TestParameterScoreOverviewFragment;
+        };
+    })>;
+} & {
+    ' $fragmentName'?: 'TestReportOverview_MovementCoordinationReport_Fragment';
+};
+type TestReportOverview_RangeReport_Fragment = {
+    __typename: 'RangeReport';
+    id: string;
+    report: {
+        __typename?: 'TestReport';
+        id: string;
+        createdAt: string;
+        name?: string | null;
+    };
+    averageParameterScores: Array<({
+        __typename?: 'TestAverageParameterScore';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestParameterScoreOverviewFragment': TestParameterScoreOverviewFragment;
+        };
+    })>;
+} & {
+    ' $fragmentName'?: 'TestReportOverview_RangeReport_Fragment';
+};
+type TestReportOverview_StabilityBalanceReport_Fragment = {
+    __typename: 'StabilityBalanceReport';
+    id: string;
+    report: {
+        __typename?: 'TestReport';
+        id: string;
+        createdAt: string;
+        name?: string | null;
+    };
+    averageParameterScores: Array<({
+        __typename?: 'TestAverageParameterScore';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestParameterScoreOverviewFragment': TestParameterScoreOverviewFragment;
+        };
+    })>;
+} & {
+    ' $fragmentName'?: 'TestReportOverview_StabilityBalanceReport_Fragment';
+};
+export type TestReportOverviewFragment = TestReportOverview_GeneralActivityReport_Fragment | TestReportOverview_MovementCoordinationReport_Fragment | TestReportOverview_RangeReport_Fragment | TestReportOverview_StabilityBalanceReport_Fragment;
+export type TestWithParameterScoresFragment = {
+    __typename?: 'Test';
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: any;
+    endedAt?: any | null;
+    timezone: string;
+    sessionId: string;
+    kindId?: string | null;
+    comment?: string | null;
+    file?: ({
+        __typename?: 'TestFile';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestFileFragment': TestFileFragment;
+        };
+    }) | null;
+    info?: {
+        __typename?: 'TestInfo';
+        athleteWeight: number;
+    } | null;
+    session: {
+        __typename?: 'Session';
+        id: string;
+        name: string;
+    };
+    action?: {
+        __typename?: 'Action';
+        id: string;
+        name: string;
+        description?: string | null;
+        instructionsPointOfInterest?: string | null;
+        instructionsMovementReport?: string | null;
+        laterality: ActionLaterality;
+        activityKind: ActionActivityKind;
+        sensorLocations: Array<SensorLocation>;
+        thresholds: Array<{
+            __typename?: 'Threshold';
+            id: string;
+            kind: ThresholdKind;
+            min: number;
+            max: number;
+            partKind: string;
+            partId: string;
+            partDimension: string;
+        }>;
+        useCases: Array<{
+            __typename?: 'UseCase';
+            id: string;
+            name: string;
+        }>;
+    } | null;
+    reports: Array<({
+        __typename?: 'GeneralActivityReport';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestReportOverview_GeneralActivityReport_Fragment': TestReportOverview_GeneralActivityReport_Fragment;
+        };
+    }) | ({
+        __typename?: 'MovementCoordinationReport';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestReportOverview_MovementCoordinationReport_Fragment': TestReportOverview_MovementCoordinationReport_Fragment;
+        };
+    }) | ({
+        __typename?: 'RangeReport';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestReportOverview_RangeReport_Fragment': TestReportOverview_RangeReport_Fragment;
+        };
+    }) | ({
+        __typename?: 'StabilityBalanceReport';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestReportOverview_StabilityBalanceReport_Fragment': TestReportOverview_StabilityBalanceReport_Fragment;
+        };
+    })>;
+    analysis: Array<({
+        __typename?: 'TestAnalysisSummary';
+    } & {
+        ' $fragmentRefs'?: {
+            'ProfileSessionTestAnalysisFragment': ProfileSessionTestAnalysisFragment;
+        };
+    })>;
+} & {
+    ' $fragmentName'?: 'TestWithParameterScoresFragment';
+};
+export type ProfileSessionTestAnalysisFragment = {
+    __typename?: 'TestAnalysisSummary';
+    id: string;
+    name?: string | null;
+    classification?: string | null;
+    kind: TestAnalysisKind;
+    createdAt: any;
+    updatedAt: any;
+    startedAt?: any | null;
+    actionSide?: AnalysisActionSide | null;
+    hasBeenGenerated: boolean;
+    action?: {
+        __typename?: 'AnalysisAction';
+        id: string;
+        name: string;
+    } | null;
+} & {
+    ' $fragmentName'?: 'ProfileSessionTestAnalysisFragment';
+};
+export type ProfileSessionTestFragment = {
+    __typename?: 'Test';
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+    startedAt: any;
+    endedAt?: any | null;
+    timezone: string;
+    sessionId: string;
+    kindId?: string | null;
+    comment?: string | null;
+    file?: ({
+        __typename?: 'TestFile';
+    } & {
+        ' $fragmentRefs'?: {
+            'TestFileFragment': TestFileFragment;
+        };
+    }) | null;
+    info?: {
+        __typename?: 'TestInfo';
+        athleteWeight: number;
+    } | null;
+    analysis: Array<({
+        __typename?: 'TestAnalysisSummary';
+    } & {
+        ' $fragmentRefs'?: {
+            'ProfileSessionTestAnalysisFragment': ProfileSessionTestAnalysisFragment;
+        };
+    })>;
+    action?: {
+        __typename?: 'Action';
+        id: string;
+        name: string;
+        activityKind: ActionActivityKind;
+        description?: string | null;
+        instructionsPointOfInterest?: string | null;
+        instructionsMovementReport?: string | null;
+        laterality: ActionLaterality;
+        sensorLocations: Array<SensorLocation>;
+        thresholds: Array<{
+            __typename?: 'Threshold';
+            id: string;
+            kind: ThresholdKind;
+            min: number;
+            max: number;
+            partKind: string;
+            partId: string;
+            partDimension: string;
+        }>;
+        useCases: Array<{
+            __typename?: 'UseCase';
+            id: string;
+            name: string;
+        }>;
+    } | null;
+} & {
+    ' $fragmentName'?: 'ProfileSessionTestFragment';
+};
+export type ProfileSessionFragment = {
+    __typename?: 'Session';
+    id: string;
+    name: string;
+    createdAt: string;
+    updatedAt: string;
+    createdById: string;
+    createdForId: string;
+    startedAt: any;
+    tests: Array<({
+        __typename?: 'Test';
+    } & {
+        ' $fragmentRefs'?: {
+            'ProfileSessionTestFragment': ProfileSessionTestFragment;
+        };
+    })>;
+} & {
+    ' $fragmentName'?: 'ProfileSessionFragment';
+};
+export type CreateActionMutationVariables = Exact<{
+    fields: CreateActionInput;
+}>;
+export type CreateActionMutation = {
+    __typename?: 'Mutation';
+    createAction: ({
+        __typename?: 'Action';
+    } & {
+        ' $fragmentRefs'?: {
+            'AssessmentActionFragment': AssessmentActionFragment;
+        };
+    });
+};
+export type UpdateActionMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    fields: UpdateActionInput;
+}>;
+export type UpdateActionMutation = {
+    __typename?: 'Mutation';
+    updateAction: ({
+        __typename?: 'Action';
+    } & {
+        ' $fragmentRefs'?: {
+            'AssessmentActionFragment': AssessmentActionFragment;
+        };
+    });
+};
+export type CreateLibraryModuleMutationVariables = Exact<{
+    input: CreateModuleInput;
+}>;
+export type CreateLibraryModuleMutation = {
+    __typename?: 'Mutation';
+    createModule: ({
+        __typename?: 'ActionModule';
+    } & {
+        ' $fragmentRefs'?: {
+            'LibraryActionModuleFragment': LibraryActionModuleFragment;
+        };
+    });
+};
+export type DeleteLibraryModuleMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type DeleteLibraryModuleMutation = {
+    __typename?: 'Mutation';
+    deleteModule: boolean;
+};
+export type UpdateLibraryModuleMutationVariables = Exact<{
+    id: Scalars['ID']['input'];
+    input: UpdateModuleInput;
+}>;
+export type UpdateLibraryModuleMutation = {
+    __typename?: 'Mutation';
+    updateModule: ({
+        __typename?: 'ActionModule';
+    } & {
+        ' $fragmentRefs'?: {
+            'LibraryActionModuleFragment': LibraryActionModuleFragment;
+        };
+    });
+};
+export type CopyModulesMutationVariables = Exact<{
+    input: CopyModulesInput;
+}>;
+export type CopyModulesMutation = {
+    __typename?: 'Mutation';
+    copyModules: boolean;
+};
+export type GetActionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetActionsQuery = {
+    __typename?: 'Query';
+    actions: Array<({
+        __typename?: 'Action';
+    } & {
+        ' $fragmentRefs'?: {
+            'AssessmentActionFragment': AssessmentActionFragment;
+        };
+    })>;
+};
+export type GetQuantumOwnedActionsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetQuantumOwnedActionsQuery = {
+    __typename?: 'Query';
+    quantumOwnedActions: Array<({
+        __typename?: 'Action';
+    } & {
+        ' $fragmentRefs'?: {
+            'AssessmentActionFragment': AssessmentActionFragment;
+        };
+    })>;
+};
+export type GetActionByIdQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type GetActionByIdQuery = {
+    __typename?: 'Query';
+    getActionById?: ({
+        __typename?: 'Action';
+    } & {
+        ' $fragmentRefs'?: {
+            'AssessmentActionFragment': AssessmentActionFragment;
+        };
+    }) | null;
+};
+export type SearchUseCasesQueryVariables = Exact<{
+    query: Scalars['String']['input'];
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type SearchUseCasesQuery = {
+    __typename?: 'Query';
+    useCases: Array<{
+        __typename?: 'UseCase';
+        id: string;
+        name: string;
+    }>;
+};
+export type SearchQuantumOwnedUseCasesQueryVariables = Exact<{
+    query: Scalars['String']['input'];
+    skip?: InputMaybe<Scalars['Int']['input']>;
+    limit?: InputMaybe<Scalars['Int']['input']>;
+}>;
+export type SearchQuantumOwnedUseCasesQuery = {
+    __typename?: 'Query';
+    quantumOwnedUseCases: Array<{
+        __typename?: 'UseCase';
+        id: string;
+        name: string;
+    }>;
+};
+export type GetGroupsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetGroupsQuery = {
+    __typename?: 'Query';
+    groups: Array<({
+        __typename?: 'Group';
+    } & {
+        ' $fragmentRefs'?: {
+            'UserGroupFragment': UserGroupFragment;
+        };
+    })>;
+};
+export type GetModulesByGroupQueryVariables = Exact<{
+    groupId: Scalars['ID']['input'];
+}>;
+export type GetModulesByGroupQuery = {
+    __typename?: 'Query';
+    group?: {
+        __typename?: 'Group';
+        name: string;
+    } | null;
+    modules: Array<({
+        __typename?: 'ActionModule';
+    } & {
+        ' $fragmentRefs'?: {
+            'LibraryActionModuleFragment': LibraryActionModuleFragment;
+        };
+    })>;
+};
+export type GetActionsByGroupQueryVariables = Exact<{
+    groupId: Scalars['ID']['input'];
+}>;
+export type GetActionsByGroupQuery = {
+    __typename?: 'Query';
+    group?: {
+        __typename?: 'Group';
+        name: string;
+    } | null;
+    actions: Array<({
+        __typename?: 'Action';
+    } & {
+        ' $fragmentRefs'?: {
+            'AssessmentActionFragment': AssessmentActionFragment;
+        };
+    })>;
+};
+export type GetLibraryModulesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetLibraryModulesQuery = {
+    __typename?: 'Query';
+    modules: Array<({
+        __typename?: 'ActionModule';
+    } & {
+        ' $fragmentRefs'?: {
+            'LibraryActionModuleFragment': LibraryActionModuleFragment;
+        };
+    })>;
+};
+export type GetLibraryModuleQueryVariables = Exact<{
+    id: Scalars['ID']['input'];
+}>;
+export type GetLibraryModuleQuery = {
+    __typename?: 'Query';
+    module?: ({
+        __typename?: 'ActionModule';
+    } & {
+        ' $fragmentRefs'?: {
+            'LibraryActionModuleFragment': LibraryActionModuleFragment;
+        };
+    }) | null;
+};
+export type GetAllModuleCategoriesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GetAllModuleCategoriesQuery = {
+    __typename?: 'Query';
+    moduleCategories: Array<({
+        __typename?: 'ModuleCategory';
+    } & {
+        ' $fragmentRefs'?: {
+            'LibraryModuleCategoryFragment': LibraryModuleCategoryFragment;
+        };
+    })>;
+};
+export declare const AnalysisDiscreteMetricFragmentDoc: DocumentNode<AnalysisDiscreteMetricFragment, unknown>;
+export declare const AnalysisComparativeMetricFragmentDoc: DocumentNode<AnalysisComparativeMetricFragment, unknown>;
+export declare const AnalysisKeypointsMetricFragmentDoc: DocumentNode<AnalysisKeypointsMetricFragment, unknown>;
+export declare const AnalysisTableMetricFragmentDoc: DocumentNode<AnalysisTableMetricFragment, unknown>;
+export declare const AnalysisImageMetricFragmentDoc: DocumentNode<AnalysisImageMetricFragment, unknown>;
+export declare const HistoricalAnalysisMetricFragmentDoc: DocumentNode<HistoricalAnalysisMetricFragment, unknown>;
+export declare const AnalysisThresholdFragmentDoc: DocumentNode<AnalysisThresholdFragment, unknown>;
+export declare const AnalysisMetricFragmentDoc: DocumentNode<AnalysisMetricFragment, unknown>;
+export declare const PoseTaskFragmentDoc: DocumentNode<PoseTaskFragment, unknown>;
+export declare const TranscodeTaskFragmentDoc: DocumentNode<TranscodeTaskFragment, unknown>;
+export declare const TestFileFragmentDoc: DocumentNode<TestFileFragment, unknown>;
+export declare const AnalysisTestActionFragmentDoc: DocumentNode<AnalysisTestActionFragment, unknown>;
+export declare const FullTestAnalysisFragmentDoc: DocumentNode<FullTestAnalysisFragment, unknown>;
+export declare const BasicTestAnalysisFragmentDoc: DocumentNode<BasicTestAnalysisFragment, unknown>;
+export declare const ReviewTestReportFragmentDoc: DocumentNode<ReviewTestReportFragment, unknown>;
+export declare const UserGroupFragmentDoc: DocumentNode<UserGroupFragment, unknown>;
+export declare const AssessmentActionFragmentDoc: DocumentNode<AssessmentActionFragment, unknown>;
+export declare const LibraryModuleActionFragmentDoc: DocumentNode<LibraryModuleActionFragment, unknown>;
+export declare const LibraryModuleCategoryFragmentDoc: DocumentNode<LibraryModuleCategoryFragment, unknown>;
+export declare const LibraryActionModuleFragmentDoc: DocumentNode<LibraryActionModuleFragment, unknown>;
+export declare const ReviewParameterFragmentDoc: DocumentNode<ReviewParameterFragment, unknown>;
+export declare const ReviewTrialParameterMetricsFragmentDoc: DocumentNode<ReviewTrialParameterMetricsFragment, unknown>;
+export declare const ReviewTrialParameterDataFragmentDoc: DocumentNode<ReviewTrialParameterDataFragment, unknown>;
+export declare const ReviewTrialParameterFragmentDoc: DocumentNode<ReviewTrialParameterFragment, unknown>;
+export declare const ReviewTrialFragmentDoc: DocumentNode<ReviewTrialFragment, unknown>;
+export declare const TestParameterScoreOverviewFragmentDoc: DocumentNode<TestParameterScoreOverviewFragment, unknown>;
+export declare const TestReportOverviewFragmentDoc: DocumentNode<TestReportOverviewFragment, unknown>;
+export declare const ProfileSessionTestAnalysisFragmentDoc: DocumentNode<ProfileSessionTestAnalysisFragment, unknown>;
+export declare const TestWithParameterScoresFragmentDoc: DocumentNode<TestWithParameterScoresFragment, unknown>;
+export declare const ProfileSessionTestFragmentDoc: DocumentNode<ProfileSessionTestFragment, unknown>;
+export declare const ProfileSessionFragmentDoc: DocumentNode<ProfileSessionFragment, unknown>;
+export declare const CreateActionDocument: DocumentNode<CreateActionMutation, CreateActionMutationVariables>;
+export declare const UpdateActionDocument: DocumentNode<UpdateActionMutation, UpdateActionMutationVariables>;
+export declare const CreateLibraryModuleDocument: DocumentNode<CreateLibraryModuleMutation, CreateLibraryModuleMutationVariables>;
+export declare const DeleteLibraryModuleDocument: DocumentNode<DeleteLibraryModuleMutation, DeleteLibraryModuleMutationVariables>;
+export declare const UpdateLibraryModuleDocument: DocumentNode<UpdateLibraryModuleMutation, UpdateLibraryModuleMutationVariables>;
+export declare const CopyModulesDocument: DocumentNode<CopyModulesMutation, CopyModulesMutationVariables>;
+export declare const GetActionsDocument: DocumentNode<GetActionsQuery, GetActionsQueryVariables>;
+export declare const GetQuantumOwnedActionsDocument: DocumentNode<GetQuantumOwnedActionsQuery, GetQuantumOwnedActionsQueryVariables>;
+export declare const GetActionByIdDocument: DocumentNode<GetActionByIdQuery, GetActionByIdQueryVariables>;
+export declare const SearchUseCasesDocument: DocumentNode<SearchUseCasesQuery, SearchUseCasesQueryVariables>;
+export declare const SearchQuantumOwnedUseCasesDocument: DocumentNode<SearchQuantumOwnedUseCasesQuery, SearchQuantumOwnedUseCasesQueryVariables>;
+export declare const GetGroupsDocument: DocumentNode<GetGroupsQuery, GetGroupsQueryVariables>;
+export declare const GetModulesByGroupDocument: DocumentNode<GetModulesByGroupQuery, GetModulesByGroupQueryVariables>;
+export declare const GetActionsByGroupDocument: DocumentNode<GetActionsByGroupQuery, GetActionsByGroupQueryVariables>;
+export declare const GetLibraryModulesDocument: DocumentNode<GetLibraryModulesQuery, GetLibraryModulesQueryVariables>;
+export declare const GetLibraryModuleDocument: DocumentNode<GetLibraryModuleQuery, GetLibraryModuleQueryVariables>;
+export declare const GetAllModuleCategoriesDocument: DocumentNode<GetAllModuleCategoriesQuery, GetAllModuleCategoriesQueryVariables>;
+export {};