@manta-eu/client 0.1.0

package/dist/generated/graphql.d.ts

@@ -0,0 +1,4719 @@
+import { GraphQLClient } from "graphql-request";
+import { UseMutationOptions, UseQueryOptions, UseSuspenseQueryOptions } from "@tanstack/react-query";
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+export type MakeEmpty<T extends {
+    [key: string]: unknown;
+}, K extends keyof T> = {
+    [_ in K]?: never;
+};
+export type Incremental<T> = T | {
+    [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: {
+        input: string;
+        output: string;
+    };
+    String: {
+        input: string;
+        output: string;
+    };
+    Boolean: {
+        input: boolean;
+        output: boolean;
+    };
+    Int: {
+        input: number;
+        output: number;
+    };
+    Float: {
+        input: number;
+        output: number;
+    };
+    BigInt: {
+        input: bigint;
+        output: bigint;
+    };
+    CountryCode: {
+        input: string;
+        output: string;
+    };
+    Currency: {
+        input: string;
+        output: string;
+    };
+    DID: {
+        input: string;
+        output: string;
+    };
+    DatalogRule: {
+        input: string;
+        output: string;
+    };
+    Date: {
+        input: Date | string;
+        output: Date | string;
+    };
+    DateTime: {
+        input: Date | string;
+        output: Date | string;
+    };
+    Decimal: {
+        input: string;
+        output: string;
+    };
+    Duration: {
+        input: string;
+        output: string;
+    };
+    EmailAddress: {
+        input: string;
+        output: string;
+    };
+    GUID: {
+        input: string;
+        output: string;
+    };
+    HSL: {
+        input: string;
+        output: string;
+    };
+    HSLA: {
+        input: string;
+        output: string;
+    };
+    HexColorCode: {
+        input: string;
+        output: string;
+    };
+    IBAN: {
+        input: string;
+        output: string;
+    };
+    IPv4: {
+        input: string;
+        output: string;
+    };
+    IPv6: {
+        input: string;
+        output: string;
+    };
+    IRI: {
+        input: string;
+        output: string;
+    };
+    ISBN: {
+        input: string;
+        output: string;
+    };
+    ISO8601Duration: {
+        input: string;
+        output: string;
+    };
+    JSON: {
+        input: unknown;
+        output: unknown;
+    };
+    JSONObject: {
+        input: Record<string, unknown>;
+        output: Record<string, unknown>;
+    };
+    Latitude: {
+        input: number;
+        output: number;
+    };
+    LocalDate: {
+        input: string;
+        output: string;
+    };
+    LocalDateTime: {
+        input: string;
+        output: string;
+    };
+    LocalEndTime: {
+        input: string;
+        output: string;
+    };
+    LocalTime: {
+        input: string;
+        output: string;
+    };
+    Locale: {
+        input: string;
+        output: string;
+    };
+    Long: {
+        input: bigint;
+        output: bigint;
+    };
+    Longitude: {
+        input: number;
+        output: number;
+    };
+    MAC: {
+        input: string;
+        output: string;
+    };
+    NegativeFloat: {
+        input: number;
+        output: number;
+    };
+    NegativeInt: {
+        input: number;
+        output: number;
+    };
+    NonNegativeFloat: {
+        input: number;
+        output: number;
+    };
+    NonNegativeInt: {
+        input: number;
+        output: number;
+    };
+    NonPositiveFloat: {
+        input: number;
+        output: number;
+    };
+    NonPositiveInt: {
+        input: number;
+        output: number;
+    };
+    ObjectID: {
+        input: string;
+        output: string;
+    };
+    PhoneNumber: {
+        input: string;
+        output: string;
+    };
+    Port: {
+        input: number;
+        output: number;
+    };
+    PositiveFloat: {
+        input: number;
+        output: number;
+    };
+    PositiveInt: {
+        input: number;
+        output: number;
+    };
+    PostalCode: {
+        input: string;
+        output: string;
+    };
+    RGB: {
+        input: string;
+        output: string;
+    };
+    RGBA: {
+        input: string;
+        output: string;
+    };
+    SafeInt: {
+        input: number;
+        output: number;
+    };
+    SemVer: {
+        input: string;
+        output: string;
+    };
+    Time: {
+        input: Date | string;
+        output: Date | string;
+    };
+    TimeZone: {
+        input: string;
+        output: string;
+    };
+    Timestamp: {
+        input: Date | string | number;
+        output: Date | string | number;
+    };
+    URL: {
+        input: URL | string;
+        output: URL | string;
+    };
+    USCurrency: {
+        input: string;
+        output: string;
+    };
+    UUID: {
+        input: string;
+        output: string;
+    };
+    UnsignedFloat: {
+        input: number;
+        output: number;
+    };
+    UnsignedInt: {
+        input: number;
+        output: number;
+    };
+    UtcOffset: {
+        input: string;
+        output: string;
+    };
+    Void: {
+        input: void;
+        output: void;
+    };
+};
+export type GQLAbortUploadInput = {
+    storageKey: Scalars["String"]["input"];
+    uploadId: Scalars["String"]["input"];
+};
+export type GQLAbortUploadResponse = {
+    __typename?: "AbortUploadResponse";
+    ok: Scalars["Boolean"]["output"];
+};
+export type GQLAccessibleDatastore = {
+    __typename?: "AccessibleDatastore";
+    depth: Scalars["Int"]["output"];
+    id: Scalars["String"]["output"];
+    live?: Maybe<Scalars["Boolean"]["output"]>;
+    name: Scalars["String"]["output"];
+    selectable: Scalars["Boolean"]["output"];
+    status?: Maybe<GQLDatastoreProvisioningStatus>;
+};
+export type GQLActionCountByType = {
+    __typename?: "ActionCountByType";
+    count: Scalars["Int"]["output"];
+    typeName: Scalars["String"]["output"];
+};
+export type GQLActionPlanActivity = {
+    __typename?: "ActionPlanActivity";
+    entityName: Scalars["String"]["output"];
+    id: Scalars["String"]["output"];
+    operation: Scalars["String"]["output"];
+    typeName: Scalars["String"]["output"];
+};
+export type GQLActionPlanCreatedBy = GQLActionPlanCreatedByManta | GQLActionPlanCreatedByUser;
+export type GQLActionPlanCreatedByManta = {
+    __typename?: "ActionPlanCreatedByManta";
+    confidenceScore?: Maybe<Scalars["Float"]["output"]>;
+    reason?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLActionPlanCreatedByUser = {
+    __typename?: "ActionPlanCreatedByUser";
+    id: Scalars["UUID"]["output"];
+    reason?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLActionPlanDiffByType = {
+    __typename?: "ActionPlanDiffByType";
+    addedCount: Scalars["Int"]["output"];
+    typeIri: Scalars["IRI"]["output"];
+    typeName: Scalars["String"]["output"];
+    updatedCount: Scalars["Int"]["output"];
+};
+export type GQLActionPlanDiffResponse = {
+    __typename?: "ActionPlanDiffResponse";
+    byTypes: Array<GQLActionPlanDiffByType>;
+    deleted: Array<Scalars["String"]["output"]>;
+    error?: Maybe<Scalars["String"]["output"]>;
+    planGraph: Scalars["String"]["output"];
+    summary: GQLActionPlanDiffSummary;
+};
+export type GQLActionPlanDiffSummary = {
+    __typename?: "ActionPlanDiffSummary";
+    added: Scalars["Int"]["output"];
+    deleted: Scalars["Int"]["output"];
+    types: Scalars["Int"]["output"];
+    updated: Scalars["Int"]["output"];
+};
+export type GQLActionPlanExecutionEvent = {
+    __typename?: "ActionPlanExecutionEvent";
+    activity?: Maybe<GQLActionPlanActivity>;
+    progress: Scalars["Int"]["output"];
+    status: GQLActionPlanExecutionStatus;
+    timestamp: Scalars["DateTime"]["output"];
+    workflowId: Scalars["String"]["output"];
+};
+export type GQLActionPlanExecutionInput = {
+    addedCount: Scalars["Int"]["input"];
+    typeName: Scalars["String"]["input"];
+    updatedCount: Scalars["Int"]["input"];
+};
+export declare enum GQLActionPlanExecutionStatus {
+    ActivityCompleted = "ACTIVITY_COMPLETED",
+    ActivityStarted = "ACTIVITY_STARTED",
+    Completed = "COMPLETED",
+    Failed = "FAILED",
+    Started = "STARTED"
+}
+export type GQLActionPlanGraph = {
+    __typename?: "ActionPlanGraph";
+    actionCount: Scalars["Int"]["output"];
+    actionCountByType: Array<GQLActionCountByType>;
+    completedActionCount: Scalars["Int"]["output"];
+    createdBy: GQLActionPlanCreatedBy;
+    description?: Maybe<Scalars["String"]["output"]>;
+    duration?: Maybe<Scalars["ISO8601Duration"]["output"]>;
+    estimatedCost?: Maybe<GQLQuantitativeValue>;
+    estimatedROI?: Maybe<GQLQuantitativeValue>;
+    estimatedReturn?: Maybe<GQLQuantitativeValue>;
+    iri: Scalars["IRI"]["output"];
+    potentialProfit?: Maybe<GQLQuantitativeValue>;
+    primaryIntegration?: Maybe<GQLIntegration>;
+    priority?: Maybe<GQLActionPlanPriority>;
+    state?: Maybe<GQLActionPlanState>;
+    statements: Scalars["Int"]["output"];
+    subjects: Scalars["Int"]["output"];
+};
+export type GQLActionPlanGraphResponse = {
+    __typename?: "ActionPlanGraphResponse";
+    graph: Scalars["JSON"]["output"];
+};
+export type GQLActionPlanOrderBy = {
+    direction: GQLOrderDirection;
+    field: GQLActionPlanOrderField;
+};
+export declare enum GQLActionPlanOrderField {
+    CreatedBy = "CREATED_BY",
+    EstimatedCost = "ESTIMATED_COST",
+    EstimatedReturn = "ESTIMATED_RETURN",
+    EstimatedRoi = "ESTIMATED_ROI",
+    MantaPriority = "MANTA_PRIORITY",
+    State = "STATE"
+}
+export declare enum GQLActionPlanPriority {
+    High = "HIGH",
+    Low = "LOW",
+    Medium = "MEDIUM"
+}
+export type GQLActionPlanRun = {
+    __typename?: "ActionPlanRun";
+    activityIri: Scalars["IRI"]["output"];
+    dryRun: Scalars["Boolean"]["output"];
+    endedAt?: Maybe<Scalars["DateTime"]["output"]>;
+    errorMessage?: Maybe<Scalars["String"]["output"]>;
+    operationType?: Maybe<Scalars["String"]["output"]>;
+    planGraphIri: Scalars["IRI"]["output"];
+    startedAt: Scalars["DateTime"]["output"];
+    status: GQLActionPlanRunStatus;
+};
+export type GQLActionPlanRunHistoryResponse = {
+    __typename?: "ActionPlanRunHistoryResponse";
+    runs: Array<GQLActionPlanRun>;
+    totalCount: Scalars["Int"]["output"];
+};
+export declare enum GQLActionPlanRunStatus {
+    Completed = "COMPLETED",
+    Failed = "FAILED",
+    Running = "RUNNING"
+}
+export type GQLActionPlanSamplesResponse = {
+    __typename?: "ActionPlanSamplesResponse";
+    count: Scalars["Int"]["output"];
+    error?: Maybe<Scalars["String"]["output"]>;
+    samples: Array<GQLPlanSample>;
+    typeIri: Scalars["IRI"]["output"];
+    typeName: Scalars["String"]["output"];
+};
+export declare enum GQLActionPlanState {
+    Completed = "COMPLETED",
+    Draft = "DRAFT",
+    Failed = "FAILED",
+    Running = "RUNNING",
+    TimedOut = "TIMED_OUT"
+}
+export type GQLActionPlanSummary = {
+    __typename?: "ActionPlanSummary";
+    description?: Maybe<Scalars["String"]["output"]>;
+    iri: Scalars["IRI"]["output"];
+    name: Scalars["String"]["output"];
+    potentialProfit?: Maybe<GQLQuantitativeValue>;
+    primaryIntegration?: Maybe<GQLIntegration>;
+    priority?: Maybe<GQLActionPlanPriority>;
+};
+export type GQLActionPlansResponse = {
+    __typename?: "ActionPlansResponse";
+    count: Scalars["Int"]["output"];
+    plans: Array<GQLActionPlanGraph>;
+};
+export type GQLActionPlansSummaryAggregate = {
+    __typename?: "ActionPlansSummaryAggregate";
+    expectedReturn?: Maybe<GQLApproximateQuantitativeValue>;
+    investment?: Maybe<GQLApproximateQuantitativeValue>;
+    potentialProfit?: Maybe<GQLApproximateQuantitativeValue>;
+};
+export type GQLActionPlansSummaryResponse = {
+    __typename?: "ActionPlansSummaryResponse";
+    aggregate: GQLActionPlansSummaryAggregate;
+    plans: Array<GQLActionPlanSummary>;
+};
+export type GQLApproximateQuantitativeValue = {
+    __typename?: "ApproximateQuantitativeValue";
+    maxValue: Scalars["Decimal"]["output"];
+    minValue: Scalars["Decimal"]["output"];
+    unitCode: Scalars["String"]["output"];
+    unitText?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLAvailableTeam = {
+    __typename?: "AvailableTeam";
+    name: Scalars["String"]["output"];
+};
+export type GQLAvailableTeamsResponse = {
+    __typename?: "AvailableTeamsResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    teams: Array<GQLAvailableTeam>;
+};
+export type GQLBringDatastoreOnlineResponse = {
+    __typename?: "BringDatastoreOnlineResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLCancelActionPlanResponse = {
+    __typename?: "CancelActionPlanResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLClearStagedRulesResponse = {
+    __typename?: "ClearStagedRulesResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    rulesCleared: Scalars["Int"]["output"];
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLCommitStagedRulesResponse = {
+    __typename?: "CommitStagedRulesResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    rulesAdded: Scalars["Int"]["output"];
+    rulesDeleted: Scalars["Int"]["output"];
+    rulesUpdated: Scalars["Int"]["output"];
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLCompleteUploadInput = {
+    facts: GQLFileFactsInput;
+    fileName: Scalars["String"]["input"];
+    parts: Array<GQLUploadedPartInput>;
+    storageKey: Scalars["String"]["input"];
+    uploadId: Scalars["String"]["input"];
+};
+export type GQLCompleteUploadResponse = {
+    __typename?: "CompleteUploadResponse";
+    fileIri: Scalars["IRI"]["output"];
+    mediaType: Scalars["String"]["output"];
+};
+export type GQLConflictingMemory = {
+    __typename?: "ConflictingMemory";
+    createdBy?: Maybe<Scalars["String"]["output"]>;
+    currentTeams: Array<Scalars["String"]["output"]>;
+    description?: Maybe<Scalars["String"]["output"]>;
+    importance: Scalars["Int"]["output"];
+    iri: Scalars["IRI"]["output"];
+    kind: GQLMemoryKind;
+    label: Scalars["String"]["output"];
+    memoryTrustedUntil?: Maybe<Scalars["DateTime"]["output"]>;
+    memoryValidUntil?: Maybe<Scalars["DateTime"]["output"]>;
+    reason: Scalars["String"]["output"];
+};
+export type GQLConnectStripeAccountResponse = {
+    __typename?: "ConnectStripeAccountResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    stripeAccountId?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLConnectedAccount = {
+    __typename?: "ConnectedAccount";
+    externalId: Scalars["String"]["output"];
+    id: Scalars["String"]["output"];
+    integration: GQLIntegration;
+};
+export type GQLConsolidateMemoriesInput = {
+    customProperties?: InputMaybe<Scalars["JSONObject"]["input"]>;
+    derived?: InputMaybe<Scalars["Boolean"]["input"]>;
+    description?: InputMaybe<Scalars["String"]["input"]>;
+    importance?: InputMaybe<Scalars["Int"]["input"]>;
+    kind?: InputMaybe<GQLMemoryKind>;
+    label: Scalars["String"]["input"];
+    memoryIris: Array<Scalars["IRI"]["input"]>;
+    memorySubclass?: InputMaybe<Scalars["IRI"]["input"]>;
+    scope: GQLMemoryScope;
+    teams?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+export type GQLConsolidationCluster = {
+    __typename?: "ConsolidationCluster";
+    memories: Array<GQLMemory>;
+    reason: Scalars["String"]["output"];
+    suggestedDescription: Scalars["String"]["output"];
+    suggestedLabel: Scalars["String"]["output"];
+};
+export type GQLConversationStarter = {
+    __typename?: "ConversationStarter";
+    description?: Maybe<Scalars["String"]["output"]>;
+    id: Scalars["String"]["output"];
+    priority?: Maybe<Scalars["Int"]["output"]>;
+    title: Scalars["String"]["output"];
+};
+export declare enum GQLConversationStarterSource {
+    Default = "DEFAULT",
+    KnowledgeGraph = "KNOWLEDGE_GRAPH",
+    Plan = "PLAN"
+}
+export type GQLConversationStartersResponse = {
+    __typename?: "ConversationStartersResponse";
+    count: Scalars["Int"]["output"];
+    source: GQLConversationStarterSource;
+    starters: Array<GQLConversationStarter>;
+};
+export type GQLCreateInferalIntegrationInput = {
+    provider: GQLInferalProviderInput;
+    stream: GQLInferalStreamInput;
+};
+export type GQLCreateInferalIntegrationResponse = {
+    __typename?: "CreateInferalIntegrationResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    inferalIntegrationId?: Maybe<Scalars["String"]["output"]>;
+    status: GQLRelayIntegrationStatus;
+    streamId?: Maybe<Scalars["String"]["output"]>;
+    streamUrl?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLCreateMemoryInput = {
+    aboutEntityIris?: InputMaybe<Array<Scalars["IRI"]["input"]>>;
+    confidence?: InputMaybe<Scalars["Float"]["input"]>;
+    customProperties?: InputMaybe<Scalars["JSONObject"]["input"]>;
+    description?: InputMaybe<Scalars["String"]["input"]>;
+    importance?: InputMaybe<Scalars["Int"]["input"]>;
+    kind?: InputMaybe<GQLMemoryKind>;
+    label: Scalars["String"]["input"];
+    memorySource?: InputMaybe<Scalars["IRI"]["input"]>;
+    memorySubclass?: InputMaybe<Scalars["IRI"]["input"]>;
+    memoryTrustedUntil?: InputMaybe<Scalars["DateTime"]["input"]>;
+    memoryValidFrom?: InputMaybe<Scalars["DateTime"]["input"]>;
+    memoryValidUntil?: InputMaybe<Scalars["DateTime"]["input"]>;
+    scope?: InputMaybe<GQLMemoryScope>;
+    supersedesMemoryIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    supersedesMemoryIris?: InputMaybe<Array<Scalars["IRI"]["input"]>>;
+    teams?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+export type GQLCreateMemoryResponse = {
+    __typename?: "CreateMemoryResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    memory?: Maybe<GQLMemory>;
+};
+export type GQLCurrentFactValueResponse = {
+    __typename?: "CurrentFactValueResponse";
+    currentObject?: Maybe<Scalars["String"]["output"]>;
+    error?: Maybe<Scalars["String"]["output"]>;
+    status: GQLFactValueStatus;
+};
+export type GQLDatastoreProvisioningStatus = {
+    __typename?: "DatastoreProvisioningStatus";
+    datastoreId: Scalars["String"]["output"];
+    exists: Scalars["Boolean"]["output"];
+    known: Scalars["Boolean"]["output"];
+    materialized: Scalars["Boolean"]["output"];
+    offline: Scalars["Boolean"]["output"];
+    ready: Scalars["Boolean"]["output"];
+    registered?: Maybe<Scalars["Boolean"]["output"]>;
+};
+export type GQLDatastoreTreeNode = {
+    __typename?: "DatastoreTreeNode";
+    datastoreId?: Maybe<Scalars["String"]["output"]>;
+    depth: Scalars["Int"]["output"];
+    id: Scalars["String"]["output"];
+    isOrganization: Scalars["Boolean"]["output"];
+    name: Scalars["String"]["output"];
+    organizationAlias: Scalars["String"]["output"];
+    organizationId: Scalars["String"]["output"];
+    organizationName: Scalars["String"]["output"];
+    path: Scalars["String"]["output"];
+    provisionedAt?: Maybe<Scalars["String"]["output"]>;
+    provisionedBy?: Maybe<Scalars["String"]["output"]>;
+    removed: Scalars["Boolean"]["output"];
+};
+export type GQLDeleteActionPlanInput = {
+    planGraphIri: Scalars["IRI"]["input"];
+};
+export type GQLDeleteActionPlanResponse = {
+    __typename?: "DeleteActionPlanResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLDeleteMemoryResponse = {
+    __typename?: "DeleteMemoryResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLDeleteUserAccountResponse = {
+    __typename?: "DeleteUserAccountResponse";
+    deleted: Scalars["Boolean"]["output"];
+    id: Scalars["String"]["output"];
+};
+export type GQLDetectMemoryConflictsInput = {
+    description: Scalars["String"]["input"];
+    excludeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    label: Scalars["String"]["input"];
+    scope: GQLMemoryScope;
+    teams?: InputMaybe<Array<Scalars["String"]["input"]>>;
+    wantToStopAfterMs?: InputMaybe<Scalars["Int"]["input"]>;
+};
+export type GQLDetectMemoryConflictsResult = {
+    __typename?: "DetectMemoryConflictsResult";
+    conflicts: Array<GQLConflictingMemory>;
+    timedOut: Scalars["Boolean"]["output"];
+};
+export type GQLDisconnectConnectedAccountResponse = {
+    __typename?: "DisconnectConnectedAccountResponse";
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLDisconnectGmailIntegrationResponse = {
+    __typename?: "DisconnectGmailIntegrationResponse";
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLDisconnectInferalIntegrationResponse = {
+    __typename?: "DisconnectInferalIntegrationResponse";
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLEntityCount = {
+    __typename?: "EntityCount";
+    count: Scalars["Int"]["output"];
+    type: Scalars["String"]["output"];
+};
+export type GQLExactQuantitativeValue = {
+    __typename?: "ExactQuantitativeValue";
+    unitCode: Scalars["String"]["output"];
+    unitText?: Maybe<Scalars["String"]["output"]>;
+    value: Scalars["Decimal"]["output"];
+};
+export type GQLExecuteActionAdditionInput = {
+    actionShape: Scalars["IRI"]["input"];
+    properties: Scalars["JSONObject"]["input"];
+    rdfType: Scalars["IRI"]["input"];
+    subjectIri: Scalars["IRI"]["input"];
+};
+export type GQLExecuteActionDeletionInput = {
+    actionShape: Scalars["IRI"]["input"];
+    rdfType: Scalars["IRI"]["input"];
+    subjectIri: Scalars["IRI"]["input"];
+};
+export declare enum GQLExecuteActionErrorCode {
+    BadRequest = "BAD_REQUEST",
+    Conflict = "CONFLICT",
+    Unknown = "UNKNOWN"
+}
+export type GQLExecuteActionPlanInput = {
+    autoApprove?: InputMaybe<Scalars["Boolean"]["input"]>;
+    chatIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    dryRun?: InputMaybe<Scalars["Boolean"]["input"]>;
+    namedGraphIri: Scalars["IRI"]["input"];
+    shaclShapeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+};
+export type GQLExecuteActionPlanResponse = {
+    __typename?: "ExecuteActionPlanResponse";
+    content: Scalars["String"]["output"];
+    data?: Maybe<Scalars["String"]["output"]>;
+    error?: Maybe<Scalars["String"]["output"]>;
+    planValidation?: Maybe<GQLPlanValidation>;
+    semanticDiff?: Maybe<GQLSemanticDiff>;
+    success: Scalars["Boolean"]["output"];
+    workflowId?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLExecuteActionResponse = {
+    __typename?: "ExecuteActionResponse";
+    code?: Maybe<GQLExecuteActionErrorCode>;
+    error?: Maybe<Scalars["String"]["output"]>;
+    namedGraphIri?: Maybe<Scalars["IRI"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+    workflowId?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLExecuteActionUpdateInput = {
+    actionShape: Scalars["IRI"]["input"];
+    properties: Scalars["JSONObject"]["input"];
+    rdfType: Scalars["IRI"]["input"];
+    subjectIri: Scalars["IRI"]["input"];
+};
+export declare enum GQLFactValueStatus {
+    Changed = "CHANGED",
+    Removed = "REMOVED",
+    Unchanged = "UNCHANGED",
+    Unknown = "UNKNOWN"
+}
+export type GQLFileFactsInput = {
+    byteSize: Scalars["SafeInt"]["input"];
+    height?: InputMaybe<Scalars["PositiveInt"]["input"]>;
+    sha256?: InputMaybe<Scalars["String"]["input"]>;
+    width?: InputMaybe<Scalars["PositiveInt"]["input"]>;
+};
+export type GQLGmailIntegration = {
+    __typename?: "GmailIntegration";
+    email: Scalars["String"]["output"];
+    error?: Maybe<Scalars["String"]["output"]>;
+    lastSyncedAt?: Maybe<Scalars["String"]["output"]>;
+    messagesIngested: Scalars["Int"]["output"];
+    status: GQLGmailIntegrationStatus;
+};
+export declare enum GQLGmailIntegrationStatus {
+    Active = "ACTIVE",
+    Connecting = "CONNECTING",
+    Error = "ERROR",
+    Revoked = "REVOKED"
+}
+export type GQLGoogleAdAccount = {
+    __typename?: "GoogleAdAccount";
+    connectable?: Maybe<Scalars["Boolean"]["output"]>;
+    id: Scalars["String"]["output"];
+    level?: Maybe<Scalars["String"]["output"]>;
+    manager?: Maybe<Scalars["Boolean"]["output"]>;
+    name?: Maybe<Scalars["String"]["output"]>;
+    parent?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLGoogleAnalyticsProperty = {
+    __typename?: "GoogleAnalyticsProperty";
+    account?: Maybe<Scalars["Boolean"]["output"]>;
+    connectable?: Maybe<Scalars["Boolean"]["output"]>;
+    externalId?: Maybe<Scalars["String"]["output"]>;
+    id: Scalars["String"]["output"];
+    name?: Maybe<Scalars["String"]["output"]>;
+    parent?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLGoogleAnalyticsSetupProgress = {
+    __typename?: "GoogleAnalyticsSetupProgress";
+    lastError?: Maybe<GQLGoogleSetupLastError>;
+    properties?: Maybe<Array<GQLGoogleAnalyticsProperty>>;
+    state: Array<GQLGoogleSetupStateEnum>;
+};
+export type GQLGoogleSetupLastError = {
+    __typename?: "GoogleSetupLastError";
+    message: Scalars["String"]["output"];
+    severity: Scalars["String"]["output"];
+    title?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLGoogleSetupProgress = {
+    __typename?: "GoogleSetupProgress";
+    accounts?: Maybe<Array<GQLGoogleAdAccount>>;
+    lastError?: Maybe<GQLGoogleSetupLastError>;
+    state: Array<GQLGoogleSetupStateEnum>;
+};
+export declare enum GQLGoogleSetupStateEnum {
+    ConnectingAccounts = "CONNECTING_ACCOUNTS",
+    FatallyFailed = "FATALLY_FAILED",
+    FetchingAccounts = "FETCHING_ACCOUNTS",
+    Finished = "FINISHED",
+    Initializing = "INITIALIZING",
+    NotFound = "NOT_FOUND",
+    SelectingAccounts = "SELECTING_ACCOUNTS",
+    Setup = "SETUP",
+    TimedOut = "TIMED_OUT"
+}
+export type GQLGrantOperatorRoleResponse = {
+    __typename?: "GrantOperatorRoleResponse";
+    id: Scalars["String"]["output"];
+    operator: Scalars["Boolean"]["output"];
+};
+export type GQLHotelProfileInput = {
+    address?: InputMaybe<Scalars["String"]["input"]>;
+    declaredMonthlyAdSpend?: InputMaybe<Scalars["Float"]["input"]>;
+    jobTitle?: InputMaybe<Scalars["String"]["input"]>;
+    name: Scalars["String"]["input"];
+    outlets?: InputMaybe<Array<Scalars["String"]["input"]>>;
+    rooms?: InputMaybe<Scalars["Int"]["input"]>;
+    url?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type GQLImageObject = {
+    __typename?: "ImageObject";
+    caption?: Maybe<Scalars["String"]["output"]>;
+    height?: Maybe<Scalars["NonNegativeInt"]["output"]>;
+    url: Scalars["URL"]["output"];
+    width?: Maybe<Scalars["NonNegativeInt"]["output"]>;
+};
+export type GQLInferalIntegration = {
+    __typename?: "InferalIntegration";
+    id: Scalars["String"]["output"];
+    isInFlight: Scalars["Boolean"]["output"];
+    provider: GQLInferalIntegrationProvider;
+    shopId: Scalars["String"]["output"];
+    status: GQLRelayIntegrationStatus;
+    streamName: Scalars["String"]["output"];
+    streamUrl?: Maybe<Scalars["String"]["output"]>;
+};
+export declare enum GQLInferalIntegrationProvider {
+    GoogleAds = "GOOGLE_ADS",
+    GoogleAnalytics = "GOOGLE_ANALYTICS",
+    GoogleMerchant = "GOOGLE_MERCHANT",
+    Linkedin = "LINKEDIN",
+    Mailchimp = "MAILCHIMP",
+    Meta = "META",
+    Pinterest = "PINTEREST",
+    Shopify = "SHOPIFY",
+    Slack = "SLACK",
+    Triplewhale = "TRIPLEWHALE",
+    Woocommerce = "WOOCOMMERCE"
+}
+export declare enum GQLInferalLocation {
+    Afr = "AFR",
+    Apac = "APAC",
+    Eeur = "EEUR",
+    Enam = "ENAM",
+    Me = "ME",
+    Oc = "OC",
+    Sam = "SAM",
+    Weur = "WEUR",
+    Wnam = "WNAM"
+}
+export type GQLInferalProviderInput = {
+    shopify: GQLShopifyProviderInput;
+    triplewhale?: never;
+    woocommerce?: never;
+} | {
+    shopify?: never;
+    triplewhale: GQLTriplewhaleProviderInput;
+    woocommerce?: never;
+} | {
+    shopify?: never;
+    triplewhale?: never;
+    woocommerce: GQLWoocommerceProviderInput;
+};
+export type GQLInferalStreamInput = {
+    location: GQLInferalLocation;
+    name: Scalars["String"]["input"];
+};
+export type GQLInitiateUploadInput = {
+    byteSize: Scalars["SafeInt"]["input"];
+    fileName: Scalars["String"]["input"];
+};
+export type GQLInitiateUploadResponse = {
+    __typename?: "InitiateUploadResponse";
+    partUrls: Array<GQLUploadPartUrl>;
+    storageKey: Scalars["String"]["output"];
+    uploadId: Scalars["String"]["output"];
+};
+export declare enum GQLIntegration {
+    Dash = "DASH",
+    Figma = "FIGMA",
+    Google = "GOOGLE",
+    GoogleAnalytics = "GOOGLE_ANALYTICS",
+    Linkedin = "LINKEDIN",
+    Meta = "META",
+    Shopify = "SHOPIFY",
+    Slack = "SLACK",
+    Snapchat = "SNAPCHAT",
+    Woocommerce = "WOOCOMMERCE"
+}
+export type GQLKnowledgeGraphCapacity = {
+    __typename?: "KnowledgeGraphCapacity";
+    currentTriples?: Maybe<Scalars["Long"]["output"]>;
+    entitySummary?: Maybe<Array<GQLEntityCount>>;
+    maxTriples: Scalars["Long"]["output"];
+    percentageFull?: Maybe<Scalars["Float"]["output"]>;
+    remainingCapacity?: Maybe<Scalars["Long"]["output"]>;
+};
+export type GQLKnowledgeGraphDataVersion = {
+    __typename?: "KnowledgeGraphDataVersion";
+    uniqueId: Scalars["String"]["output"];
+    version: Scalars["Long"]["output"];
+};
+export type GQLKnowledgeGraphState = {
+    __typename?: "KnowledgeGraphState";
+    capacity: GQLKnowledgeGraphCapacity;
+    dataVersion?: Maybe<GQLKnowledgeGraphDataVersion>;
+    exists: Scalars["Boolean"]["output"];
+    isLoaded: Scalars["Boolean"]["output"];
+    offline: Scalars["Boolean"]["output"];
+};
+export declare enum GQLLdesAuthType {
+    Basic = "BASIC",
+    Bearer = "BEARER"
+}
+export type GQLLdesStream = {
+    __typename?: "LDESStream";
+    after?: Maybe<Scalars["DateTime"]["output"]>;
+    datastoreId: Scalars["String"]["output"];
+    phase: GQLLdesStreamPhase;
+    stats: GQLLdesStreamStats;
+    url: Scalars["String"]["output"];
+};
+export type GQLLdesStreamAuthInput = {
+    password?: InputMaybe<Scalars["String"]["input"]>;
+    token?: InputMaybe<Scalars["String"]["input"]>;
+    type: GQLLdesAuthType;
+    username?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type GQLLdesStreamDeleteResponse = {
+    __typename?: "LDESStreamDeleteResponse";
+    stream?: Maybe<GQLLdesStream>;
+    success: Scalars["Boolean"]["output"];
+};
+export declare enum GQLLdesStreamPhase {
+    Active = "ACTIVE",
+    Error = "ERROR",
+    Idle = "IDLE",
+    Paused = "PAUSED",
+    Waiting = "WAITING"
+}
+export type GQLLdesStreamResponse = {
+    __typename?: "LDESStreamResponse";
+    stream: GQLLdesStream;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLLdesStreamStats = {
+    __typename?: "LDESStreamStats";
+    lastError?: Maybe<Scalars["String"]["output"]>;
+    lastMemberAt?: Maybe<Scalars["DateTime"]["output"]>;
+    lastMemberUri?: Maybe<Scalars["IRI"]["output"]>;
+    lastPollAt?: Maybe<Scalars["DateTime"]["output"]>;
+    membersWritten: Scalars["Int"]["output"];
+    nextPollAt?: Maybe<Scalars["DateTime"]["output"]>;
+    pollingIntervalSeconds?: Maybe<Scalars["Int"]["output"]>;
+};
+export type GQLLinkUnlinkedDatastoreInput = {
+    atOrganizationRoot?: InputMaybe<Scalars["Boolean"]["input"]>;
+    datastoreId: Scalars["String"]["input"];
+    name: Scalars["String"]["input"];
+    organizationName: Scalars["String"]["input"];
+    parentPath?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+export type GQLLinkedinAdAccount = {
+    __typename?: "LinkedinAdAccount";
+    id: Scalars["String"]["output"];
+    name: Scalars["String"]["output"];
+};
+export type GQLLinkedinSetupError = {
+    __typename?: "LinkedinSetupError";
+    message: Scalars["String"]["output"];
+    severity: Scalars["String"]["output"];
+    title?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLLinkedinSetupProgress = {
+    __typename?: "LinkedinSetupProgress";
+    accounts?: Maybe<Array<GQLLinkedinAdAccount>>;
+    lastError?: Maybe<GQLLinkedinSetupError>;
+    state: Array<Scalars["String"]["output"]>;
+};
+export type GQLManageRdFoxRuleInput = {
+    dryRun?: InputMaybe<Scalars["Boolean"]["input"]>;
+    expectNoInference?: InputMaybe<Scalars["Boolean"]["input"]>;
+    humanIntent: Scalars["String"]["input"];
+    newRule?: InputMaybe<Scalars["DatalogRule"]["input"]>;
+    operation: GQLRuleOperation;
+    ruleIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    testTriple?: InputMaybe<GQLTestTripleInput>;
+};
+export type GQLManageRdFoxRuleResponse = {
+    __typename?: "ManageRDFoxRuleResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    inferenceTest?: Maybe<Scalars["String"]["output"]>;
+    inferenceVerified: Scalars["Boolean"]["output"];
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLManualActionChangeAssigneesPayload = {
+    __typename?: "ManualActionChangeAssigneesPayload";
+    manualActionProgress: GQLManualActionProgressResult;
+};
+export type GQLManualActionProgressResult = {
+    __typename?: "ManualActionProgressResult";
+    manualAction?: Maybe<GQLManualActionResult>;
+    state: Array<Scalars["String"]["output"]>;
+};
+export type GQLManualActionResolvePayload = {
+    __typename?: "ManualActionResolvePayload";
+    manualActionProgress: GQLManualActionProgressResult;
+};
+export declare enum GQLManualActionResolveStatus {
+    Completed = "COMPLETED",
+    Rejected = "REJECTED"
+}
+export type GQLManualActionResult = {
+    __typename?: "ManualActionResult";
+    assignees: Array<Scalars["String"]["output"]>;
+    resolvedBy?: Maybe<Scalars["String"]["output"]>;
+    status?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLMaterializeOntologyCoverageResponse = {
+    __typename?: "MaterializeOntologyCoverageResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLMemoriesResponse = {
+    __typename?: "MemoriesResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    memories: Array<GQLMemory>;
+};
+export type GQLMemory = {
+    __typename?: "Memory";
+    aboutEntityIris: Array<Scalars["IRI"]["output"]>;
+    confidence?: Maybe<Scalars["Float"]["output"]>;
+    createdBy?: Maybe<Scalars["String"]["output"]>;
+    customProperties?: Maybe<Scalars["JSONObject"]["output"]>;
+    description?: Maybe<Scalars["String"]["output"]>;
+    extractedAt: Scalars["DateTime"]["output"];
+    importance: Scalars["Int"]["output"];
+    iri: Scalars["IRI"]["output"];
+    kind: GQLMemoryKind;
+    label: Scalars["String"]["output"];
+    memoryCiteCount: Scalars["Int"]["output"];
+    memoryEvidence?: Maybe<Scalars["String"]["output"]>;
+    memoryLastUsedAt?: Maybe<Scalars["DateTime"]["output"]>;
+    memorySource: Scalars["IRI"]["output"];
+    memorySubclass?: Maybe<Scalars["IRI"]["output"]>;
+    memoryTrustedUntil?: Maybe<Scalars["DateTime"]["output"]>;
+    memoryUseCount: Scalars["Int"]["output"];
+    memoryValidFrom?: Maybe<Scalars["DateTime"]["output"]>;
+    memoryValidUntil?: Maybe<Scalars["DateTime"]["output"]>;
+    scope: GQLMemoryScope;
+    supersededBy?: Maybe<Scalars["IRI"]["output"]>;
+    supersedesMemory?: Maybe<Scalars["IRI"]["output"]>;
+    teams: Array<Scalars["String"]["output"]>;
+    updatedAt: Scalars["DateTime"]["output"];
+};
+export type GQLMemoryAbstraction = {
+    __typename?: "MemoryAbstraction";
+    memories: Array<GQLMemory>;
+    reason: Scalars["String"]["output"];
+    suggestedDescription: Scalars["String"]["output"];
+    suggestedLabel: Scalars["String"]["output"];
+};
+export type GQLMemoryConsolidationInput = {
+    scope: GQLMemoryScope;
+    wantToStopAfterMs?: InputMaybe<Scalars["Int"]["input"]>;
+};
+export declare enum GQLMemoryKind {
+    Context = "context",
+    Fact = "fact",
+    Objective = "objective",
+    Preference = "preference"
+}
+export type GQLMemoryRedundancyResult = {
+    __typename?: "MemoryRedundancyResult";
+    abstractions: Array<GQLMemoryAbstraction>;
+    clusters: Array<GQLConsolidationCluster>;
+    comparedCount?: Maybe<Scalars["Int"]["output"]>;
+    error?: Maybe<Scalars["String"]["output"]>;
+    timedOut: Scalars["Boolean"]["output"];
+};
+export type GQLMemoryReplayPoint = {
+    __typename?: "MemoryReplayPoint";
+    candidateLosses: Scalars["Int"]["output"];
+    candidateTotal: Scalars["Int"]["output"];
+    candidateWins: Scalars["Int"]["output"];
+    conclusive: Scalars["Boolean"]["output"];
+    losses: Scalars["Int"]["output"];
+    recordedAt: Scalars["DateTime"]["output"];
+    ties: Scalars["Int"]["output"];
+    total: Scalars["Int"]["output"];
+    wins: Scalars["Int"]["output"];
+};
+export type GQLMemoryReplaySeriesResult = {
+    __typename?: "MemoryReplaySeriesResult";
+    error?: Maybe<Scalars["String"]["output"]>;
+    points: Array<GQLMemoryReplayPoint>;
+};
+export type GQLMemorySchema = {
+    __typename?: "MemorySchema";
+    description?: Maybe<Scalars["String"]["output"]>;
+    iri: Scalars["IRI"]["output"];
+    label: Scalars["String"]["output"];
+    properties: Array<GQLMemorySchemaProperty>;
+};
+export type GQLMemorySchemaProperty = {
+    __typename?: "MemorySchemaProperty";
+    allowedValues: Array<Scalars["String"]["output"]>;
+    dataType: Scalars["String"]["output"];
+    inferred: Scalars["Boolean"]["output"];
+    keyProperty: Scalars["Boolean"]["output"];
+    label: Scalars["String"]["output"];
+    path: Scalars["IRI"]["output"];
+    required: Scalars["Boolean"]["output"];
+};
+export type GQLMemorySchemaPropertyInput = {
+    allowedValues?: InputMaybe<Array<Scalars["String"]["input"]>>;
+    dataType: Scalars["String"]["input"];
+    label: Scalars["String"]["input"];
+    path: Scalars["IRI"]["input"];
+    required: Scalars["Boolean"]["input"];
+};
+export type GQLMemorySchemasResponse = {
+    __typename?: "MemorySchemasResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    schemas: Array<GQLMemorySchema>;
+};
+export declare enum GQLMemoryScope {
+    Company = "company",
+    Team = "team",
+    User = "user"
+}
+export type GQLMetaAdAccount = {
+    __typename?: "MetaAdAccount";
+    id: Scalars["String"]["output"];
+    name?: Maybe<Scalars["String"]["output"]>;
+    parent?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLMetaSetupLastError = {
+    __typename?: "MetaSetupLastError";
+    message: Scalars["String"]["output"];
+    severity: Scalars["String"]["output"];
+    title?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLMetaSetupProgress = {
+    __typename?: "MetaSetupProgress";
+    accounts?: Maybe<Array<GQLMetaAdAccount>>;
+    lastError?: Maybe<GQLMetaSetupLastError>;
+    state: Array<GQLMetaSetupStateEnum>;
+};
+export declare enum GQLMetaSetupStateEnum {
+    ConnectingAccounts = "CONNECTING_ACCOUNTS",
+    FatallyFailed = "FATALLY_FAILED",
+    FetchingAccounts = "FETCHING_ACCOUNTS",
+    Finished = "FINISHED",
+    NotFound = "NOT_FOUND",
+    SelectingAccounts = "SELECTING_ACCOUNTS",
+    Setup = "SETUP",
+    TimedOut = "TIMED_OUT"
+}
+export type GQLMutation = {
+    __typename?: "Mutation";
+    abortUpload: GQLAbortUploadResponse;
+    bringDatastoreOnline: GQLBringDatastoreOnlineResponse;
+    cancelActionPlan: GQLCancelActionPlanResponse;
+    clearStagedRules: GQLClearStagedRulesResponse;
+    commitStagedRules: GQLCommitStagedRulesResponse;
+    completeUpload: GQLCompleteUploadResponse;
+    connectStripeAccount: GQLConnectStripeAccountResponse;
+    consolidateMemories: GQLCreateMemoryResponse;
+    createInferalIntegration: GQLCreateInferalIntegrationResponse;
+    createMemory: GQLCreateMemoryResponse;
+    deleteActionPlan: GQLDeleteActionPlanResponse;
+    deleteLDESStream: GQLLdesStreamDeleteResponse;
+    deleteMemory: GQLDeleteMemoryResponse;
+    deleteUserAccount: GQLDeleteUserAccountResponse;
+    disconnectConnectedAccount: GQLDisconnectConnectedAccountResponse;
+    disconnectGmailIntegration: GQLDisconnectGmailIntegrationResponse;
+    disconnectInferalIntegration: GQLDisconnectInferalIntegrationResponse;
+    executeActionAddition: GQLExecuteActionResponse;
+    executeActionDeletion: GQLExecuteActionResponse;
+    executeActionPlan: GQLExecuteActionPlanResponse;
+    executeActionUpdate: GQLExecuteActionResponse;
+    generateStructuredData: GQLStructuredDataResponse;
+    googleAnalyticsSetupConnect: GQLGoogleAnalyticsSetupProgress;
+    googleSetupConnect: GQLGoogleSetupProgress;
+    grantOperatorRole: GQLGrantOperatorRoleResponse;
+    initiateUpload: GQLInitiateUploadResponse;
+    linkUnlinkedDatastore: GQLProvisionDatastoreResponse;
+    linkedinSetupConnect?: Maybe<GQLLinkedinSetupProgress>;
+    manageRDFoxRule: GQLManageRdFoxRuleResponse;
+    manualActionChangeAssignees?: Maybe<GQLManualActionChangeAssigneesPayload>;
+    manualActionResolve?: Maybe<GQLManualActionResolvePayload>;
+    materializeOntologyCoverage: GQLMaterializeOntologyCoverageResponse;
+    metaSetupConnect: GQLMetaSetupProgress;
+    pauseLDESStream: GQLLdesStreamResponse;
+    provisionDatastore: GQLProvisionDatastoreResponse;
+    reconfirmMemory: GQLUpdateMemoryResponse;
+    recordHotelProfile: GQLRecordHotelProfileResponse;
+    registerDatastore: GQLRegisterDatastoreResponse;
+    releaseRuleOwnership: GQLReleaseRuleOwnershipResponse;
+    removeDatastore: GQLRemoveDatastoreResponse;
+    renameDatastoreGroup: GQLRenameDatastoreGroupResponse;
+    restoreDatastore: GQLRestoreDatastoreResponse;
+    restoreMemory: GQLRestoreMemoryResponse;
+    resumeLDESStream: GQLLdesStreamResponse;
+    revokeOperatorRole: GQLRevokeOperatorRoleResponse;
+    selfServeProvisionOrganization: GQLSelfServeProvisionOrganizationResponse;
+    stageRuleOperation: GQLStageRuleOperationResponse;
+    startLDESStream: GQLLdesStreamResponse;
+    syncGmailIntegration: GQLGmailIntegration;
+    updateMemory: GQLUpdateMemoryResponse;
+    updateUserPreferences: GQLUpdateUserPreferencesResponse;
+    validateRDFoxRule: GQLValidateRdFoxRuleResponse;
+    validateStagedRules: GQLValidateStagedRulesResponse;
+};
+export type GQLMutationAbortUploadArgs = {
+    input: GQLAbortUploadInput;
+};
+export type GQLMutationBringDatastoreOnlineArgs = {
+    datastoreId?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type GQLMutationCancelActionPlanArgs = {
+    planIri: Scalars["String"]["input"];
+};
+export type GQLMutationClearStagedRulesArgs = {
+    ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]>>;
+};
+export type GQLMutationCommitStagedRulesArgs = {
+    dryRun?: InputMaybe<Scalars["Boolean"]["input"]>;
+    ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]>>;
+};
+export type GQLMutationCompleteUploadArgs = {
+    input: GQLCompleteUploadInput;
+};
+export type GQLMutationConnectStripeAccountArgs = {
+    secretKey: Scalars["String"]["input"];
+};
+export type GQLMutationConsolidateMemoriesArgs = {
+    input: GQLConsolidateMemoriesInput;
+};
+export type GQLMutationCreateInferalIntegrationArgs = {
+    input: GQLCreateInferalIntegrationInput;
+};
+export type GQLMutationCreateMemoryArgs = {
+    input: GQLCreateMemoryInput;
+};
+export type GQLMutationDeleteActionPlanArgs = {
+    input: GQLDeleteActionPlanInput;
+};
+export type GQLMutationDeleteLdesStreamArgs = {
+    url: Scalars["String"]["input"];
+};
+export type GQLMutationDeleteMemoryArgs = {
+    memoryIri: Scalars["IRI"]["input"];
+};
+export type GQLMutationDeleteUserAccountArgs = {
+    userId: Scalars["String"]["input"];
+};
+export type GQLMutationDisconnectConnectedAccountArgs = {
+    id: Scalars["String"]["input"];
+};
+export type GQLMutationDisconnectGmailIntegrationArgs = {
+    email: Scalars["String"]["input"];
+};
+export type GQLMutationDisconnectInferalIntegrationArgs = {
+    id: Scalars["String"]["input"];
+};
+export type GQLMutationExecuteActionAdditionArgs = {
+    input: GQLExecuteActionAdditionInput;
+};
+export type GQLMutationExecuteActionDeletionArgs = {
+    input: GQLExecuteActionDeletionInput;
+};
+export type GQLMutationExecuteActionPlanArgs = {
+    input: GQLExecuteActionPlanInput;
+};
+export type GQLMutationExecuteActionUpdateArgs = {
+    input: GQLExecuteActionUpdateInput;
+};
+export type GQLMutationGenerateStructuredDataArgs = {
+    input: GQLStructuredDataInput;
+};
+export type GQLMutationGoogleAnalyticsSetupConnectArgs = {
+    propertyIds: Array<Scalars["String"]["input"]>;
+};
+export type GQLMutationGoogleSetupConnectArgs = {
+    accountIds: Array<Scalars["String"]["input"]>;
+};
+export type GQLMutationGrantOperatorRoleArgs = {
+    userId: Scalars["String"]["input"];
+};
+export type GQLMutationInitiateUploadArgs = {
+    input: GQLInitiateUploadInput;
+};
+export type GQLMutationLinkUnlinkedDatastoreArgs = {
+    input: GQLLinkUnlinkedDatastoreInput;
+};
+export type GQLMutationLinkedinSetupConnectArgs = {
+    accountIds: Array<Scalars["String"]["input"]>;
+};
+export type GQLMutationManageRdFoxRuleArgs = {
+    input: GQLManageRdFoxRuleInput;
+};
+export type GQLMutationManualActionChangeAssigneesArgs = {
+    assigneesToAdd?: InputMaybe<Array<Scalars["String"]["input"]>>;
+    assigneesToRemove?: InputMaybe<Array<Scalars["String"]["input"]>>;
+    namedGraphIri: Scalars["String"]["input"];
+    subjectIri: Scalars["String"]["input"];
+};
+export type GQLMutationManualActionResolveArgs = {
+    namedGraphIri: Scalars["String"]["input"];
+    resolvedBy: Scalars["String"]["input"];
+    status: GQLManualActionResolveStatus;
+    subjectIri: Scalars["String"]["input"];
+};
+export type GQLMutationMetaSetupConnectArgs = {
+    accountIds: Array<Scalars["String"]["input"]>;
+};
+export type GQLMutationPauseLdesStreamArgs = {
+    url: Scalars["String"]["input"];
+};
+export type GQLMutationProvisionDatastoreArgs = {
+    input: GQLProvisionDatastoreInput;
+};
+export type GQLMutationReconfirmMemoryArgs = {
+    memoryIri: Scalars["IRI"]["input"];
+};
+export type GQLMutationRecordHotelProfileArgs = {
+    input: GQLHotelProfileInput;
+};
+export type GQLMutationRegisterDatastoreArgs = {
+    datastoreId: Scalars["String"]["input"];
+};
+export type GQLMutationReleaseRuleOwnershipArgs = {
+    input: GQLReleaseRuleOwnershipInput;
+};
+export type GQLMutationRemoveDatastoreArgs = {
+    datastoreId: Scalars["String"]["input"];
+};
+export type GQLMutationRenameDatastoreGroupArgs = {
+    input: GQLRenameDatastoreGroupInput;
+};
+export type GQLMutationRestoreDatastoreArgs = {
+    datastoreId: Scalars["String"]["input"];
+};
+export type GQLMutationRestoreMemoryArgs = {
+    memoryIri: Scalars["IRI"]["input"];
+};
+export type GQLMutationResumeLdesStreamArgs = {
+    url: Scalars["String"]["input"];
+};
+export type GQLMutationRevokeOperatorRoleArgs = {
+    userId: Scalars["String"]["input"];
+};
+export type GQLMutationSelfServeProvisionOrganizationArgs = {
+    input: GQLSelfServeProvisionOrganizationInput;
+};
+export type GQLMutationStageRuleOperationArgs = {
+    input: GQLStageRuleOperationInput;
+};
+export type GQLMutationStartLdesStreamArgs = {
+    input: GQLStartLdesStreamInput;
+};
+export type GQLMutationSyncGmailIntegrationArgs = {
+    email: Scalars["String"]["input"];
+};
+export type GQLMutationUpdateMemoryArgs = {
+    input: GQLUpdateMemoryInput;
+};
+export type GQLMutationUpdateUserPreferencesArgs = {
+    input: GQLUpdateUserPreferencesInput;
+};
+export type GQLMutationValidateRdFoxRuleArgs = {
+    input: GQLValidateRdFoxRuleInput;
+};
+export type GQLMutationValidateStagedRulesArgs = {
+    ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]>>;
+};
+export type GQLNodePropertiesResponse = {
+    __typename?: "NodePropertiesResponse";
+    label?: Maybe<Scalars["String"]["output"]>;
+    properties: Array<GQLPropertyChange>;
+    subject: Scalars["String"]["output"];
+    typeName?: Maybe<Scalars["String"]["output"]>;
+};
+export declare enum GQLOrderDirection {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+export type GQLPerson = {
+    __typename?: "Person";
+    name: Scalars["String"]["output"];
+    url?: Maybe<Scalars["String"]["output"]>;
+};
+export declare enum GQLPlanOperation {
+    Added = "ADDED",
+    Updated = "UPDATED"
+}
+export type GQLPlanSample = {
+    __typename?: "PlanSample";
+    description?: Maybe<Scalars["String"]["output"]>;
+    label?: Maybe<Scalars["String"]["output"]>;
+    operation: GQLPlanOperation;
+    properties: Array<GQLPropertyChange>;
+    subject: Scalars["String"]["output"];
+};
+export type GQLPlanValidation = {
+    __typename?: "PlanValidation";
+    completeness: Scalars["Float"]["output"];
+    issues?: Maybe<Array<Scalars["String"]["output"]>>;
+    valid: Scalars["Boolean"]["output"];
+};
+export type GQLPropertyChange = {
+    __typename?: "PropertyChange";
+    beforeObject?: Maybe<Scalars["String"]["output"]>;
+    beforeObjectLabel?: Maybe<Scalars["String"]["output"]>;
+    changeType: GQLPropertyChangeType;
+    object: Scalars["String"]["output"];
+    objectLabel?: Maybe<Scalars["String"]["output"]>;
+    predicate: Scalars["String"]["output"];
+    predicateLabel?: Maybe<Scalars["String"]["output"]>;
+};
+export declare enum GQLPropertyChangeType {
+    Added = "ADDED",
+    Unchanged = "UNCHANGED",
+    Updated = "UPDATED"
+}
+export type GQLProvisionDatastoreInput = {
+    atOrganizationRoot?: InputMaybe<Scalars["Boolean"]["input"]>;
+    name: Scalars["String"]["input"];
+    organizationName: Scalars["String"]["input"];
+    parentPath?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+export type GQLProvisionDatastoreResponse = {
+    __typename?: "ProvisionDatastoreResponse";
+    datastoreId?: Maybe<Scalars["String"]["output"]>;
+    error?: Maybe<Scalars["String"]["output"]>;
+    name?: Maybe<Scalars["String"]["output"]>;
+    path?: Maybe<Scalars["String"]["output"]>;
+    pending: Scalars["Boolean"]["output"];
+    runId?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLQuantitativeValue = GQLApproximateQuantitativeValue | GQLExactQuantitativeValue;
+export type GQLQuery = {
+    __typename?: "Query";
+    accessibleDatastores: Array<GQLAccessibleDatastore>;
+    actionPlanDiff: GQLActionPlanDiffResponse;
+    actionPlanGraph: GQLActionPlanGraphResponse;
+    actionPlanRunHistory: GQLActionPlanRunHistoryResponse;
+    actionPlanSamples: GQLActionPlanSamplesResponse;
+    actionPlans: GQLActionPlansResponse;
+    actionPlansSummary: GQLActionPlansSummaryResponse;
+    availableTeams: GQLAvailableTeamsResponse;
+    connectedAccounts: Array<GQLConnectedAccount>;
+    conversationStarters: GQLConversationStartersResponse;
+    currentFactValue: GQLCurrentFactValueResponse;
+    datastoreProvisioningStatuses: Array<GQLDatastoreProvisioningStatus>;
+    datastoreTree: Array<GQLDatastoreTreeNode>;
+    detectMemoryConflicts: GQLDetectMemoryConflictsResult;
+    explainRDFoxFact: GQLRdFoxExplanationResponse;
+    gmailIntegrations: Array<GQLGmailIntegration>;
+    googleAnalyticsSetupProgress: GQLGoogleAnalyticsSetupProgress;
+    googleSetupProgress: GQLGoogleSetupProgress;
+    inferalIntegrations: Array<GQLInferalIntegration>;
+    knowledgeGraphState: GQLKnowledgeGraphState;
+    ldesStreams: Array<GQLLdesStream>;
+    linkedinSetupProgress?: Maybe<GQLLinkedinSetupProgress>;
+    memories: GQLMemoriesResponse;
+    memoryRedundancyReview: GQLMemoryRedundancyResult;
+    memoryReplaySeries: GQLMemoryReplaySeriesResult;
+    memorySchemas: GQLMemorySchemasResponse;
+    metaSetupProgress: GQLMetaSetupProgress;
+    nodeProperties: GQLNodePropertiesResponse;
+    nodeRelationships: GQLActionPlanGraphResponse;
+    rules: GQLRulesResponse;
+    shaclShapes: GQLShaclShapesResponse;
+    sparqlQuery: GQLSparqlQueryResponse;
+    stripeConnectionStatus: GQLStripeConnectionStatus;
+    supportedActionShapes: GQLSupportedActionShapesResponse;
+    unlinkedDatastores: Array<GQLUnlinkedDatastore>;
+    userPreferences: GQLUserPreferences;
+    validateActionPlan: GQLValidateActionPlanResponse;
+};
+export type GQLQueryActionPlanDiffArgs = {
+    planGraphIri: Scalars["IRI"]["input"];
+};
+export type GQLQueryActionPlanGraphArgs = {
+    limit?: InputMaybe<Scalars["Int"]["input"]>;
+    planGraphIri: Scalars["IRI"]["input"];
+    typeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+};
+export type GQLQueryActionPlanRunHistoryArgs = {
+    limit?: InputMaybe<Scalars["Int"]["input"]>;
+    offset?: InputMaybe<Scalars["Int"]["input"]>;
+    planGraphIris: Array<Scalars["IRI"]["input"]>;
+};
+export type GQLQueryActionPlanSamplesArgs = {
+    limit?: InputMaybe<Scalars["Int"]["input"]>;
+    planGraphIri: Scalars["IRI"]["input"];
+    typeIri: Scalars["IRI"]["input"];
+};
+export type GQLQueryActionPlansArgs = {
+    limit?: InputMaybe<Scalars["PositiveInt"]["input"]>;
+    offset?: InputMaybe<Scalars["NonNegativeInt"]["input"]>;
+    orderBy?: InputMaybe<GQLActionPlanOrderBy>;
+    planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    search?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type GQLQueryConversationStartersArgs = {
+    planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+};
+export type GQLQueryCurrentFactValueArgs = {
+    namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+    object: Scalars["String"]["input"];
+    objectDatatype?: InputMaybe<Scalars["String"]["input"]>;
+    predicate?: InputMaybe<Scalars["String"]["input"]>;
+    subject: Scalars["String"]["input"];
+};
+export type GQLQueryDatastoreProvisioningStatusesArgs = {
+    datastoreIds: Array<Scalars["String"]["input"]>;
+};
+export type GQLQueryDetectMemoryConflictsArgs = {
+    input: GQLDetectMemoryConflictsInput;
+};
+export type GQLQueryExplainRdFoxFactArgs = {
+    namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+    object: Scalars["String"]["input"];
+    objectDatatype?: InputMaybe<Scalars["String"]["input"]>;
+    predicate?: InputMaybe<Scalars["String"]["input"]>;
+    subject: Scalars["String"]["input"];
+    summarize?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+export type GQLQueryKnowledgeGraphStateArgs = {
+    dataVersion?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type GQLQueryMemoriesArgs = {
+    includeArchived?: InputMaybe<Scalars["Boolean"]["input"]>;
+    includeOutOfWindow?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+export type GQLQueryMemoryRedundancyReviewArgs = {
+    input: GQLMemoryConsolidationInput;
+};
+export type GQLQueryMemoryReplaySeriesArgs = {
+    limit?: InputMaybe<Scalars["Int"]["input"]>;
+};
+export type GQLQueryNodePropertiesArgs = {
+    nodeIri: Scalars["String"]["input"];
+    planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+};
+export type GQLQueryNodeRelationshipsArgs = {
+    depth?: InputMaybe<Scalars["Int"]["input"]>;
+    nodeIri: Scalars["IRI"]["input"];
+    planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+};
+export type GQLQueryRulesArgs = {
+    filterByOwner?: InputMaybe<Scalars["String"]["input"]>;
+    includeDependencyGraph?: InputMaybe<Scalars["Boolean"]["input"]>;
+    limit?: InputMaybe<Scalars["Int"]["input"]>;
+    namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+    offset?: InputMaybe<Scalars["Int"]["input"]>;
+    ruleIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    search?: InputMaybe<Scalars["String"]["input"]>;
+    typeFilter?: InputMaybe<Array<Scalars["IRI"]["input"]>>;
+};
+export type GQLQueryShaclShapesArgs = {
+    shapeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    targetClass?: InputMaybe<Scalars["IRI"]["input"]>;
+};
+export type GQLQuerySparqlQueryArgs = {
+    query: Scalars["String"]["input"];
+};
+export type GQLQuerySupportedActionShapesArgs = {
+    rdfType?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type GQLQueryValidateActionPlanArgs = {
+    planGraphIri: Scalars["IRI"]["input"];
+    shaclShapeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+};
+export type GQLRdFoxExplanationResponse = {
+    __typename?: "RDFoxExplanationResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    facts: Scalars["JSON"]["output"];
+    formatted: Scalars["String"]["output"];
+    summary?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLRecordHotelProfileResponse = {
+    __typename?: "RecordHotelProfileResponse";
+    companyIri?: Maybe<Scalars["IRI"]["output"]>;
+    error?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLRegisterDatastoreResponse = {
+    __typename?: "RegisterDatastoreResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export declare enum GQLRelayIntegrationStatus {
+    Active = "ACTIVE",
+    Creating = "CREATING",
+    Deleted = "DELETED",
+    Deleting = "DELETING",
+    Error = "ERROR",
+    Failed = "FAILED",
+    Initializing = "INITIALIZING",
+    Paused = "PAUSED",
+    Pending = "PENDING"
+}
+export type GQLReleaseRuleOwnershipInput = {
+    humanIntent: Scalars["String"]["input"];
+    ruleIri: Scalars["IRI"]["input"];
+};
+export type GQLReleaseRuleOwnershipResponse = {
+    __typename?: "ReleaseRuleOwnershipResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    newOwner: Scalars["String"]["output"];
+    previousOwner: Scalars["String"]["output"];
+    ruleIri: Scalars["IRI"]["output"];
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLRemoveDatastoreResponse = {
+    __typename?: "RemoveDatastoreResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLRenameDatastoreGroupInput = {
+    id: Scalars["String"]["input"];
+    isOrganization: Scalars["Boolean"]["input"];
+    name: Scalars["String"]["input"];
+    organizationId: Scalars["String"]["input"];
+};
+export type GQLRenameDatastoreGroupResponse = {
+    __typename?: "RenameDatastoreGroupResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLRestoreDatastoreResponse = {
+    __typename?: "RestoreDatastoreResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLRestoreMemoryResponse = {
+    __typename?: "RestoreMemoryResponse";
+    blockedByIri?: Maybe<Scalars["IRI"]["output"]>;
+    blockedByLabel?: Maybe<Scalars["String"]["output"]>;
+    error?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLRevokeOperatorRoleResponse = {
+    __typename?: "RevokeOperatorRoleResponse";
+    id: Scalars["String"]["output"];
+    operator: Scalars["Boolean"]["output"];
+};
+export type GQLRule = {
+    __typename?: "Rule";
+    committedRule?: Maybe<Scalars["DatalogRule"]["output"]>;
+    committedVocabulary?: Maybe<GQLRuleVocabulary>;
+    component?: Maybe<Scalars["IRI"]["output"]>;
+    dependentRules: Array<Scalars["IRI"]["output"]>;
+    dependsNegativelyOn: Array<Scalars["IRI"]["output"]>;
+    dependsPositivelyOn: Array<Scalars["IRI"]["output"]>;
+    isModified: Scalars["Boolean"]["output"];
+    isStaged: Scalars["Boolean"]["output"];
+    mentionedTypes: Array<Scalars["IRI"]["output"]>;
+    namedGraphs: Array<Scalars["IRI"]["output"]>;
+    ownedBy?: Maybe<GQLRuleOwnership>;
+    ruleIri: Scalars["IRI"]["output"];
+    stagedRule?: Maybe<Scalars["DatalogRule"]["output"]>;
+    stratumIndex?: Maybe<Scalars["Int"]["output"]>;
+    unifiesWith: Array<Scalars["IRI"]["output"]>;
+};
+export declare enum GQLRuleOperation {
+    Add = "ADD",
+    Change = "CHANGE",
+    Remove = "REMOVE"
+}
+export declare enum GQLRuleOwner {
+    Manta = "MANTA",
+    User = "USER"
+}
+export type GQLRuleOwnership = {
+    __typename?: "RuleOwnership";
+    type: GQLRuleOwner;
+    userId?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLRuleStructure = {
+    __typename?: "RuleStructure";
+    bodyFormulas: Scalars["Int"]["output"];
+    headAtoms: Scalars["Int"]["output"];
+    variables: Array<Scalars["String"]["output"]>;
+};
+export type GQLRuleVocabulary = {
+    __typename?: "RuleVocabulary";
+    body: GQLRuleVocabularyPosition;
+    error?: Maybe<Scalars["String"]["output"]>;
+    head: GQLRuleVocabularyPosition;
+};
+export type GQLRuleVocabularyPosition = {
+    __typename?: "RuleVocabularyPosition";
+    classes: Array<Scalars["IRI"]["output"]>;
+    predicates: Array<Scalars["IRI"]["output"]>;
+};
+export type GQLRulesResponse = {
+    __typename?: "RulesResponse";
+    count: Scalars["Int"]["output"];
+    error?: Maybe<Scalars["String"]["output"]>;
+    jsonLdGraph: Scalars["JSON"]["output"];
+    rules: Array<GQLRule>;
+};
+export type GQLSelfServeInvitationInput = {
+    email: Scalars["String"]["input"];
+    role: Scalars["String"]["input"];
+    teams?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+export declare enum GQLSelfServeInvitationOutcome {
+    AlreadyMember = "ALREADY_MEMBER",
+    Failed = "FAILED",
+    Invited = "INVITED"
+}
+export type GQLSelfServeInvitationResult = {
+    __typename?: "SelfServeInvitationResult";
+    email: Scalars["String"]["output"];
+    message?: Maybe<Scalars["String"]["output"]>;
+    outcome: GQLSelfServeInvitationOutcome;
+    userId?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLSelfServeProvisionOrganizationInput = {
+    invitations?: InputMaybe<Array<GQLSelfServeInvitationInput>>;
+    jobTitle?: InputMaybe<Scalars["String"]["input"]>;
+    organizationName: Scalars["String"]["input"];
+    sendInvitationEmails?: InputMaybe<Scalars["Boolean"]["input"]>;
+    teams?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+export type GQLSelfServeProvisionOrganizationResponse = {
+    __typename?: "SelfServeProvisionOrganizationResponse";
+    datastores: Array<GQLSelfServeProvisionedDatastore>;
+    error?: Maybe<Scalars["String"]["output"]>;
+    invitations: Array<GQLSelfServeInvitationResult>;
+    organizationAlias?: Maybe<Scalars["String"]["output"]>;
+    organizationId?: Maybe<Scalars["String"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLSelfServeProvisionedDatastore = {
+    __typename?: "SelfServeProvisionedDatastore";
+    datastoreId: Scalars["String"]["output"];
+    name: Scalars["String"]["output"];
+    path: Scalars["String"]["output"];
+    pending: Scalars["Boolean"]["output"];
+    runId?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLSemanticDiff = {
+    __typename?: "SemanticDiff";
+    creates: Scalars["Int"]["output"];
+    deletes: Scalars["Int"]["output"];
+    operations?: Maybe<Scalars["String"]["output"]>;
+    updates: Scalars["Int"]["output"];
+};
+export declare enum GQLShaclSeverity {
+    Info = "INFO",
+    Violation = "VIOLATION",
+    Warning = "WARNING"
+}
+export type GQLShaclShapesResponse = {
+    __typename?: "ShaclShapesResponse";
+    shapeIris: Array<Scalars["IRI"]["output"]>;
+    turtle: Scalars["String"]["output"];
+};
+export type GQLShaclValidationReport = {
+    __typename?: "ShaclValidationReport";
+    conforms: Scalars["Boolean"]["output"];
+    resultCount: Scalars["Int"]["output"];
+    results: Array<GQLShaclValidationResult>;
+};
+export type GQLShaclValidationResult = {
+    __typename?: "ShaclValidationResult";
+    focusNode: Scalars["String"]["output"];
+    message?: Maybe<Scalars["String"]["output"]>;
+    resultPath?: Maybe<Scalars["String"]["output"]>;
+    severity: GQLShaclSeverity;
+    sourceConstraintComponent: Scalars["String"]["output"];
+    sourceShape?: Maybe<Scalars["String"]["output"]>;
+    value?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLShopifyProviderInput = {
+    apiKey: Scalars["String"]["input"];
+    shopId: Scalars["String"]["input"];
+};
+export type GQLSparqlJsonResults = {
+    __typename?: "SparqlJsonResults";
+    head: GQLSparqlResultHead;
+    results: GQLSparqlResultSet;
+};
+export type GQLSparqlQueryResponse = {
+    __typename?: "SparqlQueryResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    graph?: Maybe<Scalars["JSON"]["output"]>;
+    results?: Maybe<GQLSparqlJsonResults>;
+};
+export type GQLSparqlResultHead = {
+    __typename?: "SparqlResultHead";
+    link?: Maybe<Array<Scalars["String"]["output"]>>;
+    vars?: Maybe<Array<Scalars["String"]["output"]>>;
+};
+export type GQLSparqlResultSet = {
+    __typename?: "SparqlResultSet";
+    bindings: Array<Scalars["JSON"]["output"]>;
+};
+export type GQLStageRuleOperationInput = {
+    humanIntent: Scalars["String"]["input"];
+    newRule?: InputMaybe<Scalars["DatalogRule"]["input"]>;
+    operation: GQLRuleOperation;
+    ruleIri?: InputMaybe<Scalars["IRI"]["input"]>;
+};
+export type GQLStageRuleOperationResponse = {
+    __typename?: "StageRuleOperationResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    operation: Scalars["String"]["output"];
+    ruleIri?: Maybe<Scalars["IRI"]["output"]>;
+    success: Scalars["Boolean"]["output"];
+};
+export type GQLStartLdesStreamInput = {
+    after?: InputMaybe<Scalars["DateTime"]["input"]>;
+    auth?: InputMaybe<GQLLdesStreamAuthInput>;
+    url: Scalars["String"]["input"];
+};
+export type GQLStripeConnectionStatus = {
+    __typename?: "StripeConnectionStatus";
+    connected: Scalars["Boolean"]["output"];
+    stripeAccountId?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLStructuredDataInput = {
+    context?: InputMaybe<Scalars["JSONObject"]["input"]>;
+    prompt: Scalars["String"]["input"];
+    schema: Scalars["JSONObject"]["input"];
+};
+export type GQLStructuredDataResponse = {
+    __typename?: "StructuredDataResponse";
+    data?: Maybe<Scalars["JSON"]["output"]>;
+    error?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLSubscription = {
+    __typename?: "Subscription";
+    actionPlanExecution: GQLActionPlanExecutionEvent;
+};
+export type GQLSubscriptionActionPlanExecutionArgs = {
+    byTypes: Array<GQLActionPlanExecutionInput>;
+    planGraphIri: Scalars["String"]["input"];
+    workflowId: Scalars["String"]["input"];
+};
+export type GQLSupportedActionShape = {
+    __typename?: "SupportedActionShape";
+    actionShape: Scalars["IRI"]["output"];
+    operations: Array<Scalars["String"]["output"]>;
+    rdfTypes: Array<Scalars["IRI"]["output"]>;
+    supportsCreate: Scalars["Boolean"]["output"];
+    supportsDelete: Scalars["Boolean"]["output"];
+    supportsUpdate: Scalars["Boolean"]["output"];
+};
+export type GQLSupportedActionShapesResponse = {
+    __typename?: "SupportedActionShapesResponse";
+    count: Scalars["Int"]["output"];
+    error?: Maybe<Scalars["String"]["output"]>;
+    supportedActionShapes: Array<GQLSupportedActionShape>;
+};
+export type GQLTestTripleInput = {
+    object: GQLTestTripleObjectInput;
+    predicate: Scalars["String"]["input"];
+    subject: Scalars["String"]["input"];
+};
+export type GQLTestTripleObjectInput = {
+    datatype?: InputMaybe<Scalars["String"]["input"]>;
+    language?: InputMaybe<Scalars["String"]["input"]>;
+    type: GQLTestTripleObjectType;
+    value: Scalars["String"]["input"];
+};
+export declare enum GQLTestTripleObjectType {
+    Iri = "IRI",
+    Literal = "LITERAL"
+}
+export type GQLTriplewhaleProviderInput = {
+    apiKey: Scalars["String"]["input"];
+    shopId: Scalars["String"]["input"];
+};
+export type GQLUnlinkedDatastore = {
+    __typename?: "UnlinkedDatastore";
+    id: Scalars["String"]["output"];
+};
+export type GQLUpdateMemoryInput = {
+    aboutEntityIris?: InputMaybe<Array<Scalars["IRI"]["input"]>>;
+    confidence?: InputMaybe<Scalars["Float"]["input"]>;
+    customProperties?: InputMaybe<Scalars["JSONObject"]["input"]>;
+    description?: InputMaybe<Scalars["String"]["input"]>;
+    importance?: InputMaybe<Scalars["Int"]["input"]>;
+    iri: Scalars["IRI"]["input"];
+    kind?: InputMaybe<GQLMemoryKind>;
+    label: Scalars["String"]["input"];
+    memorySubclass?: InputMaybe<Scalars["IRI"]["input"]>;
+    memoryTrustedUntil?: InputMaybe<Scalars["DateTime"]["input"]>;
+    memoryValidFrom?: InputMaybe<Scalars["DateTime"]["input"]>;
+    memoryValidUntil?: InputMaybe<Scalars["DateTime"]["input"]>;
+    scope?: InputMaybe<GQLMemoryScope>;
+    supersedesMemoryIris?: InputMaybe<Array<Scalars["IRI"]["input"]>>;
+    teams?: InputMaybe<Array<Scalars["String"]["input"]>>;
+};
+export type GQLUpdateMemoryResponse = {
+    __typename?: "UpdateMemoryResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    memory?: Maybe<GQLMemory>;
+};
+export type GQLUpdateUserPreferencesInput = {
+    defaultMemoryTtlDays?: InputMaybe<Scalars["Int"]["input"]>;
+    jobTitle?: InputMaybe<Scalars["String"]["input"]>;
+};
+export type GQLUpdateUserPreferencesResponse = {
+    __typename?: "UpdateUserPreferencesResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    preferences?: Maybe<GQLUserPreferences>;
+};
+export type GQLUploadPartUrl = {
+    __typename?: "UploadPartUrl";
+    partNumber: Scalars["PositiveInt"]["output"];
+    url: Scalars["String"]["output"];
+};
+export type GQLUploadedPartInput = {
+    etag: Scalars["String"]["input"];
+    partNumber: Scalars["PositiveInt"]["input"];
+};
+export type GQLUserPreferences = {
+    __typename?: "UserPreferences";
+    defaultMemoryTtlDays?: Maybe<Scalars["Int"]["output"]>;
+    jobTitle?: Maybe<Scalars["String"]["output"]>;
+};
+export type GQLValidateActionPlanResponse = {
+    __typename?: "ValidateActionPlanResponse";
+    completeness: Scalars["Float"]["output"];
+    conforms: Scalars["Boolean"]["output"];
+    error?: Maybe<Scalars["String"]["output"]>;
+    planGraphIri: Scalars["IRI"]["output"];
+    report: GQLShaclValidationReport;
+    shaclShapeIri?: Maybe<Scalars["IRI"]["output"]>;
+    valid: Scalars["Boolean"]["output"];
+};
+export type GQLValidateRdFoxRuleInput = {
+    rule: Scalars["DatalogRule"]["input"];
+};
+export type GQLValidateRdFoxRuleResponse = {
+    __typename?: "ValidateRDFoxRuleResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    ruleStructure?: Maybe<GQLRuleStructure>;
+    valid: Scalars["Boolean"]["output"];
+};
+export type GQLValidateStagedRulesResponse = {
+    __typename?: "ValidateStagedRulesResponse";
+    error?: Maybe<Scalars["String"]["output"]>;
+    isStratifiable: Scalars["Boolean"]["output"];
+    isValid: Scalars["Boolean"]["output"];
+    nonStratifiableComponents: Array<Scalars["String"]["output"]>;
+    syntaxErrors: Array<Scalars["String"]["output"]>;
+};
+export type GQLWoocommerceProviderInput = {
+    consumerKey: Scalars["String"]["input"];
+    consumerSecret: Scalars["String"]["input"];
+    sourceUrl: Scalars["String"]["input"];
+};
+export type GQLMemoryFieldsFragment = {
+    __typename?: "Memory";
+    iri: string;
+    label: string;
+    description?: string | null;
+    confidence?: number | null;
+    extractedAt: Date | string;
+    memorySource: string;
+    scope: GQLMemoryScope;
+    kind: GQLMemoryKind;
+    memoryValidFrom?: Date | string | null;
+    memoryValidUntil?: Date | string | null;
+    memoryTrustedUntil?: Date | string | null;
+    memoryLastUsedAt?: Date | string | null;
+    memoryUseCount: number;
+    memoryCiteCount: number;
+    memoryEvidence?: string | null;
+    aboutEntityIris: Array<string>;
+    supersedesMemory?: string | null;
+    teams: Array<string>;
+    importance: number;
+    memorySubclass?: string | null;
+    customProperties?: Record<string, unknown> | null;
+};
+export type GQLMemoryMutationResultFragment = {
+    __typename?: "UpdateMemoryResponse";
+    error?: string | null;
+    memory?: {
+        __typename?: "Memory";
+        iri: string;
+        label: string;
+        description?: string | null;
+        confidence?: number | null;
+        extractedAt: Date | string;
+        memorySource: string;
+        scope: GQLMemoryScope;
+        kind: GQLMemoryKind;
+        memoryValidFrom?: Date | string | null;
+        memoryValidUntil?: Date | string | null;
+        memoryTrustedUntil?: Date | string | null;
+        memoryLastUsedAt?: Date | string | null;
+        memoryUseCount: number;
+        memoryCiteCount: number;
+        memoryEvidence?: string | null;
+        aboutEntityIris: Array<string>;
+        supersedesMemory?: string | null;
+        teams: Array<string>;
+        importance: number;
+        memorySubclass?: string | null;
+        customProperties?: Record<string, unknown> | null;
+    } | null;
+};
+export type GQLAbortUploadMutationVariables = Exact<{
+    input: GQLAbortUploadInput;
+}>;
+export type GQLAbortUploadMutation = {
+    __typename?: "Mutation";
+    abortUpload: {
+        __typename?: "AbortUploadResponse";
+        ok: boolean;
+    };
+};
+export type GQLBringDatastoreOnlineMutationVariables = Exact<{
+    datastoreId?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+export type GQLBringDatastoreOnlineMutation = {
+    __typename?: "Mutation";
+    bringDatastoreOnline: {
+        __typename?: "BringDatastoreOnlineResponse";
+        success: boolean;
+        error?: string | null;
+    };
+};
+export type GQLCancelActionPlanMutationVariables = Exact<{
+    planIri: Scalars["String"]["input"];
+}>;
+export type GQLCancelActionPlanMutation = {
+    __typename?: "Mutation";
+    cancelActionPlan: {
+        __typename?: "CancelActionPlanResponse";
+        success: boolean;
+        error?: string | null;
+    };
+};
+export type GQLClearStagedRulesMutationVariables = Exact<{
+    ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
+}>;
+export type GQLClearStagedRulesMutation = {
+    __typename?: "Mutation";
+    clearStagedRules: {
+        __typename?: "ClearStagedRulesResponse";
+        success: boolean;
+        rulesCleared: number;
+        error?: string | null;
+    };
+};
+export type GQLCommitStagedRulesMutationVariables = Exact<{
+    dryRun?: InputMaybe<Scalars["Boolean"]["input"]>;
+    ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
+}>;
+export type GQLCommitStagedRulesMutation = {
+    __typename?: "Mutation";
+    commitStagedRules: {
+        __typename?: "CommitStagedRulesResponse";
+        success: boolean;
+        rulesAdded: number;
+        rulesUpdated: number;
+        rulesDeleted: number;
+        error?: string | null;
+    };
+};
+export type GQLCompleteUploadMutationVariables = Exact<{
+    input: GQLCompleteUploadInput;
+}>;
+export type GQLCompleteUploadMutation = {
+    __typename?: "Mutation";
+    completeUpload: {
+        __typename?: "CompleteUploadResponse";
+        fileIri: string;
+        mediaType: string;
+    };
+};
+export type GQLConsolidateMemoriesMutationVariables = Exact<{
+    input: GQLConsolidateMemoriesInput;
+}>;
+export type GQLConsolidateMemoriesMutation = {
+    __typename?: "Mutation";
+    consolidateMemories: {
+        __typename?: "CreateMemoryResponse";
+        error?: string | null;
+        memory?: {
+            __typename?: "Memory";
+            iri: string;
+            label: string;
+            description?: string | null;
+            confidence?: number | null;
+            extractedAt: Date | string;
+            memorySource: string;
+            scope: GQLMemoryScope;
+            kind: GQLMemoryKind;
+            memoryValidFrom?: Date | string | null;
+            memoryValidUntil?: Date | string | null;
+            memoryTrustedUntil?: Date | string | null;
+            memoryLastUsedAt?: Date | string | null;
+            memoryUseCount: number;
+            memoryCiteCount: number;
+            memoryEvidence?: string | null;
+            aboutEntityIris: Array<string>;
+            supersedesMemory?: string | null;
+            teams: Array<string>;
+            importance: number;
+            memorySubclass?: string | null;
+            customProperties?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type GQLCreateInferalIntegrationMutationVariables = Exact<{
+    input: GQLCreateInferalIntegrationInput;
+}>;
+export type GQLCreateInferalIntegrationMutation = {
+    __typename?: "Mutation";
+    createInferalIntegration: {
+        __typename?: "CreateInferalIntegrationResponse";
+        status: GQLRelayIntegrationStatus;
+        inferalIntegrationId?: string | null;
+        streamId?: string | null;
+        streamUrl?: string | null;
+        error?: string | null;
+    };
+};
+export type GQLCreateMemoryMutationVariables = Exact<{
+    input: GQLCreateMemoryInput;
+}>;
+export type GQLCreateMemoryMutation = {
+    __typename?: "Mutation";
+    createMemory: {
+        __typename?: "CreateMemoryResponse";
+        error?: string | null;
+        memory?: {
+            __typename?: "Memory";
+            createdBy?: string | null;
+            iri: string;
+            label: string;
+            description?: string | null;
+            confidence?: number | null;
+            extractedAt: Date | string;
+            memorySource: string;
+            scope: GQLMemoryScope;
+            kind: GQLMemoryKind;
+            memoryValidFrom?: Date | string | null;
+            memoryValidUntil?: Date | string | null;
+            memoryTrustedUntil?: Date | string | null;
+            memoryLastUsedAt?: Date | string | null;
+            memoryUseCount: number;
+            memoryCiteCount: number;
+            memoryEvidence?: string | null;
+            aboutEntityIris: Array<string>;
+            supersedesMemory?: string | null;
+            teams: Array<string>;
+            importance: number;
+            memorySubclass?: string | null;
+            customProperties?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type GQLDeleteActionPlanMutationVariables = Exact<{
+    input: GQLDeleteActionPlanInput;
+}>;
+export type GQLDeleteActionPlanMutation = {
+    __typename?: "Mutation";
+    deleteActionPlan: {
+        __typename?: "DeleteActionPlanResponse";
+        success: boolean;
+        error?: string | null;
+    };
+};
+export type GQLDeleteLdesStreamMutationVariables = Exact<{
+    url: Scalars["String"]["input"];
+}>;
+export type GQLDeleteLdesStreamMutation = {
+    __typename?: "Mutation";
+    deleteLDESStream: {
+        __typename?: "LDESStreamDeleteResponse";
+        success: boolean;
+        stream?: {
+            __typename?: "LDESStream";
+            url: string;
+            phase: GQLLdesStreamPhase;
+        } | null;
+    };
+};
+export type GQLDeleteMemoryMutationVariables = Exact<{
+    memoryIri: Scalars["IRI"]["input"];
+}>;
+export type GQLDeleteMemoryMutation = {
+    __typename?: "Mutation";
+    deleteMemory: {
+        __typename?: "DeleteMemoryResponse";
+        success: boolean;
+        error?: string | null;
+    };
+};
+export type GQLDeleteUserAccountMutationVariables = Exact<{
+    userId: Scalars["String"]["input"];
+}>;
+export type GQLDeleteUserAccountMutation = {
+    __typename?: "Mutation";
+    deleteUserAccount: {
+        __typename?: "DeleteUserAccountResponse";
+        id: string;
+        deleted: boolean;
+    };
+};
+export type GQLDisconnectConnectedAccountMutationVariables = Exact<{
+    id: Scalars["String"]["input"];
+}>;
+export type GQLDisconnectConnectedAccountMutation = {
+    __typename?: "Mutation";
+    disconnectConnectedAccount: {
+        __typename?: "DisconnectConnectedAccountResponse";
+        success: boolean;
+    };
+};
+export type GQLDisconnectGmailIntegrationMutationVariables = Exact<{
+    email: Scalars["String"]["input"];
+}>;
+export type GQLDisconnectGmailIntegrationMutation = {
+    __typename?: "Mutation";
+    disconnectGmailIntegration: {
+        __typename?: "DisconnectGmailIntegrationResponse";
+        success: boolean;
+    };
+};
+export type GQLDisconnectInferalIntegrationMutationVariables = Exact<{
+    id: Scalars["String"]["input"];
+}>;
+export type GQLDisconnectInferalIntegrationMutation = {
+    __typename?: "Mutation";
+    disconnectInferalIntegration: {
+        __typename?: "DisconnectInferalIntegrationResponse";
+        success: boolean;
+    };
+};
+export type GQLExecuteAgentActionAdditionMutationVariables = Exact<{
+    input: GQLExecuteActionAdditionInput;
+}>;
+export type GQLExecuteAgentActionAdditionMutation = {
+    __typename?: "Mutation";
+    executeActionAddition: {
+        __typename?: "ExecuteActionResponse";
+        success: boolean;
+        workflowId?: string | null;
+        namedGraphIri?: string | null;
+        error?: string | null;
+        code?: GQLExecuteActionErrorCode | null;
+    };
+};
+export type GQLExecuteAgentActionDeletionMutationVariables = Exact<{
+    input: GQLExecuteActionDeletionInput;
+}>;
+export type GQLExecuteAgentActionDeletionMutation = {
+    __typename?: "Mutation";
+    executeActionDeletion: {
+        __typename?: "ExecuteActionResponse";
+        success: boolean;
+        workflowId?: string | null;
+        namedGraphIri?: string | null;
+        error?: string | null;
+        code?: GQLExecuteActionErrorCode | null;
+    };
+};
+export type GQLExecuteAgentActionPlanMutationVariables = Exact<{
+    input: GQLExecuteActionPlanInput;
+}>;
+export type GQLExecuteAgentActionPlanMutation = {
+    __typename?: "Mutation";
+    executeActionPlan: {
+        __typename?: "ExecuteActionPlanResponse";
+        success: boolean;
+        content: string;
+        workflowId?: string | null;
+        error?: string | null;
+        planValidation?: {
+            __typename?: "PlanValidation";
+            valid: boolean;
+            completeness: number;
+            issues?: Array<string> | null;
+        } | null;
+        semanticDiff?: {
+            __typename?: "SemanticDiff";
+            creates: number;
+            updates: number;
+            deletes: number;
+            operations?: string | null;
+        } | null;
+    };
+};
+export type GQLExecuteAgentActionUpdateMutationVariables = Exact<{
+    input: GQLExecuteActionUpdateInput;
+}>;
+export type GQLExecuteAgentActionUpdateMutation = {
+    __typename?: "Mutation";
+    executeActionUpdate: {
+        __typename?: "ExecuteActionResponse";
+        success: boolean;
+        workflowId?: string | null;
+        namedGraphIri?: string | null;
+        error?: string | null;
+        code?: GQLExecuteActionErrorCode | null;
+    };
+};
+export type GQLGenerateStructuredDataMutationVariables = Exact<{
+    input: GQLStructuredDataInput;
+}>;
+export type GQLGenerateStructuredDataMutation = {
+    __typename?: "Mutation";
+    generateStructuredData: {
+        __typename?: "StructuredDataResponse";
+        data?: unknown | null;
+        error?: string | null;
+    };
+};
+export type GQLGoogleAnalyticsSetupConnectMutationVariables = Exact<{
+    propertyIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>;
+export type GQLGoogleAnalyticsSetupConnectMutation = {
+    __typename?: "Mutation";
+    googleAnalyticsSetupConnect: {
+        __typename?: "GoogleAnalyticsSetupProgress";
+        state: Array<GQLGoogleSetupStateEnum>;
+        properties?: Array<{
+            __typename?: "GoogleAnalyticsProperty";
+            id: string;
+            name?: string | null;
+            parent?: string | null;
+        }> | null;
+        lastError?: {
+            __typename?: "GoogleSetupLastError";
+            severity: string;
+            title?: string | null;
+            message: string;
+        } | null;
+    };
+};
+export type GQLGoogleSetupConnectMutationVariables = Exact<{
+    accountIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>;
+export type GQLGoogleSetupConnectMutation = {
+    __typename?: "Mutation";
+    googleSetupConnect: {
+        __typename?: "GoogleSetupProgress";
+        state: Array<GQLGoogleSetupStateEnum>;
+        accounts?: Array<{
+            __typename?: "GoogleAdAccount";
+            id: string;
+            name?: string | null;
+            parent?: string | null;
+        }> | null;
+        lastError?: {
+            __typename?: "GoogleSetupLastError";
+            severity: string;
+            title?: string | null;
+            message: string;
+        } | null;
+    };
+};
+export type GQLGrantOperatorRoleMutationVariables = Exact<{
+    userId: Scalars["String"]["input"];
+}>;
+export type GQLGrantOperatorRoleMutation = {
+    __typename?: "Mutation";
+    grantOperatorRole: {
+        __typename?: "GrantOperatorRoleResponse";
+        id: string;
+        operator: boolean;
+    };
+};
+export type GQLInitiateUploadMutationVariables = Exact<{
+    input: GQLInitiateUploadInput;
+}>;
+export type GQLInitiateUploadMutation = {
+    __typename?: "Mutation";
+    initiateUpload: {
+        __typename?: "InitiateUploadResponse";
+        uploadId: string;
+        storageKey: string;
+        partUrls: Array<{
+            __typename?: "UploadPartUrl";
+            partNumber: number;
+            url: string;
+        }>;
+    };
+};
+export type GQLLinkUnlinkedDatastoreMutationVariables = Exact<{
+    input: GQLLinkUnlinkedDatastoreInput;
+}>;
+export type GQLLinkUnlinkedDatastoreMutation = {
+    __typename?: "Mutation";
+    linkUnlinkedDatastore: {
+        __typename?: "ProvisionDatastoreResponse";
+        success: boolean;
+        error?: string | null;
+        datastoreId?: string | null;
+        name?: string | null;
+        path?: string | null;
+    };
+};
+export type GQLLinkedinSetupConnectMutationVariables = Exact<{
+    accountIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>;
+export type GQLLinkedinSetupConnectMutation = {
+    __typename?: "Mutation";
+    linkedinSetupConnect?: {
+        __typename?: "LinkedinSetupProgress";
+        state: Array<string>;
+        accounts?: Array<{
+            __typename?: "LinkedinAdAccount";
+            id: string;
+            name: string;
+        }> | null;
+        lastError?: {
+            __typename?: "LinkedinSetupError";
+            severity: string;
+            message: string;
+            title?: string | null;
+        } | null;
+    } | null;
+};
+export type GQLChangeManualActionAssigneesMutationVariables = Exact<{
+    namedGraphIri: Scalars["String"]["input"];
+    subjectIri: Scalars["String"]["input"];
+    assigneesToAdd?: InputMaybe<Array<Scalars["String"]["input"]> | Scalars["String"]["input"]>;
+    assigneesToRemove?: InputMaybe<Array<Scalars["String"]["input"]> | Scalars["String"]["input"]>;
+}>;
+export type GQLChangeManualActionAssigneesMutation = {
+    __typename?: "Mutation";
+    manualActionChangeAssignees?: {
+        __typename?: "ManualActionChangeAssigneesPayload";
+        manualActionProgress: {
+            __typename?: "ManualActionProgressResult";
+            state: Array<string>;
+            manualAction?: {
+                __typename?: "ManualActionResult";
+                status?: string | null;
+                assignees: Array<string>;
+            } | null;
+        };
+    } | null;
+};
+export type GQLResolveManualActionMutationVariables = Exact<{
+    namedGraphIri: Scalars["String"]["input"];
+    subjectIri: Scalars["String"]["input"];
+    resolvedBy: Scalars["String"]["input"];
+    status: GQLManualActionResolveStatus;
+}>;
+export type GQLResolveManualActionMutation = {
+    __typename?: "Mutation";
+    manualActionResolve?: {
+        __typename?: "ManualActionResolvePayload";
+        manualActionProgress: {
+            __typename?: "ManualActionProgressResult";
+            state: Array<string>;
+            manualAction?: {
+                __typename?: "ManualActionResult";
+                status?: string | null;
+                assignees: Array<string>;
+            } | null;
+        };
+    } | null;
+};
+export type GQLMaterializeOntologyCoverageMutationVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLMaterializeOntologyCoverageMutation = {
+    __typename?: "Mutation";
+    materializeOntologyCoverage: {
+        __typename?: "MaterializeOntologyCoverageResponse";
+        success: boolean;
+        error?: string | null;
+    };
+};
+export type GQLMetaSetupConnectMutationVariables = Exact<{
+    accountIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>;
+export type GQLMetaSetupConnectMutation = {
+    __typename?: "Mutation";
+    metaSetupConnect: {
+        __typename?: "MetaSetupProgress";
+        state: Array<GQLMetaSetupStateEnum>;
+        accounts?: Array<{
+            __typename?: "MetaAdAccount";
+            id: string;
+            name?: string | null;
+            parent?: string | null;
+        }> | null;
+        lastError?: {
+            __typename?: "MetaSetupLastError";
+            severity: string;
+            title?: string | null;
+            message: string;
+        } | null;
+    };
+};
+export type GQLPauseLdesStreamMutationVariables = Exact<{
+    url: Scalars["String"]["input"];
+}>;
+export type GQLPauseLdesStreamMutation = {
+    __typename?: "Mutation";
+    pauseLDESStream: {
+        __typename?: "LDESStreamResponse";
+        success: boolean;
+        stream: {
+            __typename?: "LDESStream";
+            url: string;
+            phase: GQLLdesStreamPhase;
+        };
+    };
+};
+export type GQLProvisionDatastoreMutationVariables = Exact<{
+    input: GQLProvisionDatastoreInput;
+}>;
+export type GQLProvisionDatastoreMutation = {
+    __typename?: "Mutation";
+    provisionDatastore: {
+        __typename?: "ProvisionDatastoreResponse";
+        success: boolean;
+        error?: string | null;
+        datastoreId?: string | null;
+        name?: string | null;
+        path?: string | null;
+        pending: boolean;
+        runId?: string | null;
+    };
+};
+export type GQLReconfirmMemoryMutationVariables = Exact<{
+    memoryIri: Scalars["IRI"]["input"];
+}>;
+export type GQLReconfirmMemoryMutation = {
+    __typename?: "Mutation";
+    reconfirmMemory: {
+        __typename?: "UpdateMemoryResponse";
+        error?: string | null;
+        memory?: {
+            __typename?: "Memory";
+            iri: string;
+            label: string;
+            description?: string | null;
+            confidence?: number | null;
+            extractedAt: Date | string;
+            memorySource: string;
+            scope: GQLMemoryScope;
+            kind: GQLMemoryKind;
+            memoryValidFrom?: Date | string | null;
+            memoryValidUntil?: Date | string | null;
+            memoryTrustedUntil?: Date | string | null;
+            memoryLastUsedAt?: Date | string | null;
+            memoryUseCount: number;
+            memoryCiteCount: number;
+            memoryEvidence?: string | null;
+            aboutEntityIris: Array<string>;
+            supersedesMemory?: string | null;
+            teams: Array<string>;
+            importance: number;
+            memorySubclass?: string | null;
+            customProperties?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type GQLRegisterDatastoreMutationVariables = Exact<{
+    datastoreId: Scalars["String"]["input"];
+}>;
+export type GQLRegisterDatastoreMutation = {
+    __typename?: "Mutation";
+    registerDatastore: {
+        __typename?: "RegisterDatastoreResponse";
+        success: boolean;
+        error?: string | null;
+    };
+};
+export type GQLReleaseRuleOwnershipMutationVariables = Exact<{
+    input: GQLReleaseRuleOwnershipInput;
+}>;
+export type GQLReleaseRuleOwnershipMutation = {
+    __typename?: "Mutation";
+    releaseRuleOwnership: {
+        __typename?: "ReleaseRuleOwnershipResponse";
+        success: boolean;
+        ruleIri: string;
+        previousOwner: string;
+        error?: string | null;
+    };
+};
+export type GQLRemoveDatastoreMutationVariables = Exact<{
+    datastoreId: Scalars["String"]["input"];
+}>;
+export type GQLRemoveDatastoreMutation = {
+    __typename?: "Mutation";
+    removeDatastore: {
+        __typename?: "RemoveDatastoreResponse";
+        success: boolean;
+        error?: string | null;
+    };
+};
+export type GQLRenameDatastoreGroupMutationVariables = Exact<{
+    input: GQLRenameDatastoreGroupInput;
+}>;
+export type GQLRenameDatastoreGroupMutation = {
+    __typename?: "Mutation";
+    renameDatastoreGroup: {
+        __typename?: "RenameDatastoreGroupResponse";
+        success: boolean;
+        error?: string | null;
+    };
+};
+export type GQLRestoreDatastoreMutationVariables = Exact<{
+    datastoreId: Scalars["String"]["input"];
+}>;
+export type GQLRestoreDatastoreMutation = {
+    __typename?: "Mutation";
+    restoreDatastore: {
+        __typename?: "RestoreDatastoreResponse";
+        success: boolean;
+        error?: string | null;
+    };
+};
+export type GQLRestoreMemoryMutationVariables = Exact<{
+    memoryIri: Scalars["IRI"]["input"];
+}>;
+export type GQLRestoreMemoryMutation = {
+    __typename?: "Mutation";
+    restoreMemory: {
+        __typename?: "RestoreMemoryResponse";
+        success: boolean;
+        blockedByIri?: string | null;
+        blockedByLabel?: string | null;
+        error?: string | null;
+    };
+};
+export type GQLResumeLdesStreamMutationVariables = Exact<{
+    url: Scalars["String"]["input"];
+}>;
+export type GQLResumeLdesStreamMutation = {
+    __typename?: "Mutation";
+    resumeLDESStream: {
+        __typename?: "LDESStreamResponse";
+        success: boolean;
+        stream: {
+            __typename?: "LDESStream";
+            url: string;
+            phase: GQLLdesStreamPhase;
+        };
+    };
+};
+export type GQLRevokeOperatorRoleMutationVariables = Exact<{
+    userId: Scalars["String"]["input"];
+}>;
+export type GQLRevokeOperatorRoleMutation = {
+    __typename?: "Mutation";
+    revokeOperatorRole: {
+        __typename?: "RevokeOperatorRoleResponse";
+        id: string;
+        operator: boolean;
+    };
+};
+export type GQLStageRuleOperationMutationVariables = Exact<{
+    input: GQLStageRuleOperationInput;
+}>;
+export type GQLStageRuleOperationMutation = {
+    __typename?: "Mutation";
+    stageRuleOperation: {
+        __typename?: "StageRuleOperationResponse";
+        success: boolean;
+        ruleIri?: string | null;
+        operation: string;
+        error?: string | null;
+    };
+};
+export type GQLStartLdesStreamMutationVariables = Exact<{
+    input: GQLStartLdesStreamInput;
+}>;
+export type GQLStartLdesStreamMutation = {
+    __typename?: "Mutation";
+    startLDESStream: {
+        __typename?: "LDESStreamResponse";
+        success: boolean;
+        stream: {
+            __typename?: "LDESStream";
+            url: string;
+            phase: GQLLdesStreamPhase;
+            after?: Date | string | null;
+            stats: {
+                __typename?: "LDESStreamStats";
+                membersWritten: number;
+                lastError?: string | null;
+            };
+        };
+    };
+};
+export type GQLSyncGmailIntegrationMutationVariables = Exact<{
+    email: Scalars["String"]["input"];
+}>;
+export type GQLSyncGmailIntegrationMutation = {
+    __typename?: "Mutation";
+    syncGmailIntegration: {
+        __typename?: "GmailIntegration";
+        email: string;
+        status: GQLGmailIntegrationStatus;
+        error?: string | null;
+        lastSyncedAt?: string | null;
+        messagesIngested: number;
+    };
+};
+export type GQLUpdateMemoryMutationVariables = Exact<{
+    input: GQLUpdateMemoryInput;
+}>;
+export type GQLUpdateMemoryMutation = {
+    __typename?: "Mutation";
+    updateMemory: {
+        __typename?: "UpdateMemoryResponse";
+        error?: string | null;
+        memory?: {
+            __typename?: "Memory";
+            iri: string;
+            label: string;
+            description?: string | null;
+            confidence?: number | null;
+            extractedAt: Date | string;
+            memorySource: string;
+            scope: GQLMemoryScope;
+            kind: GQLMemoryKind;
+            memoryValidFrom?: Date | string | null;
+            memoryValidUntil?: Date | string | null;
+            memoryTrustedUntil?: Date | string | null;
+            memoryLastUsedAt?: Date | string | null;
+            memoryUseCount: number;
+            memoryCiteCount: number;
+            memoryEvidence?: string | null;
+            aboutEntityIris: Array<string>;
+            supersedesMemory?: string | null;
+            teams: Array<string>;
+            importance: number;
+            memorySubclass?: string | null;
+            customProperties?: Record<string, unknown> | null;
+        } | null;
+    };
+};
+export type GQLUpdateUserPreferencesMutationVariables = Exact<{
+    input: GQLUpdateUserPreferencesInput;
+}>;
+export type GQLUpdateUserPreferencesMutation = {
+    __typename?: "Mutation";
+    updateUserPreferences: {
+        __typename?: "UpdateUserPreferencesResponse";
+        error?: string | null;
+        preferences?: {
+            __typename?: "UserPreferences";
+            defaultMemoryTtlDays?: number | null;
+        } | null;
+    };
+};
+export type GQLValidateStagedRulesMutationVariables = Exact<{
+    ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
+}>;
+export type GQLValidateStagedRulesMutation = {
+    __typename?: "Mutation";
+    validateStagedRules: {
+        __typename?: "ValidateStagedRulesResponse";
+        isValid: boolean;
+        isStratifiable: boolean;
+        syntaxErrors: Array<string>;
+        nonStratifiableComponents: Array<string>;
+        error?: string | null;
+    };
+};
+export type GQLActionPlanRulesQueryVariables = Exact<{
+    namedGraph: Scalars["IRI"]["input"];
+    search?: InputMaybe<Scalars["String"]["input"]>;
+    limit: Scalars["Int"]["input"];
+    offset: Scalars["Int"]["input"];
+}>;
+export type GQLActionPlanRulesQuery = {
+    __typename?: "Query";
+    rules: {
+        __typename?: "RulesResponse";
+        count: number;
+        error?: string | null;
+        rules: Array<{
+            __typename?: "Rule";
+            ruleIri: string;
+            committedRule?: string | null;
+            stagedRule?: string | null;
+            isStaged: boolean;
+            isModified: boolean;
+        }>;
+    };
+};
+export type GQLActionPlanRunHistoryQueryVariables = Exact<{
+    planGraphIris: Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"];
+    limit?: InputMaybe<Scalars["Int"]["input"]>;
+    offset?: InputMaybe<Scalars["Int"]["input"]>;
+}>;
+export type GQLActionPlanRunHistoryQuery = {
+    __typename?: "Query";
+    actionPlanRunHistory: {
+        __typename?: "ActionPlanRunHistoryResponse";
+        totalCount: number;
+        runs: Array<{
+            __typename?: "ActionPlanRun";
+            activityIri: string;
+            planGraphIri: string;
+            startedAt: Date | string;
+            endedAt?: Date | string | null;
+            status: GQLActionPlanRunStatus;
+            operationType?: string | null;
+            errorMessage?: string | null;
+            dryRun: boolean;
+        }>;
+    };
+};
+export type GQLActionPlanSamplesQueryVariables = Exact<{
+    planGraphIri: Scalars["IRI"]["input"];
+    typeIri: Scalars["IRI"]["input"];
+    limit?: InputMaybe<Scalars["Int"]["input"]>;
+}>;
+export type GQLActionPlanSamplesQuery = {
+    __typename?: "Query";
+    actionPlanSamples: {
+        __typename?: "ActionPlanSamplesResponse";
+        count: number;
+        typeIri: string;
+        typeName: string;
+        error?: string | null;
+        samples: Array<{
+            __typename?: "PlanSample";
+            subject: string;
+            label?: string | null;
+            description?: string | null;
+            operation: GQLPlanOperation;
+            properties: Array<{
+                __typename?: "PropertyChange";
+                predicate: string;
+                predicateLabel?: string | null;
+                object: string;
+                objectLabel?: string | null;
+                beforeObject?: string | null;
+                beforeObjectLabel?: string | null;
+                changeType: GQLPropertyChangeType;
+            }>;
+        }>;
+    };
+};
+export type GQLGetActionPlansSummaryQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLGetActionPlansSummaryQuery = {
+    __typename?: "Query";
+    actionPlansSummary: {
+        __typename?: "ActionPlansSummaryResponse";
+        aggregate: {
+            __typename?: "ActionPlansSummaryAggregate";
+            potentialProfit?: {
+                __typename?: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+            investment?: {
+                __typename?: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+            expectedReturn?: {
+                __typename?: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+        };
+        plans: Array<{
+            __typename?: "ActionPlanSummary";
+            name: string;
+            iri: string;
+            description?: string | null;
+            priority?: GQLActionPlanPriority | null;
+            primaryIntegration?: GQLIntegration | null;
+            potentialProfit?: {
+                __typename?: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | {
+                __typename?: "ExactQuantitativeValue";
+                value: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+        }>;
+    };
+};
+export type GQLActionPlanFieldsFragment = {
+    __typename?: "ActionPlanGraph";
+    iri: string;
+    statements: number;
+    subjects: number;
+    state?: GQLActionPlanState | null;
+    description?: string | null;
+    duration?: string | null;
+    primaryIntegration?: GQLIntegration | null;
+    priority?: GQLActionPlanPriority | null;
+    actionCount: number;
+    completedActionCount: number;
+    actionCountByType: Array<{
+        __typename?: "ActionCountByType";
+        typeName: string;
+        count: number;
+    }>;
+    createdBy: {
+        __typename: "ActionPlanCreatedByManta";
+        reason?: string | null;
+        confidenceScore?: number | null;
+    } | {
+        __typename: "ActionPlanCreatedByUser";
+        id: string;
+        reason?: string | null;
+    };
+    estimatedCost?: {
+        __typename: "ApproximateQuantitativeValue";
+        minValue: string;
+        maxValue: string;
+        unitCode: string;
+        unitText?: string | null;
+    } | {
+        __typename: "ExactQuantitativeValue";
+        value: string;
+        unitCode: string;
+        unitText?: string | null;
+    } | null;
+    estimatedReturn?: {
+        __typename: "ApproximateQuantitativeValue";
+        minValue: string;
+        maxValue: string;
+        unitCode: string;
+        unitText?: string | null;
+    } | {
+        __typename: "ExactQuantitativeValue";
+        value: string;
+        unitCode: string;
+        unitText?: string | null;
+    } | null;
+    estimatedROI?: {
+        __typename: "ApproximateQuantitativeValue";
+        minValue: string;
+        maxValue: string;
+        unitCode: string;
+        unitText?: string | null;
+    } | {
+        __typename: "ExactQuantitativeValue";
+        value: string;
+        unitCode: string;
+        unitText?: string | null;
+    } | null;
+    potentialProfit?: {
+        __typename: "ApproximateQuantitativeValue";
+        minValue: string;
+        maxValue: string;
+        unitCode: string;
+        unitText?: string | null;
+    } | {
+        __typename: "ExactQuantitativeValue";
+        value: string;
+        unitCode: string;
+        unitText?: string | null;
+    } | null;
+};
+export type GQLActionPlansQueryVariables = Exact<{
+    search?: InputMaybe<Scalars["String"]["input"]>;
+    orderBy?: InputMaybe<GQLActionPlanOrderBy>;
+    limit?: InputMaybe<Scalars["PositiveInt"]["input"]>;
+    offset?: InputMaybe<Scalars["NonNegativeInt"]["input"]>;
+}>;
+export type GQLActionPlansQuery = {
+    __typename?: "Query";
+    actionPlans: {
+        __typename?: "ActionPlansResponse";
+        count: number;
+        plans: Array<{
+            __typename?: "ActionPlanGraph";
+            iri: string;
+            statements: number;
+            subjects: number;
+            state?: GQLActionPlanState | null;
+            description?: string | null;
+            duration?: string | null;
+            primaryIntegration?: GQLIntegration | null;
+            priority?: GQLActionPlanPriority | null;
+            actionCount: number;
+            completedActionCount: number;
+            actionCountByType: Array<{
+                __typename?: "ActionCountByType";
+                typeName: string;
+                count: number;
+            }>;
+            createdBy: {
+                __typename: "ActionPlanCreatedByManta";
+                reason?: string | null;
+                confidenceScore?: number | null;
+            } | {
+                __typename: "ActionPlanCreatedByUser";
+                id: string;
+                reason?: string | null;
+            };
+            estimatedCost?: {
+                __typename: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | {
+                __typename: "ExactQuantitativeValue";
+                value: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+            estimatedReturn?: {
+                __typename: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | {
+                __typename: "ExactQuantitativeValue";
+                value: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+            estimatedROI?: {
+                __typename: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | {
+                __typename: "ExactQuantitativeValue";
+                value: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+            potentialProfit?: {
+                __typename: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | {
+                __typename: "ExactQuantitativeValue";
+                value: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+        }>;
+    };
+};
+export type GQLActionPlanByIriQueryVariables = Exact<{
+    planGraphIri: Scalars["IRI"]["input"];
+}>;
+export type GQLActionPlanByIriQuery = {
+    __typename?: "Query";
+    actionPlans: {
+        __typename?: "ActionPlansResponse";
+        count: number;
+        plans: Array<{
+            __typename?: "ActionPlanGraph";
+            iri: string;
+            statements: number;
+            subjects: number;
+            state?: GQLActionPlanState | null;
+            description?: string | null;
+            duration?: string | null;
+            primaryIntegration?: GQLIntegration | null;
+            priority?: GQLActionPlanPriority | null;
+            actionCount: number;
+            completedActionCount: number;
+            actionCountByType: Array<{
+                __typename?: "ActionCountByType";
+                typeName: string;
+                count: number;
+            }>;
+            createdBy: {
+                __typename: "ActionPlanCreatedByManta";
+                reason?: string | null;
+                confidenceScore?: number | null;
+            } | {
+                __typename: "ActionPlanCreatedByUser";
+                id: string;
+                reason?: string | null;
+            };
+            estimatedCost?: {
+                __typename: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | {
+                __typename: "ExactQuantitativeValue";
+                value: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+            estimatedReturn?: {
+                __typename: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | {
+                __typename: "ExactQuantitativeValue";
+                value: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+            estimatedROI?: {
+                __typename: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | {
+                __typename: "ExactQuantitativeValue";
+                value: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+            potentialProfit?: {
+                __typename: "ApproximateQuantitativeValue";
+                minValue: string;
+                maxValue: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | {
+                __typename: "ExactQuantitativeValue";
+                value: string;
+                unitCode: string;
+                unitText?: string | null;
+            } | null;
+        }>;
+    };
+};
+export type GQLActionPlanDiffQueryVariables = Exact<{
+    planGraphIri: Scalars["IRI"]["input"];
+}>;
+export type GQLActionPlanDiffQuery = {
+    __typename?: "Query";
+    actionPlanDiff: {
+        __typename?: "ActionPlanDiffResponse";
+        planGraph: string;
+        deleted: Array<string>;
+        error?: string | null;
+        byTypes: Array<{
+            __typename?: "ActionPlanDiffByType";
+            typeIri: string;
+            typeName: string;
+            addedCount: number;
+            updatedCount: number;
+        }>;
+        summary: {
+            __typename?: "ActionPlanDiffSummary";
+            added: number;
+            updated: number;
+            deleted: number;
+            types: number;
+        };
+    };
+};
+export type GQLAvailableTeamsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLAvailableTeamsQuery = {
+    __typename?: "Query";
+    availableTeams: {
+        __typename?: "AvailableTeamsResponse";
+        error?: string | null;
+        teams: Array<{
+            __typename?: "AvailableTeam";
+            name: string;
+        }>;
+    };
+};
+export type GQLConnectedAccountsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLConnectedAccountsQuery = {
+    __typename?: "Query";
+    connectedAccounts: Array<{
+        __typename?: "ConnectedAccount";
+        id: string;
+        integration: GQLIntegration;
+        externalId: string;
+    }>;
+};
+export type GQLConversationStartersQueryVariables = Exact<{
+    planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+}>;
+export type GQLConversationStartersQuery = {
+    __typename?: "Query";
+    conversationStarters: {
+        __typename?: "ConversationStartersResponse";
+        count: number;
+        source: GQLConversationStarterSource;
+        starters: Array<{
+            __typename?: "ConversationStarter";
+            id: string;
+            title: string;
+            description?: string | null;
+            priority?: number | null;
+        }>;
+    };
+};
+export type GQLCoverageRulesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLCoverageRulesQuery = {
+    __typename?: "Query";
+    rules: {
+        __typename?: "RulesResponse";
+        count: number;
+        error?: string | null;
+        rules: Array<{
+            __typename?: "Rule";
+            ruleIri: string;
+            committedVocabulary?: {
+                __typename?: "RuleVocabulary";
+                error?: string | null;
+                head: {
+                    __typename?: "RuleVocabularyPosition";
+                    classes: Array<string>;
+                    predicates: Array<string>;
+                };
+                body: {
+                    __typename?: "RuleVocabularyPosition";
+                    classes: Array<string>;
+                    predicates: Array<string>;
+                };
+            } | null;
+        }>;
+    };
+};
+export type GQLCurrentFactValueQueryVariables = Exact<{
+    subject: Scalars["String"]["input"];
+    predicate?: InputMaybe<Scalars["String"]["input"]>;
+    object: Scalars["String"]["input"];
+    objectDatatype?: InputMaybe<Scalars["String"]["input"]>;
+    namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+}>;
+export type GQLCurrentFactValueQuery = {
+    __typename?: "Query";
+    currentFactValue: {
+        __typename?: "CurrentFactValueResponse";
+        status: GQLFactValueStatus;
+        currentObject?: string | null;
+        error?: string | null;
+    };
+};
+export type GQLDatastoreProvisioningStatusesQueryVariables = Exact<{
+    datastoreIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>;
+export type GQLDatastoreProvisioningStatusesQuery = {
+    __typename?: "Query";
+    datastoreProvisioningStatuses: Array<{
+        __typename?: "DatastoreProvisioningStatus";
+        datastoreId: string;
+        exists: boolean;
+        materialized: boolean;
+        registered?: boolean | null;
+        offline: boolean;
+        known: boolean;
+        ready: boolean;
+    }>;
+};
+export type GQLDatastoreTreeQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLDatastoreTreeQuery = {
+    __typename?: "Query";
+    datastoreTree: Array<{
+        __typename?: "DatastoreTreeNode";
+        id: string;
+        name: string;
+        depth: number;
+        organizationId: string;
+        organizationName: string;
+        organizationAlias: string;
+        path: string;
+        datastoreId?: string | null;
+        removed: boolean;
+        provisionedAt?: string | null;
+        provisionedBy?: string | null;
+        isOrganization: boolean;
+    }>;
+};
+export type GQLDetectMemoryConflictsQueryVariables = Exact<{
+    input: GQLDetectMemoryConflictsInput;
+}>;
+export type GQLDetectMemoryConflictsQuery = {
+    __typename?: "Query";
+    detectMemoryConflicts: {
+        __typename?: "DetectMemoryConflictsResult";
+        timedOut: boolean;
+        conflicts: Array<{
+            __typename?: "ConflictingMemory";
+            iri: string;
+            label: string;
+            description?: string | null;
+            reason: string;
+            currentTeams: Array<string>;
+            kind: GQLMemoryKind;
+            importance: number;
+            memoryValidUntil?: Date | string | null;
+            memoryTrustedUntil?: Date | string | null;
+            createdBy?: string | null;
+        }>;
+    };
+};
+export type GQLExplainRdFoxFactQueryVariables = Exact<{
+    subject: Scalars["String"]["input"];
+    predicate?: InputMaybe<Scalars["String"]["input"]>;
+    object: Scalars["String"]["input"];
+    objectDatatype?: InputMaybe<Scalars["String"]["input"]>;
+    summarize?: InputMaybe<Scalars["Boolean"]["input"]>;
+    namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+}>;
+export type GQLExplainRdFoxFactQuery = {
+    __typename?: "Query";
+    explainRDFoxFact: {
+        __typename?: "RDFoxExplanationResponse";
+        facts: unknown;
+        formatted: string;
+        summary?: string | null;
+        error?: string | null;
+    };
+};
+export type GQLGmailIntegrationsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLGmailIntegrationsQuery = {
+    __typename?: "Query";
+    gmailIntegrations: Array<{
+        __typename?: "GmailIntegration";
+        email: string;
+        status: GQLGmailIntegrationStatus;
+        error?: string | null;
+        lastSyncedAt?: string | null;
+        messagesIngested: number;
+    }>;
+};
+export type GQLGoogleAnalyticsSetupProgressQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLGoogleAnalyticsSetupProgressQuery = {
+    __typename?: "Query";
+    googleAnalyticsSetupProgress: {
+        __typename?: "GoogleAnalyticsSetupProgress";
+        state: Array<GQLGoogleSetupStateEnum>;
+        properties?: Array<{
+            __typename?: "GoogleAnalyticsProperty";
+            id: string;
+            name?: string | null;
+            parent?: string | null;
+            account?: boolean | null;
+            connectable?: boolean | null;
+            externalId?: string | null;
+        }> | null;
+        lastError?: {
+            __typename?: "GoogleSetupLastError";
+            severity: string;
+            title?: string | null;
+            message: string;
+        } | null;
+    };
+};
+export type GQLGoogleSetupProgressQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLGoogleSetupProgressQuery = {
+    __typename?: "Query";
+    googleSetupProgress: {
+        __typename?: "GoogleSetupProgress";
+        state: Array<GQLGoogleSetupStateEnum>;
+        accounts?: Array<{
+            __typename?: "GoogleAdAccount";
+            id: string;
+            name?: string | null;
+            parent?: string | null;
+            manager?: boolean | null;
+            level?: string | null;
+            connectable?: boolean | null;
+        }> | null;
+        lastError?: {
+            __typename?: "GoogleSetupLastError";
+            severity: string;
+            title?: string | null;
+            message: string;
+        } | null;
+    };
+};
+export type GQLInferalIntegrationsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLInferalIntegrationsQuery = {
+    __typename?: "Query";
+    inferalIntegrations: Array<{
+        __typename?: "InferalIntegration";
+        id: string;
+        provider: GQLInferalIntegrationProvider;
+        shopId: string;
+        streamName: string;
+        streamUrl?: string | null;
+        status: GQLRelayIntegrationStatus;
+        isInFlight: boolean;
+    }>;
+};
+export type GQLKnowledgeGraphStateQueryVariables = Exact<{
+    dataVersion?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+export type GQLKnowledgeGraphStateQuery = {
+    __typename?: "Query";
+    knowledgeGraphState: {
+        __typename?: "KnowledgeGraphState";
+        exists: boolean;
+        isLoaded: boolean;
+        offline: boolean;
+        capacity: {
+            __typename?: "KnowledgeGraphCapacity";
+            maxTriples: bigint;
+            currentTriples?: bigint | null;
+            percentageFull?: number | null;
+            remainingCapacity?: bigint | null;
+            entitySummary?: Array<{
+                __typename?: "EntityCount";
+                type: string;
+                count: number;
+            }> | null;
+        };
+        dataVersion?: {
+            __typename?: "KnowledgeGraphDataVersion";
+            uniqueId: string;
+            version: bigint;
+        } | null;
+    };
+};
+export type GQLLdesStreamsQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLLdesStreamsQuery = {
+    __typename?: "Query";
+    ldesStreams: Array<{
+        __typename?: "LDESStream";
+        url: string;
+        datastoreId: string;
+        phase: GQLLdesStreamPhase;
+        after?: Date | string | null;
+        stats: {
+            __typename?: "LDESStreamStats";
+            membersWritten: number;
+            lastMemberUri?: string | null;
+            lastMemberAt?: Date | string | null;
+            lastPollAt?: Date | string | null;
+            nextPollAt?: Date | string | null;
+            lastError?: string | null;
+        };
+    }>;
+};
+export type GQLLinkedinSetupProgressQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLLinkedinSetupProgressQuery = {
+    __typename?: "Query";
+    linkedinSetupProgress?: {
+        __typename?: "LinkedinSetupProgress";
+        state: Array<string>;
+        accounts?: Array<{
+            __typename?: "LinkedinAdAccount";
+            id: string;
+            name: string;
+        }> | null;
+        lastError?: {
+            __typename?: "LinkedinSetupError";
+            severity: string;
+            message: string;
+            title?: string | null;
+        } | null;
+    } | null;
+};
+export type GQLMemoriesQueryVariables = Exact<{
+    includeArchived?: InputMaybe<Scalars["Boolean"]["input"]>;
+    includeOutOfWindow?: InputMaybe<Scalars["Boolean"]["input"]>;
+}>;
+export type GQLMemoriesQuery = {
+    __typename?: "Query";
+    memories: {
+        __typename?: "MemoriesResponse";
+        error?: string | null;
+        memories: Array<{
+            __typename?: "Memory";
+            updatedAt: Date | string;
+            supersededBy?: string | null;
+            createdBy?: string | null;
+            iri: string;
+            label: string;
+            description?: string | null;
+            confidence?: number | null;
+            extractedAt: Date | string;
+            memorySource: string;
+            scope: GQLMemoryScope;
+            kind: GQLMemoryKind;
+            memoryValidFrom?: Date | string | null;
+            memoryValidUntil?: Date | string | null;
+            memoryTrustedUntil?: Date | string | null;
+            memoryLastUsedAt?: Date | string | null;
+            memoryUseCount: number;
+            memoryCiteCount: number;
+            memoryEvidence?: string | null;
+            aboutEntityIris: Array<string>;
+            supersedesMemory?: string | null;
+            teams: Array<string>;
+            importance: number;
+            memorySubclass?: string | null;
+            customProperties?: Record<string, unknown> | null;
+        }>;
+    };
+};
+export type GQLMemoryRedundancyReviewQueryVariables = Exact<{
+    input: GQLMemoryConsolidationInput;
+}>;
+export type GQLMemoryRedundancyReviewQuery = {
+    __typename?: "Query";
+    memoryRedundancyReview: {
+        __typename?: "MemoryRedundancyResult";
+        comparedCount?: number | null;
+        timedOut: boolean;
+        error?: string | null;
+        clusters: Array<{
+            __typename?: "ConsolidationCluster";
+            reason: string;
+            suggestedLabel: string;
+            suggestedDescription: string;
+            memories: Array<{
+                __typename?: "Memory";
+                iri: string;
+                label: string;
+                description?: string | null;
+                confidence?: number | null;
+                extractedAt: Date | string;
+                memorySource: string;
+                scope: GQLMemoryScope;
+                kind: GQLMemoryKind;
+                memoryValidFrom?: Date | string | null;
+                memoryValidUntil?: Date | string | null;
+                memoryTrustedUntil?: Date | string | null;
+                memoryLastUsedAt?: Date | string | null;
+                memoryUseCount: number;
+                memoryCiteCount: number;
+                memoryEvidence?: string | null;
+                aboutEntityIris: Array<string>;
+                supersedesMemory?: string | null;
+                teams: Array<string>;
+                importance: number;
+                memorySubclass?: string | null;
+                customProperties?: Record<string, unknown> | null;
+            }>;
+        }>;
+        abstractions: Array<{
+            __typename?: "MemoryAbstraction";
+            reason: string;
+            suggestedLabel: string;
+            suggestedDescription: string;
+            memories: Array<{
+                __typename?: "Memory";
+                iri: string;
+                label: string;
+                description?: string | null;
+                confidence?: number | null;
+                extractedAt: Date | string;
+                memorySource: string;
+                scope: GQLMemoryScope;
+                kind: GQLMemoryKind;
+                memoryValidFrom?: Date | string | null;
+                memoryValidUntil?: Date | string | null;
+                memoryTrustedUntil?: Date | string | null;
+                memoryLastUsedAt?: Date | string | null;
+                memoryUseCount: number;
+                memoryCiteCount: number;
+                memoryEvidence?: string | null;
+                aboutEntityIris: Array<string>;
+                supersedesMemory?: string | null;
+                teams: Array<string>;
+                importance: number;
+                memorySubclass?: string | null;
+                customProperties?: Record<string, unknown> | null;
+            }>;
+        }>;
+    };
+};
+export type GQLMemorySchemasQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLMemorySchemasQuery = {
+    __typename?: "Query";
+    memorySchemas: {
+        __typename?: "MemorySchemasResponse";
+        error?: string | null;
+        schemas: Array<{
+            __typename?: "MemorySchema";
+            iri: string;
+            label: string;
+            description?: string | null;
+            properties: Array<{
+                __typename?: "MemorySchemaProperty";
+                path: string;
+                label: string;
+                dataType: string;
+                required: boolean;
+                allowedValues: Array<string>;
+                keyProperty: boolean;
+                inferred: boolean;
+            }>;
+        }>;
+    };
+};
+export type GQLMetaSetupProgressQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLMetaSetupProgressQuery = {
+    __typename?: "Query";
+    metaSetupProgress: {
+        __typename?: "MetaSetupProgress";
+        state: Array<GQLMetaSetupStateEnum>;
+        accounts?: Array<{
+            __typename?: "MetaAdAccount";
+            id: string;
+            name?: string | null;
+            parent?: string | null;
+        }> | null;
+        lastError?: {
+            __typename?: "MetaSetupLastError";
+            severity: string;
+            title?: string | null;
+            message: string;
+        } | null;
+    };
+};
+export type GQLNodePropertiesQueryVariables = Exact<{
+    nodeIri: Scalars["String"]["input"];
+    planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+}>;
+export type GQLNodePropertiesQuery = {
+    __typename?: "Query";
+    nodeProperties: {
+        __typename?: "NodePropertiesResponse";
+        subject: string;
+        label?: string | null;
+        typeName?: string | null;
+        properties: Array<{
+            __typename?: "PropertyChange";
+            predicate: string;
+            predicateLabel?: string | null;
+            object: string;
+            objectLabel?: string | null;
+            beforeObject?: string | null;
+            beforeObjectLabel?: string | null;
+            changeType: GQLPropertyChangeType;
+        }>;
+    };
+};
+export type GQLNodeRelationshipsQueryVariables = Exact<{
+    nodeIri: Scalars["IRI"]["input"];
+    planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    depth?: InputMaybe<Scalars["Int"]["input"]>;
+}>;
+export type GQLNodeRelationshipsQuery = {
+    __typename?: "Query";
+    nodeRelationships: {
+        __typename?: "ActionPlanGraphResponse";
+        graph: unknown;
+    };
+};
+export type GQLRulesQueryVariables = Exact<{
+    ruleIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    filterByOwner?: InputMaybe<Scalars["String"]["input"]>;
+    namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+    typeFilter?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
+}>;
+export type GQLRulesQuery = {
+    __typename?: "Query";
+    rules: {
+        __typename?: "RulesResponse";
+        jsonLdGraph: unknown;
+        count: number;
+        error?: string | null;
+        rules: Array<{
+            __typename?: "Rule";
+            ruleIri: string;
+            committedRule?: string | null;
+            stagedRule?: string | null;
+            isStaged: boolean;
+            isModified: boolean;
+            namedGraphs: Array<string>;
+            mentionedTypes: Array<string>;
+            component?: string | null;
+            stratumIndex?: number | null;
+            dependsPositivelyOn: Array<string>;
+            dependsNegativelyOn: Array<string>;
+            dependentRules: Array<string>;
+            unifiesWith: Array<string>;
+            ownedBy?: {
+                __typename?: "RuleOwnership";
+                type: GQLRuleOwner;
+                userId?: string | null;
+            } | null;
+        }>;
+    };
+};
+export type GQLShaclShapesQueryVariables = Exact<{
+    shapeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+}>;
+export type GQLShaclShapesQuery = {
+    __typename?: "Query";
+    shaclShapes: {
+        __typename?: "ShaclShapesResponse";
+        turtle: string;
+        shapeIris: Array<string>;
+    };
+};
+export type GQLSparqlQueryQueryVariables = Exact<{
+    query: Scalars["String"]["input"];
+}>;
+export type GQLSparqlQueryQuery = {
+    __typename?: "Query";
+    sparqlQuery: {
+        __typename?: "SparqlQueryResponse";
+        graph?: unknown | null;
+        error?: string | null;
+        results?: {
+            __typename?: "SparqlJsonResults";
+            head: {
+                __typename?: "SparqlResultHead";
+                vars?: Array<string> | null;
+                link?: Array<string> | null;
+            };
+            results: {
+                __typename?: "SparqlResultSet";
+                bindings: Array<unknown>;
+            };
+        } | null;
+    };
+};
+export type GQLSupportedActionShapesQueryVariables = Exact<{
+    rdfType?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+export type GQLSupportedActionShapesQuery = {
+    __typename?: "Query";
+    supportedActionShapes: {
+        __typename?: "SupportedActionShapesResponse";
+        count: number;
+        error?: string | null;
+        supportedActionShapes: Array<{
+            __typename?: "SupportedActionShape";
+            actionShape: string;
+            rdfTypes: Array<string>;
+            operations: Array<string>;
+            supportsCreate: boolean;
+            supportsUpdate: boolean;
+            supportsDelete: boolean;
+        }>;
+    };
+};
+export type GQLUnlinkedDatastoresQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLUnlinkedDatastoresQuery = {
+    __typename?: "Query";
+    unlinkedDatastores: Array<{
+        __typename?: "UnlinkedDatastore";
+        id: string;
+    }>;
+};
+export type GQLUserPreferencesQueryVariables = Exact<{
+    [key: string]: never;
+}>;
+export type GQLUserPreferencesQuery = {
+    __typename?: "Query";
+    userPreferences: {
+        __typename?: "UserPreferences";
+        defaultMemoryTtlDays?: number | null;
+    };
+};
+export type GQLValidateActionPlanQueryVariables = Exact<{
+    planGraphIri: Scalars["IRI"]["input"];
+    shaclShapeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+}>;
+export type GQLValidateActionPlanQuery = {
+    __typename?: "Query";
+    validateActionPlan: {
+        __typename?: "ValidateActionPlanResponse";
+        valid: boolean;
+        conforms: boolean;
+        planGraphIri: string;
+        shaclShapeIri?: string | null;
+        completeness: number;
+        error?: string | null;
+        report: {
+            __typename?: "ShaclValidationReport";
+            conforms: boolean;
+            resultCount: number;
+            results: Array<{
+                __typename?: "ShaclValidationResult";
+                focusNode: string;
+                resultPath?: string | null;
+                value?: string | null;
+                sourceShape?: string | null;
+                sourceConstraintComponent: string;
+                severity: GQLShaclSeverity;
+                message?: string | null;
+            }>;
+        };
+    };
+};
+export declare const MemoryFieldsFragmentDoc = "\n    fragment MemoryFields on Memory {\n  iri\n  label\n  description\n  confidence\n  extractedAt\n  memorySource\n  scope\n  kind\n  memoryValidFrom\n  memoryValidUntil\n  memoryTrustedUntil\n  memoryLastUsedAt\n  memoryUseCount\n  memoryCiteCount\n  memoryEvidence\n  aboutEntityIris\n  supersedesMemory\n  teams\n  importance\n  memorySubclass\n  customProperties\n}\n    ";
+export declare const MemoryMutationResultFragmentDoc = "\n    fragment MemoryMutationResult on UpdateMemoryResponse {\n  memory {\n    ...MemoryFields\n  }\n  error\n}\n    \n    fragment MemoryFields on Memory {\n  iri\n  label\n  description\n  confidence\n  extractedAt\n  memorySource\n  scope\n  kind\n  memoryValidFrom\n  memoryValidUntil\n  memoryTrustedUntil\n  memoryLastUsedAt\n  memoryUseCount\n  memoryCiteCount\n  memoryEvidence\n  aboutEntityIris\n  supersedesMemory\n  teams\n  importance\n  memorySubclass\n  customProperties\n}\n    ";
+export declare const ActionPlanFieldsFragmentDoc = "\n    fragment ActionPlanFields on ActionPlanGraph {\n  iri\n  statements\n  subjects\n  state\n  description\n  duration\n  primaryIntegration\n  priority\n  actionCount\n  completedActionCount\n  actionCountByType {\n    typeName\n    count\n  }\n  createdBy {\n    ... on ActionPlanCreatedByManta {\n      __typename\n      reason\n      confidenceScore\n    }\n    ... on ActionPlanCreatedByUser {\n      __typename\n      id\n      reason\n    }\n  }\n  estimatedCost {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n  estimatedReturn {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n  estimatedROI {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n  potentialProfit {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n}\n    ";
+export declare const AbortUploadDocument = "\n    mutation abortUpload($input: AbortUploadInput!) {\n  abortUpload(input: $input) {\n    ok\n  }\n}\n    ";
+export declare const useAbortUploadMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLAbortUploadMutation, TError, GQLAbortUploadMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLAbortUploadMutation, TError, Exact<{
+    input: GQLAbortUploadInput;
+}>, TContext>;
+export declare const BringDatastoreOnlineDocument = "\n    mutation BringDatastoreOnline($datastoreId: String) {\n  bringDatastoreOnline(datastoreId: $datastoreId) {\n    success\n    error\n  }\n}\n    ";
+export declare const useBringDatastoreOnlineMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLBringDatastoreOnlineMutation, TError, GQLBringDatastoreOnlineMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLBringDatastoreOnlineMutation, TError, Exact<{
+    datastoreId?: InputMaybe<Scalars["String"]["input"]>;
+}>, TContext>;
+export declare const CancelActionPlanDocument = "\n    mutation CancelActionPlan($planIri: String!) {\n  cancelActionPlan(planIri: $planIri) {\n    success\n    error\n  }\n}\n    ";
+export declare const useCancelActionPlanMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLCancelActionPlanMutation, TError, GQLCancelActionPlanMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLCancelActionPlanMutation, TError, Exact<{
+    planIri: Scalars["String"]["input"];
+}>, TContext>;
+export declare const ClearStagedRulesDocument = "\n    mutation ClearStagedRules($ruleIris: [IRI!]) {\n  clearStagedRules(ruleIris: $ruleIris) {\n    success\n    rulesCleared\n    error\n  }\n}\n    ";
+export declare const useClearStagedRulesMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLClearStagedRulesMutation, TError, GQLClearStagedRulesMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLClearStagedRulesMutation, TError, Exact<{
+    ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
+}>, TContext>;
+export declare const CommitStagedRulesDocument = "\n    mutation CommitStagedRules($dryRun: Boolean, $ruleIris: [IRI!]) {\n  commitStagedRules(dryRun: $dryRun, ruleIris: $ruleIris) {\n    success\n    rulesAdded\n    rulesUpdated\n    rulesDeleted\n    error\n  }\n}\n    ";
+export declare const useCommitStagedRulesMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLCommitStagedRulesMutation, TError, GQLCommitStagedRulesMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLCommitStagedRulesMutation, TError, Exact<{
+    dryRun?: InputMaybe<Scalars["Boolean"]["input"]>;
+    ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
+}>, TContext>;
+export declare const CompleteUploadDocument = "\n    mutation completeUpload($input: CompleteUploadInput!) {\n  completeUpload(input: $input) {\n    fileIri\n    mediaType\n  }\n}\n    ";
+export declare const useCompleteUploadMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLCompleteUploadMutation, TError, GQLCompleteUploadMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLCompleteUploadMutation, TError, Exact<{
+    input: GQLCompleteUploadInput;
+}>, TContext>;
+export declare const ConsolidateMemoriesDocument = "\n    mutation ConsolidateMemories($input: ConsolidateMemoriesInput!) {\n  consolidateMemories(input: $input) {\n    memory {\n      ...MemoryFields\n    }\n    error\n  }\n}\n    \n    fragment MemoryFields on Memory {\n  iri\n  label\n  description\n  confidence\n  extractedAt\n  memorySource\n  scope\n  kind\n  memoryValidFrom\n  memoryValidUntil\n  memoryTrustedUntil\n  memoryLastUsedAt\n  memoryUseCount\n  memoryCiteCount\n  memoryEvidence\n  aboutEntityIris\n  supersedesMemory\n  teams\n  importance\n  memorySubclass\n  customProperties\n}\n    ";
+export declare const useConsolidateMemoriesMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLConsolidateMemoriesMutation, TError, GQLConsolidateMemoriesMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLConsolidateMemoriesMutation, TError, Exact<{
+    input: GQLConsolidateMemoriesInput;
+}>, TContext>;
+export declare const CreateInferalIntegrationDocument = "\n    mutation CreateInferalIntegration($input: CreateInferalIntegrationInput!) {\n  createInferalIntegration(input: $input) {\n    status\n    inferalIntegrationId\n    streamId\n    streamUrl\n    error\n  }\n}\n    ";
+export declare const useCreateInferalIntegrationMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLCreateInferalIntegrationMutation, TError, GQLCreateInferalIntegrationMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLCreateInferalIntegrationMutation, TError, Exact<{
+    input: GQLCreateInferalIntegrationInput;
+}>, TContext>;
+export declare const CreateMemoryDocument = "\n    mutation CreateMemory($input: CreateMemoryInput!) {\n  createMemory(input: $input) {\n    memory {\n      ...MemoryFields\n      createdBy\n    }\n    error\n  }\n}\n    \n    fragment MemoryFields on Memory {\n  iri\n  label\n  description\n  confidence\n  extractedAt\n  memorySource\n  scope\n  kind\n  memoryValidFrom\n  memoryValidUntil\n  memoryTrustedUntil\n  memoryLastUsedAt\n  memoryUseCount\n  memoryCiteCount\n  memoryEvidence\n  aboutEntityIris\n  supersedesMemory\n  teams\n  importance\n  memorySubclass\n  customProperties\n}\n    ";
+export declare const useCreateMemoryMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLCreateMemoryMutation, TError, GQLCreateMemoryMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLCreateMemoryMutation, TError, Exact<{
+    input: GQLCreateMemoryInput;
+}>, TContext>;
+export declare const DeleteActionPlanDocument = "\n    mutation DeleteActionPlan($input: DeleteActionPlanInput!) {\n  deleteActionPlan(input: $input) {\n    success\n    error\n  }\n}\n    ";
+export declare const useDeleteActionPlanMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLDeleteActionPlanMutation, TError, GQLDeleteActionPlanMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLDeleteActionPlanMutation, TError, Exact<{
+    input: GQLDeleteActionPlanInput;
+}>, TContext>;
+export declare const DeleteLdesStreamDocument = "\n    mutation DeleteLdesStream($url: String!) {\n  deleteLDESStream(url: $url) {\n    success\n    stream {\n      url\n      phase\n    }\n  }\n}\n    ";
+export declare const useDeleteLdesStreamMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLDeleteLdesStreamMutation, TError, GQLDeleteLdesStreamMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLDeleteLdesStreamMutation, TError, Exact<{
+    url: Scalars["String"]["input"];
+}>, TContext>;
+export declare const DeleteMemoryDocument = "\n    mutation DeleteMemory($memoryIri: IRI!) {\n  deleteMemory(memoryIri: $memoryIri) {\n    success\n    error\n  }\n}\n    ";
+export declare const useDeleteMemoryMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLDeleteMemoryMutation, TError, GQLDeleteMemoryMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLDeleteMemoryMutation, TError, Exact<{
+    memoryIri: Scalars["IRI"]["input"];
+}>, TContext>;
+export declare const DeleteUserAccountDocument = "\n    mutation DeleteUserAccount($userId: String!) {\n  deleteUserAccount(userId: $userId) {\n    id\n    deleted\n  }\n}\n    ";
+export declare const useDeleteUserAccountMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLDeleteUserAccountMutation, TError, GQLDeleteUserAccountMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLDeleteUserAccountMutation, TError, Exact<{
+    userId: Scalars["String"]["input"];
+}>, TContext>;
+export declare const DisconnectConnectedAccountDocument = "\n    mutation DisconnectConnectedAccount($id: String!) {\n  disconnectConnectedAccount(id: $id) {\n    success\n  }\n}\n    ";
+export declare const useDisconnectConnectedAccountMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLDisconnectConnectedAccountMutation, TError, GQLDisconnectConnectedAccountMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLDisconnectConnectedAccountMutation, TError, Exact<{
+    id: Scalars["String"]["input"];
+}>, TContext>;
+export declare const DisconnectGmailIntegrationDocument = "\n    mutation DisconnectGmailIntegration($email: String!) {\n  disconnectGmailIntegration(email: $email) {\n    success\n  }\n}\n    ";
+export declare const useDisconnectGmailIntegrationMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLDisconnectGmailIntegrationMutation, TError, GQLDisconnectGmailIntegrationMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLDisconnectGmailIntegrationMutation, TError, Exact<{
+    email: Scalars["String"]["input"];
+}>, TContext>;
+export declare const DisconnectInferalIntegrationDocument = "\n    mutation DisconnectInferalIntegration($id: String!) {\n  disconnectInferalIntegration(id: $id) {\n    success\n  }\n}\n    ";
+export declare const useDisconnectInferalIntegrationMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLDisconnectInferalIntegrationMutation, TError, GQLDisconnectInferalIntegrationMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLDisconnectInferalIntegrationMutation, TError, Exact<{
+    id: Scalars["String"]["input"];
+}>, TContext>;
+export declare const ExecuteAgentActionAdditionDocument = "\n    mutation ExecuteAgentActionAddition($input: ExecuteActionAdditionInput!) {\n  executeActionAddition(input: $input) {\n    success\n    workflowId\n    namedGraphIri\n    error\n    code\n  }\n}\n    ";
+export declare const useExecuteAgentActionAdditionMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLExecuteAgentActionAdditionMutation, TError, GQLExecuteAgentActionAdditionMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLExecuteAgentActionAdditionMutation, TError, Exact<{
+    input: GQLExecuteActionAdditionInput;
+}>, TContext>;
+export declare const ExecuteAgentActionDeletionDocument = "\n    mutation ExecuteAgentActionDeletion($input: ExecuteActionDeletionInput!) {\n  executeActionDeletion(input: $input) {\n    success\n    workflowId\n    namedGraphIri\n    error\n    code\n  }\n}\n    ";
+export declare const useExecuteAgentActionDeletionMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLExecuteAgentActionDeletionMutation, TError, GQLExecuteAgentActionDeletionMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLExecuteAgentActionDeletionMutation, TError, Exact<{
+    input: GQLExecuteActionDeletionInput;
+}>, TContext>;
+export declare const ExecuteAgentActionPlanDocument = "\n    mutation ExecuteAgentActionPlan($input: ExecuteActionPlanInput!) {\n  executeActionPlan(input: $input) {\n    success\n    content\n    workflowId\n    error\n    planValidation {\n      valid\n      completeness\n      issues\n    }\n    semanticDiff {\n      creates\n      updates\n      deletes\n      operations\n    }\n  }\n}\n    ";
+export declare const useExecuteAgentActionPlanMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLExecuteAgentActionPlanMutation, TError, GQLExecuteAgentActionPlanMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLExecuteAgentActionPlanMutation, TError, Exact<{
+    input: GQLExecuteActionPlanInput;
+}>, TContext>;
+export declare const ExecuteAgentActionUpdateDocument = "\n    mutation ExecuteAgentActionUpdate($input: ExecuteActionUpdateInput!) {\n  executeActionUpdate(input: $input) {\n    success\n    workflowId\n    namedGraphIri\n    error\n    code\n  }\n}\n    ";
+export declare const useExecuteAgentActionUpdateMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLExecuteAgentActionUpdateMutation, TError, GQLExecuteAgentActionUpdateMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLExecuteAgentActionUpdateMutation, TError, Exact<{
+    input: GQLExecuteActionUpdateInput;
+}>, TContext>;
+export declare const GenerateStructuredDataDocument = "\n    mutation GenerateStructuredData($input: StructuredDataInput!) {\n  generateStructuredData(input: $input) {\n    data\n    error\n  }\n}\n    ";
+export declare const useGenerateStructuredDataMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLGenerateStructuredDataMutation, TError, GQLGenerateStructuredDataMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLGenerateStructuredDataMutation, TError, Exact<{
+    input: GQLStructuredDataInput;
+}>, TContext>;
+export declare const GoogleAnalyticsSetupConnectDocument = "\n    mutation GoogleAnalyticsSetupConnect($propertyIds: [String!]!) {\n  googleAnalyticsSetupConnect(propertyIds: $propertyIds) {\n    state\n    properties {\n      id\n      name\n      parent\n    }\n    lastError {\n      severity\n      title\n      message\n    }\n  }\n}\n    ";
+export declare const useGoogleAnalyticsSetupConnectMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLGoogleAnalyticsSetupConnectMutation, TError, GQLGoogleAnalyticsSetupConnectMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLGoogleAnalyticsSetupConnectMutation, TError, Exact<{
+    propertyIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>, TContext>;
+export declare const GoogleSetupConnectDocument = "\n    mutation GoogleSetupConnect($accountIds: [String!]!) {\n  googleSetupConnect(accountIds: $accountIds) {\n    state\n    accounts {\n      id\n      name\n      parent\n    }\n    lastError {\n      severity\n      title\n      message\n    }\n  }\n}\n    ";
+export declare const useGoogleSetupConnectMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLGoogleSetupConnectMutation, TError, GQLGoogleSetupConnectMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLGoogleSetupConnectMutation, TError, Exact<{
+    accountIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>, TContext>;
+export declare const GrantOperatorRoleDocument = "\n    mutation GrantOperatorRole($userId: String!) {\n  grantOperatorRole(userId: $userId) {\n    id\n    operator\n  }\n}\n    ";
+export declare const useGrantOperatorRoleMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLGrantOperatorRoleMutation, TError, GQLGrantOperatorRoleMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLGrantOperatorRoleMutation, TError, Exact<{
+    userId: Scalars["String"]["input"];
+}>, TContext>;
+export declare const InitiateUploadDocument = "\n    mutation initiateUpload($input: InitiateUploadInput!) {\n  initiateUpload(input: $input) {\n    uploadId\n    storageKey\n    partUrls {\n      partNumber\n      url\n    }\n  }\n}\n    ";
+export declare const useInitiateUploadMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLInitiateUploadMutation, TError, GQLInitiateUploadMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLInitiateUploadMutation, TError, Exact<{
+    input: GQLInitiateUploadInput;
+}>, TContext>;
+export declare const LinkUnlinkedDatastoreDocument = "\n    mutation LinkUnlinkedDatastore($input: LinkUnlinkedDatastoreInput!) {\n  linkUnlinkedDatastore(input: $input) {\n    success\n    error\n    datastoreId\n    name\n    path\n  }\n}\n    ";
+export declare const useLinkUnlinkedDatastoreMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLLinkUnlinkedDatastoreMutation, TError, GQLLinkUnlinkedDatastoreMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLLinkUnlinkedDatastoreMutation, TError, Exact<{
+    input: GQLLinkUnlinkedDatastoreInput;
+}>, TContext>;
+export declare const LinkedinSetupConnectDocument = "\n    mutation LinkedinSetupConnect($accountIds: [String!]!) {\n  linkedinSetupConnect(accountIds: $accountIds) {\n    state\n    accounts {\n      id\n      name\n    }\n    lastError {\n      severity\n      message\n      title\n    }\n  }\n}\n    ";
+export declare const useLinkedinSetupConnectMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLLinkedinSetupConnectMutation, TError, GQLLinkedinSetupConnectMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLLinkedinSetupConnectMutation, TError, Exact<{
+    accountIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>, TContext>;
+export declare const ChangeManualActionAssigneesDocument = "\n    mutation ChangeManualActionAssignees($namedGraphIri: String!, $subjectIri: String!, $assigneesToAdd: [String!], $assigneesToRemove: [String!]) {\n  manualActionChangeAssignees(\n    namedGraphIri: $namedGraphIri\n    subjectIri: $subjectIri\n    assigneesToAdd: $assigneesToAdd\n    assigneesToRemove: $assigneesToRemove\n  ) {\n    manualActionProgress {\n      state\n      manualAction {\n        status\n        assignees\n      }\n    }\n  }\n}\n    ";
+export declare const useChangeManualActionAssigneesMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLChangeManualActionAssigneesMutation, TError, GQLChangeManualActionAssigneesMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLChangeManualActionAssigneesMutation, TError, Exact<{
+    namedGraphIri: Scalars["String"]["input"];
+    subjectIri: Scalars["String"]["input"];
+    assigneesToAdd?: InputMaybe<Array<Scalars["String"]["input"]> | Scalars["String"]["input"]>;
+    assigneesToRemove?: InputMaybe<Array<Scalars["String"]["input"]> | Scalars["String"]["input"]>;
+}>, TContext>;
+export declare const ResolveManualActionDocument = "\n    mutation ResolveManualAction($namedGraphIri: String!, $subjectIri: String!, $resolvedBy: String!, $status: ManualActionResolveStatus!) {\n  manualActionResolve(\n    namedGraphIri: $namedGraphIri\n    subjectIri: $subjectIri\n    resolvedBy: $resolvedBy\n    status: $status\n  ) {\n    manualActionProgress {\n      state\n      manualAction {\n        status\n        assignees\n      }\n    }\n  }\n}\n    ";
+export declare const useResolveManualActionMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLResolveManualActionMutation, TError, GQLResolveManualActionMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLResolveManualActionMutation, TError, Exact<{
+    namedGraphIri: Scalars["String"]["input"];
+    subjectIri: Scalars["String"]["input"];
+    resolvedBy: Scalars["String"]["input"];
+    status: GQLManualActionResolveStatus;
+}>, TContext>;
+export declare const MaterializeOntologyCoverageDocument = "\n    mutation MaterializeOntologyCoverage {\n  materializeOntologyCoverage {\n    success\n    error\n  }\n}\n    ";
+export declare const useMaterializeOntologyCoverageMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLMaterializeOntologyCoverageMutation, TError, GQLMaterializeOntologyCoverageMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLMaterializeOntologyCoverageMutation, TError, Exact<{
+    [key: string]: never;
+}>, TContext>;
+export declare const MetaSetupConnectDocument = "\n    mutation MetaSetupConnect($accountIds: [String!]!) {\n  metaSetupConnect(accountIds: $accountIds) {\n    state\n    accounts {\n      id\n      name\n      parent\n    }\n    lastError {\n      severity\n      title\n      message\n    }\n  }\n}\n    ";
+export declare const useMetaSetupConnectMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLMetaSetupConnectMutation, TError, GQLMetaSetupConnectMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLMetaSetupConnectMutation, TError, Exact<{
+    accountIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>, TContext>;
+export declare const PauseLdesStreamDocument = "\n    mutation PauseLdesStream($url: String!) {\n  pauseLDESStream(url: $url) {\n    success\n    stream {\n      url\n      phase\n    }\n  }\n}\n    ";
+export declare const usePauseLdesStreamMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLPauseLdesStreamMutation, TError, GQLPauseLdesStreamMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLPauseLdesStreamMutation, TError, Exact<{
+    url: Scalars["String"]["input"];
+}>, TContext>;
+export declare const ProvisionDatastoreDocument = "\n    mutation ProvisionDatastore($input: ProvisionDatastoreInput!) {\n  provisionDatastore(input: $input) {\n    success\n    error\n    datastoreId\n    name\n    path\n    pending\n    runId\n  }\n}\n    ";
+export declare const useProvisionDatastoreMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLProvisionDatastoreMutation, TError, GQLProvisionDatastoreMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLProvisionDatastoreMutation, TError, Exact<{
+    input: GQLProvisionDatastoreInput;
+}>, TContext>;
+export declare const ReconfirmMemoryDocument = "\n    mutation ReconfirmMemory($memoryIri: IRI!) {\n  reconfirmMemory(memoryIri: $memoryIri) {\n    ...MemoryMutationResult\n  }\n}\n    \n    fragment MemoryMutationResult on UpdateMemoryResponse {\n  memory {\n    ...MemoryFields\n  }\n  error\n}\n    \n    fragment MemoryFields on Memory {\n  iri\n  label\n  description\n  confidence\n  extractedAt\n  memorySource\n  scope\n  kind\n  memoryValidFrom\n  memoryValidUntil\n  memoryTrustedUntil\n  memoryLastUsedAt\n  memoryUseCount\n  memoryCiteCount\n  memoryEvidence\n  aboutEntityIris\n  supersedesMemory\n  teams\n  importance\n  memorySubclass\n  customProperties\n}\n    ";
+export declare const useReconfirmMemoryMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLReconfirmMemoryMutation, TError, GQLReconfirmMemoryMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLReconfirmMemoryMutation, TError, Exact<{
+    memoryIri: Scalars["IRI"]["input"];
+}>, TContext>;
+export declare const RegisterDatastoreDocument = "\n    mutation RegisterDatastore($datastoreId: String!) {\n  registerDatastore(datastoreId: $datastoreId) {\n    success\n    error\n  }\n}\n    ";
+export declare const useRegisterDatastoreMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLRegisterDatastoreMutation, TError, GQLRegisterDatastoreMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLRegisterDatastoreMutation, TError, Exact<{
+    datastoreId: Scalars["String"]["input"];
+}>, TContext>;
+export declare const ReleaseRuleOwnershipDocument = "\n    mutation ReleaseRuleOwnership($input: ReleaseRuleOwnershipInput!) {\n  releaseRuleOwnership(input: $input) {\n    success\n    ruleIri\n    previousOwner\n    error\n  }\n}\n    ";
+export declare const useReleaseRuleOwnershipMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLReleaseRuleOwnershipMutation, TError, GQLReleaseRuleOwnershipMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLReleaseRuleOwnershipMutation, TError, Exact<{
+    input: GQLReleaseRuleOwnershipInput;
+}>, TContext>;
+export declare const RemoveDatastoreDocument = "\n    mutation RemoveDatastore($datastoreId: String!) {\n  removeDatastore(datastoreId: $datastoreId) {\n    success\n    error\n  }\n}\n    ";
+export declare const useRemoveDatastoreMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLRemoveDatastoreMutation, TError, GQLRemoveDatastoreMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLRemoveDatastoreMutation, TError, Exact<{
+    datastoreId: Scalars["String"]["input"];
+}>, TContext>;
+export declare const RenameDatastoreGroupDocument = "\n    mutation RenameDatastoreGroup($input: RenameDatastoreGroupInput!) {\n  renameDatastoreGroup(input: $input) {\n    success\n    error\n  }\n}\n    ";
+export declare const useRenameDatastoreGroupMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLRenameDatastoreGroupMutation, TError, GQLRenameDatastoreGroupMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLRenameDatastoreGroupMutation, TError, Exact<{
+    input: GQLRenameDatastoreGroupInput;
+}>, TContext>;
+export declare const RestoreDatastoreDocument = "\n    mutation RestoreDatastore($datastoreId: String!) {\n  restoreDatastore(datastoreId: $datastoreId) {\n    success\n    error\n  }\n}\n    ";
+export declare const useRestoreDatastoreMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLRestoreDatastoreMutation, TError, GQLRestoreDatastoreMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLRestoreDatastoreMutation, TError, Exact<{
+    datastoreId: Scalars["String"]["input"];
+}>, TContext>;
+export declare const RestoreMemoryDocument = "\n    mutation RestoreMemory($memoryIri: IRI!) {\n  restoreMemory(memoryIri: $memoryIri) {\n    success\n    blockedByIri\n    blockedByLabel\n    error\n  }\n}\n    ";
+export declare const useRestoreMemoryMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLRestoreMemoryMutation, TError, GQLRestoreMemoryMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLRestoreMemoryMutation, TError, Exact<{
+    memoryIri: Scalars["IRI"]["input"];
+}>, TContext>;
+export declare const ResumeLdesStreamDocument = "\n    mutation ResumeLdesStream($url: String!) {\n  resumeLDESStream(url: $url) {\n    success\n    stream {\n      url\n      phase\n    }\n  }\n}\n    ";
+export declare const useResumeLdesStreamMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLResumeLdesStreamMutation, TError, GQLResumeLdesStreamMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLResumeLdesStreamMutation, TError, Exact<{
+    url: Scalars["String"]["input"];
+}>, TContext>;
+export declare const RevokeOperatorRoleDocument = "\n    mutation RevokeOperatorRole($userId: String!) {\n  revokeOperatorRole(userId: $userId) {\n    id\n    operator\n  }\n}\n    ";
+export declare const useRevokeOperatorRoleMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLRevokeOperatorRoleMutation, TError, GQLRevokeOperatorRoleMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLRevokeOperatorRoleMutation, TError, Exact<{
+    userId: Scalars["String"]["input"];
+}>, TContext>;
+export declare const StageRuleOperationDocument = "\n    mutation StageRuleOperation($input: StageRuleOperationInput!) {\n  stageRuleOperation(input: $input) {\n    success\n    ruleIri\n    operation\n    error\n  }\n}\n    ";
+export declare const useStageRuleOperationMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLStageRuleOperationMutation, TError, GQLStageRuleOperationMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLStageRuleOperationMutation, TError, Exact<{
+    input: GQLStageRuleOperationInput;
+}>, TContext>;
+export declare const StartLdesStreamDocument = "\n    mutation StartLdesStream($input: StartLDESStreamInput!) {\n  startLDESStream(input: $input) {\n    success\n    stream {\n      url\n      phase\n      after\n      stats {\n        membersWritten\n        lastError\n      }\n    }\n  }\n}\n    ";
+export declare const useStartLdesStreamMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLStartLdesStreamMutation, TError, GQLStartLdesStreamMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLStartLdesStreamMutation, TError, Exact<{
+    input: GQLStartLdesStreamInput;
+}>, TContext>;
+export declare const SyncGmailIntegrationDocument = "\n    mutation SyncGmailIntegration($email: String!) {\n  syncGmailIntegration(email: $email) {\n    email\n    status\n    error\n    lastSyncedAt\n    messagesIngested\n  }\n}\n    ";
+export declare const useSyncGmailIntegrationMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLSyncGmailIntegrationMutation, TError, GQLSyncGmailIntegrationMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLSyncGmailIntegrationMutation, TError, Exact<{
+    email: Scalars["String"]["input"];
+}>, TContext>;
+export declare const UpdateMemoryDocument = "\n    mutation UpdateMemory($input: UpdateMemoryInput!) {\n  updateMemory(input: $input) {\n    ...MemoryMutationResult\n  }\n}\n    \n    fragment MemoryMutationResult on UpdateMemoryResponse {\n  memory {\n    ...MemoryFields\n  }\n  error\n}\n    \n    fragment MemoryFields on Memory {\n  iri\n  label\n  description\n  confidence\n  extractedAt\n  memorySource\n  scope\n  kind\n  memoryValidFrom\n  memoryValidUntil\n  memoryTrustedUntil\n  memoryLastUsedAt\n  memoryUseCount\n  memoryCiteCount\n  memoryEvidence\n  aboutEntityIris\n  supersedesMemory\n  teams\n  importance\n  memorySubclass\n  customProperties\n}\n    ";
+export declare const useUpdateMemoryMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLUpdateMemoryMutation, TError, GQLUpdateMemoryMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLUpdateMemoryMutation, TError, Exact<{
+    input: GQLUpdateMemoryInput;
+}>, TContext>;
+export declare const UpdateUserPreferencesDocument = "\n    mutation UpdateUserPreferences($input: UpdateUserPreferencesInput!) {\n  updateUserPreferences(input: $input) {\n    preferences {\n      defaultMemoryTtlDays\n    }\n    error\n  }\n}\n    ";
+export declare const useUpdateUserPreferencesMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLUpdateUserPreferencesMutation, TError, GQLUpdateUserPreferencesMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLUpdateUserPreferencesMutation, TError, Exact<{
+    input: GQLUpdateUserPreferencesInput;
+}>, TContext>;
+export declare const ValidateStagedRulesDocument = "\n    mutation ValidateStagedRules($ruleIris: [IRI!]) {\n  validateStagedRules(ruleIris: $ruleIris) {\n    isValid\n    isStratifiable\n    syntaxErrors\n    nonStratifiableComponents\n    error\n  }\n}\n    ";
+export declare const useValidateStagedRulesMutation: <TError = unknown, TContext = unknown>(client: GraphQLClient, options?: UseMutationOptions<GQLValidateStagedRulesMutation, TError, GQLValidateStagedRulesMutationVariables, TContext>, headers?: RequestInit["headers"]) => import("@tanstack/react-query").UseMutationResult<GQLValidateStagedRulesMutation, TError, Exact<{
+    ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
+}>, TContext>;
+export declare const ActionPlanRulesDocument = "\n    query ActionPlanRules($namedGraph: IRI!, $search: String, $limit: Int!, $offset: Int!) {\n  rules(\n    namedGraph: $namedGraph\n    search: $search\n    limit: $limit\n    offset: $offset\n    includeDependencyGraph: false\n  ) {\n    rules {\n      ruleIri\n      committedRule\n      stagedRule\n      isStaged\n      isModified\n    }\n    count\n    error\n  }\n}\n    ";
+export declare const useActionPlanRulesQuery: {
+    <TData = GQLActionPlanRulesQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanRulesQueryVariables, options?: Omit<UseQueryOptions<GQLActionPlanRulesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLActionPlanRulesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLActionPlanRulesQueryVariables): (string | Exact<{
+        namedGraph: Scalars["IRI"]["input"];
+        search?: InputMaybe<Scalars["String"]["input"]>;
+        limit: Scalars["Int"]["input"];
+        offset: Scalars["Int"]["input"];
+    }>)[];
+};
+export declare const useSuspenseActionPlanRulesQuery: {
+    <TData = GQLActionPlanRulesQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanRulesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLActionPlanRulesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLActionPlanRulesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLActionPlanRulesQueryVariables): (string | Exact<{
+        namedGraph: Scalars["IRI"]["input"];
+        search?: InputMaybe<Scalars["String"]["input"]>;
+        limit: Scalars["Int"]["input"];
+        offset: Scalars["Int"]["input"];
+    }>)[];
+};
+export declare const ActionPlanRunHistoryDocument = "\n    query ActionPlanRunHistory($planGraphIris: [IRI!]!, $limit: Int, $offset: Int) {\n  actionPlanRunHistory(\n    planGraphIris: $planGraphIris\n    limit: $limit\n    offset: $offset\n  ) {\n    totalCount\n    runs {\n      activityIri\n      planGraphIri\n      startedAt\n      endedAt\n      status\n      operationType\n      errorMessage\n      dryRun\n    }\n  }\n}\n    ";
+export declare const useActionPlanRunHistoryQuery: {
+    <TData = GQLActionPlanRunHistoryQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanRunHistoryQueryVariables, options?: Omit<UseQueryOptions<GQLActionPlanRunHistoryQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLActionPlanRunHistoryQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLActionPlanRunHistoryQueryVariables): (string | Exact<{
+        planGraphIris: Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"];
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        offset?: InputMaybe<Scalars["Int"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseActionPlanRunHistoryQuery: {
+    <TData = GQLActionPlanRunHistoryQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanRunHistoryQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLActionPlanRunHistoryQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLActionPlanRunHistoryQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLActionPlanRunHistoryQueryVariables): (string | Exact<{
+        planGraphIris: Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"];
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+        offset?: InputMaybe<Scalars["Int"]["input"]>;
+    }>)[];
+};
+export declare const ActionPlanSamplesDocument = "\n    query ActionPlanSamples($planGraphIri: IRI!, $typeIri: IRI!, $limit: Int = 5) {\n  actionPlanSamples(planGraphIri: $planGraphIri, typeIri: $typeIri, limit: $limit) {\n    samples {\n      subject\n      label\n      description\n      operation\n      properties {\n        predicate\n        predicateLabel\n        object\n        objectLabel\n        beforeObject\n        beforeObjectLabel\n        changeType\n      }\n    }\n    count\n    typeIri\n    typeName\n    error\n  }\n}\n    ";
+export declare const useActionPlanSamplesQuery: {
+    <TData = GQLActionPlanSamplesQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanSamplesQueryVariables, options?: Omit<UseQueryOptions<GQLActionPlanSamplesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLActionPlanSamplesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLActionPlanSamplesQueryVariables): (string | Exact<{
+        planGraphIri: Scalars["IRI"]["input"];
+        typeIri: Scalars["IRI"]["input"];
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseActionPlanSamplesQuery: {
+    <TData = GQLActionPlanSamplesQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanSamplesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLActionPlanSamplesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLActionPlanSamplesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLActionPlanSamplesQueryVariables): (string | Exact<{
+        planGraphIri: Scalars["IRI"]["input"];
+        typeIri: Scalars["IRI"]["input"];
+        limit?: InputMaybe<Scalars["Int"]["input"]>;
+    }>)[];
+};
+export declare const GetActionPlansSummaryDocument = "\n    query GetActionPlansSummary {\n  actionPlansSummary {\n    aggregate {\n      potentialProfit {\n        minValue\n        maxValue\n        unitCode\n        unitText\n      }\n      investment {\n        minValue\n        maxValue\n        unitCode\n        unitText\n      }\n      expectedReturn {\n        minValue\n        maxValue\n        unitCode\n        unitText\n      }\n    }\n    plans {\n      name\n      iri\n      description\n      priority\n      primaryIntegration\n      potentialProfit {\n        ... on ApproximateQuantitativeValue {\n          minValue\n          maxValue\n          unitCode\n          unitText\n        }\n        ... on ExactQuantitativeValue {\n          value\n          unitCode\n          unitText\n        }\n      }\n    }\n  }\n}\n    ";
+export declare const useGetActionPlansSummaryQuery: {
+    <TData = GQLGetActionPlansSummaryQuery, TError = unknown>(client: GraphQLClient, variables?: GQLGetActionPlansSummaryQueryVariables, options?: Omit<UseQueryOptions<GQLGetActionPlansSummaryQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLGetActionPlansSummaryQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLGetActionPlansSummaryQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseGetActionPlansSummaryQuery: {
+    <TData = GQLGetActionPlansSummaryQuery, TError = unknown>(client: GraphQLClient, variables?: GQLGetActionPlansSummaryQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLGetActionPlansSummaryQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLGetActionPlansSummaryQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLGetActionPlansSummaryQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const ActionPlansDocument = "\n    query ActionPlans($search: String, $orderBy: ActionPlanOrderBy, $limit: PositiveInt, $offset: NonNegativeInt) {\n  actionPlans(search: $search, orderBy: $orderBy, limit: $limit, offset: $offset) {\n    plans {\n      ...ActionPlanFields\n    }\n    count\n  }\n}\n    \n    fragment ActionPlanFields on ActionPlanGraph {\n  iri\n  statements\n  subjects\n  state\n  description\n  duration\n  primaryIntegration\n  priority\n  actionCount\n  completedActionCount\n  actionCountByType {\n    typeName\n    count\n  }\n  createdBy {\n    ... on ActionPlanCreatedByManta {\n      __typename\n      reason\n      confidenceScore\n    }\n    ... on ActionPlanCreatedByUser {\n      __typename\n      id\n      reason\n    }\n  }\n  estimatedCost {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n  estimatedReturn {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n  estimatedROI {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n  potentialProfit {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n}\n    ";
+export declare const useActionPlansQuery: {
+    <TData = GQLActionPlansQuery, TError = unknown>(client: GraphQLClient, variables?: GQLActionPlansQueryVariables, options?: Omit<UseQueryOptions<GQLActionPlansQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLActionPlansQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLActionPlansQueryVariables): (string | Exact<{
+        search?: InputMaybe<Scalars["String"]["input"]>;
+        orderBy?: InputMaybe<GQLActionPlanOrderBy>;
+        limit?: InputMaybe<Scalars["PositiveInt"]["input"]>;
+        offset?: InputMaybe<Scalars["NonNegativeInt"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseActionPlansQuery: {
+    <TData = GQLActionPlansQuery, TError = unknown>(client: GraphQLClient, variables?: GQLActionPlansQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLActionPlansQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLActionPlansQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLActionPlansQueryVariables): (string | Exact<{
+        search?: InputMaybe<Scalars["String"]["input"]>;
+        orderBy?: InputMaybe<GQLActionPlanOrderBy>;
+        limit?: InputMaybe<Scalars["PositiveInt"]["input"]>;
+        offset?: InputMaybe<Scalars["NonNegativeInt"]["input"]>;
+    }>)[];
+};
+export declare const ActionPlanByIriDocument = "\n    query ActionPlanByIri($planGraphIri: IRI!) {\n  actionPlans(planGraphIri: $planGraphIri) {\n    plans {\n      ...ActionPlanFields\n    }\n    count\n  }\n}\n    \n    fragment ActionPlanFields on ActionPlanGraph {\n  iri\n  statements\n  subjects\n  state\n  description\n  duration\n  primaryIntegration\n  priority\n  actionCount\n  completedActionCount\n  actionCountByType {\n    typeName\n    count\n  }\n  createdBy {\n    ... on ActionPlanCreatedByManta {\n      __typename\n      reason\n      confidenceScore\n    }\n    ... on ActionPlanCreatedByUser {\n      __typename\n      id\n      reason\n    }\n  }\n  estimatedCost {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n  estimatedReturn {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n  estimatedROI {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n  potentialProfit {\n    ... on ExactQuantitativeValue {\n      __typename\n      value\n      unitCode\n      unitText\n    }\n    ... on ApproximateQuantitativeValue {\n      __typename\n      minValue\n      maxValue\n      unitCode\n      unitText\n    }\n  }\n}\n    ";
+export declare const useActionPlanByIriQuery: {
+    <TData = GQLActionPlanByIriQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanByIriQueryVariables, options?: Omit<UseQueryOptions<GQLActionPlanByIriQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLActionPlanByIriQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLActionPlanByIriQueryVariables): (string | Exact<{
+        planGraphIri: Scalars["IRI"]["input"];
+    }>)[];
+};
+export declare const useSuspenseActionPlanByIriQuery: {
+    <TData = GQLActionPlanByIriQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanByIriQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLActionPlanByIriQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLActionPlanByIriQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLActionPlanByIriQueryVariables): (string | Exact<{
+        planGraphIri: Scalars["IRI"]["input"];
+    }>)[];
+};
+export declare const ActionPlanDiffDocument = "\n    query ActionPlanDiff($planGraphIri: IRI!) {\n  actionPlanDiff(planGraphIri: $planGraphIri) {\n    planGraph\n    byTypes {\n      typeIri\n      typeName\n      addedCount\n      updatedCount\n    }\n    deleted\n    summary {\n      added\n      updated\n      deleted\n      types\n    }\n    error\n  }\n}\n    ";
+export declare const useActionPlanDiffQuery: {
+    <TData = GQLActionPlanDiffQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanDiffQueryVariables, options?: Omit<UseQueryOptions<GQLActionPlanDiffQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLActionPlanDiffQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLActionPlanDiffQueryVariables): (string | Exact<{
+        planGraphIri: Scalars["IRI"]["input"];
+    }>)[];
+};
+export declare const useSuspenseActionPlanDiffQuery: {
+    <TData = GQLActionPlanDiffQuery, TError = unknown>(client: GraphQLClient, variables: GQLActionPlanDiffQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLActionPlanDiffQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLActionPlanDiffQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLActionPlanDiffQueryVariables): (string | Exact<{
+        planGraphIri: Scalars["IRI"]["input"];
+    }>)[];
+};
+export declare const AvailableTeamsDocument = "\n    query AvailableTeams {\n  availableTeams {\n    teams {\n      name\n    }\n    error\n  }\n}\n    ";
+export declare const useAvailableTeamsQuery: {
+    <TData = GQLAvailableTeamsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLAvailableTeamsQueryVariables, options?: Omit<UseQueryOptions<GQLAvailableTeamsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLAvailableTeamsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLAvailableTeamsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseAvailableTeamsQuery: {
+    <TData = GQLAvailableTeamsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLAvailableTeamsQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLAvailableTeamsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLAvailableTeamsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLAvailableTeamsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const ConnectedAccountsDocument = "\n    query ConnectedAccounts {\n  connectedAccounts {\n    id\n    integration\n    externalId\n  }\n}\n    ";
+export declare const useConnectedAccountsQuery: {
+    <TData = GQLConnectedAccountsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLConnectedAccountsQueryVariables, options?: Omit<UseQueryOptions<GQLConnectedAccountsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLConnectedAccountsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLConnectedAccountsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseConnectedAccountsQuery: {
+    <TData = GQLConnectedAccountsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLConnectedAccountsQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLConnectedAccountsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLConnectedAccountsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLConnectedAccountsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const ConversationStartersDocument = "\n    query ConversationStarters($planGraphIri: IRI) {\n  conversationStarters(planGraphIri: $planGraphIri) {\n    starters {\n      id\n      title\n      description\n      priority\n    }\n    count\n    source\n  }\n}\n    ";
+export declare const useConversationStartersQuery: {
+    <TData = GQLConversationStartersQuery, TError = unknown>(client: GraphQLClient, variables?: GQLConversationStartersQueryVariables, options?: Omit<UseQueryOptions<GQLConversationStartersQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLConversationStartersQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLConversationStartersQueryVariables): (string | Exact<{
+        planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseConversationStartersQuery: {
+    <TData = GQLConversationStartersQuery, TError = unknown>(client: GraphQLClient, variables?: GQLConversationStartersQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLConversationStartersQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLConversationStartersQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLConversationStartersQueryVariables): (string | Exact<{
+        planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const CoverageRulesDocument = "\n    query CoverageRules {\n  rules(includeDependencyGraph: false) {\n    rules {\n      ruleIri\n      committedVocabulary {\n        head {\n          classes\n          predicates\n        }\n        body {\n          classes\n          predicates\n        }\n        error\n      }\n    }\n    count\n    error\n  }\n}\n    ";
+export declare const useCoverageRulesQuery: {
+    <TData = GQLCoverageRulesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLCoverageRulesQueryVariables, options?: Omit<UseQueryOptions<GQLCoverageRulesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLCoverageRulesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLCoverageRulesQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseCoverageRulesQuery: {
+    <TData = GQLCoverageRulesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLCoverageRulesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLCoverageRulesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLCoverageRulesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLCoverageRulesQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const CurrentFactValueDocument = "\n    query CurrentFactValue($subject: String!, $predicate: String, $object: String!, $objectDatatype: String, $namedGraph: IRI) {\n  currentFactValue(\n    subject: $subject\n    predicate: $predicate\n    object: $object\n    objectDatatype: $objectDatatype\n    namedGraph: $namedGraph\n  ) {\n    status\n    currentObject\n    error\n  }\n}\n    ";
+export declare const useCurrentFactValueQuery: {
+    <TData = GQLCurrentFactValueQuery, TError = unknown>(client: GraphQLClient, variables: GQLCurrentFactValueQueryVariables, options?: Omit<UseQueryOptions<GQLCurrentFactValueQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLCurrentFactValueQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLCurrentFactValueQueryVariables): (string | Exact<{
+        subject: Scalars["String"]["input"];
+        predicate?: InputMaybe<Scalars["String"]["input"]>;
+        object: Scalars["String"]["input"];
+        objectDatatype?: InputMaybe<Scalars["String"]["input"]>;
+        namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseCurrentFactValueQuery: {
+    <TData = GQLCurrentFactValueQuery, TError = unknown>(client: GraphQLClient, variables: GQLCurrentFactValueQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLCurrentFactValueQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLCurrentFactValueQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLCurrentFactValueQueryVariables): (string | Exact<{
+        subject: Scalars["String"]["input"];
+        predicate?: InputMaybe<Scalars["String"]["input"]>;
+        object: Scalars["String"]["input"];
+        objectDatatype?: InputMaybe<Scalars["String"]["input"]>;
+        namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const DatastoreProvisioningStatusesDocument = "\n    query DatastoreProvisioningStatuses($datastoreIds: [String!]!) {\n  datastoreProvisioningStatuses(datastoreIds: $datastoreIds) {\n    datastoreId\n    exists\n    materialized\n    registered\n    offline\n    known\n    ready\n  }\n}\n    ";
+export declare const useDatastoreProvisioningStatusesQuery: {
+    <TData = GQLDatastoreProvisioningStatusesQuery, TError = unknown>(client: GraphQLClient, variables: GQLDatastoreProvisioningStatusesQueryVariables, options?: Omit<UseQueryOptions<GQLDatastoreProvisioningStatusesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLDatastoreProvisioningStatusesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLDatastoreProvisioningStatusesQueryVariables): (string | Exact<{
+        datastoreIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+    }>)[];
+};
+export declare const useSuspenseDatastoreProvisioningStatusesQuery: {
+    <TData = GQLDatastoreProvisioningStatusesQuery, TError = unknown>(client: GraphQLClient, variables: GQLDatastoreProvisioningStatusesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLDatastoreProvisioningStatusesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLDatastoreProvisioningStatusesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLDatastoreProvisioningStatusesQueryVariables): (string | Exact<{
+        datastoreIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+    }>)[];
+};
+export declare const DatastoreTreeDocument = "\n    query DatastoreTree {\n  datastoreTree {\n    id\n    name\n    depth\n    organizationId\n    organizationName\n    organizationAlias\n    path\n    datastoreId\n    removed\n    provisionedAt\n    provisionedBy\n    isOrganization\n  }\n}\n    ";
+export declare const useDatastoreTreeQuery: {
+    <TData = GQLDatastoreTreeQuery, TError = unknown>(client: GraphQLClient, variables?: GQLDatastoreTreeQueryVariables, options?: Omit<UseQueryOptions<GQLDatastoreTreeQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLDatastoreTreeQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLDatastoreTreeQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseDatastoreTreeQuery: {
+    <TData = GQLDatastoreTreeQuery, TError = unknown>(client: GraphQLClient, variables?: GQLDatastoreTreeQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLDatastoreTreeQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLDatastoreTreeQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLDatastoreTreeQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const DetectMemoryConflictsDocument = "\n    query DetectMemoryConflicts($input: DetectMemoryConflictsInput!) {\n  detectMemoryConflicts(input: $input) {\n    conflicts {\n      iri\n      label\n      description\n      reason\n      currentTeams\n      kind\n      importance\n      memoryValidUntil\n      memoryTrustedUntil\n      createdBy\n    }\n    timedOut\n  }\n}\n    ";
+export declare const useDetectMemoryConflictsQuery: {
+    <TData = GQLDetectMemoryConflictsQuery, TError = unknown>(client: GraphQLClient, variables: GQLDetectMemoryConflictsQueryVariables, options?: Omit<UseQueryOptions<GQLDetectMemoryConflictsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLDetectMemoryConflictsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLDetectMemoryConflictsQueryVariables): (string | Exact<{
+        input: GQLDetectMemoryConflictsInput;
+    }>)[];
+};
+export declare const useSuspenseDetectMemoryConflictsQuery: {
+    <TData = GQLDetectMemoryConflictsQuery, TError = unknown>(client: GraphQLClient, variables: GQLDetectMemoryConflictsQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLDetectMemoryConflictsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLDetectMemoryConflictsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLDetectMemoryConflictsQueryVariables): (string | Exact<{
+        input: GQLDetectMemoryConflictsInput;
+    }>)[];
+};
+export declare const ExplainRdFoxFactDocument = "\n    query ExplainRDFoxFact($subject: String!, $predicate: String, $object: String!, $objectDatatype: String, $summarize: Boolean = false, $namedGraph: IRI) {\n  explainRDFoxFact(\n    subject: $subject\n    predicate: $predicate\n    object: $object\n    objectDatatype: $objectDatatype\n    summarize: $summarize\n    namedGraph: $namedGraph\n  ) {\n    facts\n    formatted\n    summary\n    error\n  }\n}\n    ";
+export declare const useExplainRdFoxFactQuery: {
+    <TData = GQLExplainRdFoxFactQuery, TError = unknown>(client: GraphQLClient, variables: GQLExplainRdFoxFactQueryVariables, options?: Omit<UseQueryOptions<GQLExplainRdFoxFactQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLExplainRdFoxFactQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLExplainRdFoxFactQueryVariables): (string | Exact<{
+        subject: Scalars["String"]["input"];
+        predicate?: InputMaybe<Scalars["String"]["input"]>;
+        object: Scalars["String"]["input"];
+        objectDatatype?: InputMaybe<Scalars["String"]["input"]>;
+        summarize?: InputMaybe<Scalars["Boolean"]["input"]>;
+        namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseExplainRdFoxFactQuery: {
+    <TData = GQLExplainRdFoxFactQuery, TError = unknown>(client: GraphQLClient, variables: GQLExplainRdFoxFactQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLExplainRdFoxFactQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLExplainRdFoxFactQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLExplainRdFoxFactQueryVariables): (string | Exact<{
+        subject: Scalars["String"]["input"];
+        predicate?: InputMaybe<Scalars["String"]["input"]>;
+        object: Scalars["String"]["input"];
+        objectDatatype?: InputMaybe<Scalars["String"]["input"]>;
+        summarize?: InputMaybe<Scalars["Boolean"]["input"]>;
+        namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const GmailIntegrationsDocument = "\n    query GmailIntegrations {\n  gmailIntegrations {\n    email\n    status\n    error\n    lastSyncedAt\n    messagesIngested\n  }\n}\n    ";
+export declare const useGmailIntegrationsQuery: {
+    <TData = GQLGmailIntegrationsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLGmailIntegrationsQueryVariables, options?: Omit<UseQueryOptions<GQLGmailIntegrationsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLGmailIntegrationsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLGmailIntegrationsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseGmailIntegrationsQuery: {
+    <TData = GQLGmailIntegrationsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLGmailIntegrationsQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLGmailIntegrationsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLGmailIntegrationsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLGmailIntegrationsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const GoogleAnalyticsSetupProgressDocument = "\n    query GoogleAnalyticsSetupProgress {\n  googleAnalyticsSetupProgress {\n    state\n    properties {\n      id\n      name\n      parent\n      account\n      connectable\n      externalId\n    }\n    lastError {\n      severity\n      title\n      message\n    }\n  }\n}\n    ";
+export declare const useGoogleAnalyticsSetupProgressQuery: {
+    <TData = GQLGoogleAnalyticsSetupProgressQuery, TError = unknown>(client: GraphQLClient, variables?: GQLGoogleAnalyticsSetupProgressQueryVariables, options?: Omit<UseQueryOptions<GQLGoogleAnalyticsSetupProgressQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLGoogleAnalyticsSetupProgressQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLGoogleAnalyticsSetupProgressQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseGoogleAnalyticsSetupProgressQuery: {
+    <TData = GQLGoogleAnalyticsSetupProgressQuery, TError = unknown>(client: GraphQLClient, variables?: GQLGoogleAnalyticsSetupProgressQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLGoogleAnalyticsSetupProgressQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLGoogleAnalyticsSetupProgressQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLGoogleAnalyticsSetupProgressQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const GoogleSetupProgressDocument = "\n    query GoogleSetupProgress {\n  googleSetupProgress {\n    state\n    accounts {\n      id\n      name\n      parent\n      manager\n      level\n      connectable\n    }\n    lastError {\n      severity\n      title\n      message\n    }\n  }\n}\n    ";
+export declare const useGoogleSetupProgressQuery: {
+    <TData = GQLGoogleSetupProgressQuery, TError = unknown>(client: GraphQLClient, variables?: GQLGoogleSetupProgressQueryVariables, options?: Omit<UseQueryOptions<GQLGoogleSetupProgressQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLGoogleSetupProgressQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLGoogleSetupProgressQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseGoogleSetupProgressQuery: {
+    <TData = GQLGoogleSetupProgressQuery, TError = unknown>(client: GraphQLClient, variables?: GQLGoogleSetupProgressQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLGoogleSetupProgressQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLGoogleSetupProgressQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLGoogleSetupProgressQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const InferalIntegrationsDocument = "\n    query InferalIntegrations {\n  inferalIntegrations {\n    id\n    provider\n    shopId\n    streamName\n    streamUrl\n    status\n    isInFlight\n  }\n}\n    ";
+export declare const useInferalIntegrationsQuery: {
+    <TData = GQLInferalIntegrationsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLInferalIntegrationsQueryVariables, options?: Omit<UseQueryOptions<GQLInferalIntegrationsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLInferalIntegrationsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLInferalIntegrationsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseInferalIntegrationsQuery: {
+    <TData = GQLInferalIntegrationsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLInferalIntegrationsQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLInferalIntegrationsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLInferalIntegrationsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLInferalIntegrationsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const KnowledgeGraphStateDocument = "\n    query KnowledgeGraphState($dataVersion: String) {\n  knowledgeGraphState(dataVersion: $dataVersion) {\n    exists\n    isLoaded\n    offline\n    capacity {\n      maxTriples\n      currentTriples\n      percentageFull\n      remainingCapacity\n      entitySummary {\n        type\n        count\n      }\n    }\n    dataVersion {\n      uniqueId\n      version\n    }\n  }\n}\n    ";
+export declare const useKnowledgeGraphStateQuery: {
+    <TData = GQLKnowledgeGraphStateQuery, TError = unknown>(client: GraphQLClient, variables?: GQLKnowledgeGraphStateQueryVariables, options?: Omit<UseQueryOptions<GQLKnowledgeGraphStateQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLKnowledgeGraphStateQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLKnowledgeGraphStateQueryVariables): (string | Exact<{
+        dataVersion?: InputMaybe<Scalars["String"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseKnowledgeGraphStateQuery: {
+    <TData = GQLKnowledgeGraphStateQuery, TError = unknown>(client: GraphQLClient, variables?: GQLKnowledgeGraphStateQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLKnowledgeGraphStateQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLKnowledgeGraphStateQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLKnowledgeGraphStateQueryVariables): (string | Exact<{
+        dataVersion?: InputMaybe<Scalars["String"]["input"]>;
+    }>)[];
+};
+export declare const LdesStreamsDocument = "\n    query LdesStreams {\n  ldesStreams {\n    url\n    datastoreId\n    phase\n    after\n    stats {\n      membersWritten\n      lastMemberUri\n      lastMemberAt\n      lastPollAt\n      nextPollAt\n      lastError\n    }\n  }\n}\n    ";
+export declare const useLdesStreamsQuery: {
+    <TData = GQLLdesStreamsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLLdesStreamsQueryVariables, options?: Omit<UseQueryOptions<GQLLdesStreamsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLLdesStreamsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLLdesStreamsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseLdesStreamsQuery: {
+    <TData = GQLLdesStreamsQuery, TError = unknown>(client: GraphQLClient, variables?: GQLLdesStreamsQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLLdesStreamsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLLdesStreamsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLLdesStreamsQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const LinkedinSetupProgressDocument = "\n    query LinkedinSetupProgress {\n  linkedinSetupProgress {\n    state\n    accounts {\n      id\n      name\n    }\n    lastError {\n      severity\n      message\n      title\n    }\n  }\n}\n    ";
+export declare const useLinkedinSetupProgressQuery: {
+    <TData = GQLLinkedinSetupProgressQuery, TError = unknown>(client: GraphQLClient, variables?: GQLLinkedinSetupProgressQueryVariables, options?: Omit<UseQueryOptions<GQLLinkedinSetupProgressQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLLinkedinSetupProgressQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLLinkedinSetupProgressQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseLinkedinSetupProgressQuery: {
+    <TData = GQLLinkedinSetupProgressQuery, TError = unknown>(client: GraphQLClient, variables?: GQLLinkedinSetupProgressQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLLinkedinSetupProgressQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLLinkedinSetupProgressQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLLinkedinSetupProgressQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const MemoriesDocument = "\n    query Memories($includeArchived: Boolean, $includeOutOfWindow: Boolean) {\n  memories(\n    includeArchived: $includeArchived\n    includeOutOfWindow: $includeOutOfWindow\n  ) {\n    memories {\n      ...MemoryFields\n      updatedAt\n      supersededBy\n      createdBy\n    }\n    error\n  }\n}\n    \n    fragment MemoryFields on Memory {\n  iri\n  label\n  description\n  confidence\n  extractedAt\n  memorySource\n  scope\n  kind\n  memoryValidFrom\n  memoryValidUntil\n  memoryTrustedUntil\n  memoryLastUsedAt\n  memoryUseCount\n  memoryCiteCount\n  memoryEvidence\n  aboutEntityIris\n  supersedesMemory\n  teams\n  importance\n  memorySubclass\n  customProperties\n}\n    ";
+export declare const useMemoriesQuery: {
+    <TData = GQLMemoriesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLMemoriesQueryVariables, options?: Omit<UseQueryOptions<GQLMemoriesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLMemoriesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLMemoriesQueryVariables): (string | Exact<{
+        includeArchived?: InputMaybe<Scalars["Boolean"]["input"]>;
+        includeOutOfWindow?: InputMaybe<Scalars["Boolean"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseMemoriesQuery: {
+    <TData = GQLMemoriesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLMemoriesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLMemoriesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLMemoriesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLMemoriesQueryVariables): (string | Exact<{
+        includeArchived?: InputMaybe<Scalars["Boolean"]["input"]>;
+        includeOutOfWindow?: InputMaybe<Scalars["Boolean"]["input"]>;
+    }>)[];
+};
+export declare const MemoryRedundancyReviewDocument = "\n    query MemoryRedundancyReview($input: MemoryConsolidationInput!) {\n  memoryRedundancyReview(input: $input) {\n    clusters {\n      memories {\n        ...MemoryFields\n      }\n      reason\n      suggestedLabel\n      suggestedDescription\n    }\n    abstractions {\n      memories {\n        ...MemoryFields\n      }\n      reason\n      suggestedLabel\n      suggestedDescription\n    }\n    comparedCount\n    timedOut\n    error\n  }\n}\n    \n    fragment MemoryFields on Memory {\n  iri\n  label\n  description\n  confidence\n  extractedAt\n  memorySource\n  scope\n  kind\n  memoryValidFrom\n  memoryValidUntil\n  memoryTrustedUntil\n  memoryLastUsedAt\n  memoryUseCount\n  memoryCiteCount\n  memoryEvidence\n  aboutEntityIris\n  supersedesMemory\n  teams\n  importance\n  memorySubclass\n  customProperties\n}\n    ";
+export declare const useMemoryRedundancyReviewQuery: {
+    <TData = GQLMemoryRedundancyReviewQuery, TError = unknown>(client: GraphQLClient, variables: GQLMemoryRedundancyReviewQueryVariables, options?: Omit<UseQueryOptions<GQLMemoryRedundancyReviewQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLMemoryRedundancyReviewQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLMemoryRedundancyReviewQueryVariables): (string | Exact<{
+        input: GQLMemoryConsolidationInput;
+    }>)[];
+};
+export declare const useSuspenseMemoryRedundancyReviewQuery: {
+    <TData = GQLMemoryRedundancyReviewQuery, TError = unknown>(client: GraphQLClient, variables: GQLMemoryRedundancyReviewQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLMemoryRedundancyReviewQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLMemoryRedundancyReviewQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLMemoryRedundancyReviewQueryVariables): (string | Exact<{
+        input: GQLMemoryConsolidationInput;
+    }>)[];
+};
+export declare const MemorySchemasDocument = "\n    query MemorySchemas {\n  memorySchemas {\n    schemas {\n      iri\n      label\n      description\n      properties {\n        path\n        label\n        dataType\n        required\n        allowedValues\n        keyProperty\n        inferred\n      }\n    }\n    error\n  }\n}\n    ";
+export declare const useMemorySchemasQuery: {
+    <TData = GQLMemorySchemasQuery, TError = unknown>(client: GraphQLClient, variables?: GQLMemorySchemasQueryVariables, options?: Omit<UseQueryOptions<GQLMemorySchemasQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLMemorySchemasQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLMemorySchemasQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseMemorySchemasQuery: {
+    <TData = GQLMemorySchemasQuery, TError = unknown>(client: GraphQLClient, variables?: GQLMemorySchemasQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLMemorySchemasQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLMemorySchemasQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLMemorySchemasQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const MetaSetupProgressDocument = "\n    query MetaSetupProgress {\n  metaSetupProgress {\n    state\n    accounts {\n      id\n      name\n      parent\n    }\n    lastError {\n      severity\n      title\n      message\n    }\n  }\n}\n    ";
+export declare const useMetaSetupProgressQuery: {
+    <TData = GQLMetaSetupProgressQuery, TError = unknown>(client: GraphQLClient, variables?: GQLMetaSetupProgressQueryVariables, options?: Omit<UseQueryOptions<GQLMetaSetupProgressQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLMetaSetupProgressQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLMetaSetupProgressQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseMetaSetupProgressQuery: {
+    <TData = GQLMetaSetupProgressQuery, TError = unknown>(client: GraphQLClient, variables?: GQLMetaSetupProgressQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLMetaSetupProgressQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLMetaSetupProgressQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLMetaSetupProgressQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const NodePropertiesDocument = "\n    query NodeProperties($nodeIri: String!, $planGraphIri: IRI) {\n  nodeProperties(nodeIri: $nodeIri, planGraphIri: $planGraphIri) {\n    subject\n    label\n    typeName\n    properties {\n      predicate\n      predicateLabel\n      object\n      objectLabel\n      beforeObject\n      beforeObjectLabel\n      changeType\n    }\n  }\n}\n    ";
+export declare const useNodePropertiesQuery: {
+    <TData = GQLNodePropertiesQuery, TError = unknown>(client: GraphQLClient, variables: GQLNodePropertiesQueryVariables, options?: Omit<UseQueryOptions<GQLNodePropertiesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLNodePropertiesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLNodePropertiesQueryVariables): (string | Exact<{
+        nodeIri: Scalars["String"]["input"];
+        planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseNodePropertiesQuery: {
+    <TData = GQLNodePropertiesQuery, TError = unknown>(client: GraphQLClient, variables: GQLNodePropertiesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLNodePropertiesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLNodePropertiesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLNodePropertiesQueryVariables): (string | Exact<{
+        nodeIri: Scalars["String"]["input"];
+        planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const NodeRelationshipsDocument = "\n    query NodeRelationships($nodeIri: IRI!, $planGraphIri: IRI, $depth: Int = 1) {\n  nodeRelationships(nodeIri: $nodeIri, planGraphIri: $planGraphIri, depth: $depth) {\n    graph\n  }\n}\n    ";
+export declare const useNodeRelationshipsQuery: {
+    <TData = GQLNodeRelationshipsQuery, TError = unknown>(client: GraphQLClient, variables: GQLNodeRelationshipsQueryVariables, options?: Omit<UseQueryOptions<GQLNodeRelationshipsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLNodeRelationshipsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLNodeRelationshipsQueryVariables): (string | Exact<{
+        nodeIri: Scalars["IRI"]["input"];
+        planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+        depth?: InputMaybe<Scalars["Int"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseNodeRelationshipsQuery: {
+    <TData = GQLNodeRelationshipsQuery, TError = unknown>(client: GraphQLClient, variables: GQLNodeRelationshipsQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLNodeRelationshipsQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLNodeRelationshipsQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLNodeRelationshipsQueryVariables): (string | Exact<{
+        nodeIri: Scalars["IRI"]["input"];
+        planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
+        depth?: InputMaybe<Scalars["Int"]["input"]>;
+    }>)[];
+};
+export declare const RulesDocument = "\n    query Rules($ruleIri: IRI, $filterByOwner: String, $namedGraph: IRI, $typeFilter: [IRI!]) {\n  rules(\n    ruleIri: $ruleIri\n    filterByOwner: $filterByOwner\n    namedGraph: $namedGraph\n    typeFilter: $typeFilter\n  ) {\n    rules {\n      ruleIri\n      committedRule\n      stagedRule\n      isStaged\n      isModified\n      ownedBy {\n        type\n        userId\n      }\n      namedGraphs\n      mentionedTypes\n      component\n      stratumIndex\n      dependsPositivelyOn\n      dependsNegativelyOn\n      dependentRules\n      unifiesWith\n    }\n    jsonLdGraph\n    count\n    error\n  }\n}\n    ";
+export declare const useRulesQuery: {
+    <TData = GQLRulesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLRulesQueryVariables, options?: Omit<UseQueryOptions<GQLRulesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLRulesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLRulesQueryVariables): (string | Exact<{
+        ruleIri?: InputMaybe<Scalars["IRI"]["input"]>;
+        filterByOwner?: InputMaybe<Scalars["String"]["input"]>;
+        namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+        typeFilter?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseRulesQuery: {
+    <TData = GQLRulesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLRulesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLRulesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLRulesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLRulesQueryVariables): (string | Exact<{
+        ruleIri?: InputMaybe<Scalars["IRI"]["input"]>;
+        filterByOwner?: InputMaybe<Scalars["String"]["input"]>;
+        namedGraph?: InputMaybe<Scalars["IRI"]["input"]>;
+        typeFilter?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const ShaclShapesDocument = "\n    query ShaclShapes($shapeIri: IRI) {\n  shaclShapes(shapeIri: $shapeIri) {\n    turtle\n    shapeIris\n  }\n}\n    ";
+export declare const useShaclShapesQuery: {
+    <TData = GQLShaclShapesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLShaclShapesQueryVariables, options?: Omit<UseQueryOptions<GQLShaclShapesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLShaclShapesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLShaclShapesQueryVariables): (string | Exact<{
+        shapeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseShaclShapesQuery: {
+    <TData = GQLShaclShapesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLShaclShapesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLShaclShapesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLShaclShapesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLShaclShapesQueryVariables): (string | Exact<{
+        shapeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const SparqlQueryDocument = "\n    query SparqlQuery($query: String!) {\n  sparqlQuery(query: $query) {\n    results {\n      head {\n        vars\n        link\n      }\n      results {\n        bindings\n      }\n    }\n    graph\n    error\n  }\n}\n    ";
+export declare const useSparqlQueryQuery: {
+    <TData = GQLSparqlQueryQuery, TError = unknown>(client: GraphQLClient, variables: GQLSparqlQueryQueryVariables, options?: Omit<UseQueryOptions<GQLSparqlQueryQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLSparqlQueryQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLSparqlQueryQueryVariables): (string | Exact<{
+        query: Scalars["String"]["input"];
+    }>)[];
+};
+export declare const useSuspenseSparqlQueryQuery: {
+    <TData = GQLSparqlQueryQuery, TError = unknown>(client: GraphQLClient, variables: GQLSparqlQueryQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLSparqlQueryQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLSparqlQueryQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLSparqlQueryQueryVariables): (string | Exact<{
+        query: Scalars["String"]["input"];
+    }>)[];
+};
+export declare const SupportedActionShapesDocument = "\n    query SupportedActionShapes($rdfType: String) {\n  supportedActionShapes(rdfType: $rdfType) {\n    supportedActionShapes {\n      actionShape\n      rdfTypes\n      operations\n      supportsCreate\n      supportsUpdate\n      supportsDelete\n    }\n    count\n    error\n  }\n}\n    ";
+export declare const useSupportedActionShapesQuery: {
+    <TData = GQLSupportedActionShapesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLSupportedActionShapesQueryVariables, options?: Omit<UseQueryOptions<GQLSupportedActionShapesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLSupportedActionShapesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLSupportedActionShapesQueryVariables): (string | Exact<{
+        rdfType?: InputMaybe<Scalars["String"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseSupportedActionShapesQuery: {
+    <TData = GQLSupportedActionShapesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLSupportedActionShapesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLSupportedActionShapesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLSupportedActionShapesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLSupportedActionShapesQueryVariables): (string | Exact<{
+        rdfType?: InputMaybe<Scalars["String"]["input"]>;
+    }>)[];
+};
+export declare const UnlinkedDatastoresDocument = "\n    query UnlinkedDatastores {\n  unlinkedDatastores {\n    id\n  }\n}\n    ";
+export declare const useUnlinkedDatastoresQuery: {
+    <TData = GQLUnlinkedDatastoresQuery, TError = unknown>(client: GraphQLClient, variables?: GQLUnlinkedDatastoresQueryVariables, options?: Omit<UseQueryOptions<GQLUnlinkedDatastoresQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLUnlinkedDatastoresQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLUnlinkedDatastoresQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseUnlinkedDatastoresQuery: {
+    <TData = GQLUnlinkedDatastoresQuery, TError = unknown>(client: GraphQLClient, variables?: GQLUnlinkedDatastoresQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLUnlinkedDatastoresQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLUnlinkedDatastoresQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLUnlinkedDatastoresQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const UserPreferencesDocument = "\n    query UserPreferences {\n  userPreferences {\n    defaultMemoryTtlDays\n  }\n}\n    ";
+export declare const useUserPreferencesQuery: {
+    <TData = GQLUserPreferencesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLUserPreferencesQueryVariables, options?: Omit<UseQueryOptions<GQLUserPreferencesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLUserPreferencesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables?: GQLUserPreferencesQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const useSuspenseUserPreferencesQuery: {
+    <TData = GQLUserPreferencesQuery, TError = unknown>(client: GraphQLClient, variables?: GQLUserPreferencesQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLUserPreferencesQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLUserPreferencesQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables?: GQLUserPreferencesQueryVariables): (string | Exact<{
+        [key: string]: never;
+    }>)[];
+};
+export declare const ValidateActionPlanDocument = "\n    query ValidateActionPlan($planGraphIri: IRI!, $shaclShapeIri: IRI) {\n  validateActionPlan(planGraphIri: $planGraphIri, shaclShapeIri: $shaclShapeIri) {\n    valid\n    conforms\n    planGraphIri\n    shaclShapeIri\n    completeness\n    report {\n      conforms\n      resultCount\n      results {\n        focusNode\n        resultPath\n        value\n        sourceShape\n        sourceConstraintComponent\n        severity\n        message\n      }\n    }\n    error\n  }\n}\n    ";
+export declare const useValidateActionPlanQuery: {
+    <TData = GQLValidateActionPlanQuery, TError = unknown>(client: GraphQLClient, variables: GQLValidateActionPlanQueryVariables, options?: Omit<UseQueryOptions<GQLValidateActionPlanQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseQueryOptions<GQLValidateActionPlanQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseQueryResult<import("@tanstack/react-query").NoInfer<TData>, TError>;
+    getKey(variables: GQLValidateActionPlanQueryVariables): (string | Exact<{
+        planGraphIri: Scalars["IRI"]["input"];
+        shaclShapeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+export declare const useSuspenseValidateActionPlanQuery: {
+    <TData = GQLValidateActionPlanQuery, TError = unknown>(client: GraphQLClient, variables: GQLValidateActionPlanQueryVariables, options?: Omit<UseSuspenseQueryOptions<GQLValidateActionPlanQuery, TError, TData>, "queryKey"> & {
+        queryKey?: UseSuspenseQueryOptions<GQLValidateActionPlanQuery, TError, TData>["queryKey"];
+    }, headers?: RequestInit["headers"]): import("@tanstack/react-query").UseSuspenseQueryResult<TData, TError>;
+    getKey(variables: GQLValidateActionPlanQueryVariables): (string | Exact<{
+        planGraphIri: Scalars["IRI"]["input"];
+        shaclShapeIri?: InputMaybe<Scalars["IRI"]["input"]>;
+    }>)[];
+};
+//# sourceMappingURL=graphql.d.ts.map