@manta-eu/client 0.11.0 → 0.13.0

package/src/generated/graphql.ts

@@ -407,6 +407,13 @@ export type GQLCancelActionPlanResponse = {
   success: Scalars["Boolean"]["output"];
 };
 
+export type GQLClearMemorySchemaPropertyValuesInput = {
+  dryRun?: InputMaybe<Scalars["Boolean"]["input"]>;
+  expectedRevision: Scalars["Int"]["input"];
+  iri: Scalars["IRI"]["input"];
+  path: Scalars["IRI"]["input"];
+};
+
 export type GQLClearStagedRulesResponse = {
   __typename?: "ClearStagedRulesResponse";
   error?: Maybe<Scalars["String"]["output"]>;
@@ -417,6 +424,8 @@ export type GQLClearStagedRulesResponse = {
 export type GQLCommitStagedRulesResponse = {
   __typename?: "CommitStagedRulesResponse";
   error?: Maybe<Scalars["String"]["output"]>;
+  outcome: GQLRuleCommitOutcome;
+  requestId?: Maybe<Scalars["String"]["output"]>;
   rulesAdded: Scalars["Int"]["output"];
   rulesDeleted: Scalars["Int"]["output"];
   rulesUpdated: Scalars["Int"]["output"];
@@ -577,6 +586,11 @@ export type GQLCreateMemoryResponse = {
   __typename?: "CreateMemoryResponse";
   error?: Maybe<Scalars["String"]["output"]>;
   memory?: Maybe<GQLMemory>;
+  propertyErrors?: Maybe<Array<GQLMemoryPropertyProblem>>;
+};
+
+export type GQLCreateMemorySchemaInput = {
+  definition: GQLMemorySchemaDefinitionInput;
 };
 
 export type GQLCreateStripeBillingPortalSessionResponse = {
@@ -935,6 +949,15 @@ export type GQLDeleteRulePrefixResponse = {
   success: Scalars["Boolean"]["output"];
 };
 
+export type GQLDeleteUploadInput = {
+  storageKey: Scalars["String"]["input"];
+};
+
+export type GQLDeleteUploadResponse = {
+  __typename?: "DeleteUploadResponse";
+  ok: Scalars["Boolean"]["output"];
+};
+
 export type GQLDeleteUserAccountResponse = {
   __typename?: "DeleteUserAccountResponse";
   deleted: Scalars["Boolean"]["output"];
@@ -1401,6 +1424,7 @@ export type GQLKnowledgeGraphDataVersion = {
 
 export type GQLKnowledgeGraphState = {
   __typename?: "KnowledgeGraphState";
+  /** @deprecated Placeholder values: the datastore is no longer counted. */
   capacity: GQLKnowledgeGraphCapacity;
   dataVersion?: Maybe<GQLKnowledgeGraphDataVersion>;
   exists: Scalars["Boolean"]["output"];
@@ -1562,7 +1586,9 @@ export type GQLMemory = {
   aboutEntityIris: Array<Scalars["IRI"]["output"]>;
   confidence?: Maybe<Scalars["Float"]["output"]>;
   createdBy?: Maybe<Scalars["String"]["output"]>;
+  /** @deprecated Read customPropertyValues: it keeps each value of a multi-valued property apart. */
   customProperties?: Maybe<Scalars["JSONObject"]["output"]>;
+  customPropertyValues: Array<GQLMemoryPropertyValues>;
   description?: Maybe<Scalars["String"]["output"]>;
   extractedAt: Scalars["DateTime"]["output"];
   importance: Scalars["Int"]["output"];
@@ -1578,6 +1604,7 @@ export type GQLMemory = {
   memoryUseCount: Scalars["Int"]["output"];
   memoryValidFrom?: Maybe<Scalars["DateTime"]["output"]>;
   memoryValidUntil?: Maybe<Scalars["DateTime"]["output"]>;
+  schemaAssignment?: Maybe<GQLMemorySchemaAssignment>;
   scope: GQLMemoryScope;
   supersededBy?: Maybe<Scalars["IRI"]["output"]>;
   supersedesMemory?: Maybe<Scalars["IRI"]["output"]>;
@@ -1605,6 +1632,19 @@ export enum GQLMemoryKind {
   Preference = "preference",
 }
 
+export type GQLMemoryPropertyProblem = {
+  __typename?: "MemoryPropertyProblem";
+  label?: Maybe<Scalars["String"]["output"]>;
+  message: Scalars["String"]["output"];
+  path: Scalars["IRI"]["output"];
+};
+
+export type GQLMemoryPropertyValues = {
+  __typename?: "MemoryPropertyValues";
+  path: Scalars["IRI"]["output"];
+  values: Array<Scalars["String"]["output"]>;
+};
+
 export type GQLMemoryRedundancyResult = {
   __typename?: "MemoryRedundancyResult";
   abstractions: Array<GQLMemoryAbstraction>;
@@ -1635,21 +1675,177 @@ export type GQLMemoryReplaySeriesResult = {
 
 export type GQLMemorySchema = {
   __typename?: "MemorySchema";
+  createdAt?: Maybe<Scalars["DateTime"]["output"]>;
+  createdBy: GQLMemorySchemaCreator;
+  customized: Scalars["Boolean"]["output"];
+  defaultImportance?: Maybe<Scalars["Int"]["output"]>;
+  defaultMemoryKind?: Maybe<GQLMemoryKind>;
+  defaultScope?: Maybe<GQLMemoryScope>;
+  defaultVolatility?: Maybe<GQLMemoryVolatility>;
   description?: Maybe<Scalars["String"]["output"]>;
+  extractionEnabled: Scalars["Boolean"]["output"];
+  extractionGuidance?: Maybe<Scalars["String"]["output"]>;
   iri: Scalars["IRI"]["output"];
   label: Scalars["String"]["output"];
+  memoryCount?: Maybe<Scalars["Int"]["output"]>;
   properties: Array<GQLMemorySchemaProperty>;
+  revision: Scalars["Int"]["output"];
+  status: GQLMemorySchemaStatus;
+  templateStatus: GQLMemorySchemaTemplateStatus;
+  updatedAt?: Maybe<Scalars["DateTime"]["output"]>;
+};
+
+export type GQLMemorySchemaAssignment = {
+  __typename?: "MemorySchemaAssignment";
+  assignedAt?: Maybe<Scalars["DateTime"]["output"]>;
+  confidence?: Maybe<Scalars["Float"]["output"]>;
+  schemaIri: Scalars["IRI"]["output"];
+};
+
+export enum GQLMemorySchemaCreator {
+  AnotherUser = "anotherUser",
+  CurrentUser = "currentUser",
+  Manta = "manta",
+}
+
+export type GQLMemorySchemaDefinitionInput = {
+  defaultImportance?: InputMaybe<Scalars["Int"]["input"]>;
+  defaultMemoryKind?: InputMaybe<GQLMemoryKind>;
+  defaultScope?: InputMaybe<GQLMemoryScope>;
+  defaultVolatility?: InputMaybe<GQLMemoryVolatility>;
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  extractionEnabled?: InputMaybe<Scalars["Boolean"]["input"]>;
+  extractionGuidance?: InputMaybe<Scalars["String"]["input"]>;
+  key?: InputMaybe<Scalars["String"]["input"]>;
+  label: Scalars["String"]["input"];
+  properties: Array<GQLMemorySchemaPropertyDefinitionInput>;
+};
+
+export type GQLMemorySchemaImpact = {
+  __typename?: "MemorySchemaImpact";
+  blockers: Array<Scalars["String"]["output"]>;
+  clearedValues: Array<GQLMemorySchemaPropertyImpact>;
+  limitViolations: Array<GQLMemorySchemaLimitImpact>;
+  memoryCount: Scalars["Int"]["output"];
+  multiValueConflicts: Array<GQLMemorySchemaPropertyImpact>;
+  removedOptions: Array<GQLMemorySchemaOptionImpact>;
+  removedProperties: Array<GQLMemorySchemaPropertyImpact>;
+  ruleReferences: Array<GQLMemorySchemaRuleReference>;
+  typeChanges: Array<GQLMemorySchemaTypeChangeImpact>;
+};
+
+export type GQLMemorySchemaLimitImpact = {
+  __typename?: "MemorySchemaLimitImpact";
+  invalidCount: Scalars["Int"]["output"];
+  invalidSamples: Array<Scalars["String"]["output"]>;
+  label: Scalars["String"]["output"];
+  path: Scalars["IRI"]["output"];
+  valueCount: Scalars["Int"]["output"];
+};
+
+export type GQLMemorySchemaMutationResponse = {
+  __typename?: "MemorySchemaMutationResponse";
+  error?: Maybe<Scalars["String"]["output"]>;
+  impact?: Maybe<GQLMemorySchemaImpact>;
+  schema?: Maybe<GQLMemorySchema>;
+  status: GQLMemorySchemaMutationStatus;
+  validationErrors: Array<GQLMemorySchemaValidationError>;
+};
+
+export enum GQLMemorySchemaMutationStatus {
+  Blocked = "blocked",
+  Conflict = "conflict",
+  Invalid = "invalid",
+  Limit = "limit",
+  NotFound = "notFound",
+  Ok = "ok",
+  Preview = "preview",
+}
+
+export type GQLMemorySchemaOption = {
+  __typename?: "MemorySchemaOption";
+  description?: Maybe<Scalars["String"]["output"]>;
+  label?: Maybe<Scalars["String"]["output"]>;
+  value: Scalars["String"]["output"];
+};
+
+export type GQLMemorySchemaOptionImpact = {
+  __typename?: "MemorySchemaOptionImpact";
+  label: Scalars["String"]["output"];
+  memoryCount: Scalars["Int"]["output"];
+  path: Scalars["IRI"]["output"];
+  remappedTo?: Maybe<Scalars["String"]["output"]>;
+  value: Scalars["String"]["output"];
+};
+
+export type GQLMemorySchemaOptionInput = {
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  label?: InputMaybe<Scalars["String"]["input"]>;
+  value: Scalars["String"]["input"];
+};
+
+export type GQLMemorySchemaOptionRemapInput = {
+  from: Scalars["String"]["input"];
+  path: Scalars["IRI"]["input"];
+  to?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type GQLMemorySchemaOptionUsage = {
+  __typename?: "MemorySchemaOptionUsage";
+  memoryCount: Scalars["Int"]["output"];
+  value: Scalars["String"]["output"];
 };
 
 export type GQLMemorySchemaProperty = {
   __typename?: "MemorySchemaProperty";
   allowedValues: Array<Scalars["String"]["output"]>;
+  computed: Scalars["Boolean"]["output"];
   dataType: Scalars["String"]["output"];
+  defaultValue?: Maybe<Scalars["String"]["output"]>;
+  description?: Maybe<Scalars["String"]["output"]>;
+  entityClass?: Maybe<Scalars["IRI"]["output"]>;
+  /** @deprecated Renamed to computed. */
   inferred: Scalars["Boolean"]["output"];
   keyProperty: Scalars["Boolean"]["output"];
   label: Scalars["String"]["output"];
+  maxLength?: Maybe<Scalars["Int"]["output"]>;
+  maxValue?: Maybe<Scalars["String"]["output"]>;
+  minValue?: Maybe<Scalars["String"]["output"]>;
+  multiValued: Scalars["Boolean"]["output"];
+  options: Array<GQLMemorySchemaOption>;
+  order: Scalars["Int"]["output"];
   path: Scalars["IRI"]["output"];
+  pattern?: Maybe<Scalars["String"]["output"]>;
   required: Scalars["Boolean"]["output"];
+  unit?: Maybe<Scalars["String"]["output"]>;
+  valueType: GQLMemorySchemaValueType;
+};
+
+export type GQLMemorySchemaPropertyDefinitionInput = {
+  computed?: InputMaybe<Scalars["Boolean"]["input"]>;
+  defaultValue?: InputMaybe<Scalars["String"]["input"]>;
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  entityClass?: InputMaybe<Scalars["IRI"]["input"]>;
+  key?: InputMaybe<Scalars["String"]["input"]>;
+  keyProperty?: InputMaybe<Scalars["Boolean"]["input"]>;
+  label: Scalars["String"]["input"];
+  maxLength?: InputMaybe<Scalars["Int"]["input"]>;
+  maxValue?: InputMaybe<Scalars["String"]["input"]>;
+  minValue?: InputMaybe<Scalars["String"]["input"]>;
+  multiValued?: InputMaybe<Scalars["Boolean"]["input"]>;
+  options?: InputMaybe<Array<GQLMemorySchemaOptionInput>>;
+  path?: InputMaybe<Scalars["IRI"]["input"]>;
+  pattern?: InputMaybe<Scalars["String"]["input"]>;
+  required?: InputMaybe<Scalars["Boolean"]["input"]>;
+  unit?: InputMaybe<Scalars["String"]["input"]>;
+  valueType: GQLMemorySchemaValueType;
+};
+
+export type GQLMemorySchemaPropertyImpact = {
+  __typename?: "MemorySchemaPropertyImpact";
+  label: Scalars["String"]["output"];
+  memoryCount: Scalars["Int"]["output"];
+  path: Scalars["IRI"]["output"];
 };
 
 export type GQLMemorySchemaPropertyInput = {
@@ -1660,6 +1856,118 @@ export type GQLMemorySchemaPropertyInput = {
   required: Scalars["Boolean"]["input"];
 };
 
+export type GQLMemorySchemaPropertyUsage = {
+  __typename?: "MemorySchemaPropertyUsage";
+  memoryCount: Scalars["Int"]["output"];
+  options: Array<GQLMemorySchemaOptionUsage>;
+  path: Scalars["IRI"]["output"];
+};
+
+export type GQLMemorySchemaRevisionInput = {
+  expectedRevision: Scalars["Int"]["input"];
+  iri: Scalars["IRI"]["input"];
+};
+
+export type GQLMemorySchemaRuleCount = {
+  __typename?: "MemorySchemaRuleCount";
+  iri: Scalars["IRI"]["output"];
+  ruleCount: Scalars["Int"]["output"];
+};
+
+export type GQLMemorySchemaRuleCountsResponse = {
+  __typename?: "MemorySchemaRuleCountsResponse";
+  counts: Array<GQLMemorySchemaRuleCount>;
+  error?: Maybe<Scalars["String"]["output"]>;
+};
+
+export enum GQLMemorySchemaRulePosition {
+  Body = "body",
+  Head = "head",
+}
+
+export type GQLMemorySchemaRuleReference = {
+  __typename?: "MemorySchemaRuleReference";
+  kind: GQLMemorySchemaRuleReferenceKind;
+  label?: Maybe<Scalars["String"]["output"]>;
+  position: GQLMemorySchemaRulePosition;
+  ruleIri: Scalars["String"]["output"];
+  term: Scalars["IRI"]["output"];
+  value?: Maybe<Scalars["String"]["output"]>;
+};
+
+export enum GQLMemorySchemaRuleReferenceKind {
+  Class = "class",
+  Property = "property",
+  Value = "value",
+}
+
+export enum GQLMemorySchemaStatus {
+  Active = "active",
+  Archived = "archived",
+}
+
+export type GQLMemorySchemaTemplate = {
+  __typename?: "MemorySchemaTemplate";
+  live: Scalars["Boolean"]["output"];
+  schema: GQLMemorySchema;
+};
+
+export enum GQLMemorySchemaTemplateStatus {
+  Current = "current",
+  None = "none",
+  Removed = "removed",
+  Updated = "updated",
+}
+
+export type GQLMemorySchemaTemplatesResponse = {
+  __typename?: "MemorySchemaTemplatesResponse";
+  error?: Maybe<Scalars["String"]["output"]>;
+  templates: Array<GQLMemorySchemaTemplate>;
+};
+
+export type GQLMemorySchemaTypeChangeImpact = {
+  __typename?: "MemorySchemaTypeChangeImpact";
+  from: GQLMemorySchemaValueType;
+  label: Scalars["String"]["output"];
+  path: Scalars["IRI"]["output"];
+  to: GQLMemorySchemaValueType;
+  unconvertibleCount: Scalars["Int"]["output"];
+  unconvertibleSamples: Array<Scalars["String"]["output"]>;
+  valueCount: Scalars["Int"]["output"];
+};
+
+export type GQLMemorySchemaUsage = {
+  __typename?: "MemorySchemaUsage";
+  iri: Scalars["IRI"]["output"];
+  memoryCount: Scalars["Int"]["output"];
+  properties: Array<GQLMemorySchemaPropertyUsage>;
+  rules: Array<GQLMemorySchemaRuleReference>;
+};
+
+export type GQLMemorySchemaUsageResponse = {
+  __typename?: "MemorySchemaUsageResponse";
+  error?: Maybe<Scalars["String"]["output"]>;
+  usage?: Maybe<GQLMemorySchemaUsage>;
+};
+
+export type GQLMemorySchemaValidationError = {
+  __typename?: "MemorySchemaValidationError";
+  field: Scalars["String"]["output"];
+  message: Scalars["String"]["output"];
+};
+
+export enum GQLMemorySchemaValueType {
+  Boolean = "boolean",
+  Date = "date",
+  DateTime = "dateTime",
+  Decimal = "decimal",
+  Entity = "entity",
+  Integer = "integer",
+  LongText = "longText",
+  Text = "text",
+  Url = "url",
+}
+
 export type GQLMemorySchemasResponse = {
   __typename?: "MemorySchemasResponse";
   error?: Maybe<Scalars["String"]["output"]>;
@@ -1672,6 +1980,12 @@ export enum GQLMemoryScope {
   User = "user",
 }
 
+export enum GQLMemoryVolatility {
+  Slow = "slow",
+  Stable = "stable",
+  Volatile = "volatile",
+}
+
 export type GQLMetaAdAccount = {
   __typename?: "MetaAdAccount";
   externalId?: Maybe<Scalars["String"]["output"]>;
@@ -1756,11 +2070,14 @@ export type GQLMutation = {
   __typename?: "Mutation";
   abortUpload: GQLAbortUploadResponse;
   acceptInvitation: GQLInvitationAcceptedResponse;
+  addMemorySchemaFromTemplate: GQLMemorySchemaMutationResponse;
+  archiveMemorySchema: GQLMemorySchemaMutationResponse;
   assignTeamMembers: GQLAssignmentSummary;
   attributeStripeSubscription: GQLAttributeStripeSubscriptionResponse;
   awaitDataConnectionTest: GQLDataConnectionTestState;
   bringDatastoreOnline: GQLBringDatastoreOnlineResponse;
   cancelActionPlan: GQLCancelActionPlanResponse;
+  clearMemorySchemaPropertyValues: GQLMemorySchemaMutationResponse;
   clearStagedRules: GQLClearStagedRulesResponse;
   commitStagedRules: GQLCommitStagedRulesResponse;
   completeStripeCheckout: GQLCompleteStripeCheckoutResponse;
@@ -1772,6 +2089,7 @@ export type GQLMutation = {
   createDataConnection: GQLDataConnectionTestState;
   createInferalIntegration: GQLCreateInferalIntegrationResponse;
   createMemory: GQLCreateMemoryResponse;
+  createMemorySchema: GQLMemorySchemaMutationResponse;
   createRulePrefix: GQLRulePrefixResponse;
   createStripeBillingPortalSession: GQLCreateStripeBillingPortalSessionResponse;
   createStripeCheckoutSession: GQLCreateStripeCheckoutSessionResponse;
@@ -1783,12 +2101,15 @@ export type GQLMutation = {
   deleteDatastore: GQLDeleteDatastoreResponse;
   deleteLDESStream: GQLLdesStreamDeleteResponse;
   deleteMemory: GQLDeleteMemoryResponse;
+  deleteMemorySchema: GQLMemorySchemaMutationResponse;
   deleteRulePrefix: GQLDeleteRulePrefixResponse;
+  deleteUpload: GQLDeleteUploadResponse;
   deleteUserAccount: GQLDeleteUserAccountResponse;
   disconnectConnectedAccount: GQLDisconnectConnectedAccountResponse;
   disconnectCustomApp: Scalars["Boolean"]["output"];
   disconnectGmailIntegration: GQLDisconnectGmailIntegrationResponse;
   disconnectInferalIntegration: GQLDisconnectInferalIntegrationResponse;
+  dismissMemorySchemaTemplateUpdate: GQLMemorySchemaMutationResponse;
   executeActionAddition: GQLExecuteActionResponse;
   executeActionDeletion: GQLExecuteActionResponse;
   executeActionGraph: GQLExecuteActionResponse;
@@ -1818,6 +2139,7 @@ export type GQLMutation = {
   microsoftAdsSetupConnect: GQLMicrosoftAdsSetupProgress;
   pauseLDESStream: GQLLdesStreamResponse;
   provisionDatastore: GQLProvisionDatastoreResponse;
+  publishManualActionAssigned: GQLPublishChannelEventResult;
   reconfirmMemory: GQLUpdateMemoryResponse;
   recordHotelProfile: GQLRecordHotelProfileResponse;
   refreshResources: GQLRefreshResourcesResponse;
@@ -1830,6 +2152,7 @@ export type GQLMutation = {
   renameDatastoreGroup: GQLRenameDatastoreGroupResponse;
   renameUser: GQLRenameUserResponse;
   resendTeamInvitation: GQLTeamInvitationResentResponse;
+  resetMemorySchemaToTemplate: GQLMemorySchemaMutationResponse;
   restoreMemory: GQLRestoreMemoryResponse;
   resumeLDESStream: GQLLdesStreamResponse;
   revokeOperatorRole: GQLRevokeOperatorRoleResponse;
@@ -1837,15 +2160,19 @@ export type GQLMutation = {
   rotateCustomAppSecret: GQLCustomAppCredentials;
   runDatastoreDeletionStep: GQLRunDatastoreDeletionStepResult;
   selfServeProvisionOrganization: GQLSelfServeProvisionOrganizationResponse;
+  setActionPlanAutoPilot: GQLSetActionPlanAutoPilotResponse;
   setCustomAppChatAllowance: GQLCustomAppChatAllowance;
   setCustomAppEnabled: GQLCustomApp;
   setTeamMemberEnabled: GQLTeamMemberEnabledResponse;
   stageRuleOperation: GQLStageRuleOperationResponse;
   startLDESStream: GQLLdesStreamResponse;
   syncGmailIntegration: GQLGmailIntegration;
+  unarchiveMemorySchema: GQLMemorySchemaMutationResponse;
+  undoMemorySchemaAssignment: GQLUpdateMemoryResponse;
   updateCustomApp: GQLCustomApp;
   updateDataConnection: GQLDataConnectionTestState;
   updateMemory: GQLUpdateMemoryResponse;
+  updateMemorySchema: GQLMemorySchemaMutationResponse;
   updateRulePrefix: GQLRulePrefixResponse;
   updateTeamMember: GQLTeamMemberUpdateResponse;
   updateUserPreferences: GQLUpdateUserPreferencesResponse;
@@ -1861,6 +2188,14 @@ export type GQLMutationAcceptInvitationArgs = {
   organizationId: Scalars["ID"]["input"];
 };
 
+export type GQLMutationAddMemorySchemaFromTemplateArgs = {
+  templateIri: Scalars["IRI"]["input"];
+};
+
+export type GQLMutationArchiveMemorySchemaArgs = {
+  input: GQLMemorySchemaRevisionInput;
+};
+
 export type GQLMutationAssignTeamMembersArgs = {
   roles?: InputMaybe<Array<GQLAssignmentRoleInput>>;
   targets: Array<GQLAssignTargetInput>;
@@ -1884,6 +2219,10 @@ export type GQLMutationCancelActionPlanArgs = {
   planIri: Scalars["String"]["input"];
 };
 
+export type GQLMutationClearMemorySchemaPropertyValuesArgs = {
+  input: GQLClearMemorySchemaPropertyValuesInput;
+};
+
 export type GQLMutationClearStagedRulesArgs = {
   ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]>>;
 };
@@ -1936,6 +2275,10 @@ export type GQLMutationCreateMemoryArgs = {
   input: GQLCreateMemoryInput;
 };
 
+export type GQLMutationCreateMemorySchemaArgs = {
+  input: GQLCreateMemorySchemaInput;
+};
+
 export type GQLMutationCreateRulePrefixArgs = {
   input: GQLRulePrefixInput;
 };
@@ -1987,10 +2330,18 @@ export type GQLMutationDeleteMemoryArgs = {
   memoryIri: Scalars["IRI"]["input"];
 };
 
+export type GQLMutationDeleteMemorySchemaArgs = {
+  input: GQLMemorySchemaRevisionInput;
+};
+
 export type GQLMutationDeleteRulePrefixArgs = {
   name: Scalars["String"]["input"];
 };
 
+export type GQLMutationDeleteUploadArgs = {
+  input: GQLDeleteUploadInput;
+};
+
 export type GQLMutationDeleteUserAccountArgs = {
   userId: Scalars["String"]["input"];
 };
@@ -2011,6 +2362,10 @@ export type GQLMutationDisconnectInferalIntegrationArgs = {
   id: Scalars["String"]["input"];
 };
 
+export type GQLMutationDismissMemorySchemaTemplateUpdateArgs = {
+  input: GQLMemorySchemaRevisionInput;
+};
+
 export type GQLMutationExecuteActionAdditionArgs = {
   input: GQLExecuteActionAdditionInput;
 };
@@ -2141,6 +2496,10 @@ export type GQLMutationProvisionDatastoreArgs = {
   input: GQLProvisionDatastoreInput;
 };
 
+export type GQLMutationPublishManualActionAssignedArgs = {
+  input: GQLPublishManualActionAssignedInput;
+};
+
 export type GQLMutationReconfirmMemoryArgs = {
   memoryIri: Scalars["IRI"]["input"];
 };
@@ -2201,6 +2560,10 @@ export type GQLMutationResendTeamInvitationArgs = {
   userId: Scalars["String"]["input"];
 };
 
+export type GQLMutationResetMemorySchemaToTemplateArgs = {
+  input: GQLResetMemorySchemaInput;
+};
+
 export type GQLMutationRestoreMemoryArgs = {
   memoryIri: Scalars["IRI"]["input"];
 };
@@ -2232,6 +2595,10 @@ export type GQLMutationSelfServeProvisionOrganizationArgs = {
   input: GQLSelfServeProvisionOrganizationInput;
 };
 
+export type GQLMutationSetActionPlanAutoPilotArgs = {
+  input: GQLSetActionPlanAutoPilotInput;
+};
+
 export type GQLMutationSetCustomAppChatAllowanceArgs = {
   clientId: Scalars["String"]["input"];
   org?: InputMaybe<Scalars["String"]["input"]>;
@@ -2263,6 +2630,14 @@ export type GQLMutationSyncGmailIntegrationArgs = {
   email: Scalars["String"]["input"];
 };
 
+export type GQLMutationUnarchiveMemorySchemaArgs = {
+  input: GQLMemorySchemaRevisionInput;
+};
+
+export type GQLMutationUndoMemorySchemaAssignmentArgs = {
+  memoryIri: Scalars["IRI"]["input"];
+};
+
 export type GQLMutationUpdateCustomAppArgs = {
   clientId: Scalars["String"]["input"];
   datastores?: InputMaybe<Array<Scalars["String"]["input"]>>;
@@ -2282,6 +2657,10 @@ export type GQLMutationUpdateMemoryArgs = {
   input: GQLUpdateMemoryInput;
 };
 
+export type GQLMutationUpdateMemorySchemaArgs = {
+  input: GQLUpdateMemorySchemaInput;
+};
+
 export type GQLMutationUpdateRulePrefixArgs = {
   input: GQLRulePrefixInput;
 };
@@ -2407,6 +2786,21 @@ export type GQLProvisionDatastoreResponse = {
   success: Scalars["Boolean"]["output"];
 };
 
+export type GQLPublishChannelEventResult = {
+  __typename?: "PublishChannelEventResult";
+  delivered: Scalars["Int"]["output"];
+};
+
+export type GQLPublishManualActionAssignedInput = {
+  aboutIri?: InputMaybe<Scalars["String"]["input"]>;
+  actionPlanIri: Scalars["String"]["input"];
+  assignees: Array<Scalars["String"]["input"]>;
+  datastoreId: Scalars["String"]["input"];
+  description?: InputMaybe<Scalars["String"]["input"]>;
+  eventId: Scalars["String"]["input"];
+  manualActionIri: Scalars["String"]["input"];
+};
+
 export type GQLQuantitativeValue = GQLApproximateQuantitativeValue | GQLExactQuantitativeValue;
 
 export type GQLQuery = {
@@ -2454,6 +2848,9 @@ export type GQLQuery = {
   memories: GQLMemoriesResponse;
   memoryRedundancyReview: GQLMemoryRedundancyResult;
   memoryReplaySeries: GQLMemoryReplaySeriesResult;
+  memorySchemaRuleCounts: GQLMemorySchemaRuleCountsResponse;
+  memorySchemaTemplates: GQLMemorySchemaTemplatesResponse;
+  memorySchemaUsage: GQLMemorySchemaUsageResponse;
   memorySchemas: GQLMemorySchemasResponse;
   metaInterestSuggestions: Array<GQLMetaInterestSuggestion>;
   metaSetupProgress: GQLMetaSetupProgress;
@@ -2624,6 +3021,14 @@ export type GQLQueryMemoryReplaySeriesArgs = {
   limit?: InputMaybe<Scalars["Int"]["input"]>;
 };
 
+export type GQLQueryMemorySchemaUsageArgs = {
+  iri: Scalars["IRI"]["input"];
+};
+
+export type GQLQueryMemorySchemasArgs = {
+  includeArchived?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+
 export type GQLQueryMetaInterestSuggestionsArgs = {
   adAccountIri: Scalars["IRI"]["input"];
   limit?: InputMaybe<Scalars["Int"]["input"]>;
@@ -2826,6 +3231,14 @@ export type GQLRenameUserResponse = {
   name?: Maybe<Scalars["String"]["output"]>;
 };
 
+export type GQLResetMemorySchemaInput = {
+  clearUnconvertibleValues?: InputMaybe<Scalars["Boolean"]["input"]>;
+  dryRun?: InputMaybe<Scalars["Boolean"]["input"]>;
+  expectedRevision: Scalars["Int"]["input"];
+  iri: Scalars["IRI"]["input"];
+  optionRemaps?: InputMaybe<Array<GQLMemorySchemaOptionRemapInput>>;
+};
+
 export type GQLRestoreMemoryResponse = {
   __typename?: "RestoreMemoryResponse";
   blockedByIri?: Maybe<Scalars["IRI"]["output"]>;
@@ -2864,6 +3277,16 @@ export type GQLRule = {
   unifiesWith: Array<Scalars["IRI"]["output"]>;
 };
 
+export enum GQLRuleCommitOutcome {
+  Committed = "committed",
+  Failed = "failed",
+  GatewayGaveUp = "gateway_gave_up",
+  Locked = "locked",
+  NoChanges = "no_changes",
+  Refused = "refused",
+  TimedOut = "timed_out",
+}
+
 export enum GQLRuleOperation {
   Add = "ADD",
   Change = "CHANGE",
@@ -3050,6 +3473,21 @@ export type GQLSessionUser = {
   pictureSource?: Maybe<GQLPictureSource>;
 };
 
+export type GQLSetActionPlanAutoPilotInput = {
+  enabled: Scalars["Boolean"]["input"];
+  planGraphIri: Scalars["IRI"]["input"];
+  scheduledCadence?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type GQLSetActionPlanAutoPilotResponse = {
+  __typename?: "SetActionPlanAutoPilotResponse";
+  autoPilotEnabled?: Maybe<Scalars["Boolean"]["output"]>;
+  error?: Maybe<Scalars["String"]["output"]>;
+  planGraphIri: Scalars["IRI"]["output"];
+  ruleIri?: Maybe<Scalars["IRI"]["output"]>;
+  success: Scalars["Boolean"]["output"];
+};
+
 export enum GQLSetupAccountUnavailableReason {
   InsufficientPermissions = "INSUFFICIENT_PERMISSIONS",
   TermsNotAccepted = "TERMS_NOT_ACCEPTED",
@@ -3388,6 +3826,16 @@ export type GQLUpdateMemoryResponse = {
   __typename?: "UpdateMemoryResponse";
   error?: Maybe<Scalars["String"]["output"]>;
   memory?: Maybe<GQLMemory>;
+  propertyErrors?: Maybe<Array<GQLMemoryPropertyProblem>>;
+};
+
+export type GQLUpdateMemorySchemaInput = {
+  clearUnconvertibleValues?: InputMaybe<Scalars["Boolean"]["input"]>;
+  definition: GQLMemorySchemaDefinitionInput;
+  dryRun?: InputMaybe<Scalars["Boolean"]["input"]>;
+  expectedRevision: Scalars["Int"]["input"];
+  iri: Scalars["IRI"]["input"];
+  optionRemaps?: InputMaybe<Array<GQLMemorySchemaOptionRemapInput>>;
 };
 
 export type GQLUpdateUserPreferencesInput = {
@@ -3529,7 +3977,13 @@ export type GQLMemoryFieldsFragment = {
   teams: Array<string>;
   importance: number;
   memorySubclass?: string | null;
-  customProperties?: Record<string, unknown> | null;
+  customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+  schemaAssignment?: {
+    __typename?: "MemorySchemaAssignment";
+    schemaIri: string;
+    confidence?: number | null;
+    assignedAt?: Date | string | null;
+  } | null;
 };
 
 export type GQLMemoryMutationResultFragment = {
@@ -3557,10 +4011,210 @@ export type GQLMemoryMutationResultFragment = {
     teams: Array<string>;
     importance: number;
     memorySubclass?: string | null;
-    customProperties?: Record<string, unknown> | null;
+    customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+    schemaAssignment?: {
+      __typename?: "MemorySchemaAssignment";
+      schemaIri: string;
+      confidence?: number | null;
+      assignedAt?: Date | string | null;
+    } | null;
+  } | null;
+  propertyErrors?: Array<{
+    __typename?: "MemoryPropertyProblem";
+    path: string;
+    label?: string | null;
+    message: string;
+  }> | null;
+};
+
+export type GQLMemorySchemaFieldsFragment = {
+  __typename?: "MemorySchema";
+  iri: string;
+  label: string;
+  description?: string | null;
+  status: GQLMemorySchemaStatus;
+  revision: number;
+  defaultMemoryKind?: GQLMemoryKind | null;
+  defaultVolatility?: GQLMemoryVolatility | null;
+  defaultImportance?: number | null;
+  defaultScope?: GQLMemoryScope | null;
+  extractionEnabled: boolean;
+  extractionGuidance?: string | null;
+  templateStatus: GQLMemorySchemaTemplateStatus;
+  customized: boolean;
+  memoryCount?: number | null;
+  createdAt?: Date | string | null;
+  createdBy: GQLMemorySchemaCreator;
+  updatedAt?: Date | string | null;
+  properties: Array<{
+    __typename?: "MemorySchemaProperty";
+    path: string;
+    label: string;
+    description?: string | null;
+    order: number;
+    valueType: GQLMemorySchemaValueType;
+    dataType: string;
+    entityClass?: string | null;
+    required: boolean;
+    multiValued: boolean;
+    allowedValues: Array<string>;
+    keyProperty: boolean;
+    computed: boolean;
+    minValue?: string | null;
+    maxValue?: string | null;
+    maxLength?: number | null;
+    pattern?: string | null;
+    defaultValue?: string | null;
+    unit?: string | null;
+    options: Array<{
+      __typename?: "MemorySchemaOption";
+      value: string;
+      label?: string | null;
+      description?: string | null;
+    }>;
+  }>;
+};
+
+export type GQLMemorySchemaMutationResultFragment = {
+  __typename?: "MemorySchemaMutationResponse";
+  status: GQLMemorySchemaMutationStatus;
+  error?: string | null;
+  validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+  schema?: {
+    __typename?: "MemorySchema";
+    iri: string;
+    label: string;
+    description?: string | null;
+    status: GQLMemorySchemaStatus;
+    revision: number;
+    defaultMemoryKind?: GQLMemoryKind | null;
+    defaultVolatility?: GQLMemoryVolatility | null;
+    defaultImportance?: number | null;
+    defaultScope?: GQLMemoryScope | null;
+    extractionEnabled: boolean;
+    extractionGuidance?: string | null;
+    templateStatus: GQLMemorySchemaTemplateStatus;
+    customized: boolean;
+    memoryCount?: number | null;
+    createdAt?: Date | string | null;
+    createdBy: GQLMemorySchemaCreator;
+    updatedAt?: Date | string | null;
+    properties: Array<{
+      __typename?: "MemorySchemaProperty";
+      path: string;
+      label: string;
+      description?: string | null;
+      order: number;
+      valueType: GQLMemorySchemaValueType;
+      dataType: string;
+      entityClass?: string | null;
+      required: boolean;
+      multiValued: boolean;
+      allowedValues: Array<string>;
+      keyProperty: boolean;
+      computed: boolean;
+      minValue?: string | null;
+      maxValue?: string | null;
+      maxLength?: number | null;
+      pattern?: string | null;
+      defaultValue?: string | null;
+      unit?: string | null;
+      options: Array<{
+        __typename?: "MemorySchemaOption";
+        value: string;
+        label?: string | null;
+        description?: string | null;
+      }>;
+    }>;
+  } | null;
+  impact?: {
+    __typename?: "MemorySchemaImpact";
+    memoryCount: number;
+    blockers: Array<string>;
+    removedProperties: Array<{
+      __typename?: "MemorySchemaPropertyImpact";
+      path: string;
+      label: string;
+      memoryCount: number;
+    }>;
+    typeChanges: Array<{
+      __typename?: "MemorySchemaTypeChangeImpact";
+      path: string;
+      label: string;
+      from: GQLMemorySchemaValueType;
+      to: GQLMemorySchemaValueType;
+      valueCount: number;
+      unconvertibleCount: number;
+      unconvertibleSamples: Array<string>;
+    }>;
+    removedOptions: Array<{
+      __typename?: "MemorySchemaOptionImpact";
+      path: string;
+      label: string;
+      value: string;
+      memoryCount: number;
+      remappedTo?: string | null;
+    }>;
+    limitViolations: Array<{
+      __typename?: "MemorySchemaLimitImpact";
+      path: string;
+      label: string;
+      valueCount: number;
+      invalidCount: number;
+      invalidSamples: Array<string>;
+    }>;
+    multiValueConflicts: Array<{
+      __typename?: "MemorySchemaPropertyImpact";
+      path: string;
+      label: string;
+      memoryCount: number;
+    }>;
+    clearedValues: Array<{
+      __typename?: "MemorySchemaPropertyImpact";
+      path: string;
+      label: string;
+      memoryCount: number;
+    }>;
+    ruleReferences: Array<{
+      __typename?: "MemorySchemaRuleReference";
+      ruleIri: string;
+      label?: string | null;
+      kind: GQLMemorySchemaRuleReferenceKind;
+      term: string;
+      value?: string | null;
+      position: GQLMemorySchemaRulePosition;
+    }>;
   } | null;
 };
 
+export type GQLMemorySchemaPropertyFieldsFragment = {
+  __typename?: "MemorySchemaProperty";
+  path: string;
+  label: string;
+  description?: string | null;
+  order: number;
+  valueType: GQLMemorySchemaValueType;
+  dataType: string;
+  entityClass?: string | null;
+  required: boolean;
+  multiValued: boolean;
+  allowedValues: Array<string>;
+  keyProperty: boolean;
+  computed: boolean;
+  minValue?: string | null;
+  maxValue?: string | null;
+  maxLength?: number | null;
+  pattern?: string | null;
+  defaultValue?: string | null;
+  unit?: string | null;
+  options: Array<{
+    __typename?: "MemorySchemaOption";
+    value: string;
+    label?: string | null;
+    description?: string | null;
+  }>;
+};
+
 export type GQLAbortUploadMutationVariables = Exact<{
   input: GQLAbortUploadInput;
 }>;
@@ -3579,31 +4233,269 @@ export type GQLAcceptInvitationMutation = {
   acceptInvitation: { __typename?: "InvitationAcceptedResponse"; organizationId: string; joined: boolean };
 };
 
-export type GQLAttributeStripeSubscriptionMutationVariables = Exact<{
-  subscriptionId: Scalars["String"]["input"];
-  datastoreId: Scalars["String"]["input"];
-}>;
-
-export type GQLAttributeStripeSubscriptionMutation = {
-  __typename?: "Mutation";
-  attributeStripeSubscription: {
-    __typename?: "AttributeStripeSubscriptionResponse";
-    success: boolean;
-    status?: string | null;
-    error?: string | null;
-  };
-};
-
-export type GQLAwaitDataConnectionTestMutationVariables = Exact<{
-  id: Scalars["String"]["input"];
+export type GQLAddMemorySchemaFromTemplateMutationVariables = Exact<{
+  templateIri: Scalars["IRI"]["input"];
 }>;
 
-export type GQLAwaitDataConnectionTestMutation = {
+export type GQLAddMemorySchemaFromTemplateMutation = {
   __typename?: "Mutation";
-  awaitDataConnectionTest: {
-    __typename?: "DataConnectionTestState";
-    id: string;
-    status: GQLDataConnectionStatus;
+  addMemorySchemaFromTemplate: {
+    __typename?: "MemorySchemaMutationResponse";
+    status: GQLMemorySchemaMutationStatus;
+    error?: string | null;
+    validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+    schema?: {
+      __typename?: "MemorySchema";
+      iri: string;
+      label: string;
+      description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
+      properties: Array<{
+        __typename?: "MemorySchemaProperty";
+        path: string;
+        label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
+        dataType: string;
+        entityClass?: string | null;
+        required: boolean;
+        multiValued: boolean;
+        allowedValues: Array<string>;
+        keyProperty: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
+      }>;
+    } | null;
+    impact?: {
+      __typename?: "MemorySchemaImpact";
+      memoryCount: number;
+      blockers: Array<string>;
+      removedProperties: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      typeChanges: Array<{
+        __typename?: "MemorySchemaTypeChangeImpact";
+        path: string;
+        label: string;
+        from: GQLMemorySchemaValueType;
+        to: GQLMemorySchemaValueType;
+        valueCount: number;
+        unconvertibleCount: number;
+        unconvertibleSamples: Array<string>;
+      }>;
+      removedOptions: Array<{
+        __typename?: "MemorySchemaOptionImpact";
+        path: string;
+        label: string;
+        value: string;
+        memoryCount: number;
+        remappedTo?: string | null;
+      }>;
+      limitViolations: Array<{
+        __typename?: "MemorySchemaLimitImpact";
+        path: string;
+        label: string;
+        valueCount: number;
+        invalidCount: number;
+        invalidSamples: Array<string>;
+      }>;
+      multiValueConflicts: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      clearedValues: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      ruleReferences: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
+export type GQLArchiveMemorySchemaMutationVariables = Exact<{
+  input: GQLMemorySchemaRevisionInput;
+}>;
+
+export type GQLArchiveMemorySchemaMutation = {
+  __typename?: "Mutation";
+  archiveMemorySchema: {
+    __typename?: "MemorySchemaMutationResponse";
+    status: GQLMemorySchemaMutationStatus;
+    error?: string | null;
+    validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+    schema?: {
+      __typename?: "MemorySchema";
+      iri: string;
+      label: string;
+      description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
+      properties: Array<{
+        __typename?: "MemorySchemaProperty";
+        path: string;
+        label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
+        dataType: string;
+        entityClass?: string | null;
+        required: boolean;
+        multiValued: boolean;
+        allowedValues: Array<string>;
+        keyProperty: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
+      }>;
+    } | null;
+    impact?: {
+      __typename?: "MemorySchemaImpact";
+      memoryCount: number;
+      blockers: Array<string>;
+      removedProperties: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      typeChanges: Array<{
+        __typename?: "MemorySchemaTypeChangeImpact";
+        path: string;
+        label: string;
+        from: GQLMemorySchemaValueType;
+        to: GQLMemorySchemaValueType;
+        valueCount: number;
+        unconvertibleCount: number;
+        unconvertibleSamples: Array<string>;
+      }>;
+      removedOptions: Array<{
+        __typename?: "MemorySchemaOptionImpact";
+        path: string;
+        label: string;
+        value: string;
+        memoryCount: number;
+        remappedTo?: string | null;
+      }>;
+      limitViolations: Array<{
+        __typename?: "MemorySchemaLimitImpact";
+        path: string;
+        label: string;
+        valueCount: number;
+        invalidCount: number;
+        invalidSamples: Array<string>;
+      }>;
+      multiValueConflicts: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      clearedValues: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      ruleReferences: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
+export type GQLAttributeStripeSubscriptionMutationVariables = Exact<{
+  subscriptionId: Scalars["String"]["input"];
+  datastoreId: Scalars["String"]["input"];
+}>;
+
+export type GQLAttributeStripeSubscriptionMutation = {
+  __typename?: "Mutation";
+  attributeStripeSubscription: {
+    __typename?: "AttributeStripeSubscriptionResponse";
+    success: boolean;
+    status?: string | null;
+    error?: string | null;
+  };
+};
+
+export type GQLAwaitDataConnectionTestMutationVariables = Exact<{
+  id: Scalars["String"]["input"];
+}>;
+
+export type GQLAwaitDataConnectionTestMutation = {
+  __typename?: "Mutation";
+  awaitDataConnectionTest: {
+    __typename?: "DataConnectionTestState";
+    id: string;
+    status: GQLDataConnectionStatus;
     error?: string | null;
   };
 };
@@ -3626,6 +4518,125 @@ export type GQLCancelActionPlanMutation = {
   cancelActionPlan: { __typename?: "CancelActionPlanResponse"; success: boolean; error?: string | null };
 };
 
+export type GQLClearMemorySchemaPropertyValuesMutationVariables = Exact<{
+  input: GQLClearMemorySchemaPropertyValuesInput;
+}>;
+
+export type GQLClearMemorySchemaPropertyValuesMutation = {
+  __typename?: "Mutation";
+  clearMemorySchemaPropertyValues: {
+    __typename?: "MemorySchemaMutationResponse";
+    status: GQLMemorySchemaMutationStatus;
+    error?: string | null;
+    validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+    schema?: {
+      __typename?: "MemorySchema";
+      iri: string;
+      label: string;
+      description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
+      properties: Array<{
+        __typename?: "MemorySchemaProperty";
+        path: string;
+        label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
+        dataType: string;
+        entityClass?: string | null;
+        required: boolean;
+        multiValued: boolean;
+        allowedValues: Array<string>;
+        keyProperty: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
+      }>;
+    } | null;
+    impact?: {
+      __typename?: "MemorySchemaImpact";
+      memoryCount: number;
+      blockers: Array<string>;
+      removedProperties: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      typeChanges: Array<{
+        __typename?: "MemorySchemaTypeChangeImpact";
+        path: string;
+        label: string;
+        from: GQLMemorySchemaValueType;
+        to: GQLMemorySchemaValueType;
+        valueCount: number;
+        unconvertibleCount: number;
+        unconvertibleSamples: Array<string>;
+      }>;
+      removedOptions: Array<{
+        __typename?: "MemorySchemaOptionImpact";
+        path: string;
+        label: string;
+        value: string;
+        memoryCount: number;
+        remappedTo?: string | null;
+      }>;
+      limitViolations: Array<{
+        __typename?: "MemorySchemaLimitImpact";
+        path: string;
+        label: string;
+        valueCount: number;
+        invalidCount: number;
+        invalidSamples: Array<string>;
+      }>;
+      multiValueConflicts: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      clearedValues: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      ruleReferences: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
 export type GQLClearStagedRulesMutationVariables = Exact<{
   ruleIris?: InputMaybe<Array<Scalars["IRI"]["input"]> | Scalars["IRI"]["input"]>;
 }>;
@@ -3654,6 +4665,7 @@ export type GQLCommitStagedRulesMutation = {
     rulesUpdated: number;
     rulesDeleted: number;
     error?: string | null;
+    requestId?: string | null;
   };
 };
 
@@ -3712,8 +4724,20 @@ export type GQLConsolidateMemoriesMutation = {
       teams: Array<string>;
       importance: number;
       memorySubclass?: string | null;
-      customProperties?: Record<string, unknown> | null;
+      customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+      schemaAssignment?: {
+        __typename?: "MemorySchemaAssignment";
+        schemaIri: string;
+        confidence?: number | null;
+        assignedAt?: Date | string | null;
+      } | null;
     } | null;
+    propertyErrors?: Array<{
+      __typename?: "MemoryPropertyProblem";
+      path: string;
+      label?: string | null;
+      message: string;
+    }> | null;
   };
 };
 
@@ -3797,6 +4821,125 @@ export type GQLCreateInferalIntegrationMutation = {
   };
 };
 
+export type GQLCreateMemorySchemaMutationVariables = Exact<{
+  input: GQLCreateMemorySchemaInput;
+}>;
+
+export type GQLCreateMemorySchemaMutation = {
+  __typename?: "Mutation";
+  createMemorySchema: {
+    __typename?: "MemorySchemaMutationResponse";
+    status: GQLMemorySchemaMutationStatus;
+    error?: string | null;
+    validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+    schema?: {
+      __typename?: "MemorySchema";
+      iri: string;
+      label: string;
+      description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
+      properties: Array<{
+        __typename?: "MemorySchemaProperty";
+        path: string;
+        label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
+        dataType: string;
+        entityClass?: string | null;
+        required: boolean;
+        multiValued: boolean;
+        allowedValues: Array<string>;
+        keyProperty: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
+      }>;
+    } | null;
+    impact?: {
+      __typename?: "MemorySchemaImpact";
+      memoryCount: number;
+      blockers: Array<string>;
+      removedProperties: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      typeChanges: Array<{
+        __typename?: "MemorySchemaTypeChangeImpact";
+        path: string;
+        label: string;
+        from: GQLMemorySchemaValueType;
+        to: GQLMemorySchemaValueType;
+        valueCount: number;
+        unconvertibleCount: number;
+        unconvertibleSamples: Array<string>;
+      }>;
+      removedOptions: Array<{
+        __typename?: "MemorySchemaOptionImpact";
+        path: string;
+        label: string;
+        value: string;
+        memoryCount: number;
+        remappedTo?: string | null;
+      }>;
+      limitViolations: Array<{
+        __typename?: "MemorySchemaLimitImpact";
+        path: string;
+        label: string;
+        valueCount: number;
+        invalidCount: number;
+        invalidSamples: Array<string>;
+      }>;
+      multiValueConflicts: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      clearedValues: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      ruleReferences: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
 export type GQLCreateMemoryMutationVariables = Exact<{
   input: GQLCreateMemoryInput;
 }>;
@@ -3829,8 +4972,20 @@ export type GQLCreateMemoryMutation = {
       teams: Array<string>;
       importance: number;
       memorySubclass?: string | null;
-      customProperties?: Record<string, unknown> | null;
+      customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+      schemaAssignment?: {
+        __typename?: "MemorySchemaAssignment";
+        schemaIri: string;
+        confidence?: number | null;
+        assignedAt?: Date | string | null;
+      } | null;
     } | null;
+    propertyErrors?: Array<{
+      __typename?: "MemoryPropertyProblem";
+      path: string;
+      label?: string | null;
+      message: string;
+    }> | null;
   };
 };
 
@@ -3952,6 +5107,125 @@ export type GQLDeleteLdesStreamMutation = {
   };
 };
 
+export type GQLDeleteMemorySchemaMutationVariables = Exact<{
+  input: GQLMemorySchemaRevisionInput;
+}>;
+
+export type GQLDeleteMemorySchemaMutation = {
+  __typename?: "Mutation";
+  deleteMemorySchema: {
+    __typename?: "MemorySchemaMutationResponse";
+    status: GQLMemorySchemaMutationStatus;
+    error?: string | null;
+    validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+    schema?: {
+      __typename?: "MemorySchema";
+      iri: string;
+      label: string;
+      description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
+      properties: Array<{
+        __typename?: "MemorySchemaProperty";
+        path: string;
+        label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
+        dataType: string;
+        entityClass?: string | null;
+        required: boolean;
+        multiValued: boolean;
+        allowedValues: Array<string>;
+        keyProperty: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
+      }>;
+    } | null;
+    impact?: {
+      __typename?: "MemorySchemaImpact";
+      memoryCount: number;
+      blockers: Array<string>;
+      removedProperties: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      typeChanges: Array<{
+        __typename?: "MemorySchemaTypeChangeImpact";
+        path: string;
+        label: string;
+        from: GQLMemorySchemaValueType;
+        to: GQLMemorySchemaValueType;
+        valueCount: number;
+        unconvertibleCount: number;
+        unconvertibleSamples: Array<string>;
+      }>;
+      removedOptions: Array<{
+        __typename?: "MemorySchemaOptionImpact";
+        path: string;
+        label: string;
+        value: string;
+        memoryCount: number;
+        remappedTo?: string | null;
+      }>;
+      limitViolations: Array<{
+        __typename?: "MemorySchemaLimitImpact";
+        path: string;
+        label: string;
+        valueCount: number;
+        invalidCount: number;
+        invalidSamples: Array<string>;
+      }>;
+      multiValueConflicts: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      clearedValues: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      ruleReferences: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
 export type GQLDeleteMemoryMutationVariables = Exact<{
   memoryIri: Scalars["IRI"]["input"];
 }>;
@@ -4003,6 +5277,125 @@ export type GQLDisconnectInferalIntegrationMutation = {
   disconnectInferalIntegration: { __typename?: "DisconnectInferalIntegrationResponse"; success: boolean };
 };
 
+export type GQLDismissMemorySchemaTemplateUpdateMutationVariables = Exact<{
+  input: GQLMemorySchemaRevisionInput;
+}>;
+
+export type GQLDismissMemorySchemaTemplateUpdateMutation = {
+  __typename?: "Mutation";
+  dismissMemorySchemaTemplateUpdate: {
+    __typename?: "MemorySchemaMutationResponse";
+    status: GQLMemorySchemaMutationStatus;
+    error?: string | null;
+    validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+    schema?: {
+      __typename?: "MemorySchema";
+      iri: string;
+      label: string;
+      description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
+      properties: Array<{
+        __typename?: "MemorySchemaProperty";
+        path: string;
+        label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
+        dataType: string;
+        entityClass?: string | null;
+        required: boolean;
+        multiValued: boolean;
+        allowedValues: Array<string>;
+        keyProperty: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
+      }>;
+    } | null;
+    impact?: {
+      __typename?: "MemorySchemaImpact";
+      memoryCount: number;
+      blockers: Array<string>;
+      removedProperties: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      typeChanges: Array<{
+        __typename?: "MemorySchemaTypeChangeImpact";
+        path: string;
+        label: string;
+        from: GQLMemorySchemaValueType;
+        to: GQLMemorySchemaValueType;
+        valueCount: number;
+        unconvertibleCount: number;
+        unconvertibleSamples: Array<string>;
+      }>;
+      removedOptions: Array<{
+        __typename?: "MemorySchemaOptionImpact";
+        path: string;
+        label: string;
+        value: string;
+        memoryCount: number;
+        remappedTo?: string | null;
+      }>;
+      limitViolations: Array<{
+        __typename?: "MemorySchemaLimitImpact";
+        path: string;
+        label: string;
+        valueCount: number;
+        invalidCount: number;
+        invalidSamples: Array<string>;
+      }>;
+      multiValueConflicts: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      clearedValues: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      ruleReferences: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
 export type GQLExecuteAgentActionAdditionMutationVariables = Exact<{
   input: GQLExecuteActionAdditionInput;
 }>;
@@ -4506,8 +5899,20 @@ export type GQLReconfirmMemoryMutation = {
       teams: Array<string>;
       importance: number;
       memorySubclass?: string | null;
-      customProperties?: Record<string, unknown> | null;
+      customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+      schemaAssignment?: {
+        __typename?: "MemorySchemaAssignment";
+        schemaIri: string;
+        confidence?: number | null;
+        assignedAt?: Date | string | null;
+      } | null;
     } | null;
+    propertyErrors?: Array<{
+      __typename?: "MemoryPropertyProblem";
+      path: string;
+      label?: string | null;
+      message: string;
+    }> | null;
   };
 };
 
@@ -4609,6 +6014,125 @@ export type GQLRenameUserMutation = {
   renameUser: { __typename?: "RenameUserResponse"; id: string; name?: string | null };
 };
 
+export type GQLResetMemorySchemaToTemplateMutationVariables = Exact<{
+  input: GQLResetMemorySchemaInput;
+}>;
+
+export type GQLResetMemorySchemaToTemplateMutation = {
+  __typename?: "Mutation";
+  resetMemorySchemaToTemplate: {
+    __typename?: "MemorySchemaMutationResponse";
+    status: GQLMemorySchemaMutationStatus;
+    error?: string | null;
+    validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+    schema?: {
+      __typename?: "MemorySchema";
+      iri: string;
+      label: string;
+      description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
+      properties: Array<{
+        __typename?: "MemorySchemaProperty";
+        path: string;
+        label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
+        dataType: string;
+        entityClass?: string | null;
+        required: boolean;
+        multiValued: boolean;
+        allowedValues: Array<string>;
+        keyProperty: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
+      }>;
+    } | null;
+    impact?: {
+      __typename?: "MemorySchemaImpact";
+      memoryCount: number;
+      blockers: Array<string>;
+      removedProperties: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      typeChanges: Array<{
+        __typename?: "MemorySchemaTypeChangeImpact";
+        path: string;
+        label: string;
+        from: GQLMemorySchemaValueType;
+        to: GQLMemorySchemaValueType;
+        valueCount: number;
+        unconvertibleCount: number;
+        unconvertibleSamples: Array<string>;
+      }>;
+      removedOptions: Array<{
+        __typename?: "MemorySchemaOptionImpact";
+        path: string;
+        label: string;
+        value: string;
+        memoryCount: number;
+        remappedTo?: string | null;
+      }>;
+      limitViolations: Array<{
+        __typename?: "MemorySchemaLimitImpact";
+        path: string;
+        label: string;
+        valueCount: number;
+        invalidCount: number;
+        invalidSamples: Array<string>;
+      }>;
+      multiValueConflicts: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      clearedValues: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      ruleReferences: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
 export type GQLRestoreMemoryMutationVariables = Exact<{
   memoryIri: Scalars["IRI"]["input"];
 }>;
@@ -4704,6 +6228,22 @@ export type GQLRotateCustomAppSecretMutation = {
   };
 };
 
+export type GQLSetActionPlanAutoPilotMutationVariables = Exact<{
+  input: GQLSetActionPlanAutoPilotInput;
+}>;
+
+export type GQLSetActionPlanAutoPilotMutation = {
+  __typename?: "Mutation";
+  setActionPlanAutoPilot: {
+    __typename?: "SetActionPlanAutoPilotResponse";
+    success: boolean;
+    error?: string | null;
+    planGraphIri: string;
+    autoPilotEnabled?: boolean | null;
+    ruleIri?: string | null;
+  };
+};
+
 export type GQLSetCustomAppEnabledMutationVariables = Exact<{
   org?: InputMaybe<Scalars["String"]["input"]>;
   clientId: Scalars["String"]["input"];
@@ -4776,8 +6316,175 @@ export type GQLSyncGmailIntegrationMutation = {
     email: string;
     status: GQLGmailIntegrationStatus;
     error?: string | null;
-    lastSyncedAt?: string | null;
-    messagesIngested: number;
+    lastSyncedAt?: string | null;
+    messagesIngested: number;
+  };
+};
+
+export type GQLUnarchiveMemorySchemaMutationVariables = Exact<{
+  input: GQLMemorySchemaRevisionInput;
+}>;
+
+export type GQLUnarchiveMemorySchemaMutation = {
+  __typename?: "Mutation";
+  unarchiveMemorySchema: {
+    __typename?: "MemorySchemaMutationResponse";
+    status: GQLMemorySchemaMutationStatus;
+    error?: string | null;
+    validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+    schema?: {
+      __typename?: "MemorySchema";
+      iri: string;
+      label: string;
+      description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
+      properties: Array<{
+        __typename?: "MemorySchemaProperty";
+        path: string;
+        label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
+        dataType: string;
+        entityClass?: string | null;
+        required: boolean;
+        multiValued: boolean;
+        allowedValues: Array<string>;
+        keyProperty: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
+      }>;
+    } | null;
+    impact?: {
+      __typename?: "MemorySchemaImpact";
+      memoryCount: number;
+      blockers: Array<string>;
+      removedProperties: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      typeChanges: Array<{
+        __typename?: "MemorySchemaTypeChangeImpact";
+        path: string;
+        label: string;
+        from: GQLMemorySchemaValueType;
+        to: GQLMemorySchemaValueType;
+        valueCount: number;
+        unconvertibleCount: number;
+        unconvertibleSamples: Array<string>;
+      }>;
+      removedOptions: Array<{
+        __typename?: "MemorySchemaOptionImpact";
+        path: string;
+        label: string;
+        value: string;
+        memoryCount: number;
+        remappedTo?: string | null;
+      }>;
+      limitViolations: Array<{
+        __typename?: "MemorySchemaLimitImpact";
+        path: string;
+        label: string;
+        valueCount: number;
+        invalidCount: number;
+        invalidSamples: Array<string>;
+      }>;
+      multiValueConflicts: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      clearedValues: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      ruleReferences: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
+export type GQLUndoMemorySchemaAssignmentMutationVariables = Exact<{
+  memoryIri: Scalars["IRI"]["input"];
+}>;
+
+export type GQLUndoMemorySchemaAssignmentMutation = {
+  __typename?: "Mutation";
+  undoMemorySchemaAssignment: {
+    __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;
+      customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+      schemaAssignment?: {
+        __typename?: "MemorySchemaAssignment";
+        schemaIri: string;
+        confidence?: number | null;
+        assignedAt?: Date | string | null;
+      } | null;
+    } | null;
+    propertyErrors?: Array<{
+      __typename?: "MemoryPropertyProblem";
+      path: string;
+      label?: string | null;
+      message: string;
+    }> | null;
   };
 };
 
@@ -4827,6 +6534,125 @@ export type GQLUpdateDataConnectionMutation = {
   };
 };
 
+export type GQLUpdateMemorySchemaMutationVariables = Exact<{
+  input: GQLUpdateMemorySchemaInput;
+}>;
+
+export type GQLUpdateMemorySchemaMutation = {
+  __typename?: "Mutation";
+  updateMemorySchema: {
+    __typename?: "MemorySchemaMutationResponse";
+    status: GQLMemorySchemaMutationStatus;
+    error?: string | null;
+    validationErrors: Array<{ __typename?: "MemorySchemaValidationError"; field: string; message: string }>;
+    schema?: {
+      __typename?: "MemorySchema";
+      iri: string;
+      label: string;
+      description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
+      properties: Array<{
+        __typename?: "MemorySchemaProperty";
+        path: string;
+        label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
+        dataType: string;
+        entityClass?: string | null;
+        required: boolean;
+        multiValued: boolean;
+        allowedValues: Array<string>;
+        keyProperty: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
+      }>;
+    } | null;
+    impact?: {
+      __typename?: "MemorySchemaImpact";
+      memoryCount: number;
+      blockers: Array<string>;
+      removedProperties: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      typeChanges: Array<{
+        __typename?: "MemorySchemaTypeChangeImpact";
+        path: string;
+        label: string;
+        from: GQLMemorySchemaValueType;
+        to: GQLMemorySchemaValueType;
+        valueCount: number;
+        unconvertibleCount: number;
+        unconvertibleSamples: Array<string>;
+      }>;
+      removedOptions: Array<{
+        __typename?: "MemorySchemaOptionImpact";
+        path: string;
+        label: string;
+        value: string;
+        memoryCount: number;
+        remappedTo?: string | null;
+      }>;
+      limitViolations: Array<{
+        __typename?: "MemorySchemaLimitImpact";
+        path: string;
+        label: string;
+        valueCount: number;
+        invalidCount: number;
+        invalidSamples: Array<string>;
+      }>;
+      multiValueConflicts: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      clearedValues: Array<{
+        __typename?: "MemorySchemaPropertyImpact";
+        path: string;
+        label: string;
+        memoryCount: number;
+      }>;
+      ruleReferences: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
 export type GQLUpdateMemoryMutationVariables = Exact<{
   input: GQLUpdateMemoryInput;
 }>;
@@ -4858,8 +6684,20 @@ export type GQLUpdateMemoryMutation = {
       teams: Array<string>;
       importance: number;
       memorySubclass?: string | null;
-      customProperties?: Record<string, unknown> | null;
+      customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+      schemaAssignment?: {
+        __typename?: "MemorySchemaAssignment";
+        schemaIri: string;
+        confidence?: number | null;
+        assignedAt?: Date | string | null;
+      } | null;
     } | null;
+    propertyErrors?: Array<{
+      __typename?: "MemoryPropertyProblem";
+      path: string;
+      label?: string | null;
+      message: string;
+    }> | null;
   };
 };
 
@@ -4912,6 +6750,7 @@ export type GQLActionPlanRulesQuery = {
       stagedRule?: string | null;
       isStaged: boolean;
       isModified: boolean;
+      ownedBy?: { __typename?: "RuleOwnership"; type: GQLRuleOwner; userId?: string | null } | null;
     }>;
   };
 };
@@ -5830,9 +7669,7 @@ export type GQLInferalIntegrationsQuery = {
   }>;
 };
 
-export type GQLKnowledgeGraphStateQueryVariables = Exact<{
-  dataVersion?: InputMaybe<Scalars["String"]["input"]>;
-}>;
+export type GQLKnowledgeGraphStateQueryVariables = Exact<{ [key: string]: never }>;
 
 export type GQLKnowledgeGraphStateQuery = {
   __typename?: "Query";
@@ -5841,14 +7678,6 @@ export type GQLKnowledgeGraphStateQuery = {
     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;
   };
 };
@@ -5943,7 +7772,13 @@ export type GQLMemoriesQuery = {
       teams: Array<string>;
       importance: number;
       memorySubclass?: string | null;
-      customProperties?: Record<string, unknown> | null;
+      customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+      schemaAssignment?: {
+        __typename?: "MemorySchemaAssignment";
+        schemaIri: string;
+        confidence?: number | null;
+        assignedAt?: Date | string | null;
+      } | null;
     }>;
   };
 };
@@ -5986,7 +7821,13 @@ export type GQLMemoryRedundancyReviewQuery = {
         teams: Array<string>;
         importance: number;
         memorySubclass?: string | null;
-        customProperties?: Record<string, unknown> | null;
+        customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+        schemaAssignment?: {
+          __typename?: "MemorySchemaAssignment";
+          schemaIri: string;
+          confidence?: number | null;
+          assignedAt?: Date | string | null;
+        } | null;
       }>;
     }>;
     abstractions: Array<{
@@ -6016,13 +7857,125 @@ export type GQLMemoryRedundancyReviewQuery = {
         teams: Array<string>;
         importance: number;
         memorySubclass?: string | null;
-        customProperties?: Record<string, unknown> | null;
+        customPropertyValues: Array<{ __typename?: "MemoryPropertyValues"; path: string; values: Array<string> }>;
+        schemaAssignment?: {
+          __typename?: "MemorySchemaAssignment";
+          schemaIri: string;
+          confidence?: number | null;
+          assignedAt?: Date | string | null;
+        } | null;
       }>;
     }>;
   };
 };
 
-export type GQLMemorySchemasQueryVariables = Exact<{ [key: string]: never }>;
+export type GQLMemorySchemaRuleCountsQueryVariables = Exact<{ [key: string]: never }>;
+
+export type GQLMemorySchemaRuleCountsQuery = {
+  __typename?: "Query";
+  memorySchemaRuleCounts: {
+    __typename?: "MemorySchemaRuleCountsResponse";
+    error?: string | null;
+    counts: Array<{ __typename?: "MemorySchemaRuleCount"; iri: string; ruleCount: number }>;
+  };
+};
+
+export type GQLMemorySchemaTemplatesQueryVariables = Exact<{ [key: string]: never }>;
+
+export type GQLMemorySchemaTemplatesQuery = {
+  __typename?: "Query";
+  memorySchemaTemplates: {
+    __typename?: "MemorySchemaTemplatesResponse";
+    error?: string | null;
+    templates: Array<{
+      __typename?: "MemorySchemaTemplate";
+      live: boolean;
+      schema: {
+        __typename?: "MemorySchema";
+        iri: string;
+        label: string;
+        description?: string | null;
+        status: GQLMemorySchemaStatus;
+        revision: number;
+        defaultMemoryKind?: GQLMemoryKind | null;
+        defaultVolatility?: GQLMemoryVolatility | null;
+        defaultImportance?: number | null;
+        defaultScope?: GQLMemoryScope | null;
+        extractionEnabled: boolean;
+        extractionGuidance?: string | null;
+        templateStatus: GQLMemorySchemaTemplateStatus;
+        customized: boolean;
+        memoryCount?: number | null;
+        createdAt?: Date | string | null;
+        createdBy: GQLMemorySchemaCreator;
+        updatedAt?: Date | string | null;
+        properties: Array<{
+          __typename?: "MemorySchemaProperty";
+          path: string;
+          label: string;
+          description?: string | null;
+          order: number;
+          valueType: GQLMemorySchemaValueType;
+          dataType: string;
+          entityClass?: string | null;
+          required: boolean;
+          multiValued: boolean;
+          allowedValues: Array<string>;
+          keyProperty: boolean;
+          computed: boolean;
+          minValue?: string | null;
+          maxValue?: string | null;
+          maxLength?: number | null;
+          pattern?: string | null;
+          defaultValue?: string | null;
+          unit?: string | null;
+          options: Array<{
+            __typename?: "MemorySchemaOption";
+            value: string;
+            label?: string | null;
+            description?: string | null;
+          }>;
+        }>;
+      };
+    }>;
+  };
+};
+
+export type GQLMemorySchemaUsageQueryVariables = Exact<{
+  iri: Scalars["IRI"]["input"];
+}>;
+
+export type GQLMemorySchemaUsageQuery = {
+  __typename?: "Query";
+  memorySchemaUsage: {
+    __typename?: "MemorySchemaUsageResponse";
+    error?: string | null;
+    usage?: {
+      __typename?: "MemorySchemaUsage";
+      iri: string;
+      memoryCount: number;
+      properties: Array<{
+        __typename?: "MemorySchemaPropertyUsage";
+        path: string;
+        memoryCount: number;
+        options: Array<{ __typename?: "MemorySchemaOptionUsage"; value: string; memoryCount: number }>;
+      }>;
+      rules: Array<{
+        __typename?: "MemorySchemaRuleReference";
+        ruleIri: string;
+        label?: string | null;
+        kind: GQLMemorySchemaRuleReferenceKind;
+        term: string;
+        value?: string | null;
+        position: GQLMemorySchemaRulePosition;
+      }>;
+    } | null;
+  };
+};
+
+export type GQLMemorySchemasQueryVariables = Exact<{
+  includeArchived?: InputMaybe<Scalars["Boolean"]["input"]>;
+}>;
 
 export type GQLMemorySchemasQuery = {
   __typename?: "Query";
@@ -6034,15 +7987,46 @@ export type GQLMemorySchemasQuery = {
       iri: string;
       label: string;
       description?: string | null;
+      status: GQLMemorySchemaStatus;
+      revision: number;
+      defaultMemoryKind?: GQLMemoryKind | null;
+      defaultVolatility?: GQLMemoryVolatility | null;
+      defaultImportance?: number | null;
+      defaultScope?: GQLMemoryScope | null;
+      extractionEnabled: boolean;
+      extractionGuidance?: string | null;
+      templateStatus: GQLMemorySchemaTemplateStatus;
+      customized: boolean;
+      memoryCount?: number | null;
+      createdAt?: Date | string | null;
+      createdBy: GQLMemorySchemaCreator;
+      updatedAt?: Date | string | null;
       properties: Array<{
         __typename?: "MemorySchemaProperty";
         path: string;
         label: string;
+        description?: string | null;
+        order: number;
+        valueType: GQLMemorySchemaValueType;
         dataType: string;
+        entityClass?: string | null;
         required: boolean;
+        multiValued: boolean;
         allowedValues: Array<string>;
         keyProperty: boolean;
-        inferred: boolean;
+        computed: boolean;
+        minValue?: string | null;
+        maxValue?: string | null;
+        maxLength?: number | null;
+        pattern?: string | null;
+        defaultValue?: string | null;
+        unit?: string | null;
+        options: Array<{
+          __typename?: "MemorySchemaOption";
+          value: string;
+          label?: string | null;
+          description?: string | null;
+        }>;
       }>;
     }>;
   };
@@ -6638,7 +8622,15 @@ export const MemoryFieldsFragmentDoc = `
   teams
   importance
   memorySubclass
-  customProperties
+  customPropertyValues {
+    path
+    values
+  }
+  schemaAssignment {
+    schemaIri
+    confidence
+    assignedAt
+  }
 }
     `;
 export const MemoryMutationResultFragmentDoc = `
@@ -6647,8 +8639,127 @@ export const MemoryMutationResultFragmentDoc = `
     ...MemoryFields
   }
   error
+  propertyErrors {
+    path
+    label
+    message
+  }
 }
     ${MemoryFieldsFragmentDoc}`;
+export const MemorySchemaPropertyFieldsFragmentDoc = `
+    fragment MemorySchemaPropertyFields on MemorySchemaProperty {
+  path
+  label
+  description
+  order
+  valueType
+  dataType
+  entityClass
+  required
+  multiValued
+  allowedValues
+  options {
+    value
+    label
+    description
+  }
+  keyProperty
+  computed
+  minValue
+  maxValue
+  maxLength
+  pattern
+  defaultValue
+  unit
+}
+    `;
+export const MemorySchemaFieldsFragmentDoc = `
+    fragment MemorySchemaFields on MemorySchema {
+  iri
+  label
+  description
+  status
+  revision
+  defaultMemoryKind
+  defaultVolatility
+  defaultImportance
+  defaultScope
+  extractionEnabled
+  extractionGuidance
+  templateStatus
+  customized
+  memoryCount
+  createdAt
+  createdBy
+  updatedAt
+  properties {
+    ...MemorySchemaPropertyFields
+  }
+}
+    ${MemorySchemaPropertyFieldsFragmentDoc}`;
+export const MemorySchemaMutationResultFragmentDoc = `
+    fragment MemorySchemaMutationResult on MemorySchemaMutationResponse {
+  status
+  error
+  validationErrors {
+    field
+    message
+  }
+  schema {
+    ...MemorySchemaFields
+  }
+  impact {
+    memoryCount
+    removedProperties {
+      path
+      label
+      memoryCount
+    }
+    typeChanges {
+      path
+      label
+      from
+      to
+      valueCount
+      unconvertibleCount
+      unconvertibleSamples
+    }
+    removedOptions {
+      path
+      label
+      value
+      memoryCount
+      remappedTo
+    }
+    limitViolations {
+      path
+      label
+      valueCount
+      invalidCount
+      invalidSamples
+    }
+    multiValueConflicts {
+      path
+      label
+      memoryCount
+    }
+    clearedValues {
+      path
+      label
+      memoryCount
+    }
+    ruleReferences {
+      ruleIri
+      label
+      kind
+      term
+      value
+      position
+    }
+    blockers
+  }
+}
+    ${MemorySchemaFieldsFragmentDoc}`;
 export const ActionPlanFieldsFragmentDoc = `
     fragment ActionPlanFields on ActionPlanGraph {
   iri
@@ -6792,6 +8903,73 @@ export const useAcceptInvitationMutation = <TError = unknown, TContext = unknown
   });
 };
 
+export const AddMemorySchemaFromTemplateDocument = `
+    mutation AddMemorySchemaFromTemplate($templateIri: IRI!) {
+  addMemorySchemaFromTemplate(templateIri: $templateIri) {
+    ...MemorySchemaMutationResult
+  }
+}
+    ${MemorySchemaMutationResultFragmentDoc}`;
+
+export const useAddMemorySchemaFromTemplateMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLAddMemorySchemaFromTemplateMutation,
+    TError,
+    GQLAddMemorySchemaFromTemplateMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<
+    GQLAddMemorySchemaFromTemplateMutation,
+    TError,
+    GQLAddMemorySchemaFromTemplateMutationVariables,
+    TContext
+  >({
+    mutationKey: ["AddMemorySchemaFromTemplate"],
+    mutationFn: (variables?: GQLAddMemorySchemaFromTemplateMutationVariables) =>
+      fetcher<GQLAddMemorySchemaFromTemplateMutation, GQLAddMemorySchemaFromTemplateMutationVariables>(
+        client,
+        AddMemorySchemaFromTemplateDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
+export const ArchiveMemorySchemaDocument = `
+    mutation ArchiveMemorySchema($input: MemorySchemaRevisionInput!) {
+  archiveMemorySchema(input: $input) {
+    ...MemorySchemaMutationResult
+  }
+}
+    ${MemorySchemaMutationResultFragmentDoc}`;
+
+export const useArchiveMemorySchemaMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLArchiveMemorySchemaMutation,
+    TError,
+    GQLArchiveMemorySchemaMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<GQLArchiveMemorySchemaMutation, TError, GQLArchiveMemorySchemaMutationVariables, TContext>({
+    mutationKey: ["ArchiveMemorySchema"],
+    mutationFn: (variables?: GQLArchiveMemorySchemaMutationVariables) =>
+      fetcher<GQLArchiveMemorySchemaMutation, GQLArchiveMemorySchemaMutationVariables>(
+        client,
+        ArchiveMemorySchemaDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const AttributeStripeSubscriptionDocument = `
     mutation AttributeStripeSubscription($subscriptionId: String!, $datastoreId: String!) {
   attributeStripeSubscription(
@@ -6927,6 +9105,42 @@ export const useCancelActionPlanMutation = <TError = unknown, TContext = unknown
   });
 };
 
+export const ClearMemorySchemaPropertyValuesDocument = `
+    mutation ClearMemorySchemaPropertyValues($input: ClearMemorySchemaPropertyValuesInput!) {
+  clearMemorySchemaPropertyValues(input: $input) {
+    ...MemorySchemaMutationResult
+  }
+}
+    ${MemorySchemaMutationResultFragmentDoc}`;
+
+export const useClearMemorySchemaPropertyValuesMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLClearMemorySchemaPropertyValuesMutation,
+    TError,
+    GQLClearMemorySchemaPropertyValuesMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<
+    GQLClearMemorySchemaPropertyValuesMutation,
+    TError,
+    GQLClearMemorySchemaPropertyValuesMutationVariables,
+    TContext
+  >({
+    mutationKey: ["ClearMemorySchemaPropertyValues"],
+    mutationFn: (variables?: GQLClearMemorySchemaPropertyValuesMutationVariables) =>
+      fetcher<GQLClearMemorySchemaPropertyValuesMutation, GQLClearMemorySchemaPropertyValuesMutationVariables>(
+        client,
+        ClearMemorySchemaPropertyValuesDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const ClearStagedRulesDocument = `
     mutation ClearStagedRules($ruleIris: [IRI!]) {
   clearStagedRules(ruleIris: $ruleIris) {
@@ -6963,6 +9177,7 @@ export const CommitStagedRulesDocument = `
     rulesUpdated
     rulesDeleted
     error
+    requestId
   }
 }
     `;
@@ -7053,6 +9268,11 @@ export const ConsolidateMemoriesDocument = `
       ...MemoryFields
     }
     error
+    propertyErrors {
+      path
+      label
+      message
+    }
   }
 }
     ${MemoryFieldsFragmentDoc}`;
@@ -7232,6 +9452,32 @@ export const useCreateInferalIntegrationMutation = <TError = unknown, TContext =
   });
 };
 
+export const CreateMemorySchemaDocument = `
+    mutation CreateMemorySchema($input: CreateMemorySchemaInput!) {
+  createMemorySchema(input: $input) {
+    ...MemorySchemaMutationResult
+  }
+}
+    ${MemorySchemaMutationResultFragmentDoc}`;
+
+export const useCreateMemorySchemaMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<GQLCreateMemorySchemaMutation, TError, GQLCreateMemorySchemaMutationVariables, TContext>,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<GQLCreateMemorySchemaMutation, TError, GQLCreateMemorySchemaMutationVariables, TContext>({
+    mutationKey: ["CreateMemorySchema"],
+    mutationFn: (variables?: GQLCreateMemorySchemaMutationVariables) =>
+      fetcher<GQLCreateMemorySchemaMutation, GQLCreateMemorySchemaMutationVariables>(
+        client,
+        CreateMemorySchemaDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const CreateMemoryDocument = `
     mutation CreateMemory($input: CreateMemoryInput!) {
   createMemory(input: $input) {
@@ -7239,7 +9485,12 @@ export const CreateMemoryDocument = `
       ...MemoryFields
       createdBy
     }
-    error
+    error
+    propertyErrors {
+      path
+      label
+      message
+    }
   }
 }
     ${MemoryFieldsFragmentDoc}`;
@@ -7553,6 +9804,32 @@ export const useDeleteLdesStreamMutation = <TError = unknown, TContext = unknown
   });
 };
 
+export const DeleteMemorySchemaDocument = `
+    mutation DeleteMemorySchema($input: MemorySchemaRevisionInput!) {
+  deleteMemorySchema(input: $input) {
+    ...MemorySchemaMutationResult
+  }
+}
+    ${MemorySchemaMutationResultFragmentDoc}`;
+
+export const useDeleteMemorySchemaMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<GQLDeleteMemorySchemaMutation, TError, GQLDeleteMemorySchemaMutationVariables, TContext>,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<GQLDeleteMemorySchemaMutation, TError, GQLDeleteMemorySchemaMutationVariables, TContext>({
+    mutationKey: ["DeleteMemorySchema"],
+    mutationFn: (variables?: GQLDeleteMemorySchemaMutationVariables) =>
+      fetcher<GQLDeleteMemorySchemaMutation, GQLDeleteMemorySchemaMutationVariables>(
+        client,
+        DeleteMemorySchemaDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const DeleteMemoryDocument = `
     mutation DeleteMemory($memoryIri: IRI!) {
   deleteMemory(memoryIri: $memoryIri) {
@@ -7744,6 +10021,42 @@ export const useDisconnectInferalIntegrationMutation = <TError = unknown, TConte
   });
 };
 
+export const DismissMemorySchemaTemplateUpdateDocument = `
+    mutation DismissMemorySchemaTemplateUpdate($input: MemorySchemaRevisionInput!) {
+  dismissMemorySchemaTemplateUpdate(input: $input) {
+    ...MemorySchemaMutationResult
+  }
+}
+    ${MemorySchemaMutationResultFragmentDoc}`;
+
+export const useDismissMemorySchemaTemplateUpdateMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLDismissMemorySchemaTemplateUpdateMutation,
+    TError,
+    GQLDismissMemorySchemaTemplateUpdateMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<
+    GQLDismissMemorySchemaTemplateUpdateMutation,
+    TError,
+    GQLDismissMemorySchemaTemplateUpdateMutationVariables,
+    TContext
+  >({
+    mutationKey: ["DismissMemorySchemaTemplateUpdate"],
+    mutationFn: (variables?: GQLDismissMemorySchemaTemplateUpdateMutationVariables) =>
+      fetcher<GQLDismissMemorySchemaTemplateUpdateMutation, GQLDismissMemorySchemaTemplateUpdateMutationVariables>(
+        client,
+        DismissMemorySchemaTemplateUpdateDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const ExecuteAgentActionAdditionDocument = `
     mutation ExecuteAgentActionAddition($input: ExecuteActionAdditionInput!) {
   executeActionAddition(input: $input) {
@@ -9004,6 +11317,42 @@ export const useRenameUserMutation = <TError = unknown, TContext = unknown>(
   });
 };
 
+export const ResetMemorySchemaToTemplateDocument = `
+    mutation ResetMemorySchemaToTemplate($input: ResetMemorySchemaInput!) {
+  resetMemorySchemaToTemplate(input: $input) {
+    ...MemorySchemaMutationResult
+  }
+}
+    ${MemorySchemaMutationResultFragmentDoc}`;
+
+export const useResetMemorySchemaToTemplateMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLResetMemorySchemaToTemplateMutation,
+    TError,
+    GQLResetMemorySchemaToTemplateMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<
+    GQLResetMemorySchemaToTemplateMutation,
+    TError,
+    GQLResetMemorySchemaToTemplateMutationVariables,
+    TContext
+  >({
+    mutationKey: ["ResetMemorySchemaToTemplate"],
+    mutationFn: (variables?: GQLResetMemorySchemaToTemplateMutationVariables) =>
+      fetcher<GQLResetMemorySchemaToTemplateMutation, GQLResetMemorySchemaToTemplateMutationVariables>(
+        client,
+        ResetMemorySchemaToTemplateDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const RestoreMemoryDocument = `
     mutation RestoreMemory($memoryIri: IRI!) {
   restoreMemory(memoryIri: $memoryIri) {
@@ -9168,6 +11517,41 @@ export const useRotateCustomAppSecretMutation = <TError = unknown, TContext = un
   });
 };
 
+export const SetActionPlanAutoPilotDocument = `
+    mutation SetActionPlanAutoPilot($input: SetActionPlanAutoPilotInput!) {
+  setActionPlanAutoPilot(input: $input) {
+    success
+    error
+    planGraphIri
+    autoPilotEnabled
+    ruleIri
+  }
+}
+    `;
+
+export const useSetActionPlanAutoPilotMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLSetActionPlanAutoPilotMutation,
+    TError,
+    GQLSetActionPlanAutoPilotMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<GQLSetActionPlanAutoPilotMutation, TError, GQLSetActionPlanAutoPilotMutationVariables, TContext>({
+    mutationKey: ["SetActionPlanAutoPilot"],
+    mutationFn: (variables?: GQLSetActionPlanAutoPilotMutationVariables) =>
+      fetcher<GQLSetActionPlanAutoPilotMutation, GQLSetActionPlanAutoPilotMutationVariables>(
+        client,
+        SetActionPlanAutoPilotDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const SetCustomAppEnabledDocument = `
     mutation SetCustomAppEnabled($org: String, $clientId: String!, $enabled: Boolean!) {
   setCustomAppEnabled(org: $org, clientId: $clientId, enabled: $enabled) {
@@ -9298,6 +11682,73 @@ export const useSyncGmailIntegrationMutation = <TError = unknown, TContext = unk
   });
 };
 
+export const UnarchiveMemorySchemaDocument = `
+    mutation UnarchiveMemorySchema($input: MemorySchemaRevisionInput!) {
+  unarchiveMemorySchema(input: $input) {
+    ...MemorySchemaMutationResult
+  }
+}
+    ${MemorySchemaMutationResultFragmentDoc}`;
+
+export const useUnarchiveMemorySchemaMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLUnarchiveMemorySchemaMutation,
+    TError,
+    GQLUnarchiveMemorySchemaMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<GQLUnarchiveMemorySchemaMutation, TError, GQLUnarchiveMemorySchemaMutationVariables, TContext>({
+    mutationKey: ["UnarchiveMemorySchema"],
+    mutationFn: (variables?: GQLUnarchiveMemorySchemaMutationVariables) =>
+      fetcher<GQLUnarchiveMemorySchemaMutation, GQLUnarchiveMemorySchemaMutationVariables>(
+        client,
+        UnarchiveMemorySchemaDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
+export const UndoMemorySchemaAssignmentDocument = `
+    mutation UndoMemorySchemaAssignment($memoryIri: IRI!) {
+  undoMemorySchemaAssignment(memoryIri: $memoryIri) {
+    ...MemoryMutationResult
+  }
+}
+    ${MemoryMutationResultFragmentDoc}`;
+
+export const useUndoMemorySchemaAssignmentMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLUndoMemorySchemaAssignmentMutation,
+    TError,
+    GQLUndoMemorySchemaAssignmentMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<
+    GQLUndoMemorySchemaAssignmentMutation,
+    TError,
+    GQLUndoMemorySchemaAssignmentMutationVariables,
+    TContext
+  >({
+    mutationKey: ["UndoMemorySchemaAssignment"],
+    mutationFn: (variables?: GQLUndoMemorySchemaAssignmentMutationVariables) =>
+      fetcher<GQLUndoMemorySchemaAssignmentMutation, GQLUndoMemorySchemaAssignmentMutationVariables>(
+        client,
+        UndoMemorySchemaAssignmentDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const UpdateCustomAppDocument = `
     mutation UpdateCustomApp($org: String, $clientId: String!, $name: String, $redirectUris: [String!], $homeUrl: String, $machineAccess: Boolean, $datastores: [String!], $permissions: [CustomAppPermission!]) {
   updateCustomApp(
@@ -9366,6 +11817,32 @@ export const useUpdateDataConnectionMutation = <TError = unknown, TContext = unk
   });
 };
 
+export const UpdateMemorySchemaDocument = `
+    mutation UpdateMemorySchema($input: UpdateMemorySchemaInput!) {
+  updateMemorySchema(input: $input) {
+    ...MemorySchemaMutationResult
+  }
+}
+    ${MemorySchemaMutationResultFragmentDoc}`;
+
+export const useUpdateMemorySchemaMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<GQLUpdateMemorySchemaMutation, TError, GQLUpdateMemorySchemaMutationVariables, TContext>,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<GQLUpdateMemorySchemaMutation, TError, GQLUpdateMemorySchemaMutationVariables, TContext>({
+    mutationKey: ["UpdateMemorySchema"],
+    mutationFn: (variables?: GQLUpdateMemorySchemaMutationVariables) =>
+      fetcher<GQLUpdateMemorySchemaMutation, GQLUpdateMemorySchemaMutationVariables>(
+        client,
+        UpdateMemorySchemaDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const UpdateMemoryDocument = `
     mutation UpdateMemory($input: UpdateMemoryInput!) {
   updateMemory(input: $input) {
@@ -9476,6 +11953,10 @@ export const ActionPlanRulesDocument = `
       stagedRule
       isStaged
       isModified
+      ownedBy {
+        type
+        userId
+      }
     }
     count
     error
@@ -11795,21 +14276,11 @@ useSuspenseInferalIntegrationsQuery.getKey = (variables?: GQLInferalIntegrations
   variables === undefined ? ["InferalIntegrationsSuspense"] : ["InferalIntegrationsSuspense", variables];
 
 export const KnowledgeGraphStateDocument = `
-    query KnowledgeGraphState($dataVersion: String) {
-  knowledgeGraphState(dataVersion: $dataVersion) {
+    query KnowledgeGraphState {
+  knowledgeGraphState {
     exists
     isLoaded
     offline
-    capacity {
-      maxTriples
-      currentTriples
-      percentageFull
-      remainingCapacity
-      entitySummary {
-        type
-        count
-      }
-    }
     dataVersion {
       uniqueId
       version
@@ -12187,21 +14658,147 @@ useSuspenseMemoryRedundancyReviewQuery.getKey = (variables: GQLMemoryRedundancyR
   variables,
 ];
 
-export const MemorySchemasDocument = `
-    query MemorySchemas {
-  memorySchemas {
-    schemas {
+export const MemorySchemaRuleCountsDocument = `
+    query MemorySchemaRuleCounts {
+  memorySchemaRuleCounts {
+    counts {
       iri
-      label
-      description
+      ruleCount
+    }
+    error
+  }
+}
+    `;
+
+export const useMemorySchemaRuleCountsQuery = <TData = GQLMemorySchemaRuleCountsQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables?: GQLMemorySchemaRuleCountsQueryVariables,
+  options?: Omit<UseQueryOptions<GQLMemorySchemaRuleCountsQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLMemorySchemaRuleCountsQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLMemorySchemaRuleCountsQuery, TError, TData>({
+    queryKey: variables === undefined ? ["MemorySchemaRuleCounts"] : ["MemorySchemaRuleCounts", variables],
+    queryFn: fetcher<GQLMemorySchemaRuleCountsQuery, GQLMemorySchemaRuleCountsQueryVariables>(
+      client,
+      MemorySchemaRuleCountsDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useMemorySchemaRuleCountsQuery.getKey = (variables?: GQLMemorySchemaRuleCountsQueryVariables) =>
+  variables === undefined ? ["MemorySchemaRuleCounts"] : ["MemorySchemaRuleCounts", variables];
+
+export const useSuspenseMemorySchemaRuleCountsQuery = <TData = GQLMemorySchemaRuleCountsQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables?: GQLMemorySchemaRuleCountsQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLMemorySchemaRuleCountsQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLMemorySchemaRuleCountsQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLMemorySchemaRuleCountsQuery, TError, TData>({
+    queryKey:
+      variables === undefined ? ["MemorySchemaRuleCountsSuspense"] : ["MemorySchemaRuleCountsSuspense", variables],
+    queryFn: fetcher<GQLMemorySchemaRuleCountsQuery, GQLMemorySchemaRuleCountsQueryVariables>(
+      client,
+      MemorySchemaRuleCountsDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseMemorySchemaRuleCountsQuery.getKey = (variables?: GQLMemorySchemaRuleCountsQueryVariables) =>
+  variables === undefined ? ["MemorySchemaRuleCountsSuspense"] : ["MemorySchemaRuleCountsSuspense", variables];
+
+export const MemorySchemaTemplatesDocument = `
+    query MemorySchemaTemplates {
+  memorySchemaTemplates {
+    templates {
+      live
+      schema {
+        ...MemorySchemaFields
+      }
+    }
+    error
+  }
+}
+    ${MemorySchemaFieldsFragmentDoc}`;
+
+export const useMemorySchemaTemplatesQuery = <TData = GQLMemorySchemaTemplatesQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables?: GQLMemorySchemaTemplatesQueryVariables,
+  options?: Omit<UseQueryOptions<GQLMemorySchemaTemplatesQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLMemorySchemaTemplatesQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLMemorySchemaTemplatesQuery, TError, TData>({
+    queryKey: variables === undefined ? ["MemorySchemaTemplates"] : ["MemorySchemaTemplates", variables],
+    queryFn: fetcher<GQLMemorySchemaTemplatesQuery, GQLMemorySchemaTemplatesQueryVariables>(
+      client,
+      MemorySchemaTemplatesDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useMemorySchemaTemplatesQuery.getKey = (variables?: GQLMemorySchemaTemplatesQueryVariables) =>
+  variables === undefined ? ["MemorySchemaTemplates"] : ["MemorySchemaTemplates", variables];
+
+export const useSuspenseMemorySchemaTemplatesQuery = <TData = GQLMemorySchemaTemplatesQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables?: GQLMemorySchemaTemplatesQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLMemorySchemaTemplatesQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLMemorySchemaTemplatesQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLMemorySchemaTemplatesQuery, TError, TData>({
+    queryKey:
+      variables === undefined ? ["MemorySchemaTemplatesSuspense"] : ["MemorySchemaTemplatesSuspense", variables],
+    queryFn: fetcher<GQLMemorySchemaTemplatesQuery, GQLMemorySchemaTemplatesQueryVariables>(
+      client,
+      MemorySchemaTemplatesDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseMemorySchemaTemplatesQuery.getKey = (variables?: GQLMemorySchemaTemplatesQueryVariables) =>
+  variables === undefined ? ["MemorySchemaTemplatesSuspense"] : ["MemorySchemaTemplatesSuspense", variables];
+
+export const MemorySchemaUsageDocument = `
+    query MemorySchemaUsage($iri: IRI!) {
+  memorySchemaUsage(iri: $iri) {
+    usage {
+      iri
+      memoryCount
       properties {
         path
+        memoryCount
+        options {
+          value
+          memoryCount
+        }
+      }
+      rules {
+        ruleIri
         label
-        dataType
-        required
-        allowedValues
-        keyProperty
-        inferred
+        kind
+        term
+        value
+        position
       }
     }
     error
@@ -12209,6 +14806,64 @@ export const MemorySchemasDocument = `
 }
     `;
 
+export const useMemorySchemaUsageQuery = <TData = GQLMemorySchemaUsageQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLMemorySchemaUsageQueryVariables,
+  options?: Omit<UseQueryOptions<GQLMemorySchemaUsageQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLMemorySchemaUsageQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLMemorySchemaUsageQuery, TError, TData>({
+    queryKey: ["MemorySchemaUsage", variables],
+    queryFn: fetcher<GQLMemorySchemaUsageQuery, GQLMemorySchemaUsageQueryVariables>(
+      client,
+      MemorySchemaUsageDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useMemorySchemaUsageQuery.getKey = (variables: GQLMemorySchemaUsageQueryVariables) => ["MemorySchemaUsage", variables];
+
+export const useSuspenseMemorySchemaUsageQuery = <TData = GQLMemorySchemaUsageQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLMemorySchemaUsageQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLMemorySchemaUsageQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLMemorySchemaUsageQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLMemorySchemaUsageQuery, TError, TData>({
+    queryKey: ["MemorySchemaUsageSuspense", variables],
+    queryFn: fetcher<GQLMemorySchemaUsageQuery, GQLMemorySchemaUsageQueryVariables>(
+      client,
+      MemorySchemaUsageDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseMemorySchemaUsageQuery.getKey = (variables: GQLMemorySchemaUsageQueryVariables) => [
+  "MemorySchemaUsageSuspense",
+  variables,
+];
+
+export const MemorySchemasDocument = `
+    query MemorySchemas($includeArchived: Boolean) {
+  memorySchemas(includeArchived: $includeArchived) {
+    schemas {
+      ...MemorySchemaFields
+    }
+    error
+  }
+}
+    ${MemorySchemaFieldsFragmentDoc}`;
+
 export const useMemorySchemasQuery = <TData = GQLMemorySchemasQuery, TError = unknown>(
   client: GraphQLClient,
   variables?: GQLMemorySchemasQueryVariables,