@quesmed/types-rn 2.6.266 → 2.6.268

package/models/Circuit.d.ts

@@ -1,16 +1,29 @@
 import { IOsceMarksheet } from './OsceMarksheet';
 import { IOsceStation } from './OsceStation';
 import { Id } from './Type';
+export declare enum ECircuitVisibility {
+    PRIVATE = 0,
+    PUBLIC = 1
+}
+export declare enum ECircuitType {
+    MOCK = 0,
+    BODY_SYSTEM = 1,
+    CUSTOM = 2
+}
 export interface ICircuitStationInput {
     osceStationId: number;
     sortOrder: number;
 }
 export interface ICreateCircuitInput {
     name: string;
+    description?: string;
+    visibility?: ECircuitVisibility;
     stations: ICircuitStationInput[];
 }
 export interface IEditCircuitInput {
     name?: string;
+    description?: string;
+    visibility?: ECircuitVisibility;
     stations?: ICircuitStationInput[];
 }
 export interface ICircuit {
@@ -20,7 +33,8 @@ export interface ICircuit {
     userId: number;
     description: string;
     name: string;
-    preDefined: boolean;
+    visibility: ECircuitVisibility;
+    type: ECircuitType;
     stations?: IOsceStation[];
     circuitSession?: ICircuitSession | null;
 }

package/models/Circuit.js

@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECircuitType = exports.ECircuitVisibility = void 0;
+var ECircuitVisibility;
+(function (ECircuitVisibility) {
+    ECircuitVisibility[ECircuitVisibility["PRIVATE"] = 0] = "PRIVATE";
+    ECircuitVisibility[ECircuitVisibility["PUBLIC"] = 1] = "PUBLIC";
+})(ECircuitVisibility = exports.ECircuitVisibility || (exports.ECircuitVisibility = {}));
+var ECircuitType;
+(function (ECircuitType) {
+    ECircuitType[ECircuitType["MOCK"] = 0] = "MOCK";
+    ECircuitType[ECircuitType["BODY_SYSTEM"] = 1] = "BODY_SYSTEM";
+    ECircuitType[ECircuitType["CUSTOM"] = 2] = "CUSTOM";
+})(ECircuitType = exports.ECircuitType || (exports.ECircuitType = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quesmed/types-rn",
-  "version": "2.6.266",
+  "version": "2.6.268",
   "description": "Typescript types for Quesmed",
   "keywords": [
     "quesmed",

package/resolvers/fragments/circuit.js

@@ -13,7 +13,8 @@ ${picture_1.PICTURE_FIELDS}
     userId
     name
     description
-    preDefined
+    visibility
+    typeId
     stations {
       id
       name

package/resolvers/mutation/restricted/asset.d.ts

@@ -0,0 +1,20 @@
+import { FileData, IPicture, Id } from '../../../models';
+import { AdminData, graphqlNormalize } from '../../types';
+export interface IAssetInput {
+    file: File | FileData;
+    caption?: string | null;
+    name: string;
+    topicId?: Id;
+    sensitive: boolean;
+    overlay?: boolean;
+}
+export declare const CREATE_ASSETS: import("@apollo/client").DocumentNode;
+export type ICreateAssetsVar = {
+    inputs: IAssetInput[];
+};
+export type ICreateAssetsData = AdminData<(IPicture & graphqlNormalize)[], 'createAssets'>;
+export declare const REMOVE_ASSETS: import("@apollo/client").DocumentNode;
+export type IRemoveAssetsVar = {
+    ids: Id[];
+};
+export type IRemoveAssetsData = AdminData<boolean, 'removeAssets'>;

package/resolvers/mutation/restricted/asset.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOVE_ASSETS = exports.CREATE_ASSETS = void 0;
+const client_1 = require("@apollo/client");
+const fragments_1 = require("../../fragments");
+exports.CREATE_ASSETS = (0, client_1.gql) `
+  ${fragments_1.PICTURE_FIELDS}
+  mutation CreateAssets($inputs: [CreateAssetsInput!]!) {
+    restricted {
+      createAssets(inputs: $inputs) {
+        ...PictureFields
+      }
+    }
+  }
+`;
+exports.REMOVE_ASSETS = (0, client_1.gql) `
+  mutation RemoveAssets($ids: [ID!]!) {
+    restricted {
+      removeAssets(ids: $ids)
+    }
+  }
+`;

package/resolvers/mutation/restricted/index.d.ts

@@ -1,4 +1,5 @@
 export * from './agora';
+export * from './asset';
 export * from './circuit';
 export * from './book';
 export * from './chapter';
@@ -9,6 +10,7 @@ export * from './notification';
 export * from './osce';
 export * from './preset';
 export * from './questionDiscussion';
+export * from './station';
 export * from './stripe';
 export * from './todo';
 export * from './token';

package/resolvers/mutation/restricted/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./agora"), exports);
+__exportStar(require("./asset"), exports);
 __exportStar(require("./circuit"), exports);
 __exportStar(require("./book"), exports);
 __exportStar(require("./chapter"), exports);
@@ -25,6 +26,7 @@ __exportStar(require("./notification"), exports);
 __exportStar(require("./osce"), exports);
 __exportStar(require("./preset"), exports);
 __exportStar(require("./questionDiscussion"), exports);
+__exportStar(require("./station"), exports);
 __exportStar(require("./stripe"), exports);
 __exportStar(require("./todo"), exports);
 __exportStar(require("./token"), exports);

package/resolvers/mutation/restricted/station.d.ts

@@ -0,0 +1,81 @@
+import { ApolloCache } from '@apollo/client';
+import { ApolloUpdateOptions, ApolloUpdateResultRestricted } from '../..';
+import { IClinicalDataModule, Id, IOsceStation, IOsceStationPhaseTimer, IStationExaminerQuestion } from '../../../models';
+import { IAssetBinding } from '../../../models/Picture';
+import { graphqlNormalize, RestrictedData } from '../../types';
+import { EOsceType } from '../../../models';
+export interface IJobStationMarkInput {
+    header?: string;
+    name?: string;
+    index?: number;
+    excludeFromAi?: boolean;
+    weight?: number;
+}
+export declare const CREATE_STATION: import("@apollo/client").DocumentNode;
+export type ICreateStationData = RestrictedData<graphqlNormalize & IOsceStation, 'createStation'>;
+export interface ICreateStationVar {
+    input: {
+        name: string;
+        hiddenName?: string;
+        osceTypeId?: number;
+        enabled?: number;
+        visibility?: number;
+        entitlementIds?: number[];
+        difficulty?: number;
+        pictureId?: number;
+        candidateBrief?: string;
+        examinerBrief?: string;
+        actorBrief?: string;
+        llmActorBrief?: string;
+        explanation?: string;
+        aiEnabled?: boolean;
+        aiConfig?: Record<string, unknown>;
+        phaseTimers?: IOsceStationPhaseTimer;
+        clinicalData?: IClinicalDataModule[];
+        topicIds?: number[];
+        marks?: IJobStationMarkInput[];
+        examinerQuestions?: IStationExaminerQuestion[];
+        assets?: IAssetBinding[];
+    };
+}
+export declare const updateCacheOnCreateStation: (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<ICreateStationData>, options: ApolloUpdateOptions<ICreateStationVar>) => void;
+export declare const UPDATE_STATION: import("@apollo/client").DocumentNode;
+export type IUpdateStationData = RestrictedData<graphqlNormalize & IOsceStation, 'updateStation'>;
+export interface IUpdateStationVar {
+    input: {
+        id: Id;
+        name?: string;
+        enabled?: number;
+        visibility?: number;
+        osceTypeId?: number;
+        hiddenName?: string;
+        entitlementIds?: number[];
+        difficulty?: number;
+        pictureId?: number;
+        candidateBrief?: string;
+        examinerBrief?: string;
+        actorBrief?: string;
+        llmActorBrief?: string;
+        explanation?: string;
+        aiEnabled?: boolean;
+        aiConfig?: Record<string, unknown>;
+        phaseTimers?: IOsceStationPhaseTimer;
+        clinicalData?: IClinicalDataModule[];
+        topicIds?: number[];
+        marks?: IJobStationMarkInput[];
+        assets?: IAssetBinding[];
+        examinerQuestions?: IStationExaminerQuestion[];
+    };
+}
+export declare const updateCacheOnUpdateStation: (cache: ApolloCache<any>, result: ApolloUpdateResultRestricted<IUpdateStationData>, options: ApolloUpdateOptions<IUpdateStationVar>) => void;
+export interface IGenerateStationSession {
+    sessionId: string;
+}
+export type IGenerateStationData = RestrictedData<graphqlNormalize & IGenerateStationSession, 'generateStation'>;
+export interface IGenerateStationVar {
+    input: {
+        prompt: string;
+        osceTypeId: EOsceType;
+    };
+}
+export declare const GENERATE_STATION: import("@apollo/client").DocumentNode;

package/resolvers/mutation/restricted/station.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATE_STATION = exports.updateCacheOnUpdateStation = exports.UPDATE_STATION = exports.updateCacheOnCreateStation = exports.CREATE_STATION = void 0;
+const client_1 = require("@apollo/client");
+const osce_1 = require("../../fragments/osce");
+const restricted_1 = require("../../query/restricted");
+exports.CREATE_STATION = (0, client_1.gql) `
+  ${osce_1.OSCE_STATION_FIELDS}
+  mutation CreateStation($input: CreateStationInput!) {
+    restricted {
+      createStation(input: $input) {
+        ...OsceStationFields
+      }
+    }
+  }
+`;
+const updateCacheOnCreateStation = (cache, result, options) => {
+    const { createStation } = result?.data?.restricted || {};
+    const { variables } = options || {};
+    if (!createStation || !variables) {
+        return;
+    }
+    const prevData = cache.readQuery({
+        variables: { solo: false },
+        query: restricted_1.OSCE_STATIONS,
+    });
+    if (prevData) {
+        const { osceStations } = prevData.restricted || {};
+        cache.writeQuery({
+            query: restricted_1.OSCE_STATIONS,
+            variables: { solo: false },
+            data: {
+                ...prevData,
+                restricted: {
+                    ...prevData.restricted,
+                    osceStations: [{ ...createStation }, ...osceStations],
+                },
+            },
+        });
+    }
+    else {
+        cache.writeQuery({
+            query: restricted_1.OSCE_STATIONS,
+            variables: { solo: false },
+            data: {
+                restricted: {
+                    __typename: 'RestrictedQuery',
+                    osceStations: [{ ...createStation }],
+                },
+            },
+        });
+    }
+};
+exports.updateCacheOnCreateStation = updateCacheOnCreateStation;
+exports.UPDATE_STATION = (0, client_1.gql) `
+  ${osce_1.OSCE_STATION_FIELDS}
+  mutation UpdateStation($input: UpdateStationInput!) {
+    restricted {
+      updateStation(input: $input) {
+        ...OsceStationFields
+      }
+    }
+  }
+`;
+const updateCacheOnUpdateStation = (cache, result, options) => {
+    const { updateStation } = result?.data?.restricted || {};
+    const { variables } = options || {};
+    if (!updateStation || !variables) {
+        return;
+    }
+    cache.writeFragment({
+        id: cache.identify({
+            id: variables.input.id,
+            __typename: 'OsceStation',
+        }),
+        data: { ...updateStation },
+        fragment: osce_1.OSCE_STATION_FIELDS,
+        fragmentName: 'OsceStationFields',
+    });
+};
+exports.updateCacheOnUpdateStation = updateCacheOnUpdateStation;
+exports.GENERATE_STATION = (0, client_1.gql) `
+  mutation GenerateStation($input: GenerateStationInput!) {
+    restricted {
+      generateStation(input: $input) {
+        sessionId
+      }
+    }
+  }
+`;

package/resolvers/query/restricted/circuit.js

@@ -59,7 +59,8 @@ exports.CIRCUIT_SESSION = (0, client_1.gql) `
         circuit {
           id
           name
-          preDefined
+          visibility
+          typeId
         }
       }
     }
@@ -74,7 +75,8 @@ exports.CIRCUIT_SESSIONS = (0, client_1.gql) `
         circuit {
           id
           name
-          preDefined
+          visibility
+          typeId
         }
       }
     }

package/resolvers/query/restricted/index.d.ts

@@ -15,6 +15,7 @@ export * from './qBank';
 export * from './quesBook';
 export * from './question';
 export * from './replication';
+export * from './station';
 export * from './todos';
 export * from './topics';
 export * from './ukmlaTopics';

package/resolvers/query/restricted/index.js

@@ -31,6 +31,7 @@ __exportStar(require("./qBank"), exports);
 __exportStar(require("./quesBook"), exports);
 __exportStar(require("./question"), exports);
 __exportStar(require("./replication"), exports);
+__exportStar(require("./station"), exports);
 __exportStar(require("./todos"), exports);
 __exportStar(require("./topics"), exports);
 __exportStar(require("./ukmlaTopics"), exports);

package/resolvers/query/restricted/station.d.ts

@@ -0,0 +1,35 @@
+import { EOsceType, IStationExaminerQuestion } from '../../../models';
+import { graphqlNormalize, RestrictedData } from '../../types';
+export declare enum EGenerateStationStatus {
+    PENDING = "PENDING",
+    READY = "READY",
+    FAILED = "FAILED"
+}
+export interface IGeneratedStationMark {
+    header?: string;
+    name?: string;
+    index?: number;
+    weight?: number;
+    excludeFromAi?: boolean;
+}
+export interface IGeneratedStation {
+    name?: string;
+    osceTypeId?: EOsceType;
+    difficulty?: number;
+    candidateBrief?: string;
+    examinerBrief?: string;
+    actorBrief?: string;
+    explanation?: string;
+    examinerQuestions?: IStationExaminerQuestion[];
+    marks?: IGeneratedStationMark[];
+}
+export interface IGenerateStationResult {
+    status: EGenerateStationStatus;
+    station?: IGeneratedStation;
+    error?: string;
+}
+export type IGenerateStationStatusData = RestrictedData<graphqlNormalize & IGenerateStationResult, 'generateStationStatus'>;
+export interface IGenerateStationStatusVar {
+    sessionId: string;
+}
+export declare const GENERATE_STATION_STATUS: import("@apollo/client").DocumentNode;

package/resolvers/query/restricted/station.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GENERATE_STATION_STATUS = exports.EGenerateStationStatus = void 0;
+const client_1 = require("@apollo/client");
+var EGenerateStationStatus;
+(function (EGenerateStationStatus) {
+    EGenerateStationStatus["PENDING"] = "PENDING";
+    EGenerateStationStatus["READY"] = "READY";
+    EGenerateStationStatus["FAILED"] = "FAILED";
+})(EGenerateStationStatus = exports.EGenerateStationStatus || (exports.EGenerateStationStatus = {}));
+exports.GENERATE_STATION_STATUS = (0, client_1.gql) `
+  query GenerateStationStatus($sessionId: String!) {
+    restricted {
+      generateStationStatus(sessionId: $sessionId) {
+        status
+        error
+        station {
+          name
+          osceTypeId
+          difficulty
+          candidateBrief
+          examinerBrief
+          actorBrief
+          explanation
+          examinerQuestions {
+            index
+            question
+          }
+          marks {
+            header
+            name
+            index
+            weight
+            excludeFromAi
+          }
+        }
+      }
+    }
+  }
+`;