graphlit-client 1.0.20250110001 → 1.0.20250121001

package/dist/client.d.ts

@@ -22,8 +22,8 @@ declare class Graphlit {
     createAlert(alert: Types.AlertInput, correlationId?: string): Promise<Types.CreateAlertMutation>;
     updateAlert(alert: Types.AlertUpdateInput): Promise<Types.UpdateAlertMutation>;
     deleteAlert(id: string): Promise<Types.DeleteAlertMutation>;
-    deleteAlerts(): Promise<Types.DeleteAlertsMutation>;
-    deleteAllAlerts(): Promise<Types.DeleteAllAlertsMutation>;
+    deleteAlerts(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteAlertsMutation>;
+    deleteAllAlerts(filter?: Types.AlertFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllAlertsMutation>;
     enableAlert(id: string): Promise<Types.EnableAlertMutation>;
     disableAlert(id: string): Promise<Types.DisableAlertMutation>;
     getAlert(id: string): Promise<Types.GetAlertQuery>;
@@ -31,8 +31,8 @@ declare class Graphlit {
     createCollection(collection: Types.CollectionInput): Promise<Types.CreateCollectionMutation>;
     updateCollection(collection: Types.CollectionUpdateInput): Promise<Types.UpdateCollectionMutation>;
     deleteCollection(id: string): Promise<Types.DeleteCollectionMutation>;
-    deleteCollections(): Promise<Types.DeleteCollectionsMutation>;
-    deleteAllCollections(): Promise<Types.DeleteAllCollectionsMutation>;
+    deleteCollections(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteCollectionsMutation>;
+    deleteAllCollections(filter?: Types.CollectionFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllCollectionsMutation>;
     addContentsToCollections(contents: Types.EntityReferenceInput[], collections: Types.EntityReferenceInput[]): Promise<Types.AddContentsToCollectionsMutation>;
     removeContentsFromCollection(contents: Types.EntityReferenceInput[], collection: Types.EntityReferenceInput): Promise<Types.RemoveContentsFromCollectionMutation>;
     getCollection(id: string): Promise<Types.GetCollectionQuery>;
@@ -47,8 +47,8 @@ declare class Graphlit {
     ingestEncodedFile(name: string, data: string, mimeType: string, id?: string, isSynchronous?: boolean, workflow?: Types.EntityReferenceInput, collections?: [Types.EntityReferenceInput], observations?: [Types.ObservationReferenceInput], correlationId?: string): Promise<Types.IngestEncodedFileMutation>;
     updateContent(content: Types.ContentUpdateInput): Promise<Types.UpdateContentMutation>;
     deleteContent(id: string): Promise<Types.DeleteContentMutation>;
-    deleteContents(): Promise<Types.DeleteContentsMutation>;
-    deleteAllContents(): Promise<Types.DeleteAllContentsMutation>;
+    deleteContents(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteContentsMutation>;
+    deleteAllContents(filter?: Types.ContentFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllContentsMutation>;
     summarizeText(summarization: Types.SummarizationStrategyInput, text: string, textType?: Types.TextTypes, correlationId?: string): Promise<Types.SummarizeTextMutation>;
     summarizeContents(summarizations: [Types.SummarizationStrategyInput], filter?: Types.ContentFilter, correlationId?: string): Promise<Types.SummarizeContentsMutation>;
     extractText(prompt: string, text: string, tools: Types.ToolDefinitionInput[], specification?: Types.EntityReferenceInput, textType?: Types.TextTypes, correlationId?: string): Promise<Types.ExtractTextMutation>;
@@ -63,8 +63,8 @@ declare class Graphlit {
     createConversation(conversation: Types.ConversationInput, correlationId?: string): Promise<Types.CreateConversationMutation>;
     updateConversation(conversation: Types.ConversationUpdateInput): Promise<Types.UpdateConversationMutation>;
     deleteConversation(id: string): Promise<Types.DeleteConversationMutation>;
-    deleteConversations(): Promise<Types.DeleteConversationsMutation>;
-    deleteAllConversations(): Promise<Types.DeleteAllConversationsMutation>;
+    deleteConversations(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteConversationsMutation>;
+    deleteAllConversations(filter?: Types.ConversationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllConversationsMutation>;
     clearConversation(id: string): Promise<Types.ClearConversationMutation>;
     closeConversation(id: string): Promise<Types.CloseConversationMutation>;
     getConversation(id: string): Promise<Types.GetConversationQuery>;
@@ -77,15 +77,15 @@ declare class Graphlit {
     formatConversation(prompt: string, id?: string, specification?: Types.EntityReferenceInput, includeDetails?: boolean, correlationId?: string): Promise<Types.FormatConversationMutation>;
     completeConversation(completion: string, id: string, correlationId?: string): Promise<Types.CompleteConversationMutation>;
     askGraphlit(prompt: string, type?: Types.SdkTypes, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.AskGraphlitMutation>;
-    promptConversation(prompt: string, id?: string, specification?: Types.EntityReferenceInput, tools?: [Types.ToolDefinitionInput], requireTool?: boolean, includeDetails?: boolean, correlationId?: string): Promise<Types.PromptConversationMutation>;
+    promptConversation(prompt: string, id?: string, specification?: Types.EntityReferenceInput, mimeType?: string, data?: string, tools?: [Types.ToolDefinitionInput], requireTool?: boolean, includeDetails?: boolean, correlationId?: string): Promise<Types.PromptConversationMutation>;
     continueConversation(id: string, responses: [Types.ConversationToolResponseInput], correlationId?: string): Promise<Types.ContinueConversationMutation>;
     publishConversation(id: string, connector: Types.ContentPublishingConnectorInput, name?: string, workflow?: Types.EntityReferenceInput, isSynchronous?: boolean, correlationId?: string): Promise<Types.PublishConversationMutation>;
     suggestConversation(id: string, count?: number, correlationId?: string): Promise<Types.SuggestConversationMutation>;
     createFeed(feed: Types.FeedInput, correlationId?: string): Promise<Types.CreateFeedMutation>;
     updateFeed(feed: Types.FeedUpdateInput): Promise<Types.UpdateFeedMutation>;
     deleteFeed(id: string): Promise<Types.DeleteFeedMutation>;
-    deleteFeeds(): Promise<Types.DeleteFeedsMutation>;
-    deleteAllFeeds(): Promise<Types.DeleteAllFeedsMutation>;
+    deleteFeeds(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteFeedsMutation>;
+    deleteAllFeeds(filter?: Types.FeedFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllFeedsMutation>;
     enableFeed(id: string): Promise<Types.EnableFeedMutation>;
     disableFeed(id: string): Promise<Types.DeleteFeedMutation>;
     getFeed(id: string): Promise<Types.GetFeedQuery>;
@@ -95,16 +95,16 @@ declare class Graphlit {
     createSpecification(specification: Types.SpecificationInput): Promise<Types.CreateSpecificationMutation>;
     updateSpecification(specification: Types.SpecificationUpdateInput): Promise<Types.UpdateSpecificationMutation>;
     deleteSpecification(id: string): Promise<Types.DeleteSpecificationMutation>;
-    deleteSpecifications(): Promise<Types.DeleteSpecificationsMutation>;
-    deleteAllSpecifications(): Promise<Types.DeleteAllSpecificationsMutation>;
+    deleteSpecifications(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteSpecificationsMutation>;
+    deleteAllSpecifications(filter?: Types.SpecificationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllSpecificationsMutation>;
     getSpecification(id: string): Promise<Types.GetSpecificationQuery>;
     querySpecifications(filter?: Types.SpecificationFilter): Promise<Types.QuerySpecificationsQuery>;
     queryModels(filter?: Types.ModelFilter): Promise<Types.QueryModelsQuery>;
     createWorkflow(workflow: Types.WorkflowInput): Promise<Types.CreateWorkflowMutation>;
     updateWorkflow(workflow: Types.WorkflowUpdateInput): Promise<Types.UpdateWorkflowMutation>;
     deleteWorkflow(id: string): Promise<Types.DeleteWorkflowMutation>;
-    deleteWorkflows(): Promise<Types.DeleteWorkflowsMutation>;
-    deleteAllWorkflows(): Promise<Types.DeleteAllWorkflowsMutation>;
+    deleteWorkflows(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteWorkflowsMutation>;
+    deleteAllWorkflows(filter?: Types.WorkflowFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllWorkflowsMutation>;
     getWorkflow(id: string): Promise<Types.GetWorkflowQuery>;
     queryWorkflows(filter?: Types.WorkflowFilter): Promise<Types.QueryWorkflowsQuery>;
     createUser(user: Types.UserInput): Promise<Types.CreateUserMutation>;
@@ -117,141 +117,141 @@ declare class Graphlit {
     createCategory(category: Types.CategoryInput): Promise<Types.CreateCategoryMutation>;
     updateCategory(category: Types.CategoryUpdateInput): Promise<Types.UpdateCategoryMutation>;
     deleteCategory(id: string): Promise<Types.DeleteCategoryMutation>;
-    deleteCategories(): Promise<Types.DeleteCategoriesMutation>;
-    deleteAllCategories(): Promise<Types.DeleteAllCategoriesMutation>;
+    deleteCategories(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteCategoriesMutation>;
+    deleteAllCategories(filter?: Types.CategoryFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllCategoriesMutation>;
     getCategory(id: string): Promise<Types.GetCategoryQuery>;
     queryCategories(filter?: Types.CategoryFilter): Promise<Types.QueryCategoriesQuery>;
     createLabel(label: Types.LabelInput): Promise<Types.CreateLabelMutation>;
     updateLabel(label: Types.LabelUpdateInput): Promise<Types.UpdateLabelMutation>;
     deleteLabel(id: string): Promise<Types.DeleteLabelMutation>;
-    deleteLabels(): Promise<Types.DeleteLabelsMutation>;
-    deleteAllLabels(): Promise<Types.DeleteAllLabelsMutation>;
+    deleteLabels(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteLabelsMutation>;
+    deleteAllLabels(filter?: Types.LabelFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllLabelsMutation>;
     getLabel(id: string): Promise<Types.GetLabelQuery>;
     queryLabels(filter?: Types.LabelFilter): Promise<Types.QueryLabelsQuery>;
     createPerson(person: Types.PersonInput): Promise<Types.CreatePersonMutation>;
     updatePerson(person: Types.PersonUpdateInput): Promise<Types.UpdatePersonMutation>;
     deletePerson(id: string): Promise<Types.DeletePersonMutation>;
-    deletePersons(): Promise<Types.DeletePersonsMutation>;
-    deleteAllPersons(): Promise<Types.DeleteAllPersonsMutation>;
+    deletePersons(ids: [string], isSynchronous?: boolean): Promise<Types.DeletePersonsMutation>;
+    deleteAllPersons(filter?: Types.PersonFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllPersonsMutation>;
     getPerson(id: string): Promise<Types.GetPersonQuery>;
     queryPersons(filter?: Types.PersonFilter): Promise<Types.QueryPersonsQuery>;
     createOrganization(organization: Types.OrganizationInput): Promise<Types.CreateOrganizationMutation>;
     updateOrganization(organization: Types.OrganizationUpdateInput): Promise<Types.UpdateOrganizationMutation>;
     deleteOrganization(id: string): Promise<Types.DeleteOrganizationMutation>;
-    deleteOrganizations(): Promise<Types.DeleteOrganizationsMutation>;
-    deleteAllOrganizations(): Promise<Types.DeleteAllOrganizationsMutation>;
+    deleteOrganizations(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteOrganizationsMutation>;
+    deleteAllOrganizations(filter?: Types.OrganizationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllOrganizationsMutation>;
     getOrganization(id: string): Promise<Types.GetOrganizationQuery>;
     queryOrganizations(filter?: Types.OrganizationFilter): Promise<Types.QueryOrganizationsQuery>;
     createPlace(place: Types.PlaceInput): Promise<Types.CreatePlaceMutation>;
     updatePlace(place: Types.PlaceUpdateInput): Promise<Types.UpdatePlaceMutation>;
     deletePlace(id: string): Promise<Types.DeletePlaceMutation>;
-    deletePlaces(): Promise<Types.DeletePlacesMutation>;
-    deleteAllPlaces(): Promise<Types.DeleteAllPlacesMutation>;
+    deletePlaces(ids: [string], isSynchronous?: boolean): Promise<Types.DeletePlacesMutation>;
+    deleteAllPlaces(filter?: Types.PlaceFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllPlacesMutation>;
     getPlace(id: string): Promise<Types.GetPlaceQuery>;
     queryPlaces(filter?: Types.PlaceFilter): Promise<Types.QueryPlacesQuery>;
     createEvent(event: Types.EventInput): Promise<Types.CreateEventMutation>;
     updateEvent(event: Types.EventUpdateInput): Promise<Types.UpdateEventMutation>;
     deleteEvent(id: string): Promise<Types.DeleteEventMutation>;
-    deleteEvents(): Promise<Types.DeleteEventsMutation>;
-    deleteAllEvents(): Promise<Types.DeleteAllEventsMutation>;
+    deleteEvents(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteEventsMutation>;
+    deleteAllEvents(filter?: Types.EventFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllEventsMutation>;
     getEvent(id: string): Promise<Types.GetEventQuery>;
     queryEvents(filter?: Types.EventFilter): Promise<Types.QueryEventsQuery>;
     createProduct(product: Types.ProductInput): Promise<Types.CreateProductMutation>;
     updateProduct(product: Types.ProductUpdateInput): Promise<Types.UpdateProductMutation>;
     deleteProduct(id: string): Promise<Types.DeleteProductMutation>;
-    deleteProducts(): Promise<Types.DeleteProductsMutation>;
-    deleteAllProducts(): Promise<Types.DeleteAllProductsMutation>;
+    deleteProducts(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteProductsMutation>;
+    deleteAllProducts(filter?: Types.ProductFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllProductsMutation>;
     getProduct(id: string): Promise<Types.GetProductQuery>;
     queryProducts(filter?: Types.ProductFilter): Promise<Types.QueryProductsQuery>;
     createRepo(repo: Types.RepoInput): Promise<Types.CreateRepoMutation>;
     updateRepo(repo: Types.RepoUpdateInput): Promise<Types.UpdateRepoMutation>;
     deleteRepo(id: string): Promise<Types.DeleteRepoMutation>;
-    deleteRepos(): Promise<Types.DeleteReposMutation>;
-    deleteAllRepos(): Promise<Types.DeleteAllReposMutation>;
+    deleteRepos(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteReposMutation>;
+    deleteAllRepos(filter?: Types.RepoFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllReposMutation>;
     getRepo(id: string): Promise<Types.GetRepoQuery>;
     queryRepos(filter?: Types.RepoFilter): Promise<Types.QueryReposQuery>;
     createSoftware(software: Types.SoftwareInput): Promise<Types.CreateSoftwareMutation>;
     updateSoftware(software: Types.SoftwareUpdateInput): Promise<Types.UpdateSoftwareMutation>;
     deleteSoftware(id: string): Promise<Types.DeleteSoftwareMutation>;
-    deleteSoftwares(): Promise<Types.DeleteSoftwaresMutation>;
-    deleteAllSoftwares(): Promise<Types.DeleteAllSoftwaresMutation>;
+    deleteSoftwares(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteSoftwaresMutation>;
+    deleteAllSoftwares(filter?: Types.SoftwareFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllSoftwaresMutation>;
     getSoftware(id: string): Promise<Types.GetSoftwareQuery>;
     querySoftwares(filter?: Types.SoftwareFilter): Promise<Types.QuerySoftwaresQuery>;
     createMedicalCondition(MedicalCondition: Types.MedicalConditionInput): Promise<Types.CreateMedicalConditionMutation>;
     updateMedicalCondition(MedicalCondition: Types.MedicalConditionUpdateInput): Promise<Types.UpdateMedicalConditionMutation>;
     deleteMedicalCondition(id: string): Promise<Types.DeleteMedicalConditionMutation>;
-    deleteMedicalConditions(): Promise<Types.DeleteMedicalConditionsMutation>;
-    deleteAllMedicalConditions(): Promise<Types.DeleteAllMedicalConditionsMutation>;
+    deleteMedicalConditions(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalConditionsMutation>;
+    deleteAllMedicalConditions(filter?: Types.MedicalConditionFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalConditionsMutation>;
     getMedicalCondition(id: string): Promise<Types.GetMedicalConditionQuery>;
     queryMedicalConditions(filter?: Types.MedicalConditionFilter): Promise<Types.QueryMedicalConditionsQuery>;
     createMedicalGuideline(MedicalGuideline: Types.MedicalGuidelineInput): Promise<Types.CreateMedicalGuidelineMutation>;
     updateMedicalGuideline(MedicalGuideline: Types.MedicalGuidelineUpdateInput): Promise<Types.UpdateMedicalGuidelineMutation>;
     deleteMedicalGuideline(id: string): Promise<Types.DeleteMedicalGuidelineMutation>;
-    deleteMedicalGuidelines(): Promise<Types.DeleteMedicalGuidelinesMutation>;
-    deleteAllMedicalGuidelines(): Promise<Types.DeleteAllMedicalGuidelinesMutation>;
+    deleteMedicalGuidelines(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalGuidelinesMutation>;
+    deleteAllMedicalGuidelines(filter?: Types.MedicalGuidelineFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalGuidelinesMutation>;
     getMedicalGuideline(id: string): Promise<Types.GetMedicalGuidelineQuery>;
     queryMedicalGuidelines(filter?: Types.MedicalGuidelineFilter): Promise<Types.QueryMedicalGuidelinesQuery>;
     createMedicalDrug(MedicalDrug: Types.MedicalDrugInput): Promise<Types.CreateMedicalDrugMutation>;
     updateMedicalDrug(MedicalDrug: Types.MedicalDrugUpdateInput): Promise<Types.UpdateMedicalDrugMutation>;
     deleteMedicalDrug(id: string): Promise<Types.DeleteMedicalDrugMutation>;
-    deleteMedicalDrugs(): Promise<Types.DeleteMedicalDrugsMutation>;
-    deleteAllMedicalDrugs(): Promise<Types.DeleteAllMedicalDrugsMutation>;
+    deleteMedicalDrugs(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalDrugsMutation>;
+    deleteAllMedicalDrugs(filter?: Types.MedicalDrugFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalDrugsMutation>;
     getMedicalDrug(id: string): Promise<Types.GetMedicalDrugQuery>;
     queryMedicalDrugs(filter?: Types.MedicalDrugFilter): Promise<Types.QueryMedicalDrugsQuery>;
     createMedicalIndication(MedicalIndication: Types.MedicalIndicationInput): Promise<Types.CreateMedicalIndicationMutation>;
     updateMedicalIndication(MedicalIndication: Types.MedicalIndicationUpdateInput): Promise<Types.UpdateMedicalIndicationMutation>;
     deleteMedicalIndication(id: string): Promise<Types.DeleteMedicalIndicationMutation>;
-    deleteMedicalIndications(): Promise<Types.DeleteMedicalIndicationsMutation>;
-    deleteAllMedicalIndications(): Promise<Types.DeleteAllMedicalIndicationsMutation>;
+    deleteMedicalIndications(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalIndicationsMutation>;
+    deleteAllMedicalIndications(filter?: Types.MedicalIndicationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalIndicationsMutation>;
     getMedicalIndication(id: string): Promise<Types.GetMedicalIndicationQuery>;
     queryMedicalIndications(filter?: Types.MedicalIndicationFilter): Promise<Types.QueryMedicalIndicationsQuery>;
     createMedicalContraindication(MedicalContraindication: Types.MedicalContraindicationInput): Promise<Types.CreateMedicalContraindicationMutation>;
     updateMedicalContraindication(MedicalContraindication: Types.MedicalContraindicationUpdateInput): Promise<Types.UpdateMedicalContraindicationMutation>;
     deleteMedicalContraindication(id: string): Promise<Types.DeleteMedicalContraindicationMutation>;
-    deleteMedicalContraindications(): Promise<Types.DeleteMedicalContraindicationsMutation>;
-    deleteAllMedicalContraindications(): Promise<Types.DeleteAllMedicalContraindicationsMutation>;
+    deleteMedicalContraindications(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalContraindicationsMutation>;
+    deleteAllMedicalContraindications(filter?: Types.MedicalContraindicationFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalContraindicationsMutation>;
     getMedicalContraindication(id: string): Promise<Types.GetMedicalContraindicationQuery>;
     queryMedicalContraindications(filter?: Types.MedicalContraindicationFilter): Promise<Types.QueryMedicalContraindicationsQuery>;
     createMedicalTest(MedicalTest: Types.MedicalTestInput): Promise<Types.CreateMedicalTestMutation>;
     updateMedicalTest(MedicalTest: Types.MedicalTestUpdateInput): Promise<Types.UpdateMedicalTestMutation>;
     deleteMedicalTest(id: string): Promise<Types.DeleteMedicalTestMutation>;
-    deleteMedicalTests(): Promise<Types.DeleteMedicalTestsMutation>;
-    deleteAllMedicalTests(): Promise<Types.DeleteAllMedicalTestsMutation>;
+    deleteMedicalTests(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalTestsMutation>;
+    deleteAllMedicalTests(filter?: Types.MedicalTestFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalTestsMutation>;
     getMedicalTest(id: string): Promise<Types.GetMedicalTestQuery>;
     queryMedicalTests(filter?: Types.MedicalTestFilter): Promise<Types.QueryMedicalTestsQuery>;
     createMedicalDevice(MedicalDevice: Types.MedicalDeviceInput): Promise<Types.CreateMedicalDeviceMutation>;
     updateMedicalDevice(MedicalDevice: Types.MedicalDeviceUpdateInput): Promise<Types.UpdateMedicalDeviceMutation>;
     deleteMedicalDevice(id: string): Promise<Types.DeleteMedicalDeviceMutation>;
-    deleteMedicalDevices(): Promise<Types.DeleteMedicalDevicesMutation>;
-    deleteAllMedicalDevices(): Promise<Types.DeleteAllMedicalDevicesMutation>;
+    deleteMedicalDevices(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalDevicesMutation>;
+    deleteAllMedicalDevices(filter?: Types.MedicalDeviceFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalDevicesMutation>;
     getMedicalDevice(id: string): Promise<Types.GetMedicalDeviceQuery>;
     queryMedicalDevices(filter?: Types.MedicalDeviceFilter): Promise<Types.QueryMedicalDevicesQuery>;
     createMedicalProcedure(MedicalProcedure: Types.MedicalProcedureInput): Promise<Types.CreateMedicalProcedureMutation>;
     updateMedicalProcedure(MedicalProcedure: Types.MedicalProcedureUpdateInput): Promise<Types.UpdateMedicalProcedureMutation>;
     deleteMedicalProcedure(id: string): Promise<Types.DeleteMedicalProcedureMutation>;
-    deleteMedicalProcedures(): Promise<Types.DeleteMedicalProceduresMutation>;
-    deleteAllMedicalProcedures(): Promise<Types.DeleteAllMedicalProceduresMutation>;
+    deleteMedicalProcedures(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalProceduresMutation>;
+    deleteAllMedicalProcedures(filter?: Types.MedicalProcedureFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalProceduresMutation>;
     getMedicalProcedure(id: string): Promise<Types.GetMedicalProcedureQuery>;
     queryMedicalProcedures(filter?: Types.MedicalProcedureFilter): Promise<Types.QueryMedicalProceduresQuery>;
     createMedicalStudy(MedicalStudy: Types.MedicalStudyInput): Promise<Types.CreateMedicalStudyMutation>;
     updateMedicalStudy(MedicalStudy: Types.MedicalStudyUpdateInput): Promise<Types.UpdateMedicalStudyMutation>;
     deleteMedicalStudy(id: string): Promise<Types.DeleteMedicalStudyMutation>;
-    deleteMedicalStudies(): Promise<Types.DeleteMedicalStudiesMutation>;
-    deleteAllMedicalStudies(): Promise<Types.DeleteAllMedicalStudiesMutation>;
+    deleteMedicalStudies(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalStudiesMutation>;
+    deleteAllMedicalStudies(filter?: Types.MedicalStudyFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalStudiesMutation>;
     getMedicalStudy(id: string): Promise<Types.GetMedicalStudyQuery>;
     queryMedicalStudies(filter?: Types.MedicalStudyFilter): Promise<Types.QueryMedicalStudiesQuery>;
     createMedicalDrugClass(MedicalDrugClass: Types.MedicalDrugClassInput): Promise<Types.CreateMedicalDrugClassMutation>;
     updateMedicalDrugClass(MedicalDrugClass: Types.MedicalDrugClassUpdateInput): Promise<Types.UpdateMedicalDrugClassMutation>;
     deleteMedicalDrugClass(id: string): Promise<Types.DeleteMedicalDrugClassMutation>;
-    deleteMedicalDrugClasses(): Promise<Types.DeleteMedicalDrugClassesMutation>;
-    deleteAllMedicalDrugClasses(): Promise<Types.DeleteAllMedicalDrugClassesMutation>;
+    deleteMedicalDrugClasses(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalDrugClassesMutation>;
+    deleteAllMedicalDrugClasses(filter?: Types.MedicalDrugClassFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalDrugClassesMutation>;
     getMedicalDrugClass(id: string): Promise<Types.GetMedicalDrugClassQuery>;
     queryMedicalDrugClasses(filter?: Types.MedicalDrugClassFilter): Promise<Types.QueryMedicalDrugClassesQuery>;
     createMedicalTherapy(MedicalTherapy: Types.MedicalTherapyInput): Promise<Types.CreateMedicalTherapyMutation>;
     updateMedicalTherapy(MedicalTherapy: Types.MedicalTherapyUpdateInput): Promise<Types.UpdateMedicalTherapyMutation>;
     deleteMedicalTherapy(id: string): Promise<Types.DeleteMedicalTherapyMutation>;
-    deleteMedicalTherapies(): Promise<Types.DeleteMedicalTherapiesMutation>;
-    deleteAllMedicalTherapies(): Promise<Types.DeleteAllMedicalTherapiesMutation>;
+    deleteMedicalTherapies(ids: [string], isSynchronous?: boolean): Promise<Types.DeleteMedicalTherapiesMutation>;
+    deleteAllMedicalTherapies(filter?: Types.MedicalTherapyFilter, isSynchronous?: boolean, correlationId?: string): Promise<Types.DeleteAllMedicalTherapiesMutation>;
     getMedicalTherapy(id: string): Promise<Types.GetMedicalTherapyQuery>;
     queryMedicalTherapies(filter?: Types.MedicalTherapyFilter): Promise<Types.QueryMedicalTherapiesQuery>;
     createObservation(observation: Types.ObservationInput): Promise<Types.CreateObservationMutation>;

package/dist/client.js

@@ -168,14 +168,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteAlert, { id: id });
         });
     }
-    deleteAlerts() {
+    deleteAlerts(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAlerts);
+            return this.mutateAndCheckError(Documents.DeleteAlerts, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllAlerts() {
+    deleteAllAlerts(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllAlerts);
+            return this.mutateAndCheckError(Documents.DeleteAllAlerts, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     enableAlert(id) {
@@ -213,14 +213,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteCollection, { id: id });
         });
     }
-    deleteCollections() {
+    deleteCollections(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteCollections);
+            return this.mutateAndCheckError(Documents.DeleteCollections, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllCollections() {
+    deleteAllCollections(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllCollections);
+            return this.mutateAndCheckError(Documents.DeleteAllCollections, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     addContentsToCollections(contents, collections) {
@@ -293,14 +293,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteContent, { id: id });
         });
     }
-    deleteContents() {
+    deleteContents(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteContents);
+            return this.mutateAndCheckError(Documents.DeleteContents, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllContents() {
+    deleteAllContents(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllContents);
+            return this.mutateAndCheckError(Documents.DeleteAllContents, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     summarizeText(summarization, text, textType, correlationId) {
@@ -373,14 +373,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteConversation, { id: id });
         });
     }
-    deleteConversations() {
+    deleteConversations(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteConversations);
+            return this.mutateAndCheckError(Documents.DeleteConversations, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllConversations() {
+    deleteAllConversations(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllConversations);
+            return this.mutateAndCheckError(Documents.DeleteAllConversations, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     clearConversation(id) {
@@ -443,9 +443,9 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.AskGraphlit, { prompt: prompt, type: type, id: id, specification: specification, correlationId: correlationId });
         });
     }
-    promptConversation(prompt, id, specification, tools, requireTool, includeDetails, correlationId) {
+    promptConversation(prompt, id, specification, mimeType, data, tools, requireTool, includeDetails, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.PromptConversation, { prompt: prompt, id: id, specification: specification, tools: tools, requireTool: requireTool, includeDetails: includeDetails, correlationId: correlationId });
+            return this.mutateAndCheckError(Documents.PromptConversation, { prompt: prompt, id: id, specification: specification, mimeType: mimeType, data: data, tools: tools, requireTool: requireTool, includeDetails: includeDetails, correlationId: correlationId });
         });
     }
     continueConversation(id, responses, correlationId) {
@@ -478,14 +478,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteFeed, { id: id });
         });
     }
-    deleteFeeds() {
+    deleteFeeds(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteFeeds);
+            return this.mutateAndCheckError(Documents.DeleteFeeds, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllFeeds() {
+    deleteAllFeeds(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllFeeds);
+            return this.mutateAndCheckError(Documents.DeleteAllFeeds, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     enableFeed(id) {
@@ -533,14 +533,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteSpecification, { id: id });
         });
     }
-    deleteSpecifications() {
+    deleteSpecifications(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteSpecifications);
+            return this.mutateAndCheckError(Documents.DeleteSpecifications, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllSpecifications() {
+    deleteAllSpecifications(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllSpecifications);
+            return this.mutateAndCheckError(Documents.DeleteAllSpecifications, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getSpecification(id) {
@@ -573,14 +573,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteWorkflow, { id: id });
         });
     }
-    deleteWorkflows() {
+    deleteWorkflows(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteWorkflows);
+            return this.mutateAndCheckError(Documents.DeleteWorkflows, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllWorkflows() {
+    deleteAllWorkflows(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllWorkflows);
+            return this.mutateAndCheckError(Documents.DeleteAllWorkflows, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getWorkflow(id) {
@@ -643,14 +643,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteCategory, { id: id });
         });
     }
-    deleteCategories() {
+    deleteCategories(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteCategories);
+            return this.mutateAndCheckError(Documents.DeleteCategories, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllCategories() {
+    deleteAllCategories(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllCategories);
+            return this.mutateAndCheckError(Documents.DeleteAllCategories, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getCategory(id) {
@@ -678,14 +678,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteLabel, { id: id });
         });
     }
-    deleteLabels() {
+    deleteLabels(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteLabels);
+            return this.mutateAndCheckError(Documents.DeleteLabels, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllLabels() {
+    deleteAllLabels(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllLabels);
+            return this.mutateAndCheckError(Documents.DeleteAllLabels, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getLabel(id) {
@@ -713,14 +713,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeletePerson, { id: id });
         });
     }
-    deletePersons() {
+    deletePersons(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeletePersons);
+            return this.mutateAndCheckError(Documents.DeletePersons, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllPersons() {
+    deleteAllPersons(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllPersons);
+            return this.mutateAndCheckError(Documents.DeleteAllPersons, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getPerson(id) {
@@ -748,14 +748,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteOrganization, { id: id });
         });
     }
-    deleteOrganizations() {
+    deleteOrganizations(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteOrganizations);
+            return this.mutateAndCheckError(Documents.DeleteOrganizations, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllOrganizations() {
+    deleteAllOrganizations(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllOrganizations);
+            return this.mutateAndCheckError(Documents.DeleteAllOrganizations, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getOrganization(id) {
@@ -783,14 +783,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeletePlace, { id: id });
         });
     }
-    deletePlaces() {
+    deletePlaces(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeletePlaces);
+            return this.mutateAndCheckError(Documents.DeletePlaces, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllPlaces() {
+    deleteAllPlaces(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllPlaces);
+            return this.mutateAndCheckError(Documents.DeleteAllPlaces, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getPlace(id) {
@@ -818,14 +818,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteEvent, { id: id });
         });
     }
-    deleteEvents() {
+    deleteEvents(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteEvents);
+            return this.mutateAndCheckError(Documents.DeleteEvents, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllEvents() {
+    deleteAllEvents(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllEvents);
+            return this.mutateAndCheckError(Documents.DeleteAllEvents, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getEvent(id) {
@@ -853,14 +853,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteProduct, { id: id });
         });
     }
-    deleteProducts() {
+    deleteProducts(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteProducts);
+            return this.mutateAndCheckError(Documents.DeleteProducts, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllProducts() {
+    deleteAllProducts(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllProducts);
+            return this.mutateAndCheckError(Documents.DeleteAllProducts, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getProduct(id) {
@@ -888,14 +888,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteRepo, { id: id });
         });
     }
-    deleteRepos() {
+    deleteRepos(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteRepos);
+            return this.mutateAndCheckError(Documents.DeleteRepos, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllRepos() {
+    deleteAllRepos(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllRepos);
+            return this.mutateAndCheckError(Documents.DeleteAllRepos, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getRepo(id) {
@@ -923,14 +923,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteSoftware, { id: id });
         });
     }
-    deleteSoftwares() {
+    deleteSoftwares(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteSoftwares);
+            return this.mutateAndCheckError(Documents.DeleteSoftwares, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllSoftwares() {
+    deleteAllSoftwares(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllSoftwares);
+            return this.mutateAndCheckError(Documents.DeleteAllSoftwares, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getSoftware(id) {
@@ -958,14 +958,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalCondition, { id: id });
         });
     }
-    deleteMedicalConditions() {
+    deleteMedicalConditions(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalConditions);
+            return this.mutateAndCheckError(Documents.DeleteMedicalConditions, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalConditions() {
+    deleteAllMedicalConditions(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalConditions);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalConditions, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalCondition(id) {
@@ -993,14 +993,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalGuideline, { id: id });
         });
     }
-    deleteMedicalGuidelines() {
+    deleteMedicalGuidelines(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalGuidelines);
+            return this.mutateAndCheckError(Documents.DeleteMedicalGuidelines, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalGuidelines() {
+    deleteAllMedicalGuidelines(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalGuidelines);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalGuidelines, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalGuideline(id) {
@@ -1028,14 +1028,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalDrug, { id: id });
         });
     }
-    deleteMedicalDrugs() {
+    deleteMedicalDrugs(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalDrugs);
+            return this.mutateAndCheckError(Documents.DeleteMedicalDrugs, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalDrugs() {
+    deleteAllMedicalDrugs(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugs);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugs, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalDrug(id) {
@@ -1063,14 +1063,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalIndication, { id: id });
         });
     }
-    deleteMedicalIndications() {
+    deleteMedicalIndications(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalIndications);
+            return this.mutateAndCheckError(Documents.DeleteMedicalIndications, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalIndications() {
+    deleteAllMedicalIndications(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalIndications);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalIndications, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalIndication(id) {
@@ -1098,14 +1098,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalContraindication, { id: id });
         });
     }
-    deleteMedicalContraindications() {
+    deleteMedicalContraindications(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalContraindications);
+            return this.mutateAndCheckError(Documents.DeleteMedicalContraindications, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalContraindications() {
+    deleteAllMedicalContraindications(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalContraindications);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalContraindications, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalContraindication(id) {
@@ -1133,14 +1133,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalTest, { id: id });
         });
     }
-    deleteMedicalTests() {
+    deleteMedicalTests(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalTests);
+            return this.mutateAndCheckError(Documents.DeleteMedicalTests, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalTests() {
+    deleteAllMedicalTests(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalTests);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalTests, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalTest(id) {
@@ -1168,14 +1168,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalDevice, { id: id });
         });
     }
-    deleteMedicalDevices() {
+    deleteMedicalDevices(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalDevices);
+            return this.mutateAndCheckError(Documents.DeleteMedicalDevices, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalDevices() {
+    deleteAllMedicalDevices(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalDevices);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalDevices, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalDevice(id) {
@@ -1203,14 +1203,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalProcedure, { id: id });
         });
     }
-    deleteMedicalProcedures() {
+    deleteMedicalProcedures(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalProcedures);
+            return this.mutateAndCheckError(Documents.DeleteMedicalProcedures, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalProcedures() {
+    deleteAllMedicalProcedures(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalProcedures);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalProcedures, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalProcedure(id) {
@@ -1238,14 +1238,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalStudy, { id: id });
         });
     }
-    deleteMedicalStudies() {
+    deleteMedicalStudies(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalStudies);
+            return this.mutateAndCheckError(Documents.DeleteMedicalStudies, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalStudies() {
+    deleteAllMedicalStudies(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalStudies);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalStudies, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalStudy(id) {
@@ -1273,14 +1273,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalDrugClass, { id: id });
         });
     }
-    deleteMedicalDrugClasses() {
+    deleteMedicalDrugClasses(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalDrugClasses);
+            return this.mutateAndCheckError(Documents.DeleteMedicalDrugClasses, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalDrugClasses() {
+    deleteAllMedicalDrugClasses(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugClasses);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalDrugClasses, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalDrugClass(id) {
@@ -1308,14 +1308,14 @@ class Graphlit {
             return this.mutateAndCheckError(Documents.DeleteMedicalTherapy, { id: id });
         });
     }
-    deleteMedicalTherapies() {
+    deleteMedicalTherapies(ids, isSynchronous) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteMedicalTherapies);
+            return this.mutateAndCheckError(Documents.DeleteMedicalTherapies, { ids: ids, isSynchronous: isSynchronous });
         });
     }
-    deleteAllMedicalTherapies() {
+    deleteAllMedicalTherapies(filter, isSynchronous, correlationId) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.mutateAndCheckError(Documents.DeleteAllMedicalTherapies);
+            return this.mutateAndCheckError(Documents.DeleteAllMedicalTherapies, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
         });
     }
     getMedicalTherapy(id) {

package/dist/generated/graphql-documents.js

@@ -111,6 +111,9 @@ exports.GetAlert = (0, graphql_tag_1.default) `
       collections {
         id
       }
+      users {
+        id
+      }
       observations {
         type
         observable {
@@ -128,6 +131,9 @@ exports.GetAlert = (0, graphql_tag_1.default) `
         collections {
           id
         }
+        users {
+          id
+        }
         observations {
           type
           observable {
@@ -146,6 +152,9 @@ exports.GetAlert = (0, graphql_tag_1.default) `
         collections {
           id
         }
+        users {
+          id
+        }
         observations {
           type
           observable {
@@ -221,6 +230,9 @@ exports.QueryAlerts = (0, graphql_tag_1.default) `
         collections {
           id
         }
+        users {
+          id
+        }
         observations {
           type
           observable {
@@ -238,6 +250,9 @@ exports.QueryAlerts = (0, graphql_tag_1.default) `
           collections {
             id
           }
+          users {
+            id
+          }
           observations {
             type
             observable {
@@ -256,6 +271,9 @@ exports.QueryAlerts = (0, graphql_tag_1.default) `
           collections {
             id
           }
+          users {
+            id
+          }
           observations {
             type
             observable {
@@ -3600,6 +3618,9 @@ exports.GetConversation = (0, graphql_tag_1.default) `
       collections {
         id
       }
+      users {
+        id
+      }
       observations {
         type
         observable {
@@ -3617,6 +3638,9 @@ exports.GetConversation = (0, graphql_tag_1.default) `
         collections {
           id
         }
+        users {
+          id
+        }
         observations {
           type
           observable {
@@ -3635,6 +3659,9 @@ exports.GetConversation = (0, graphql_tag_1.default) `
         collections {
           id
         }
+        users {
+          id
+        }
         observations {
           type
           observable {
@@ -3669,6 +3696,9 @@ exports.GetConversation = (0, graphql_tag_1.default) `
       collections {
         id
       }
+      users {
+        id
+      }
       observations {
         type
         observable {
@@ -3686,6 +3716,9 @@ exports.GetConversation = (0, graphql_tag_1.default) `
         collections {
           id
         }
+        users {
+          id
+        }
         observations {
           type
           observable {
@@ -3704,6 +3737,9 @@ exports.GetConversation = (0, graphql_tag_1.default) `
         collections {
           id
         }
+        users {
+          id
+        }
         observations {
           type
           observable {
@@ -4451,6 +4487,9 @@ exports.QueryConversations = (0, graphql_tag_1.default) `
         collections {
           id
         }
+        users {
+          id
+        }
         observations {
           type
           observable {
@@ -4468,6 +4507,9 @@ exports.QueryConversations = (0, graphql_tag_1.default) `
           collections {
             id
           }
+          users {
+            id
+          }
           observations {
             type
             observable {
@@ -4486,6 +4528,9 @@ exports.QueryConversations = (0, graphql_tag_1.default) `
           collections {
             id
           }
+          users {
+            id
+          }
           observations {
             type
             observable {
@@ -4520,6 +4565,9 @@ exports.QueryConversations = (0, graphql_tag_1.default) `
         collections {
           id
         }
+        users {
+          id
+        }
         observations {
           type
           observable {
@@ -4537,6 +4585,9 @@ exports.QueryConversations = (0, graphql_tag_1.default) `
           collections {
             id
           }
+          users {
+            id
+          }
           observations {
             type
             observable {
@@ -4555,6 +4606,9 @@ exports.QueryConversations = (0, graphql_tag_1.default) `
           collections {
             id
           }
+          users {
+            id
+          }
           observations {
             type
             observable {

package/dist/generated/graphql-types.d.ts

@@ -673,6 +673,8 @@ export declare enum AzureDocumentIntelligenceModels {
     UsMortgageDisclosure = "US_MORTGAGE_DISCLOSURE",
     /** Pay Stub (US) */
     UsPayStub = "US_PAY_STUB",
+    /** Unified Tax Form (US) */
+    UsTaxForm = "US_TAX_FORM",
     /** 1098 Form (US) */
     UsTaxForm1098 = "US_TAX_FORM1098",
     /** 1098E Form (US) */
@@ -693,7 +695,9 @@ export declare enum AzureDocumentIntelligenceVersions {
      */
     V2024_02_29Preview = "V2024_02_29_PREVIEW",
     /** 2024-07-31 Preview API */
-    V2024_07_31Preview = "V2024_07_31_PREVIEW"
+    V2024_07_31Preview = "V2024_07_31_PREVIEW",
+    /** 2024-11-30 GA API */
+    V2024_11_30 = "V2024_11_30"
 }
 /** Represents the Azure Document Intelligence preparation properties. */
 export type AzureDocumentPreparationProperties = {
@@ -1516,6 +1520,8 @@ export type ContentCriteria = {
     or?: Maybe<Array<ContentCriteriaLevel>>;
     /** Filter by content types. */
     types?: Maybe<Array<ContentTypes>>;
+    /** Filter by users. Only applies to project scope. */
+    users?: Maybe<Array<EntityReference>>;
     /** Filter by workflows. */
     workflows?: Maybe<Array<EntityReference>>;
 };
@@ -1557,6 +1563,8 @@ export type ContentCriteriaLevel = {
     feeds?: Maybe<Array<EntityReference>>;
     /** Filter by observations. */
     observations?: Maybe<Array<ObservationCriteria>>;
+    /** Filter by users. Only applies to project scope. */
+    users?: Maybe<Array<EntityReference>>;
     /** Filter by workflows. */
     workflows?: Maybe<Array<EntityReference>>;
 };
@@ -1725,6 +1733,8 @@ export type ContentFilter = {
     types?: InputMaybe<Array<ContentTypes>>;
     /** The content URI. */
     uri?: InputMaybe<Scalars['URL']['input']>;
+    /** Filter by users. Only applies to project scope. */
+    users?: InputMaybe<Array<EntityReferenceFilter>>;
     /** Filter by workflows. */
     workflows?: InputMaybe<Array<EntityReferenceFilter>>;
 };
@@ -1736,6 +1746,8 @@ export type ContentFilterLevel = {
     feeds?: InputMaybe<Array<EntityReferenceFilter>>;
     /** Filter by observations. */
     observations?: InputMaybe<Array<ObservationReferenceFilter>>;
+    /** Filter by users. Only applies to project scope. */
+    users?: InputMaybe<Array<EntityReferenceFilter>>;
     /** Filter by workflows. */
     workflows?: InputMaybe<Array<EntityReferenceFilter>>;
 };
@@ -2370,10 +2382,15 @@ export type DeepseekModelPropertiesUpdateInput = {
 export declare enum DeepseekModels {
     /** Deepseek Chat */
     Chat = "CHAT",
-    /** Deepseek Coder */
+    /**
+     * Deepseek Coder
+     * @deprecated Deepseek Coder has been merged with Deepseek Chat, as of v2.5. Use Deepseek Chat instead.
+     */
     Coder = "CODER",
     /** Developer-specified model */
-    Custom = "CUSTOM"
+    Custom = "CUSTOM",
+    /** Deepseek Reasoner */
+    Reasoner = "REASONER"
 }
 /** Capture device type */
 export declare enum DeviceTypes {
@@ -8109,8 +8126,10 @@ export type MutationPromptArgs = {
 };
 export type MutationPromptConversationArgs = {
     correlationId?: InputMaybe<Scalars['String']['input']>;
+    data?: InputMaybe<Scalars['String']['input']>;
     id?: InputMaybe<Scalars['ID']['input']>;
     includeDetails?: InputMaybe<Scalars['Boolean']['input']>;
+    mimeType?: InputMaybe<Scalars['String']['input']>;
     prompt: Scalars['String']['input'];
     requireTool?: InputMaybe<Scalars['Boolean']['input']>;
     specification?: InputMaybe<EntityReferenceInput>;
@@ -12943,6 +12962,10 @@ export type GetAlertQuery = {
                 __typename?: 'EntityReference';
                 id: string;
             }> | null;
+            users?: Array<{
+                __typename?: 'EntityReference';
+                id: string;
+            }> | null;
             observations?: Array<{
                 __typename?: 'ObservationCriteria';
                 type: ObservableTypes;
@@ -12966,6 +12989,10 @@ export type GetAlertQuery = {
                     __typename?: 'EntityReference';
                     id: string;
                 }> | null;
+                users?: Array<{
+                    __typename?: 'EntityReference';
+                    id: string;
+                }> | null;
                 observations?: Array<{
                     __typename?: 'ObservationCriteria';
                     type: ObservableTypes;
@@ -12990,6 +13017,10 @@ export type GetAlertQuery = {
                     __typename?: 'EntityReference';
                     id: string;
                 }> | null;
+                users?: Array<{
+                    __typename?: 'EntityReference';
+                    id: string;
+                }> | null;
                 observations?: Array<{
                     __typename?: 'ObservationCriteria';
                     type: ObservableTypes;
@@ -13085,6 +13116,10 @@ export type QueryAlertsQuery = {
                     __typename?: 'EntityReference';
                     id: string;
                 }> | null;
+                users?: Array<{
+                    __typename?: 'EntityReference';
+                    id: string;
+                }> | null;
                 observations?: Array<{
                     __typename?: 'ObservationCriteria';
                     type: ObservableTypes;
@@ -13108,6 +13143,10 @@ export type QueryAlertsQuery = {
                         __typename?: 'EntityReference';
                         id: string;
                     }> | null;
+                    users?: Array<{
+                        __typename?: 'EntityReference';
+                        id: string;
+                    }> | null;
                     observations?: Array<{
                         __typename?: 'ObservationCriteria';
                         type: ObservableTypes;
@@ -13132,6 +13171,10 @@ export type QueryAlertsQuery = {
                         __typename?: 'EntityReference';
                         id: string;
                     }> | null;
+                    users?: Array<{
+                        __typename?: 'EntityReference';
+                        id: string;
+                    }> | null;
                     observations?: Array<{
                         __typename?: 'ObservationCriteria';
                         type: ObservableTypes;
@@ -16899,6 +16942,10 @@ export type GetConversationQuery = {
                 __typename?: 'EntityReference';
                 id: string;
             }> | null;
+            users?: Array<{
+                __typename?: 'EntityReference';
+                id: string;
+            }> | null;
             observations?: Array<{
                 __typename?: 'ObservationCriteria';
                 type: ObservableTypes;
@@ -16922,6 +16969,10 @@ export type GetConversationQuery = {
                     __typename?: 'EntityReference';
                     id: string;
                 }> | null;
+                users?: Array<{
+                    __typename?: 'EntityReference';
+                    id: string;
+                }> | null;
                 observations?: Array<{
                     __typename?: 'ObservationCriteria';
                     type: ObservableTypes;
@@ -16946,6 +16997,10 @@ export type GetConversationQuery = {
                     __typename?: 'EntityReference';
                     id: string;
                 }> | null;
+                users?: Array<{
+                    __typename?: 'EntityReference';
+                    id: string;
+                }> | null;
                 observations?: Array<{
                     __typename?: 'ObservationCriteria';
                     type: ObservableTypes;
@@ -16989,6 +17044,10 @@ export type GetConversationQuery = {
                 __typename?: 'EntityReference';
                 id: string;
             }> | null;
+            users?: Array<{
+                __typename?: 'EntityReference';
+                id: string;
+            }> | null;
             observations?: Array<{
                 __typename?: 'ObservationCriteria';
                 type: ObservableTypes;
@@ -17012,6 +17071,10 @@ export type GetConversationQuery = {
                     __typename?: 'EntityReference';
                     id: string;
                 }> | null;
+                users?: Array<{
+                    __typename?: 'EntityReference';
+                    id: string;
+                }> | null;
                 observations?: Array<{
                     __typename?: 'ObservationCriteria';
                     type: ObservableTypes;
@@ -17036,6 +17099,10 @@ export type GetConversationQuery = {
                     __typename?: 'EntityReference';
                     id: string;
                 }> | null;
+                users?: Array<{
+                    __typename?: 'EntityReference';
+                    id: string;
+                }> | null;
                 observations?: Array<{
                     __typename?: 'ObservationCriteria';
                     type: ObservableTypes;
@@ -17848,6 +17915,10 @@ export type QueryConversationsQuery = {
                     __typename?: 'EntityReference';
                     id: string;
                 }> | null;
+                users?: Array<{
+                    __typename?: 'EntityReference';
+                    id: string;
+                }> | null;
                 observations?: Array<{
                     __typename?: 'ObservationCriteria';
                     type: ObservableTypes;
@@ -17871,6 +17942,10 @@ export type QueryConversationsQuery = {
                         __typename?: 'EntityReference';
                         id: string;
                     }> | null;
+                    users?: Array<{
+                        __typename?: 'EntityReference';
+                        id: string;
+                    }> | null;
                     observations?: Array<{
                         __typename?: 'ObservationCriteria';
                         type: ObservableTypes;
@@ -17895,6 +17970,10 @@ export type QueryConversationsQuery = {
                         __typename?: 'EntityReference';
                         id: string;
                     }> | null;
+                    users?: Array<{
+                        __typename?: 'EntityReference';
+                        id: string;
+                    }> | null;
                     observations?: Array<{
                         __typename?: 'ObservationCriteria';
                         type: ObservableTypes;
@@ -17938,6 +18017,10 @@ export type QueryConversationsQuery = {
                     __typename?: 'EntityReference';
                     id: string;
                 }> | null;
+                users?: Array<{
+                    __typename?: 'EntityReference';
+                    id: string;
+                }> | null;
                 observations?: Array<{
                     __typename?: 'ObservationCriteria';
                     type: ObservableTypes;
@@ -17961,6 +18044,10 @@ export type QueryConversationsQuery = {
                         __typename?: 'EntityReference';
                         id: string;
                     }> | null;
+                    users?: Array<{
+                        __typename?: 'EntityReference';
+                        id: string;
+                    }> | null;
                     observations?: Array<{
                         __typename?: 'ObservationCriteria';
                         type: ObservableTypes;
@@ -17985,6 +18072,10 @@ export type QueryConversationsQuery = {
                         __typename?: 'EntityReference';
                         id: string;
                     }> | null;
+                    users?: Array<{
+                        __typename?: 'EntityReference';
+                        id: string;
+                    }> | null;
                     observations?: Array<{
                         __typename?: 'ObservationCriteria';
                         type: ObservableTypes;

package/dist/generated/graphql-types.js

@@ -99,6 +99,8 @@ var AzureDocumentIntelligenceModels;
     AzureDocumentIntelligenceModels["UsMortgageDisclosure"] = "US_MORTGAGE_DISCLOSURE";
     /** Pay Stub (US) */
     AzureDocumentIntelligenceModels["UsPayStub"] = "US_PAY_STUB";
+    /** Unified Tax Form (US) */
+    AzureDocumentIntelligenceModels["UsTaxForm"] = "US_TAX_FORM";
     /** 1098 Form (US) */
     AzureDocumentIntelligenceModels["UsTaxForm1098"] = "US_TAX_FORM1098";
     /** 1098E Form (US) */
@@ -121,6 +123,8 @@ var AzureDocumentIntelligenceVersions;
     AzureDocumentIntelligenceVersions["V2024_02_29Preview"] = "V2024_02_29_PREVIEW";
     /** 2024-07-31 Preview API */
     AzureDocumentIntelligenceVersions["V2024_07_31Preview"] = "V2024_07_31_PREVIEW";
+    /** 2024-11-30 GA API */
+    AzureDocumentIntelligenceVersions["V2024_11_30"] = "V2024_11_30";
 })(AzureDocumentIntelligenceVersions || (exports.AzureDocumentIntelligenceVersions = AzureDocumentIntelligenceVersions = {}));
 /** Azure OpenAI model type */
 var AzureOpenAiModels;
@@ -380,10 +384,15 @@ var DeepseekModels;
 (function (DeepseekModels) {
     /** Deepseek Chat */
     DeepseekModels["Chat"] = "CHAT";
-    /** Deepseek Coder */
+    /**
+     * Deepseek Coder
+     * @deprecated Deepseek Coder has been merged with Deepseek Chat, as of v2.5. Use Deepseek Chat instead.
+     */
     DeepseekModels["Coder"] = "CODER";
     /** Developer-specified model */
     DeepseekModels["Custom"] = "CUSTOM";
+    /** Deepseek Reasoner */
+    DeepseekModels["Reasoner"] = "REASONER";
 })(DeepseekModels || (exports.DeepseekModels = DeepseekModels = {}));
 /** Capture device type */
 var DeviceTypes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20250110001",
+  "version": "1.0.20250121001",
   "description": "Graphlit API TypeScript Client",
   "main": "dist/client.js",
   "types": "dist/client.d.ts",