import { ApolloClient } from "@apollo/client/core/index.js";
import type { NormalizedCacheObject } from "@apollo/client/core/index.js";
import * as Types from "./generated/graphql-types.js";
import { AgentOptions, AgentResult, StreamAgentOptions, ToolHandler } from "./types/agent.js";
import { AgentStreamEvent } from "./types/ui-events.js";
export type { AgentOptions, AgentResult, StreamAgentOptions, ToolCallResult, UsageInfo, AgentError, } from "./types/agent.js";
export type { AgentStreamEvent } from "./types/ui-events.js";
export interface RetryConfig {
    /** Maximum number of retry attempts (default: 5) */
    maxAttempts?: number;
    /** Initial delay in milliseconds (default: 300) */
    initialDelay?: number;
    /** Maximum delay in milliseconds (default: 30000) */
    maxDelay?: number;
    /** HTTP status codes that should trigger a retry (default: [429, 502, 503, 504]) */
    retryableStatusCodes?: number[];
    /** Whether to use jitter in delay calculation (default: true) */
    jitter?: boolean;
    /** Callback when a retry is attempted */
    onRetry?: (attempt: number, error: any, operation: any) => void;
}
export interface GraphlitClientOptions {
    organizationId?: string;
    environmentId?: string;
    jwtSecret?: string;
    ownerId?: string;
    userId?: string;
    apiUri?: string;
    /** Retry configuration for network errors */
    retryConfig?: RetryConfig;
}
declare class Graphlit {
    client: ApolloClient<NormalizedCacheObject> | undefined;
    token: string | undefined;
    private apiUri;
    private organizationId;
    private environmentId;
    private ownerId;
    private userId;
    private jwtSecret;
    private retryConfig;
    private openaiClient?;
    private anthropicClient?;
    private googleClient?;
    private groqClient?;
    private cerebrasClient?;
    private cohereClient?;
    private mistralClient?;
    private bedrockClient?;
    private deepseekClient?;
    constructor(organizationIdOrOptions?: string | GraphlitClientOptions, environmentId?: string, jwtSecret?: string, ownerId?: string, userId?: string, apiUri?: string);
    refreshClient(): void;
    /**
     * Set a custom OpenAI client instance for streaming
     * @param client - OpenAI client instance (e.g., new OpenAI({ apiKey: "..." }))
     */
    setOpenAIClient(client: any): void;
    /**
     * Set a custom Anthropic client instance for streaming
     * @param client - Anthropic client instance (e.g., new Anthropic({ apiKey: "..." }))
     */
    setAnthropicClient(client: any): void;
    /**
     * Set a custom Google Generative AI client instance for streaming
     * @param client - Google GenerativeAI client instance (e.g., new GoogleGenerativeAI(apiKey))
     */
    setGoogleClient(client: any): void;
    /**
     * Set a custom Groq client instance for streaming
     * @param client - Groq client instance (e.g., new Groq({ apiKey: "..." }))
     */
    setGroqClient(client: any): void;
    /**
     * Set a custom Cerebras client instance for streaming (OpenAI-compatible)
     * @param client - OpenAI client instance configured for Cerebras (e.g., new OpenAI({ apiKey: "...", baseURL: "https://api.cerebras.ai/v1" }))
     */
    setCerebrasClient(client: any): void;
    /**
     * Set a custom Cohere client instance for streaming
     * @param client - Cohere client instance (e.g., new CohereClient({ token: "..." }))
     */
    setCohereClient(client: any): void;
    /**
     * Set a custom Mistral client instance for streaming
     * @param client - Mistral client instance (e.g., new Mistral({ apiKey: "..." }))
     */
    setMistralClient(client: any): void;
    /**
     * Set a custom Bedrock client instance for streaming
     * @param client - BedrockRuntimeClient instance (e.g., new BedrockRuntimeClient({ region: "us-east-2" }))
     */
    setBedrockClient(client: any): void;
    /**
     * Set a custom Deepseek client instance for streaming
     * @param client - OpenAI client instance configured for Deepseek (e.g., new OpenAI({ baseURL: "https://api.deepseek.com", apiKey: "..." }))
     */
    setDeepseekClient(client: any): void;
    /**
     * Update retry configuration and refresh the Apollo client
     * @param retryConfig - New retry configuration
     */
    setRetryConfig(retryConfig: RetryConfig): void;
    private generateToken;
    getProject(): Promise<Types.GetProjectQuery>;
    updateProject(project: Types.ProjectUpdateInput): Promise<Types.UpdateProjectMutation>;
    lookupProjectUsage(correlationId: string): Promise<Types.LookupUsageQuery>;
    lookupProjectCredits(correlationId: string): Promise<Types.LookupCreditsQuery>;
    queryProjectTokens(startDate: Types.Scalars["DateTime"]["input"], duration: Types.Scalars["TimeSpan"]["input"]): Promise<Types.QueryTokensQuery>;
    queryProjectUsage(startDate: Types.Scalars["DateTime"]["input"], duration: Types.Scalars["TimeSpan"]["input"], names?: string[], excludedNames?: string[], offset?: Types.Scalars["Int"]["input"], limit?: Types.Scalars["Int"]["input"]): Promise<Types.QueryUsageQuery>;
    queryProjectCredits(startDate: Types.Scalars["DateTime"]["input"], duration: Types.Scalars["TimeSpan"]["input"]): Promise<Types.QueryCreditsQuery>;
    sendNotification(connector: Types.IntegrationConnectorInput, text: string, textType?: Types.TextTypes): Promise<Types.SendNotificationMutation>;
    mapWeb(uri: string, allowedPaths?: string[], excludedPaths?: string[], correlationId?: string): Promise<Types.MapWebQuery>;
    searchWeb(text: string, service?: Types.SearchServiceTypes, limit?: number, correlationId?: string): Promise<Types.SearchWebQuery>;
    createAlert(alert: Types.AlertInput, correlationId?: string): Promise<Types.CreateAlertMutation>;
    updateAlert(alert: Types.AlertUpdateInput): Promise<Types.UpdateAlertMutation>;
    deleteAlert(id: string): Promise<Types.DeleteAlertMutation>;
    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>;
    queryAlerts(filter?: Types.AlertFilter): Promise<Types.QueryAlertsQuery>;
    countAlerts(filter?: Types.AlertFilter): Promise<Types.CountAlertsQuery>;
    createCollection(collection: Types.CollectionInput): Promise<Types.CreateCollectionMutation>;
    updateCollection(collection: Types.CollectionUpdateInput): Promise<Types.UpdateCollectionMutation>;
    deleteCollection(id: string): Promise<Types.DeleteCollectionMutation>;
    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>;
    queryCollections(filter?: Types.CollectionFilter): Promise<Types.QueryCollectionsQuery>;
    countCollections(filter?: Types.CollectionFilter): Promise<Types.CountCollectionsQuery>;
    describeImage(prompt: string, uri: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.DescribeImageMutation>;
    describeEncodedImage(prompt: string, mimeType: string, data: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.DescribeEncodedImageMutation>;
    screenshotPage(uri: string, maximumHeight?: number, isSynchronous?: boolean, workflow?: Types.EntityReferenceInput, collections?: Types.EntityReferenceInput[], correlationId?: string): Promise<Types.ScreenshotPageMutation>;
    ingestTextBatch(batch: Types.TextContentInput[], textType: Types.TextTypes, collections?: Types.EntityReferenceInput[], observations?: Types.ObservationReferenceInput[], correlationId?: string): Promise<Types.IngestTextBatchMutation>;
    ingestBatch(uris: string[], workflow?: Types.EntityReferenceInput, collections?: Types.EntityReferenceInput[], observations?: Types.ObservationReferenceInput[], correlationId?: string): Promise<Types.IngestBatchMutation>;
    ingestUri(uri: string, name?: string, id?: string, isSynchronous?: boolean, workflow?: Types.EntityReferenceInput, collections?: Types.EntityReferenceInput[], observations?: Types.ObservationReferenceInput[], correlationId?: string): Promise<Types.IngestUriMutation>;
    ingestText(text: string, name?: string, textType?: Types.TextTypes, uri?: string, id?: string, isSynchronous?: boolean, workflow?: Types.EntityReferenceInput, collections?: Types.EntityReferenceInput[], observations?: Types.ObservationReferenceInput[], correlationId?: string): Promise<Types.IngestTextMutation>;
    ingestMemory(text: string, name?: string, textType?: Types.TextTypes, id?: string, collections?: Types.EntityReferenceInput[], correlationId?: string): Promise<Types.IngestMemoryMutation>;
    ingestEvent(markdown: string, name?: string, description?: string, eventDate?: Types.Scalars["DateTime"]["input"], id?: string, collections?: Types.EntityReferenceInput[], correlationId?: string): Promise<Types.IngestEventMutation>;
    ingestEncodedFile(name: string, data: string, mimeType: string, fileCreationDate?: Types.Scalars["DateTime"]["input"], fileModifiedDate?: Types.Scalars["DateTime"]["input"], 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(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>;
    extractContents(prompt: string, tools: Types.ToolDefinitionInput[], specification?: Types.EntityReferenceInput, filter?: Types.ContentFilter, correlationId?: string): Promise<Types.ExtractContentsMutation>;
    publishContents(publishPrompt: string, connector: Types.ContentPublishingConnectorInput, summaryPrompt?: string, summarySpecification?: Types.EntityReferenceInput, publishSpecification?: Types.EntityReferenceInput, name?: string, filter?: Types.ContentFilter, workflow?: Types.EntityReferenceInput, isSynchronous?: boolean, includeDetails?: boolean, correlationId?: string): Promise<Types.PublishContentsMutation>;
    publishText(text: string, textType: Types.TextTypes, connector: Types.ContentPublishingConnectorInput, name?: string, workflow?: Types.EntityReferenceInput, isSynchronous?: boolean, correlationId?: string): Promise<Types.PublishTextMutation>;
    getContent(id: string): Promise<Types.GetContentQuery>;
    lookupContents(ids: string[]): Promise<Types.LookupContentsResults>;
    queryContents(filter?: Types.ContentFilter): Promise<Types.QueryContentsQuery>;
    queryContentsFacets(filter?: Types.ContentFilter): Promise<Types.QueryContentsFacetsQuery>;
    queryContentsGraph(filter?: Types.ContentFilter): Promise<Types.QueryContentsGraphQuery>;
    countContents(filter?: Types.ContentFilter): Promise<Types.CountContentsQuery>;
    isContentDone(id: string): Promise<Types.IsContentDoneQuery>;
    createConversation(conversation: Types.ConversationInput, correlationId?: string): Promise<Types.CreateConversationMutation>;
    updateConversation(conversation: Types.ConversationUpdateInput): Promise<Types.UpdateConversationMutation>;
    deleteConversation(id: string): Promise<Types.DeleteConversationMutation>;
    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>;
    queryConversations(filter?: Types.ConversationFilter): Promise<Types.QueryConversationsQuery>;
    countConversations(filter?: Types.ConversationFilter): Promise<Types.CountConversationsQuery>;
    reviseImage(prompt: string, uri: string, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ReviseImageMutation>;
    reviseEncodedImage(prompt: string, mimeType: string, data: string, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ReviseEncodedImageMutation>;
    reviseText(prompt: string, text: string, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ReviseTextMutation>;
    reviseContent(prompt: string, content: Types.EntityReferenceInput, id?: string, specification?: Types.EntityReferenceInput, correlationId?: string): Promise<Types.ReviseContentMutation>;
    prompt(prompt?: string, mimeType?: string, data?: string, specification?: Types.EntityReferenceInput, messages?: Types.ConversationMessageInput[], correlationId?: string): Promise<Types.PromptMutation>;
    retrieveSources(prompt: string, filter?: Types.ContentFilter, augmentedFilter?: Types.ContentFilter, retrievalStrategy?: Types.RetrievalStrategyInput, rerankingStrategy?: Types.RerankingStrategyInput, correlationId?: string): Promise<Types.RetrieveSourcesMutation>;
    formatConversation(prompt: string, id?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], 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>;
    branchConversation(id: string): Promise<Types.BranchConversationMutation>;
    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>;
    queryOneDriveFolders(properties: Types.OneDriveFoldersInput, folderId?: string): Promise<Types.QueryOneDriveFoldersQuery>;
    querySharePointFolders(properties: Types.SharePointFoldersInput, libraryId: string, folderId?: string): Promise<Types.QuerySharePointFoldersQuery>;
    querySharePointLibraries(properties: Types.SharePointLibrariesInput): Promise<Types.QuerySharePointLibrariesQuery>;
    queryMicrosoftTeamsTeams(properties: Types.MicrosoftTeamsTeamsInput): Promise<Types.QueryMicrosoftTeamsTeamsQuery>;
    queryMicrosoftTeamsChannels(properties: Types.MicrosoftTeamsChannelsInput, teamId: string): Promise<Types.QueryMicrosoftTeamsChannelsQuery>;
    querySlackChannels(properties: Types.SlackChannelsInput): Promise<Types.QuerySlackChannelsQuery>;
    queryLinearProjects(properties: Types.LinearProjectsInput): Promise<Types.QueryLinearProjectsQuery>;
    queryNotionDatabases(properties: Types.NotionDatabasesInput): Promise<Types.QueryNotionDatabasesQuery>;
    queryNotionPages(properties: Types.NotionPagesInput, identifier: string): Promise<Types.QueryNotionPagesQuery>;
    createFeed(feed: Types.FeedInput, correlationId?: string): Promise<Types.CreateFeedMutation>;
    updateFeed(feed: Types.FeedUpdateInput): Promise<Types.UpdateFeedMutation>;
    deleteFeed(id: string): Promise<Types.DeleteFeedMutation>;
    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>;
    queryFeeds(filter?: Types.FeedFilter): Promise<Types.QueryFeedsQuery>;
    countFeeds(filter?: Types.FeedFilter): Promise<Types.CountFeedsQuery>;
    feedExists(filter?: Types.FeedFilter): Promise<Types.FeedExistsQuery>;
    isFeedDone(id: string): Promise<Types.IsFeedDoneQuery>;
    promptSpecifications(prompt: string, ids: string[]): Promise<Types.PromptSpecificationsMutation>;
    createSpecification(specification: Types.SpecificationInput): Promise<Types.CreateSpecificationMutation>;
    updateSpecification(specification: Types.SpecificationUpdateInput): Promise<Types.UpdateSpecificationMutation>;
    upsertSpecification(specification: Types.SpecificationInput): Promise<Types.UpsertSpecificationMutation>;
    deleteSpecification(id: string): Promise<Types.DeleteSpecificationMutation>;
    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>;
    countSpecifications(filter?: Types.SpecificationFilter): Promise<Types.CountSpecificationsQuery>;
    specificationExists(filter?: Types.SpecificationFilter): Promise<Types.SpecificationExistsQuery>;
    queryModels(filter?: Types.ModelFilter): Promise<Types.QueryModelsQuery>;
    createWorkflow(workflow: Types.WorkflowInput): Promise<Types.CreateWorkflowMutation>;
    updateWorkflow(workflow: Types.WorkflowUpdateInput): Promise<Types.UpdateWorkflowMutation>;
    upsertWorkflow(workflow: Types.WorkflowInput): Promise<Types.UpsertWorkflowMutation>;
    deleteWorkflow(id: string): Promise<Types.DeleteWorkflowMutation>;
    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>;
    countWorkflows(filter?: Types.WorkflowFilter): Promise<Types.CountWorkflowsQuery>;
    workflowExists(filter?: Types.WorkflowFilter): Promise<Types.WorkflowExistsQuery>;
    createUser(user: Types.UserInput): Promise<Types.CreateUserMutation>;
    updateUser(user: Types.UserUpdateInput): Promise<Types.UpdateUserMutation>;
    deleteUser(id: string): Promise<Types.DeleteUserMutation>;
    getUser(): Promise<Types.GetUserQuery>;
    queryUsers(filter?: Types.UserFilter): Promise<Types.QueryUsersQuery>;
    countUsers(filter?: Types.UserFilter): Promise<Types.CountUsersQuery>;
    enableUser(id: string): Promise<Types.EnableUserMutation>;
    disableUser(id: string): Promise<Types.DeleteUserMutation>;
    createCategory(category: Types.CategoryInput): Promise<Types.CreateCategoryMutation>;
    updateCategory(category: Types.CategoryUpdateInput): Promise<Types.UpdateCategoryMutation>;
    upsertCategory(category: Types.CategoryInput): Promise<Types.UpsertCategoryMutation>;
    deleteCategory(id: string): Promise<Types.DeleteCategoryMutation>;
    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>;
    upsertLabel(label: Types.LabelInput): Promise<Types.UpsertLabelMutation>;
    deleteLabel(id: string): Promise<Types.DeleteLabelMutation>;
    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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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>;
    updateObservation(observation: Types.ObservationUpdateInput): Promise<Types.UpdateObservationMutation>;
    deleteObservation(id: string): Promise<Types.DeleteObservationMutation>;
    /**
     * Creates an event handler that supports UI streaming mode
     * @internal
     */
    /**
     * Check if streaming is supported with the current configuration
     * @param specification - Optional specification to check compatibility
     * @returns true if streaming is available, false otherwise
     */
    supportsStreaming(specification?: Types.Specification): boolean;
    /**
     * Execute an agent with non-streaming response
     * @param prompt - The user prompt
     * @param conversationId - Optional conversation ID to continue
     * @param specification - Optional specification for the LLM
     * @param tools - Optional tool definitions
     * @param toolHandlers - Optional tool handler functions
     * @param options - Agent options
     * @param mimeType - Optional MIME type for multimodal input
     * @param data - Optional base64 encoded data for multimodal input
     * @param contentFilter - Optional filter for content retrieval during conversation
     * @param augmentedFilter - Optional filter to force specific content into LLM context
     * @param correlationId - Optional correlation ID for tracking
     * @returns Complete agent result with message and tool calls
     */
    promptAgent(prompt: string, conversationId?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], toolHandlers?: Record<string, ToolHandler>, options?: AgentOptions, mimeType?: string, data?: string, // base64 encoded
    contentFilter?: Types.ContentCriteriaInput, augmentedFilter?: Types.ContentCriteriaInput, correlationId?: string): Promise<AgentResult>;
    /**
     * Execute an agent with streaming response
     * @param prompt - The user prompt
     * @param onEvent - Event handler for streaming events
     * @param conversationId - Optional conversation ID to continue
     * @param specification - Optional specification for the LLM
     * @param tools - Optional tool definitions
     * @param toolHandlers - Optional tool handler functions
     * @param options - Stream agent options
     * @param mimeType - Optional MIME type for multimodal input
     * @param data - Optional base64 encoded data for multimodal input
     * @param contentFilter - Optional filter for content retrieval during conversation
     * @param augmentedFilter - Optional filter to force specific content into LLM context
     * @param correlationId - Optional correlation ID for tracking
     * @throws Error if streaming is not supported
     */
    streamAgent(prompt: string, onEvent: (event: AgentStreamEvent) => void, conversationId?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], toolHandlers?: Record<string, ToolHandler>, options?: StreamAgentOptions, mimeType?: string, data?: string, // base64 encoded
    contentFilter?: Types.ContentCriteriaInput, augmentedFilter?: Types.ContentCriteriaInput, correlationId?: string): Promise<void>;
    /**
     * Execute the streaming agent workflow with tool calling loop
     */
    private executeStreamingAgent;
    /**
     * Build message array for LLM from conversation history
     */
    private buildMessageArray;
    /**
     * Execute tools during streaming with proper event emission
     */
    private executeToolsInStream;
    /**
     * Format tool results for API
     */
    private formatToolResults;
    /**
     * Fallback to non-streaming when streaming is not available
     */
    private fallbackToNonStreaming;
    /**
     * Stream with OpenAI client
     */
    private streamWithOpenAI;
    /**
     * Stream with Anthropic client
     */
    private streamWithAnthropic;
    /**
     * Stream with Google client
     */
    private streamWithGoogle;
    /**
     * Stream with Groq client (OpenAI-compatible)
     */
    private streamWithGroq;
    /**
     * Stream with Cerebras client (OpenAI-compatible)
     */
    private streamWithCerebras;
    /**
     * Stream with Cohere client
     */
    private streamWithCohere;
    /**
     * Stream with Mistral client
     */
    private streamWithMistral;
    /**
     * Stream with Bedrock client
     */
    private streamWithBedrock;
    /**
     * Stream with Deepseek client
     */
    private streamWithDeepseek;
    private executeToolsForPromptAgent;
    private prettyPrintGraphQLError;
    private mutateAndCheckError;
    private queryAndCheckError;
}
export { Graphlit };
export * as Types from "./generated/graphql-types.js";