@manta-eu/client 0.1.0

package/dist/generated/graphql.js

@@ -0,0 +1,2452 @@
+import { useMutation, useQuery, useSuspenseQuery, } from "@tanstack/react-query";
+function fetcher(client, query, variables, requestHeaders) {
+    return async () => client.request({
+        document: query,
+        variables,
+        requestHeaders,
+    });
+}
+export var GQLActionPlanExecutionStatus;
+(function (GQLActionPlanExecutionStatus) {
+    GQLActionPlanExecutionStatus["ActivityCompleted"] = "ACTIVITY_COMPLETED";
+    GQLActionPlanExecutionStatus["ActivityStarted"] = "ACTIVITY_STARTED";
+    GQLActionPlanExecutionStatus["Completed"] = "COMPLETED";
+    GQLActionPlanExecutionStatus["Failed"] = "FAILED";
+    GQLActionPlanExecutionStatus["Started"] = "STARTED";
+})(GQLActionPlanExecutionStatus || (GQLActionPlanExecutionStatus = {}));
+export var GQLActionPlanOrderField;
+(function (GQLActionPlanOrderField) {
+    GQLActionPlanOrderField["CreatedBy"] = "CREATED_BY";
+    GQLActionPlanOrderField["EstimatedCost"] = "ESTIMATED_COST";
+    GQLActionPlanOrderField["EstimatedReturn"] = "ESTIMATED_RETURN";
+    GQLActionPlanOrderField["EstimatedRoi"] = "ESTIMATED_ROI";
+    GQLActionPlanOrderField["MantaPriority"] = "MANTA_PRIORITY";
+    GQLActionPlanOrderField["State"] = "STATE";
+})(GQLActionPlanOrderField || (GQLActionPlanOrderField = {}));
+export var GQLActionPlanPriority;
+(function (GQLActionPlanPriority) {
+    GQLActionPlanPriority["High"] = "HIGH";
+    GQLActionPlanPriority["Low"] = "LOW";
+    GQLActionPlanPriority["Medium"] = "MEDIUM";
+})(GQLActionPlanPriority || (GQLActionPlanPriority = {}));
+export var GQLActionPlanRunStatus;
+(function (GQLActionPlanRunStatus) {
+    GQLActionPlanRunStatus["Completed"] = "COMPLETED";
+    GQLActionPlanRunStatus["Failed"] = "FAILED";
+    GQLActionPlanRunStatus["Running"] = "RUNNING";
+})(GQLActionPlanRunStatus || (GQLActionPlanRunStatus = {}));
+export var GQLActionPlanState;
+(function (GQLActionPlanState) {
+    GQLActionPlanState["Completed"] = "COMPLETED";
+    GQLActionPlanState["Draft"] = "DRAFT";
+    GQLActionPlanState["Failed"] = "FAILED";
+    GQLActionPlanState["Running"] = "RUNNING";
+    GQLActionPlanState["TimedOut"] = "TIMED_OUT";
+})(GQLActionPlanState || (GQLActionPlanState = {}));
+export var GQLConversationStarterSource;
+(function (GQLConversationStarterSource) {
+    GQLConversationStarterSource["Default"] = "DEFAULT";
+    GQLConversationStarterSource["KnowledgeGraph"] = "KNOWLEDGE_GRAPH";
+    GQLConversationStarterSource["Plan"] = "PLAN";
+})(GQLConversationStarterSource || (GQLConversationStarterSource = {}));
+export var GQLExecuteActionErrorCode;
+(function (GQLExecuteActionErrorCode) {
+    GQLExecuteActionErrorCode["BadRequest"] = "BAD_REQUEST";
+    GQLExecuteActionErrorCode["Conflict"] = "CONFLICT";
+    GQLExecuteActionErrorCode["Unknown"] = "UNKNOWN";
+})(GQLExecuteActionErrorCode || (GQLExecuteActionErrorCode = {}));
+export var GQLFactValueStatus;
+(function (GQLFactValueStatus) {
+    GQLFactValueStatus["Changed"] = "CHANGED";
+    GQLFactValueStatus["Removed"] = "REMOVED";
+    GQLFactValueStatus["Unchanged"] = "UNCHANGED";
+    GQLFactValueStatus["Unknown"] = "UNKNOWN";
+})(GQLFactValueStatus || (GQLFactValueStatus = {}));
+export var GQLGmailIntegrationStatus;
+(function (GQLGmailIntegrationStatus) {
+    GQLGmailIntegrationStatus["Active"] = "ACTIVE";
+    GQLGmailIntegrationStatus["Connecting"] = "CONNECTING";
+    GQLGmailIntegrationStatus["Error"] = "ERROR";
+    GQLGmailIntegrationStatus["Revoked"] = "REVOKED";
+})(GQLGmailIntegrationStatus || (GQLGmailIntegrationStatus = {}));
+export var GQLGoogleSetupStateEnum;
+(function (GQLGoogleSetupStateEnum) {
+    GQLGoogleSetupStateEnum["ConnectingAccounts"] = "CONNECTING_ACCOUNTS";
+    GQLGoogleSetupStateEnum["FatallyFailed"] = "FATALLY_FAILED";
+    GQLGoogleSetupStateEnum["FetchingAccounts"] = "FETCHING_ACCOUNTS";
+    GQLGoogleSetupStateEnum["Finished"] = "FINISHED";
+    GQLGoogleSetupStateEnum["Initializing"] = "INITIALIZING";
+    GQLGoogleSetupStateEnum["NotFound"] = "NOT_FOUND";
+    GQLGoogleSetupStateEnum["SelectingAccounts"] = "SELECTING_ACCOUNTS";
+    GQLGoogleSetupStateEnum["Setup"] = "SETUP";
+    GQLGoogleSetupStateEnum["TimedOut"] = "TIMED_OUT";
+})(GQLGoogleSetupStateEnum || (GQLGoogleSetupStateEnum = {}));
+export var GQLInferalIntegrationProvider;
+(function (GQLInferalIntegrationProvider) {
+    GQLInferalIntegrationProvider["GoogleAds"] = "GOOGLE_ADS";
+    GQLInferalIntegrationProvider["GoogleAnalytics"] = "GOOGLE_ANALYTICS";
+    GQLInferalIntegrationProvider["GoogleMerchant"] = "GOOGLE_MERCHANT";
+    GQLInferalIntegrationProvider["Linkedin"] = "LINKEDIN";
+    GQLInferalIntegrationProvider["Mailchimp"] = "MAILCHIMP";
+    GQLInferalIntegrationProvider["Meta"] = "META";
+    GQLInferalIntegrationProvider["Pinterest"] = "PINTEREST";
+    GQLInferalIntegrationProvider["Shopify"] = "SHOPIFY";
+    GQLInferalIntegrationProvider["Slack"] = "SLACK";
+    GQLInferalIntegrationProvider["Triplewhale"] = "TRIPLEWHALE";
+    GQLInferalIntegrationProvider["Woocommerce"] = "WOOCOMMERCE";
+})(GQLInferalIntegrationProvider || (GQLInferalIntegrationProvider = {}));
+export var GQLInferalLocation;
+(function (GQLInferalLocation) {
+    GQLInferalLocation["Afr"] = "AFR";
+    GQLInferalLocation["Apac"] = "APAC";
+    GQLInferalLocation["Eeur"] = "EEUR";
+    GQLInferalLocation["Enam"] = "ENAM";
+    GQLInferalLocation["Me"] = "ME";
+    GQLInferalLocation["Oc"] = "OC";
+    GQLInferalLocation["Sam"] = "SAM";
+    GQLInferalLocation["Weur"] = "WEUR";
+    GQLInferalLocation["Wnam"] = "WNAM";
+})(GQLInferalLocation || (GQLInferalLocation = {}));
+export var GQLIntegration;
+(function (GQLIntegration) {
+    GQLIntegration["Dash"] = "DASH";
+    GQLIntegration["Figma"] = "FIGMA";
+    GQLIntegration["Google"] = "GOOGLE";
+    GQLIntegration["GoogleAnalytics"] = "GOOGLE_ANALYTICS";
+    GQLIntegration["Linkedin"] = "LINKEDIN";
+    GQLIntegration["Meta"] = "META";
+    GQLIntegration["Shopify"] = "SHOPIFY";
+    GQLIntegration["Slack"] = "SLACK";
+    GQLIntegration["Snapchat"] = "SNAPCHAT";
+    GQLIntegration["Woocommerce"] = "WOOCOMMERCE";
+})(GQLIntegration || (GQLIntegration = {}));
+export var GQLLdesAuthType;
+(function (GQLLdesAuthType) {
+    GQLLdesAuthType["Basic"] = "BASIC";
+    GQLLdesAuthType["Bearer"] = "BEARER";
+})(GQLLdesAuthType || (GQLLdesAuthType = {}));
+export var GQLLdesStreamPhase;
+(function (GQLLdesStreamPhase) {
+    GQLLdesStreamPhase["Active"] = "ACTIVE";
+    GQLLdesStreamPhase["Error"] = "ERROR";
+    GQLLdesStreamPhase["Idle"] = "IDLE";
+    GQLLdesStreamPhase["Paused"] = "PAUSED";
+    GQLLdesStreamPhase["Waiting"] = "WAITING";
+})(GQLLdesStreamPhase || (GQLLdesStreamPhase = {}));
+export var GQLManualActionResolveStatus;
+(function (GQLManualActionResolveStatus) {
+    GQLManualActionResolveStatus["Completed"] = "COMPLETED";
+    GQLManualActionResolveStatus["Rejected"] = "REJECTED";
+})(GQLManualActionResolveStatus || (GQLManualActionResolveStatus = {}));
+export var GQLMemoryKind;
+(function (GQLMemoryKind) {
+    GQLMemoryKind["Context"] = "context";
+    GQLMemoryKind["Fact"] = "fact";
+    GQLMemoryKind["Objective"] = "objective";
+    GQLMemoryKind["Preference"] = "preference";
+})(GQLMemoryKind || (GQLMemoryKind = {}));
+export var GQLMemoryScope;
+(function (GQLMemoryScope) {
+    GQLMemoryScope["Company"] = "company";
+    GQLMemoryScope["Team"] = "team";
+    GQLMemoryScope["User"] = "user";
+})(GQLMemoryScope || (GQLMemoryScope = {}));
+export var GQLMetaSetupStateEnum;
+(function (GQLMetaSetupStateEnum) {
+    GQLMetaSetupStateEnum["ConnectingAccounts"] = "CONNECTING_ACCOUNTS";
+    GQLMetaSetupStateEnum["FatallyFailed"] = "FATALLY_FAILED";
+    GQLMetaSetupStateEnum["FetchingAccounts"] = "FETCHING_ACCOUNTS";
+    GQLMetaSetupStateEnum["Finished"] = "FINISHED";
+    GQLMetaSetupStateEnum["NotFound"] = "NOT_FOUND";
+    GQLMetaSetupStateEnum["SelectingAccounts"] = "SELECTING_ACCOUNTS";
+    GQLMetaSetupStateEnum["Setup"] = "SETUP";
+    GQLMetaSetupStateEnum["TimedOut"] = "TIMED_OUT";
+})(GQLMetaSetupStateEnum || (GQLMetaSetupStateEnum = {}));
+export var GQLOrderDirection;
+(function (GQLOrderDirection) {
+    GQLOrderDirection["Asc"] = "ASC";
+    GQLOrderDirection["Desc"] = "DESC";
+})(GQLOrderDirection || (GQLOrderDirection = {}));
+export var GQLPlanOperation;
+(function (GQLPlanOperation) {
+    GQLPlanOperation["Added"] = "ADDED";
+    GQLPlanOperation["Updated"] = "UPDATED";
+})(GQLPlanOperation || (GQLPlanOperation = {}));
+export var GQLPropertyChangeType;
+(function (GQLPropertyChangeType) {
+    GQLPropertyChangeType["Added"] = "ADDED";
+    GQLPropertyChangeType["Unchanged"] = "UNCHANGED";
+    GQLPropertyChangeType["Updated"] = "UPDATED";
+})(GQLPropertyChangeType || (GQLPropertyChangeType = {}));
+export var GQLRelayIntegrationStatus;
+(function (GQLRelayIntegrationStatus) {
+    GQLRelayIntegrationStatus["Active"] = "ACTIVE";
+    GQLRelayIntegrationStatus["Creating"] = "CREATING";
+    GQLRelayIntegrationStatus["Deleted"] = "DELETED";
+    GQLRelayIntegrationStatus["Deleting"] = "DELETING";
+    GQLRelayIntegrationStatus["Error"] = "ERROR";
+    GQLRelayIntegrationStatus["Failed"] = "FAILED";
+    GQLRelayIntegrationStatus["Initializing"] = "INITIALIZING";
+    GQLRelayIntegrationStatus["Paused"] = "PAUSED";
+    GQLRelayIntegrationStatus["Pending"] = "PENDING";
+})(GQLRelayIntegrationStatus || (GQLRelayIntegrationStatus = {}));
+export var GQLRuleOperation;
+(function (GQLRuleOperation) {
+    GQLRuleOperation["Add"] = "ADD";
+    GQLRuleOperation["Change"] = "CHANGE";
+    GQLRuleOperation["Remove"] = "REMOVE";
+})(GQLRuleOperation || (GQLRuleOperation = {}));
+export var GQLRuleOwner;
+(function (GQLRuleOwner) {
+    GQLRuleOwner["Manta"] = "MANTA";
+    GQLRuleOwner["User"] = "USER";
+})(GQLRuleOwner || (GQLRuleOwner = {}));
+export var GQLSelfServeInvitationOutcome;
+(function (GQLSelfServeInvitationOutcome) {
+    GQLSelfServeInvitationOutcome["AlreadyMember"] = "ALREADY_MEMBER";
+    GQLSelfServeInvitationOutcome["Failed"] = "FAILED";
+    GQLSelfServeInvitationOutcome["Invited"] = "INVITED";
+})(GQLSelfServeInvitationOutcome || (GQLSelfServeInvitationOutcome = {}));
+export var GQLShaclSeverity;
+(function (GQLShaclSeverity) {
+    GQLShaclSeverity["Info"] = "INFO";
+    GQLShaclSeverity["Violation"] = "VIOLATION";
+    GQLShaclSeverity["Warning"] = "WARNING";
+})(GQLShaclSeverity || (GQLShaclSeverity = {}));
+export var GQLTestTripleObjectType;
+(function (GQLTestTripleObjectType) {
+    GQLTestTripleObjectType["Iri"] = "IRI";
+    GQLTestTripleObjectType["Literal"] = "LITERAL";
+})(GQLTestTripleObjectType || (GQLTestTripleObjectType = {}));
+export const MemoryFieldsFragmentDoc = `
+    fragment MemoryFields on Memory {
+  iri
+  label
+  description
+  confidence
+  extractedAt
+  memorySource
+  scope
+  kind
+  memoryValidFrom
+  memoryValidUntil
+  memoryTrustedUntil
+  memoryLastUsedAt
+  memoryUseCount
+  memoryCiteCount
+  memoryEvidence
+  aboutEntityIris
+  supersedesMemory
+  teams
+  importance
+  memorySubclass
+  customProperties
+}
+    `;
+export const MemoryMutationResultFragmentDoc = `
+    fragment MemoryMutationResult on UpdateMemoryResponse {
+  memory {
+    ...MemoryFields
+  }
+  error
+}
+    ${MemoryFieldsFragmentDoc}`;
+export const ActionPlanFieldsFragmentDoc = `
+    fragment ActionPlanFields on ActionPlanGraph {
+  iri
+  statements
+  subjects
+  state
+  description
+  duration
+  primaryIntegration
+  priority
+  actionCount
+  completedActionCount
+  actionCountByType {
+    typeName
+    count
+  }
+  createdBy {
+    ... on ActionPlanCreatedByManta {
+      __typename
+      reason
+      confidenceScore
+    }
+    ... on ActionPlanCreatedByUser {
+      __typename
+      id
+      reason
+    }
+  }
+  estimatedCost {
+    ... on ExactQuantitativeValue {
+      __typename
+      value
+      unitCode
+      unitText
+    }
+    ... on ApproximateQuantitativeValue {
+      __typename
+      minValue
+      maxValue
+      unitCode
+      unitText
+    }
+  }
+  estimatedReturn {
+    ... on ExactQuantitativeValue {
+      __typename
+      value
+      unitCode
+      unitText
+    }
+    ... on ApproximateQuantitativeValue {
+      __typename
+      minValue
+      maxValue
+      unitCode
+      unitText
+    }
+  }
+  estimatedROI {
+    ... on ExactQuantitativeValue {
+      __typename
+      value
+      unitCode
+      unitText
+    }
+    ... on ApproximateQuantitativeValue {
+      __typename
+      minValue
+      maxValue
+      unitCode
+      unitText
+    }
+  }
+  potentialProfit {
+    ... on ExactQuantitativeValue {
+      __typename
+      value
+      unitCode
+      unitText
+    }
+    ... on ApproximateQuantitativeValue {
+      __typename
+      minValue
+      maxValue
+      unitCode
+      unitText
+    }
+  }
+}
+    `;
+export const AbortUploadDocument = `
+    mutation abortUpload($input: AbortUploadInput!) {
+  abortUpload(input: $input) {
+    ok
+  }
+}
+    `;
+export const useAbortUploadMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["abortUpload"],
+        mutationFn: (variables) => fetcher(client, AbortUploadDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const BringDatastoreOnlineDocument = `
+    mutation BringDatastoreOnline($datastoreId: String) {
+  bringDatastoreOnline(datastoreId: $datastoreId) {
+    success
+    error
+  }
+}
+    `;
+export const useBringDatastoreOnlineMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["BringDatastoreOnline"],
+        mutationFn: (variables) => fetcher(client, BringDatastoreOnlineDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const CancelActionPlanDocument = `
+    mutation CancelActionPlan($planIri: String!) {
+  cancelActionPlan(planIri: $planIri) {
+    success
+    error
+  }
+}
+    `;
+export const useCancelActionPlanMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["CancelActionPlan"],
+        mutationFn: (variables) => fetcher(client, CancelActionPlanDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ClearStagedRulesDocument = `
+    mutation ClearStagedRules($ruleIris: [IRI!]) {
+  clearStagedRules(ruleIris: $ruleIris) {
+    success
+    rulesCleared
+    error
+  }
+}
+    `;
+export const useClearStagedRulesMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ClearStagedRules"],
+        mutationFn: (variables) => fetcher(client, ClearStagedRulesDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const CommitStagedRulesDocument = `
+    mutation CommitStagedRules($dryRun: Boolean, $ruleIris: [IRI!]) {
+  commitStagedRules(dryRun: $dryRun, ruleIris: $ruleIris) {
+    success
+    rulesAdded
+    rulesUpdated
+    rulesDeleted
+    error
+  }
+}
+    `;
+export const useCommitStagedRulesMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["CommitStagedRules"],
+        mutationFn: (variables) => fetcher(client, CommitStagedRulesDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const CompleteUploadDocument = `
+    mutation completeUpload($input: CompleteUploadInput!) {
+  completeUpload(input: $input) {
+    fileIri
+    mediaType
+  }
+}
+    `;
+export const useCompleteUploadMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["completeUpload"],
+        mutationFn: (variables) => fetcher(client, CompleteUploadDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ConsolidateMemoriesDocument = `
+    mutation ConsolidateMemories($input: ConsolidateMemoriesInput!) {
+  consolidateMemories(input: $input) {
+    memory {
+      ...MemoryFields
+    }
+    error
+  }
+}
+    ${MemoryFieldsFragmentDoc}`;
+export const useConsolidateMemoriesMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ConsolidateMemories"],
+        mutationFn: (variables) => fetcher(client, ConsolidateMemoriesDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const CreateInferalIntegrationDocument = `
+    mutation CreateInferalIntegration($input: CreateInferalIntegrationInput!) {
+  createInferalIntegration(input: $input) {
+    status
+    inferalIntegrationId
+    streamId
+    streamUrl
+    error
+  }
+}
+    `;
+export const useCreateInferalIntegrationMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["CreateInferalIntegration"],
+        mutationFn: (variables) => fetcher(client, CreateInferalIntegrationDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const CreateMemoryDocument = `
+    mutation CreateMemory($input: CreateMemoryInput!) {
+  createMemory(input: $input) {
+    memory {
+      ...MemoryFields
+      createdBy
+    }
+    error
+  }
+}
+    ${MemoryFieldsFragmentDoc}`;
+export const useCreateMemoryMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["CreateMemory"],
+        mutationFn: (variables) => fetcher(client, CreateMemoryDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const DeleteActionPlanDocument = `
+    mutation DeleteActionPlan($input: DeleteActionPlanInput!) {
+  deleteActionPlan(input: $input) {
+    success
+    error
+  }
+}
+    `;
+export const useDeleteActionPlanMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["DeleteActionPlan"],
+        mutationFn: (variables) => fetcher(client, DeleteActionPlanDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const DeleteLdesStreamDocument = `
+    mutation DeleteLdesStream($url: String!) {
+  deleteLDESStream(url: $url) {
+    success
+    stream {
+      url
+      phase
+    }
+  }
+}
+    `;
+export const useDeleteLdesStreamMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["DeleteLdesStream"],
+        mutationFn: (variables) => fetcher(client, DeleteLdesStreamDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const DeleteMemoryDocument = `
+    mutation DeleteMemory($memoryIri: IRI!) {
+  deleteMemory(memoryIri: $memoryIri) {
+    success
+    error
+  }
+}
+    `;
+export const useDeleteMemoryMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["DeleteMemory"],
+        mutationFn: (variables) => fetcher(client, DeleteMemoryDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const DeleteUserAccountDocument = `
+    mutation DeleteUserAccount($userId: String!) {
+  deleteUserAccount(userId: $userId) {
+    id
+    deleted
+  }
+}
+    `;
+export const useDeleteUserAccountMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["DeleteUserAccount"],
+        mutationFn: (variables) => fetcher(client, DeleteUserAccountDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const DisconnectConnectedAccountDocument = `
+    mutation DisconnectConnectedAccount($id: String!) {
+  disconnectConnectedAccount(id: $id) {
+    success
+  }
+}
+    `;
+export const useDisconnectConnectedAccountMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["DisconnectConnectedAccount"],
+        mutationFn: (variables) => fetcher(client, DisconnectConnectedAccountDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const DisconnectGmailIntegrationDocument = `
+    mutation DisconnectGmailIntegration($email: String!) {
+  disconnectGmailIntegration(email: $email) {
+    success
+  }
+}
+    `;
+export const useDisconnectGmailIntegrationMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["DisconnectGmailIntegration"],
+        mutationFn: (variables) => fetcher(client, DisconnectGmailIntegrationDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const DisconnectInferalIntegrationDocument = `
+    mutation DisconnectInferalIntegration($id: String!) {
+  disconnectInferalIntegration(id: $id) {
+    success
+  }
+}
+    `;
+export const useDisconnectInferalIntegrationMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["DisconnectInferalIntegration"],
+        mutationFn: (variables) => fetcher(client, DisconnectInferalIntegrationDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ExecuteAgentActionAdditionDocument = `
+    mutation ExecuteAgentActionAddition($input: ExecuteActionAdditionInput!) {
+  executeActionAddition(input: $input) {
+    success
+    workflowId
+    namedGraphIri
+    error
+    code
+  }
+}
+    `;
+export const useExecuteAgentActionAdditionMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ExecuteAgentActionAddition"],
+        mutationFn: (variables) => fetcher(client, ExecuteAgentActionAdditionDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ExecuteAgentActionDeletionDocument = `
+    mutation ExecuteAgentActionDeletion($input: ExecuteActionDeletionInput!) {
+  executeActionDeletion(input: $input) {
+    success
+    workflowId
+    namedGraphIri
+    error
+    code
+  }
+}
+    `;
+export const useExecuteAgentActionDeletionMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ExecuteAgentActionDeletion"],
+        mutationFn: (variables) => fetcher(client, ExecuteAgentActionDeletionDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ExecuteAgentActionPlanDocument = `
+    mutation ExecuteAgentActionPlan($input: ExecuteActionPlanInput!) {
+  executeActionPlan(input: $input) {
+    success
+    content
+    workflowId
+    error
+    planValidation {
+      valid
+      completeness
+      issues
+    }
+    semanticDiff {
+      creates
+      updates
+      deletes
+      operations
+    }
+  }
+}
+    `;
+export const useExecuteAgentActionPlanMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ExecuteAgentActionPlan"],
+        mutationFn: (variables) => fetcher(client, ExecuteAgentActionPlanDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ExecuteAgentActionUpdateDocument = `
+    mutation ExecuteAgentActionUpdate($input: ExecuteActionUpdateInput!) {
+  executeActionUpdate(input: $input) {
+    success
+    workflowId
+    namedGraphIri
+    error
+    code
+  }
+}
+    `;
+export const useExecuteAgentActionUpdateMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ExecuteAgentActionUpdate"],
+        mutationFn: (variables) => fetcher(client, ExecuteAgentActionUpdateDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const GenerateStructuredDataDocument = `
+    mutation GenerateStructuredData($input: StructuredDataInput!) {
+  generateStructuredData(input: $input) {
+    data
+    error
+  }
+}
+    `;
+export const useGenerateStructuredDataMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["GenerateStructuredData"],
+        mutationFn: (variables) => fetcher(client, GenerateStructuredDataDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const GoogleAnalyticsSetupConnectDocument = `
+    mutation GoogleAnalyticsSetupConnect($propertyIds: [String!]!) {
+  googleAnalyticsSetupConnect(propertyIds: $propertyIds) {
+    state
+    properties {
+      id
+      name
+      parent
+    }
+    lastError {
+      severity
+      title
+      message
+    }
+  }
+}
+    `;
+export const useGoogleAnalyticsSetupConnectMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["GoogleAnalyticsSetupConnect"],
+        mutationFn: (variables) => fetcher(client, GoogleAnalyticsSetupConnectDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const GoogleSetupConnectDocument = `
+    mutation GoogleSetupConnect($accountIds: [String!]!) {
+  googleSetupConnect(accountIds: $accountIds) {
+    state
+    accounts {
+      id
+      name
+      parent
+    }
+    lastError {
+      severity
+      title
+      message
+    }
+  }
+}
+    `;
+export const useGoogleSetupConnectMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["GoogleSetupConnect"],
+        mutationFn: (variables) => fetcher(client, GoogleSetupConnectDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const GrantOperatorRoleDocument = `
+    mutation GrantOperatorRole($userId: String!) {
+  grantOperatorRole(userId: $userId) {
+    id
+    operator
+  }
+}
+    `;
+export const useGrantOperatorRoleMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["GrantOperatorRole"],
+        mutationFn: (variables) => fetcher(client, GrantOperatorRoleDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const InitiateUploadDocument = `
+    mutation initiateUpload($input: InitiateUploadInput!) {
+  initiateUpload(input: $input) {
+    uploadId
+    storageKey
+    partUrls {
+      partNumber
+      url
+    }
+  }
+}
+    `;
+export const useInitiateUploadMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["initiateUpload"],
+        mutationFn: (variables) => fetcher(client, InitiateUploadDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const LinkUnlinkedDatastoreDocument = `
+    mutation LinkUnlinkedDatastore($input: LinkUnlinkedDatastoreInput!) {
+  linkUnlinkedDatastore(input: $input) {
+    success
+    error
+    datastoreId
+    name
+    path
+  }
+}
+    `;
+export const useLinkUnlinkedDatastoreMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["LinkUnlinkedDatastore"],
+        mutationFn: (variables) => fetcher(client, LinkUnlinkedDatastoreDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const LinkedinSetupConnectDocument = `
+    mutation LinkedinSetupConnect($accountIds: [String!]!) {
+  linkedinSetupConnect(accountIds: $accountIds) {
+    state
+    accounts {
+      id
+      name
+    }
+    lastError {
+      severity
+      message
+      title
+    }
+  }
+}
+    `;
+export const useLinkedinSetupConnectMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["LinkedinSetupConnect"],
+        mutationFn: (variables) => fetcher(client, LinkedinSetupConnectDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ChangeManualActionAssigneesDocument = `
+    mutation ChangeManualActionAssignees($namedGraphIri: String!, $subjectIri: String!, $assigneesToAdd: [String!], $assigneesToRemove: [String!]) {
+  manualActionChangeAssignees(
+    namedGraphIri: $namedGraphIri
+    subjectIri: $subjectIri
+    assigneesToAdd: $assigneesToAdd
+    assigneesToRemove: $assigneesToRemove
+  ) {
+    manualActionProgress {
+      state
+      manualAction {
+        status
+        assignees
+      }
+    }
+  }
+}
+    `;
+export const useChangeManualActionAssigneesMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ChangeManualActionAssignees"],
+        mutationFn: (variables) => fetcher(client, ChangeManualActionAssigneesDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ResolveManualActionDocument = `
+    mutation ResolveManualAction($namedGraphIri: String!, $subjectIri: String!, $resolvedBy: String!, $status: ManualActionResolveStatus!) {
+  manualActionResolve(
+    namedGraphIri: $namedGraphIri
+    subjectIri: $subjectIri
+    resolvedBy: $resolvedBy
+    status: $status
+  ) {
+    manualActionProgress {
+      state
+      manualAction {
+        status
+        assignees
+      }
+    }
+  }
+}
+    `;
+export const useResolveManualActionMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ResolveManualAction"],
+        mutationFn: (variables) => fetcher(client, ResolveManualActionDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const MaterializeOntologyCoverageDocument = `
+    mutation MaterializeOntologyCoverage {
+  materializeOntologyCoverage {
+    success
+    error
+  }
+}
+    `;
+export const useMaterializeOntologyCoverageMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["MaterializeOntologyCoverage"],
+        mutationFn: (variables) => fetcher(client, MaterializeOntologyCoverageDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const MetaSetupConnectDocument = `
+    mutation MetaSetupConnect($accountIds: [String!]!) {
+  metaSetupConnect(accountIds: $accountIds) {
+    state
+    accounts {
+      id
+      name
+      parent
+    }
+    lastError {
+      severity
+      title
+      message
+    }
+  }
+}
+    `;
+export const useMetaSetupConnectMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["MetaSetupConnect"],
+        mutationFn: (variables) => fetcher(client, MetaSetupConnectDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const PauseLdesStreamDocument = `
+    mutation PauseLdesStream($url: String!) {
+  pauseLDESStream(url: $url) {
+    success
+    stream {
+      url
+      phase
+    }
+  }
+}
+    `;
+export const usePauseLdesStreamMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["PauseLdesStream"],
+        mutationFn: (variables) => fetcher(client, PauseLdesStreamDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ProvisionDatastoreDocument = `
+    mutation ProvisionDatastore($input: ProvisionDatastoreInput!) {
+  provisionDatastore(input: $input) {
+    success
+    error
+    datastoreId
+    name
+    path
+    pending
+    runId
+  }
+}
+    `;
+export const useProvisionDatastoreMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ProvisionDatastore"],
+        mutationFn: (variables) => fetcher(client, ProvisionDatastoreDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ReconfirmMemoryDocument = `
+    mutation ReconfirmMemory($memoryIri: IRI!) {
+  reconfirmMemory(memoryIri: $memoryIri) {
+    ...MemoryMutationResult
+  }
+}
+    ${MemoryMutationResultFragmentDoc}`;
+export const useReconfirmMemoryMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ReconfirmMemory"],
+        mutationFn: (variables) => fetcher(client, ReconfirmMemoryDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const RegisterDatastoreDocument = `
+    mutation RegisterDatastore($datastoreId: String!) {
+  registerDatastore(datastoreId: $datastoreId) {
+    success
+    error
+  }
+}
+    `;
+export const useRegisterDatastoreMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["RegisterDatastore"],
+        mutationFn: (variables) => fetcher(client, RegisterDatastoreDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ReleaseRuleOwnershipDocument = `
+    mutation ReleaseRuleOwnership($input: ReleaseRuleOwnershipInput!) {
+  releaseRuleOwnership(input: $input) {
+    success
+    ruleIri
+    previousOwner
+    error
+  }
+}
+    `;
+export const useReleaseRuleOwnershipMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ReleaseRuleOwnership"],
+        mutationFn: (variables) => fetcher(client, ReleaseRuleOwnershipDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const RemoveDatastoreDocument = `
+    mutation RemoveDatastore($datastoreId: String!) {
+  removeDatastore(datastoreId: $datastoreId) {
+    success
+    error
+  }
+}
+    `;
+export const useRemoveDatastoreMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["RemoveDatastore"],
+        mutationFn: (variables) => fetcher(client, RemoveDatastoreDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const RenameDatastoreGroupDocument = `
+    mutation RenameDatastoreGroup($input: RenameDatastoreGroupInput!) {
+  renameDatastoreGroup(input: $input) {
+    success
+    error
+  }
+}
+    `;
+export const useRenameDatastoreGroupMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["RenameDatastoreGroup"],
+        mutationFn: (variables) => fetcher(client, RenameDatastoreGroupDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const RestoreDatastoreDocument = `
+    mutation RestoreDatastore($datastoreId: String!) {
+  restoreDatastore(datastoreId: $datastoreId) {
+    success
+    error
+  }
+}
+    `;
+export const useRestoreDatastoreMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["RestoreDatastore"],
+        mutationFn: (variables) => fetcher(client, RestoreDatastoreDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const RestoreMemoryDocument = `
+    mutation RestoreMemory($memoryIri: IRI!) {
+  restoreMemory(memoryIri: $memoryIri) {
+    success
+    blockedByIri
+    blockedByLabel
+    error
+  }
+}
+    `;
+export const useRestoreMemoryMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["RestoreMemory"],
+        mutationFn: (variables) => fetcher(client, RestoreMemoryDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ResumeLdesStreamDocument = `
+    mutation ResumeLdesStream($url: String!) {
+  resumeLDESStream(url: $url) {
+    success
+    stream {
+      url
+      phase
+    }
+  }
+}
+    `;
+export const useResumeLdesStreamMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ResumeLdesStream"],
+        mutationFn: (variables) => fetcher(client, ResumeLdesStreamDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const RevokeOperatorRoleDocument = `
+    mutation RevokeOperatorRole($userId: String!) {
+  revokeOperatorRole(userId: $userId) {
+    id
+    operator
+  }
+}
+    `;
+export const useRevokeOperatorRoleMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["RevokeOperatorRole"],
+        mutationFn: (variables) => fetcher(client, RevokeOperatorRoleDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const StageRuleOperationDocument = `
+    mutation StageRuleOperation($input: StageRuleOperationInput!) {
+  stageRuleOperation(input: $input) {
+    success
+    ruleIri
+    operation
+    error
+  }
+}
+    `;
+export const useStageRuleOperationMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["StageRuleOperation"],
+        mutationFn: (variables) => fetcher(client, StageRuleOperationDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const StartLdesStreamDocument = `
+    mutation StartLdesStream($input: StartLDESStreamInput!) {
+  startLDESStream(input: $input) {
+    success
+    stream {
+      url
+      phase
+      after
+      stats {
+        membersWritten
+        lastError
+      }
+    }
+  }
+}
+    `;
+export const useStartLdesStreamMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["StartLdesStream"],
+        mutationFn: (variables) => fetcher(client, StartLdesStreamDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const SyncGmailIntegrationDocument = `
+    mutation SyncGmailIntegration($email: String!) {
+  syncGmailIntegration(email: $email) {
+    email
+    status
+    error
+    lastSyncedAt
+    messagesIngested
+  }
+}
+    `;
+export const useSyncGmailIntegrationMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["SyncGmailIntegration"],
+        mutationFn: (variables) => fetcher(client, SyncGmailIntegrationDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const UpdateMemoryDocument = `
+    mutation UpdateMemory($input: UpdateMemoryInput!) {
+  updateMemory(input: $input) {
+    ...MemoryMutationResult
+  }
+}
+    ${MemoryMutationResultFragmentDoc}`;
+export const useUpdateMemoryMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["UpdateMemory"],
+        mutationFn: (variables) => fetcher(client, UpdateMemoryDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const UpdateUserPreferencesDocument = `
+    mutation UpdateUserPreferences($input: UpdateUserPreferencesInput!) {
+  updateUserPreferences(input: $input) {
+    preferences {
+      defaultMemoryTtlDays
+    }
+    error
+  }
+}
+    `;
+export const useUpdateUserPreferencesMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["UpdateUserPreferences"],
+        mutationFn: (variables) => fetcher(client, UpdateUserPreferencesDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ValidateStagedRulesDocument = `
+    mutation ValidateStagedRules($ruleIris: [IRI!]) {
+  validateStagedRules(ruleIris: $ruleIris) {
+    isValid
+    isStratifiable
+    syntaxErrors
+    nonStratifiableComponents
+    error
+  }
+}
+    `;
+export const useValidateStagedRulesMutation = (client, options, headers) => {
+    return useMutation({
+        mutationKey: ["ValidateStagedRules"],
+        mutationFn: (variables) => fetcher(client, ValidateStagedRulesDocument, variables, headers)(),
+        ...options,
+    });
+};
+export const ActionPlanRulesDocument = `
+    query ActionPlanRules($namedGraph: IRI!, $search: String, $limit: Int!, $offset: Int!) {
+  rules(
+    namedGraph: $namedGraph
+    search: $search
+    limit: $limit
+    offset: $offset
+    includeDependencyGraph: false
+  ) {
+    rules {
+      ruleIri
+      committedRule
+      stagedRule
+      isStaged
+      isModified
+    }
+    count
+    error
+  }
+}
+    `;
+export const useActionPlanRulesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["ActionPlanRules", variables],
+        queryFn: fetcher(client, ActionPlanRulesDocument, variables, headers),
+        ...options,
+    });
+};
+useActionPlanRulesQuery.getKey = (variables) => ["ActionPlanRules", variables];
+export const useSuspenseActionPlanRulesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["ActionPlanRulesSuspense", variables],
+        queryFn: fetcher(client, ActionPlanRulesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseActionPlanRulesQuery.getKey = (variables) => [
+    "ActionPlanRulesSuspense",
+    variables,
+];
+export const ActionPlanRunHistoryDocument = `
+    query ActionPlanRunHistory($planGraphIris: [IRI!]!, $limit: Int, $offset: Int) {
+  actionPlanRunHistory(
+    planGraphIris: $planGraphIris
+    limit: $limit
+    offset: $offset
+  ) {
+    totalCount
+    runs {
+      activityIri
+      planGraphIri
+      startedAt
+      endedAt
+      status
+      operationType
+      errorMessage
+      dryRun
+    }
+  }
+}
+    `;
+export const useActionPlanRunHistoryQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["ActionPlanRunHistory", variables],
+        queryFn: fetcher(client, ActionPlanRunHistoryDocument, variables, headers),
+        ...options,
+    });
+};
+useActionPlanRunHistoryQuery.getKey = (variables) => [
+    "ActionPlanRunHistory",
+    variables,
+];
+export const useSuspenseActionPlanRunHistoryQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["ActionPlanRunHistorySuspense", variables],
+        queryFn: fetcher(client, ActionPlanRunHistoryDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseActionPlanRunHistoryQuery.getKey = (variables) => [
+    "ActionPlanRunHistorySuspense",
+    variables,
+];
+export const ActionPlanSamplesDocument = `
+    query ActionPlanSamples($planGraphIri: IRI!, $typeIri: IRI!, $limit: Int = 5) {
+  actionPlanSamples(planGraphIri: $planGraphIri, typeIri: $typeIri, limit: $limit) {
+    samples {
+      subject
+      label
+      description
+      operation
+      properties {
+        predicate
+        predicateLabel
+        object
+        objectLabel
+        beforeObject
+        beforeObjectLabel
+        changeType
+      }
+    }
+    count
+    typeIri
+    typeName
+    error
+  }
+}
+    `;
+export const useActionPlanSamplesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["ActionPlanSamples", variables],
+        queryFn: fetcher(client, ActionPlanSamplesDocument, variables, headers),
+        ...options,
+    });
+};
+useActionPlanSamplesQuery.getKey = (variables) => ["ActionPlanSamples", variables];
+export const useSuspenseActionPlanSamplesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["ActionPlanSamplesSuspense", variables],
+        queryFn: fetcher(client, ActionPlanSamplesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseActionPlanSamplesQuery.getKey = (variables) => [
+    "ActionPlanSamplesSuspense",
+    variables,
+];
+export const GetActionPlansSummaryDocument = `
+    query GetActionPlansSummary {
+  actionPlansSummary {
+    aggregate {
+      potentialProfit {
+        minValue
+        maxValue
+        unitCode
+        unitText
+      }
+      investment {
+        minValue
+        maxValue
+        unitCode
+        unitText
+      }
+      expectedReturn {
+        minValue
+        maxValue
+        unitCode
+        unitText
+      }
+    }
+    plans {
+      name
+      iri
+      description
+      priority
+      primaryIntegration
+      potentialProfit {
+        ... on ApproximateQuantitativeValue {
+          minValue
+          maxValue
+          unitCode
+          unitText
+        }
+        ... on ExactQuantitativeValue {
+          value
+          unitCode
+          unitText
+        }
+      }
+    }
+  }
+}
+    `;
+export const useGetActionPlansSummaryQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["GetActionPlansSummary"] : ["GetActionPlansSummary", variables],
+        queryFn: fetcher(client, GetActionPlansSummaryDocument, variables, headers),
+        ...options,
+    });
+};
+useGetActionPlansSummaryQuery.getKey = (variables) => variables === undefined ? ["GetActionPlansSummary"] : ["GetActionPlansSummary", variables];
+export const useSuspenseGetActionPlansSummaryQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["GetActionPlansSummarySuspense"] : ["GetActionPlansSummarySuspense", variables],
+        queryFn: fetcher(client, GetActionPlansSummaryDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseGetActionPlansSummaryQuery.getKey = (variables) => variables === undefined ? ["GetActionPlansSummarySuspense"] : ["GetActionPlansSummarySuspense", variables];
+export const ActionPlansDocument = `
+    query ActionPlans($search: String, $orderBy: ActionPlanOrderBy, $limit: PositiveInt, $offset: NonNegativeInt) {
+  actionPlans(search: $search, orderBy: $orderBy, limit: $limit, offset: $offset) {
+    plans {
+      ...ActionPlanFields
+    }
+    count
+  }
+}
+    ${ActionPlanFieldsFragmentDoc}`;
+export const useActionPlansQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["ActionPlans"] : ["ActionPlans", variables],
+        queryFn: fetcher(client, ActionPlansDocument, variables, headers),
+        ...options,
+    });
+};
+useActionPlansQuery.getKey = (variables) => variables === undefined ? ["ActionPlans"] : ["ActionPlans", variables];
+export const useSuspenseActionPlansQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["ActionPlansSuspense"] : ["ActionPlansSuspense", variables],
+        queryFn: fetcher(client, ActionPlansDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseActionPlansQuery.getKey = (variables) => variables === undefined ? ["ActionPlansSuspense"] : ["ActionPlansSuspense", variables];
+export const ActionPlanByIriDocument = `
+    query ActionPlanByIri($planGraphIri: IRI!) {
+  actionPlans(planGraphIri: $planGraphIri) {
+    plans {
+      ...ActionPlanFields
+    }
+    count
+  }
+}
+    ${ActionPlanFieldsFragmentDoc}`;
+export const useActionPlanByIriQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["ActionPlanByIri", variables],
+        queryFn: fetcher(client, ActionPlanByIriDocument, variables, headers),
+        ...options,
+    });
+};
+useActionPlanByIriQuery.getKey = (variables) => ["ActionPlanByIri", variables];
+export const useSuspenseActionPlanByIriQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["ActionPlanByIriSuspense", variables],
+        queryFn: fetcher(client, ActionPlanByIriDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseActionPlanByIriQuery.getKey = (variables) => [
+    "ActionPlanByIriSuspense",
+    variables,
+];
+export const ActionPlanDiffDocument = `
+    query ActionPlanDiff($planGraphIri: IRI!) {
+  actionPlanDiff(planGraphIri: $planGraphIri) {
+    planGraph
+    byTypes {
+      typeIri
+      typeName
+      addedCount
+      updatedCount
+    }
+    deleted
+    summary {
+      added
+      updated
+      deleted
+      types
+    }
+    error
+  }
+}
+    `;
+export const useActionPlanDiffQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["ActionPlanDiff", variables],
+        queryFn: fetcher(client, ActionPlanDiffDocument, variables, headers),
+        ...options,
+    });
+};
+useActionPlanDiffQuery.getKey = (variables) => ["ActionPlanDiff", variables];
+export const useSuspenseActionPlanDiffQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["ActionPlanDiffSuspense", variables],
+        queryFn: fetcher(client, ActionPlanDiffDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseActionPlanDiffQuery.getKey = (variables) => [
+    "ActionPlanDiffSuspense",
+    variables,
+];
+export const AvailableTeamsDocument = `
+    query AvailableTeams {
+  availableTeams {
+    teams {
+      name
+    }
+    error
+  }
+}
+    `;
+export const useAvailableTeamsQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["AvailableTeams"] : ["AvailableTeams", variables],
+        queryFn: fetcher(client, AvailableTeamsDocument, variables, headers),
+        ...options,
+    });
+};
+useAvailableTeamsQuery.getKey = (variables) => variables === undefined ? ["AvailableTeams"] : ["AvailableTeams", variables];
+export const useSuspenseAvailableTeamsQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["AvailableTeamsSuspense"] : ["AvailableTeamsSuspense", variables],
+        queryFn: fetcher(client, AvailableTeamsDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseAvailableTeamsQuery.getKey = (variables) => variables === undefined ? ["AvailableTeamsSuspense"] : ["AvailableTeamsSuspense", variables];
+export const ConnectedAccountsDocument = `
+    query ConnectedAccounts {
+  connectedAccounts {
+    id
+    integration
+    externalId
+  }
+}
+    `;
+export const useConnectedAccountsQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["ConnectedAccounts"] : ["ConnectedAccounts", variables],
+        queryFn: fetcher(client, ConnectedAccountsDocument, variables, headers),
+        ...options,
+    });
+};
+useConnectedAccountsQuery.getKey = (variables) => variables === undefined ? ["ConnectedAccounts"] : ["ConnectedAccounts", variables];
+export const useSuspenseConnectedAccountsQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["ConnectedAccountsSuspense"] : ["ConnectedAccountsSuspense", variables],
+        queryFn: fetcher(client, ConnectedAccountsDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseConnectedAccountsQuery.getKey = (variables) => variables === undefined ? ["ConnectedAccountsSuspense"] : ["ConnectedAccountsSuspense", variables];
+export const ConversationStartersDocument = `
+    query ConversationStarters($planGraphIri: IRI) {
+  conversationStarters(planGraphIri: $planGraphIri) {
+    starters {
+      id
+      title
+      description
+      priority
+    }
+    count
+    source
+  }
+}
+    `;
+export const useConversationStartersQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["ConversationStarters"] : ["ConversationStarters", variables],
+        queryFn: fetcher(client, ConversationStartersDocument, variables, headers),
+        ...options,
+    });
+};
+useConversationStartersQuery.getKey = (variables) => variables === undefined ? ["ConversationStarters"] : ["ConversationStarters", variables];
+export const useSuspenseConversationStartersQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["ConversationStartersSuspense"] : ["ConversationStartersSuspense", variables],
+        queryFn: fetcher(client, ConversationStartersDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseConversationStartersQuery.getKey = (variables) => variables === undefined ? ["ConversationStartersSuspense"] : ["ConversationStartersSuspense", variables];
+export const CoverageRulesDocument = `
+    query CoverageRules {
+  rules(includeDependencyGraph: false) {
+    rules {
+      ruleIri
+      committedVocabulary {
+        head {
+          classes
+          predicates
+        }
+        body {
+          classes
+          predicates
+        }
+        error
+      }
+    }
+    count
+    error
+  }
+}
+    `;
+export const useCoverageRulesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["CoverageRules"] : ["CoverageRules", variables],
+        queryFn: fetcher(client, CoverageRulesDocument, variables, headers),
+        ...options,
+    });
+};
+useCoverageRulesQuery.getKey = (variables) => variables === undefined ? ["CoverageRules"] : ["CoverageRules", variables];
+export const useSuspenseCoverageRulesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["CoverageRulesSuspense"] : ["CoverageRulesSuspense", variables],
+        queryFn: fetcher(client, CoverageRulesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseCoverageRulesQuery.getKey = (variables) => variables === undefined ? ["CoverageRulesSuspense"] : ["CoverageRulesSuspense", variables];
+export const CurrentFactValueDocument = `
+    query CurrentFactValue($subject: String!, $predicate: String, $object: String!, $objectDatatype: String, $namedGraph: IRI) {
+  currentFactValue(
+    subject: $subject
+    predicate: $predicate
+    object: $object
+    objectDatatype: $objectDatatype
+    namedGraph: $namedGraph
+  ) {
+    status
+    currentObject
+    error
+  }
+}
+    `;
+export const useCurrentFactValueQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["CurrentFactValue", variables],
+        queryFn: fetcher(client, CurrentFactValueDocument, variables, headers),
+        ...options,
+    });
+};
+useCurrentFactValueQuery.getKey = (variables) => ["CurrentFactValue", variables];
+export const useSuspenseCurrentFactValueQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["CurrentFactValueSuspense", variables],
+        queryFn: fetcher(client, CurrentFactValueDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseCurrentFactValueQuery.getKey = (variables) => [
+    "CurrentFactValueSuspense",
+    variables,
+];
+export const DatastoreProvisioningStatusesDocument = `
+    query DatastoreProvisioningStatuses($datastoreIds: [String!]!) {
+  datastoreProvisioningStatuses(datastoreIds: $datastoreIds) {
+    datastoreId
+    exists
+    materialized
+    registered
+    offline
+    known
+    ready
+  }
+}
+    `;
+export const useDatastoreProvisioningStatusesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["DatastoreProvisioningStatuses", variables],
+        queryFn: fetcher(client, DatastoreProvisioningStatusesDocument, variables, headers),
+        ...options,
+    });
+};
+useDatastoreProvisioningStatusesQuery.getKey = (variables) => [
+    "DatastoreProvisioningStatuses",
+    variables,
+];
+export const useSuspenseDatastoreProvisioningStatusesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["DatastoreProvisioningStatusesSuspense", variables],
+        queryFn: fetcher(client, DatastoreProvisioningStatusesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseDatastoreProvisioningStatusesQuery.getKey = (variables) => [
+    "DatastoreProvisioningStatusesSuspense",
+    variables,
+];
+export const DatastoreTreeDocument = `
+    query DatastoreTree {
+  datastoreTree {
+    id
+    name
+    depth
+    organizationId
+    organizationName
+    organizationAlias
+    path
+    datastoreId
+    removed
+    provisionedAt
+    provisionedBy
+    isOrganization
+  }
+}
+    `;
+export const useDatastoreTreeQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["DatastoreTree"] : ["DatastoreTree", variables],
+        queryFn: fetcher(client, DatastoreTreeDocument, variables, headers),
+        ...options,
+    });
+};
+useDatastoreTreeQuery.getKey = (variables) => variables === undefined ? ["DatastoreTree"] : ["DatastoreTree", variables];
+export const useSuspenseDatastoreTreeQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["DatastoreTreeSuspense"] : ["DatastoreTreeSuspense", variables],
+        queryFn: fetcher(client, DatastoreTreeDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseDatastoreTreeQuery.getKey = (variables) => variables === undefined ? ["DatastoreTreeSuspense"] : ["DatastoreTreeSuspense", variables];
+export const DetectMemoryConflictsDocument = `
+    query DetectMemoryConflicts($input: DetectMemoryConflictsInput!) {
+  detectMemoryConflicts(input: $input) {
+    conflicts {
+      iri
+      label
+      description
+      reason
+      currentTeams
+      kind
+      importance
+      memoryValidUntil
+      memoryTrustedUntil
+      createdBy
+    }
+    timedOut
+  }
+}
+    `;
+export const useDetectMemoryConflictsQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["DetectMemoryConflicts", variables],
+        queryFn: fetcher(client, DetectMemoryConflictsDocument, variables, headers),
+        ...options,
+    });
+};
+useDetectMemoryConflictsQuery.getKey = (variables) => [
+    "DetectMemoryConflicts",
+    variables,
+];
+export const useSuspenseDetectMemoryConflictsQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["DetectMemoryConflictsSuspense", variables],
+        queryFn: fetcher(client, DetectMemoryConflictsDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseDetectMemoryConflictsQuery.getKey = (variables) => [
+    "DetectMemoryConflictsSuspense",
+    variables,
+];
+export const ExplainRdFoxFactDocument = `
+    query ExplainRDFoxFact($subject: String!, $predicate: String, $object: String!, $objectDatatype: String, $summarize: Boolean = false, $namedGraph: IRI) {
+  explainRDFoxFact(
+    subject: $subject
+    predicate: $predicate
+    object: $object
+    objectDatatype: $objectDatatype
+    summarize: $summarize
+    namedGraph: $namedGraph
+  ) {
+    facts
+    formatted
+    summary
+    error
+  }
+}
+    `;
+export const useExplainRdFoxFactQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["ExplainRDFoxFact", variables],
+        queryFn: fetcher(client, ExplainRdFoxFactDocument, variables, headers),
+        ...options,
+    });
+};
+useExplainRdFoxFactQuery.getKey = (variables) => ["ExplainRDFoxFact", variables];
+export const useSuspenseExplainRdFoxFactQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["ExplainRDFoxFactSuspense", variables],
+        queryFn: fetcher(client, ExplainRdFoxFactDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseExplainRdFoxFactQuery.getKey = (variables) => [
+    "ExplainRDFoxFactSuspense",
+    variables,
+];
+export const GmailIntegrationsDocument = `
+    query GmailIntegrations {
+  gmailIntegrations {
+    email
+    status
+    error
+    lastSyncedAt
+    messagesIngested
+  }
+}
+    `;
+export const useGmailIntegrationsQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["GmailIntegrations"] : ["GmailIntegrations", variables],
+        queryFn: fetcher(client, GmailIntegrationsDocument, variables, headers),
+        ...options,
+    });
+};
+useGmailIntegrationsQuery.getKey = (variables) => variables === undefined ? ["GmailIntegrations"] : ["GmailIntegrations", variables];
+export const useSuspenseGmailIntegrationsQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["GmailIntegrationsSuspense"] : ["GmailIntegrationsSuspense", variables],
+        queryFn: fetcher(client, GmailIntegrationsDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseGmailIntegrationsQuery.getKey = (variables) => variables === undefined ? ["GmailIntegrationsSuspense"] : ["GmailIntegrationsSuspense", variables];
+export const GoogleAnalyticsSetupProgressDocument = `
+    query GoogleAnalyticsSetupProgress {
+  googleAnalyticsSetupProgress {
+    state
+    properties {
+      id
+      name
+      parent
+      account
+      connectable
+      externalId
+    }
+    lastError {
+      severity
+      title
+      message
+    }
+  }
+}
+    `;
+export const useGoogleAnalyticsSetupProgressQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["GoogleAnalyticsSetupProgress"] : ["GoogleAnalyticsSetupProgress", variables],
+        queryFn: fetcher(client, GoogleAnalyticsSetupProgressDocument, variables, headers),
+        ...options,
+    });
+};
+useGoogleAnalyticsSetupProgressQuery.getKey = (variables) => variables === undefined ? ["GoogleAnalyticsSetupProgress"] : ["GoogleAnalyticsSetupProgress", variables];
+export const useSuspenseGoogleAnalyticsSetupProgressQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined
+            ? ["GoogleAnalyticsSetupProgressSuspense"]
+            : ["GoogleAnalyticsSetupProgressSuspense", variables],
+        queryFn: fetcher(client, GoogleAnalyticsSetupProgressDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseGoogleAnalyticsSetupProgressQuery.getKey = (variables) => variables === undefined
+    ? ["GoogleAnalyticsSetupProgressSuspense"]
+    : ["GoogleAnalyticsSetupProgressSuspense", variables];
+export const GoogleSetupProgressDocument = `
+    query GoogleSetupProgress {
+  googleSetupProgress {
+    state
+    accounts {
+      id
+      name
+      parent
+      manager
+      level
+      connectable
+    }
+    lastError {
+      severity
+      title
+      message
+    }
+  }
+}
+    `;
+export const useGoogleSetupProgressQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["GoogleSetupProgress"] : ["GoogleSetupProgress", variables],
+        queryFn: fetcher(client, GoogleSetupProgressDocument, variables, headers),
+        ...options,
+    });
+};
+useGoogleSetupProgressQuery.getKey = (variables) => variables === undefined ? ["GoogleSetupProgress"] : ["GoogleSetupProgress", variables];
+export const useSuspenseGoogleSetupProgressQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["GoogleSetupProgressSuspense"] : ["GoogleSetupProgressSuspense", variables],
+        queryFn: fetcher(client, GoogleSetupProgressDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseGoogleSetupProgressQuery.getKey = (variables) => variables === undefined ? ["GoogleSetupProgressSuspense"] : ["GoogleSetupProgressSuspense", variables];
+export const InferalIntegrationsDocument = `
+    query InferalIntegrations {
+  inferalIntegrations {
+    id
+    provider
+    shopId
+    streamName
+    streamUrl
+    status
+    isInFlight
+  }
+}
+    `;
+export const useInferalIntegrationsQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["InferalIntegrations"] : ["InferalIntegrations", variables],
+        queryFn: fetcher(client, InferalIntegrationsDocument, variables, headers),
+        ...options,
+    });
+};
+useInferalIntegrationsQuery.getKey = (variables) => variables === undefined ? ["InferalIntegrations"] : ["InferalIntegrations", variables];
+export const useSuspenseInferalIntegrationsQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["InferalIntegrationsSuspense"] : ["InferalIntegrationsSuspense", variables],
+        queryFn: fetcher(client, InferalIntegrationsDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseInferalIntegrationsQuery.getKey = (variables) => variables === undefined ? ["InferalIntegrationsSuspense"] : ["InferalIntegrationsSuspense", variables];
+export const KnowledgeGraphStateDocument = `
+    query KnowledgeGraphState($dataVersion: String) {
+  knowledgeGraphState(dataVersion: $dataVersion) {
+    exists
+    isLoaded
+    offline
+    capacity {
+      maxTriples
+      currentTriples
+      percentageFull
+      remainingCapacity
+      entitySummary {
+        type
+        count
+      }
+    }
+    dataVersion {
+      uniqueId
+      version
+    }
+  }
+}
+    `;
+export const useKnowledgeGraphStateQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["KnowledgeGraphState"] : ["KnowledgeGraphState", variables],
+        queryFn: fetcher(client, KnowledgeGraphStateDocument, variables, headers),
+        ...options,
+    });
+};
+useKnowledgeGraphStateQuery.getKey = (variables) => variables === undefined ? ["KnowledgeGraphState"] : ["KnowledgeGraphState", variables];
+export const useSuspenseKnowledgeGraphStateQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["KnowledgeGraphStateSuspense"] : ["KnowledgeGraphStateSuspense", variables],
+        queryFn: fetcher(client, KnowledgeGraphStateDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseKnowledgeGraphStateQuery.getKey = (variables) => variables === undefined ? ["KnowledgeGraphStateSuspense"] : ["KnowledgeGraphStateSuspense", variables];
+export const LdesStreamsDocument = `
+    query LdesStreams {
+  ldesStreams {
+    url
+    datastoreId
+    phase
+    after
+    stats {
+      membersWritten
+      lastMemberUri
+      lastMemberAt
+      lastPollAt
+      nextPollAt
+      lastError
+    }
+  }
+}
+    `;
+export const useLdesStreamsQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["LdesStreams"] : ["LdesStreams", variables],
+        queryFn: fetcher(client, LdesStreamsDocument, variables, headers),
+        ...options,
+    });
+};
+useLdesStreamsQuery.getKey = (variables) => variables === undefined ? ["LdesStreams"] : ["LdesStreams", variables];
+export const useSuspenseLdesStreamsQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["LdesStreamsSuspense"] : ["LdesStreamsSuspense", variables],
+        queryFn: fetcher(client, LdesStreamsDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseLdesStreamsQuery.getKey = (variables) => variables === undefined ? ["LdesStreamsSuspense"] : ["LdesStreamsSuspense", variables];
+export const LinkedinSetupProgressDocument = `
+    query LinkedinSetupProgress {
+  linkedinSetupProgress {
+    state
+    accounts {
+      id
+      name
+    }
+    lastError {
+      severity
+      message
+      title
+    }
+  }
+}
+    `;
+export const useLinkedinSetupProgressQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["LinkedinSetupProgress"] : ["LinkedinSetupProgress", variables],
+        queryFn: fetcher(client, LinkedinSetupProgressDocument, variables, headers),
+        ...options,
+    });
+};
+useLinkedinSetupProgressQuery.getKey = (variables) => variables === undefined ? ["LinkedinSetupProgress"] : ["LinkedinSetupProgress", variables];
+export const useSuspenseLinkedinSetupProgressQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["LinkedinSetupProgressSuspense"] : ["LinkedinSetupProgressSuspense", variables],
+        queryFn: fetcher(client, LinkedinSetupProgressDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseLinkedinSetupProgressQuery.getKey = (variables) => variables === undefined ? ["LinkedinSetupProgressSuspense"] : ["LinkedinSetupProgressSuspense", variables];
+export const MemoriesDocument = `
+    query Memories($includeArchived: Boolean, $includeOutOfWindow: Boolean) {
+  memories(
+    includeArchived: $includeArchived
+    includeOutOfWindow: $includeOutOfWindow
+  ) {
+    memories {
+      ...MemoryFields
+      updatedAt
+      supersededBy
+      createdBy
+    }
+    error
+  }
+}
+    ${MemoryFieldsFragmentDoc}`;
+export const useMemoriesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["Memories"] : ["Memories", variables],
+        queryFn: fetcher(client, MemoriesDocument, variables, headers),
+        ...options,
+    });
+};
+useMemoriesQuery.getKey = (variables) => variables === undefined ? ["Memories"] : ["Memories", variables];
+export const useSuspenseMemoriesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["MemoriesSuspense"] : ["MemoriesSuspense", variables],
+        queryFn: fetcher(client, MemoriesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseMemoriesQuery.getKey = (variables) => variables === undefined ? ["MemoriesSuspense"] : ["MemoriesSuspense", variables];
+export const MemoryRedundancyReviewDocument = `
+    query MemoryRedundancyReview($input: MemoryConsolidationInput!) {
+  memoryRedundancyReview(input: $input) {
+    clusters {
+      memories {
+        ...MemoryFields
+      }
+      reason
+      suggestedLabel
+      suggestedDescription
+    }
+    abstractions {
+      memories {
+        ...MemoryFields
+      }
+      reason
+      suggestedLabel
+      suggestedDescription
+    }
+    comparedCount
+    timedOut
+    error
+  }
+}
+    ${MemoryFieldsFragmentDoc}`;
+export const useMemoryRedundancyReviewQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["MemoryRedundancyReview", variables],
+        queryFn: fetcher(client, MemoryRedundancyReviewDocument, variables, headers),
+        ...options,
+    });
+};
+useMemoryRedundancyReviewQuery.getKey = (variables) => [
+    "MemoryRedundancyReview",
+    variables,
+];
+export const useSuspenseMemoryRedundancyReviewQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["MemoryRedundancyReviewSuspense", variables],
+        queryFn: fetcher(client, MemoryRedundancyReviewDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseMemoryRedundancyReviewQuery.getKey = (variables) => [
+    "MemoryRedundancyReviewSuspense",
+    variables,
+];
+export const MemorySchemasDocument = `
+    query MemorySchemas {
+  memorySchemas {
+    schemas {
+      iri
+      label
+      description
+      properties {
+        path
+        label
+        dataType
+        required
+        allowedValues
+        keyProperty
+        inferred
+      }
+    }
+    error
+  }
+}
+    `;
+export const useMemorySchemasQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["MemorySchemas"] : ["MemorySchemas", variables],
+        queryFn: fetcher(client, MemorySchemasDocument, variables, headers),
+        ...options,
+    });
+};
+useMemorySchemasQuery.getKey = (variables) => variables === undefined ? ["MemorySchemas"] : ["MemorySchemas", variables];
+export const useSuspenseMemorySchemasQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["MemorySchemasSuspense"] : ["MemorySchemasSuspense", variables],
+        queryFn: fetcher(client, MemorySchemasDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseMemorySchemasQuery.getKey = (variables) => variables === undefined ? ["MemorySchemasSuspense"] : ["MemorySchemasSuspense", variables];
+export const MetaSetupProgressDocument = `
+    query MetaSetupProgress {
+  metaSetupProgress {
+    state
+    accounts {
+      id
+      name
+      parent
+    }
+    lastError {
+      severity
+      title
+      message
+    }
+  }
+}
+    `;
+export const useMetaSetupProgressQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["MetaSetupProgress"] : ["MetaSetupProgress", variables],
+        queryFn: fetcher(client, MetaSetupProgressDocument, variables, headers),
+        ...options,
+    });
+};
+useMetaSetupProgressQuery.getKey = (variables) => variables === undefined ? ["MetaSetupProgress"] : ["MetaSetupProgress", variables];
+export const useSuspenseMetaSetupProgressQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["MetaSetupProgressSuspense"] : ["MetaSetupProgressSuspense", variables],
+        queryFn: fetcher(client, MetaSetupProgressDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseMetaSetupProgressQuery.getKey = (variables) => variables === undefined ? ["MetaSetupProgressSuspense"] : ["MetaSetupProgressSuspense", variables];
+export const NodePropertiesDocument = `
+    query NodeProperties($nodeIri: String!, $planGraphIri: IRI) {
+  nodeProperties(nodeIri: $nodeIri, planGraphIri: $planGraphIri) {
+    subject
+    label
+    typeName
+    properties {
+      predicate
+      predicateLabel
+      object
+      objectLabel
+      beforeObject
+      beforeObjectLabel
+      changeType
+    }
+  }
+}
+    `;
+export const useNodePropertiesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["NodeProperties", variables],
+        queryFn: fetcher(client, NodePropertiesDocument, variables, headers),
+        ...options,
+    });
+};
+useNodePropertiesQuery.getKey = (variables) => ["NodeProperties", variables];
+export const useSuspenseNodePropertiesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["NodePropertiesSuspense", variables],
+        queryFn: fetcher(client, NodePropertiesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseNodePropertiesQuery.getKey = (variables) => [
+    "NodePropertiesSuspense",
+    variables,
+];
+export const NodeRelationshipsDocument = `
+    query NodeRelationships($nodeIri: IRI!, $planGraphIri: IRI, $depth: Int = 1) {
+  nodeRelationships(nodeIri: $nodeIri, planGraphIri: $planGraphIri, depth: $depth) {
+    graph
+  }
+}
+    `;
+export const useNodeRelationshipsQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["NodeRelationships", variables],
+        queryFn: fetcher(client, NodeRelationshipsDocument, variables, headers),
+        ...options,
+    });
+};
+useNodeRelationshipsQuery.getKey = (variables) => ["NodeRelationships", variables];
+export const useSuspenseNodeRelationshipsQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["NodeRelationshipsSuspense", variables],
+        queryFn: fetcher(client, NodeRelationshipsDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseNodeRelationshipsQuery.getKey = (variables) => [
+    "NodeRelationshipsSuspense",
+    variables,
+];
+export const RulesDocument = `
+    query Rules($ruleIri: IRI, $filterByOwner: String, $namedGraph: IRI, $typeFilter: [IRI!]) {
+  rules(
+    ruleIri: $ruleIri
+    filterByOwner: $filterByOwner
+    namedGraph: $namedGraph
+    typeFilter: $typeFilter
+  ) {
+    rules {
+      ruleIri
+      committedRule
+      stagedRule
+      isStaged
+      isModified
+      ownedBy {
+        type
+        userId
+      }
+      namedGraphs
+      mentionedTypes
+      component
+      stratumIndex
+      dependsPositivelyOn
+      dependsNegativelyOn
+      dependentRules
+      unifiesWith
+    }
+    jsonLdGraph
+    count
+    error
+  }
+}
+    `;
+export const useRulesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["Rules"] : ["Rules", variables],
+        queryFn: fetcher(client, RulesDocument, variables, headers),
+        ...options,
+    });
+};
+useRulesQuery.getKey = (variables) => variables === undefined ? ["Rules"] : ["Rules", variables];
+export const useSuspenseRulesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["RulesSuspense"] : ["RulesSuspense", variables],
+        queryFn: fetcher(client, RulesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseRulesQuery.getKey = (variables) => variables === undefined ? ["RulesSuspense"] : ["RulesSuspense", variables];
+export const ShaclShapesDocument = `
+    query ShaclShapes($shapeIri: IRI) {
+  shaclShapes(shapeIri: $shapeIri) {
+    turtle
+    shapeIris
+  }
+}
+    `;
+export const useShaclShapesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["ShaclShapes"] : ["ShaclShapes", variables],
+        queryFn: fetcher(client, ShaclShapesDocument, variables, headers),
+        ...options,
+    });
+};
+useShaclShapesQuery.getKey = (variables) => variables === undefined ? ["ShaclShapes"] : ["ShaclShapes", variables];
+export const useSuspenseShaclShapesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["ShaclShapesSuspense"] : ["ShaclShapesSuspense", variables],
+        queryFn: fetcher(client, ShaclShapesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseShaclShapesQuery.getKey = (variables) => variables === undefined ? ["ShaclShapesSuspense"] : ["ShaclShapesSuspense", variables];
+export const SparqlQueryDocument = `
+    query SparqlQuery($query: String!) {
+  sparqlQuery(query: $query) {
+    results {
+      head {
+        vars
+        link
+      }
+      results {
+        bindings
+      }
+    }
+    graph
+    error
+  }
+}
+    `;
+export const useSparqlQueryQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["SparqlQuery", variables],
+        queryFn: fetcher(client, SparqlQueryDocument, variables, headers),
+        ...options,
+    });
+};
+useSparqlQueryQuery.getKey = (variables) => ["SparqlQuery", variables];
+export const useSuspenseSparqlQueryQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["SparqlQuerySuspense", variables],
+        queryFn: fetcher(client, SparqlQueryDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseSparqlQueryQuery.getKey = (variables) => ["SparqlQuerySuspense", variables];
+export const SupportedActionShapesDocument = `
+    query SupportedActionShapes($rdfType: String) {
+  supportedActionShapes(rdfType: $rdfType) {
+    supportedActionShapes {
+      actionShape
+      rdfTypes
+      operations
+      supportsCreate
+      supportsUpdate
+      supportsDelete
+    }
+    count
+    error
+  }
+}
+    `;
+export const useSupportedActionShapesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["SupportedActionShapes"] : ["SupportedActionShapes", variables],
+        queryFn: fetcher(client, SupportedActionShapesDocument, variables, headers),
+        ...options,
+    });
+};
+useSupportedActionShapesQuery.getKey = (variables) => variables === undefined ? ["SupportedActionShapes"] : ["SupportedActionShapes", variables];
+export const useSuspenseSupportedActionShapesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["SupportedActionShapesSuspense"] : ["SupportedActionShapesSuspense", variables],
+        queryFn: fetcher(client, SupportedActionShapesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseSupportedActionShapesQuery.getKey = (variables) => variables === undefined ? ["SupportedActionShapesSuspense"] : ["SupportedActionShapesSuspense", variables];
+export const UnlinkedDatastoresDocument = `
+    query UnlinkedDatastores {
+  unlinkedDatastores {
+    id
+  }
+}
+    `;
+export const useUnlinkedDatastoresQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["UnlinkedDatastores"] : ["UnlinkedDatastores", variables],
+        queryFn: fetcher(client, UnlinkedDatastoresDocument, variables, headers),
+        ...options,
+    });
+};
+useUnlinkedDatastoresQuery.getKey = (variables) => variables === undefined ? ["UnlinkedDatastores"] : ["UnlinkedDatastores", variables];
+export const useSuspenseUnlinkedDatastoresQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["UnlinkedDatastoresSuspense"] : ["UnlinkedDatastoresSuspense", variables],
+        queryFn: fetcher(client, UnlinkedDatastoresDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseUnlinkedDatastoresQuery.getKey = (variables) => variables === undefined ? ["UnlinkedDatastoresSuspense"] : ["UnlinkedDatastoresSuspense", variables];
+export const UserPreferencesDocument = `
+    query UserPreferences {
+  userPreferences {
+    defaultMemoryTtlDays
+  }
+}
+    `;
+export const useUserPreferencesQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: variables === undefined ? ["UserPreferences"] : ["UserPreferences", variables],
+        queryFn: fetcher(client, UserPreferencesDocument, variables, headers),
+        ...options,
+    });
+};
+useUserPreferencesQuery.getKey = (variables) => variables === undefined ? ["UserPreferences"] : ["UserPreferences", variables];
+export const useSuspenseUserPreferencesQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: variables === undefined ? ["UserPreferencesSuspense"] : ["UserPreferencesSuspense", variables],
+        queryFn: fetcher(client, UserPreferencesDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseUserPreferencesQuery.getKey = (variables) => variables === undefined ? ["UserPreferencesSuspense"] : ["UserPreferencesSuspense", variables];
+export const ValidateActionPlanDocument = `
+    query ValidateActionPlan($planGraphIri: IRI!, $shaclShapeIri: IRI) {
+  validateActionPlan(planGraphIri: $planGraphIri, shaclShapeIri: $shaclShapeIri) {
+    valid
+    conforms
+    planGraphIri
+    shaclShapeIri
+    completeness
+    report {
+      conforms
+      resultCount
+      results {
+        focusNode
+        resultPath
+        value
+        sourceShape
+        sourceConstraintComponent
+        severity
+        message
+      }
+    }
+    error
+  }
+}
+    `;
+export const useValidateActionPlanQuery = (client, variables, options, headers) => {
+    return useQuery({
+        queryKey: ["ValidateActionPlan", variables],
+        queryFn: fetcher(client, ValidateActionPlanDocument, variables, headers),
+        ...options,
+    });
+};
+useValidateActionPlanQuery.getKey = (variables) => [
+    "ValidateActionPlan",
+    variables,
+];
+export const useSuspenseValidateActionPlanQuery = (client, variables, options, headers) => {
+    return useSuspenseQuery({
+        queryKey: ["ValidateActionPlanSuspense", variables],
+        queryFn: fetcher(client, ValidateActionPlanDocument, variables, headers),
+        ...options,
+    });
+};
+useSuspenseValidateActionPlanQuery.getKey = (variables) => [
+    "ValidateActionPlanSuspense",
+    variables,
+];