@manta-eu/client 0.8.0 → 0.9.0

package/src/generated/graphql.ts

@@ -860,6 +860,7 @@ export type GQLDatastoreSubscription = {
   inGoodStanding: Scalars["Boolean"]["output"];
   interval?: Maybe<Scalars["String"]["output"]>;
   intervalCount?: Maybe<Scalars["Int"]["output"]>;
+  managed: Scalars["Boolean"]["output"];
   productIds: Array<Scalars["String"]["output"]>;
   status: Scalars["String"]["output"];
 };
@@ -1127,6 +1128,25 @@ export type GQLGoogleBrandSuggestion = {
   urls: Array<Scalars["String"]["output"]>;
 };
 
+export type GQLGoogleMerchantCenterAccount = {
+  __typename?: "GoogleMerchantCenterAccount";
+  advanced?: Maybe<Scalars["Boolean"]["output"]>;
+  externalId?: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["String"]["output"];
+  isConnectable?: Maybe<Scalars["Boolean"]["output"]>;
+  name?: Maybe<Scalars["String"]["output"]>;
+  parent?: Maybe<Scalars["String"]["output"]>;
+  testAccount?: Maybe<Scalars["Boolean"]["output"]>;
+  unavailableReason?: Maybe<GQLSetupAccountUnavailableReason>;
+};
+
+export type GQLGoogleMerchantCenterSetupProgress = {
+  __typename?: "GoogleMerchantCenterSetupProgress";
+  accounts?: Maybe<Array<GQLGoogleMerchantCenterAccount>>;
+  lastError?: Maybe<GQLGoogleSetupLastError>;
+  state: Array<GQLGoogleSetupStateEnum>;
+};
+
 export type GQLGoogleSetupLastError = {
   __typename?: "GoogleSetupLastError";
   message: Scalars["String"]["output"];
@@ -1283,6 +1303,7 @@ export enum GQLIntegration {
   Figma = "FIGMA",
   Google = "GOOGLE",
   GoogleAnalytics = "GOOGLE_ANALYTICS",
+  GoogleMerchantCenter = "GOOGLE_MERCHANT_CENTER",
   Linkedin = "LINKEDIN",
   Meta = "META",
   MicrosoftAds = "MICROSOFT_ADS",
@@ -1635,6 +1656,15 @@ export type GQLMetaAdAccount = {
   unavailableReason?: Maybe<GQLSetupAccountUnavailableReason>;
 };
 
+export type GQLMetaInterestSuggestion = {
+  __typename?: "MetaInterestSuggestion";
+  audienceSizeLowerBound?: Maybe<Scalars["Float"]["output"]>;
+  audienceSizeUpperBound?: Maybe<Scalars["Float"]["output"]>;
+  id: Scalars["String"]["output"];
+  name: Scalars["String"]["output"];
+  path: Array<Scalars["String"]["output"]>;
+};
+
 export type GQLMetaPage = {
   __typename?: "MetaPage";
   id: Scalars["String"]["output"];
@@ -1738,6 +1768,7 @@ export type GQLMutation = {
   forgetUserName: GQLForgetUserNameResponse;
   generateStructuredData: GQLStructuredDataResponse;
   googleAnalyticsSetupConnect: GQLGoogleAnalyticsSetupProgress;
+  googleMerchantCenterSetupConnect: GQLGoogleMerchantCenterSetupProgress;
   googleSetupConnect: GQLGoogleSetupProgress;
   grantOperatorRole: GQLGrantOperatorRoleResponse;
   initiateUpload: GQLInitiateUploadResponse;
@@ -1760,6 +1791,7 @@ export type GQLMutation = {
   provisionDatastore: GQLProvisionDatastoreResponse;
   reconfirmMemory: GQLUpdateMemoryResponse;
   recordHotelProfile: GQLRecordHotelProfileResponse;
+  refreshResources: GQLRefreshResourcesResponse;
   registerDatastore: GQLRegisterDatastoreResponse;
   releaseRuleOwnership: GQLReleaseRuleOwnershipResponse;
   removeCustomAppUser: GQLCustomAppUserRemoval;
@@ -1970,6 +2002,10 @@ export type GQLMutationGoogleAnalyticsSetupConnectArgs = {
   propertyIds: Array<Scalars["String"]["input"]>;
 };
 
+export type GQLMutationGoogleMerchantCenterSetupConnectArgs = {
+  accountIds: Array<Scalars["String"]["input"]>;
+};
+
 export type GQLMutationGoogleSetupConnectArgs = {
   accountIds: Array<Scalars["String"]["input"]>;
 };
@@ -2072,8 +2108,13 @@ export type GQLMutationRecordHotelProfileArgs = {
   input: GQLHotelProfileInput;
 };
 
+export type GQLMutationRefreshResourcesArgs = {
+  resources: Array<GQLRefreshResourceInput>;
+};
+
 export type GQLMutationRegisterDatastoreArgs = {
   datastoreId: Scalars["String"]["input"];
+  launchProvisioning?: InputMaybe<Scalars["Boolean"]["input"]>;
 };
 
 export type GQLMutationReleaseRuleOwnershipArgs = {
@@ -2360,15 +2401,18 @@ export type GQLQuery = {
   gmailIntegrations: Array<GQLGmailIntegration>;
   googleAnalyticsSetupProgress: GQLGoogleAnalyticsSetupProgress;
   googleBrandSuggestions: Array<GQLGoogleBrandSuggestion>;
+  googleMerchantCenterSetupProgress: GQLGoogleMerchantCenterSetupProgress;
   googleSetupProgress: GQLGoogleSetupProgress;
   inferalIntegrations: Array<GQLInferalIntegration>;
   knowledgeGraphState: GQLKnowledgeGraphState;
   ldesStreams: Array<GQLLdesStream>;
   linkedinSetupProgress?: Maybe<GQLLinkedinSetupProgress>;
+  manualActionProgress?: Maybe<GQLManualActionProgressResult>;
   memories: GQLMemoriesResponse;
   memoryRedundancyReview: GQLMemoryRedundancyResult;
   memoryReplaySeries: GQLMemoryReplaySeriesResult;
   memorySchemas: GQLMemorySchemasResponse;
+  metaInterestSuggestions: Array<GQLMetaInterestSuggestion>;
   metaSetupProgress: GQLMetaSetupProgress;
   microsoftAdsSetupProgress: GQLMicrosoftAdsSetupProgress;
   nodeProperties: GQLNodePropertiesResponse;
@@ -2377,6 +2421,8 @@ export type GQLQuery = {
   organizationLinking?: Maybe<GQLOrganizationLinking>;
   organizationNameAvailable: GQLOrganizationNameAvailability;
   pendingInvitations: Array<GQLPendingInvitation>;
+  refreshResourceCapabilities: GQLRefreshResourceCapabilitiesResponse;
+  refreshResourcesStatus: GQLRefreshResourcesStatusResponse;
   rules: GQLRulesResponse;
   sessionContext: GQLSessionContext;
   shaclShapes: GQLShaclShapesResponse;
@@ -2512,6 +2558,11 @@ export type GQLQueryKnowledgeGraphStateArgs = {
   dataVersion?: InputMaybe<Scalars["String"]["input"]>;
 };
 
+export type GQLQueryManualActionProgressArgs = {
+  namedGraphIri: Scalars["String"]["input"];
+  subjectIri: Scalars["String"]["input"];
+};
+
 export type GQLQueryMemoriesArgs = {
   includeArchived?: InputMaybe<Scalars["Boolean"]["input"]>;
   includeOutOfWindow?: InputMaybe<Scalars["Boolean"]["input"]>;
@@ -2525,6 +2576,13 @@ export type GQLQueryMemoryReplaySeriesArgs = {
   limit?: InputMaybe<Scalars["Int"]["input"]>;
 };
 
+export type GQLQueryMetaInterestSuggestionsArgs = {
+  adAccountIri: Scalars["IRI"]["input"];
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  locale?: InputMaybe<Scalars["String"]["input"]>;
+  term: Scalars["String"]["input"];
+};
+
 export type GQLQueryNodePropertiesArgs = {
   nodeIri: Scalars["String"]["input"];
   planGraphIri?: InputMaybe<Scalars["IRI"]["input"]>;
@@ -2540,6 +2598,14 @@ export type GQLQueryOrganizationNameAvailableArgs = {
   name: Scalars["String"]["input"];
 };
 
+export type GQLQueryRefreshResourceCapabilitiesArgs = {
+  rdfTypes: Array<Scalars["String"]["input"]>;
+};
+
+export type GQLQueryRefreshResourcesStatusArgs = {
+  workflowId: Scalars["String"]["input"];
+};
+
 export type GQLQueryRulesArgs = {
   filterByOwner?: InputMaybe<Scalars["String"]["input"]>;
   includeDependencyGraph?: InputMaybe<Scalars["Boolean"]["input"]>;
@@ -2613,9 +2679,57 @@ export type GQLRecordHotelProfileResponse = {
   error?: Maybe<Scalars["String"]["output"]>;
 };
 
+export type GQLRefreshResourceCapabilitiesResponse = {
+  __typename?: "RefreshResourceCapabilitiesResponse";
+  capabilities: Array<GQLRefreshResourceCapability>;
+};
+
+export type GQLRefreshResourceCapability = {
+  __typename?: "RefreshResourceCapability";
+  rdfType: Scalars["String"]["output"];
+  supportsRefresh: Scalars["Boolean"]["output"];
+};
+
+export type GQLRefreshResourceInput = {
+  iri: Scalars["String"]["input"];
+  type: Scalars["String"]["input"];
+};
+
+export type GQLRefreshResourceResult = {
+  __typename?: "RefreshResourceResult";
+  iri: Scalars["String"]["output"];
+  refreshStatus: GQLRefreshResourceStatus;
+  type: Scalars["String"]["output"];
+};
+
+export enum GQLRefreshResourceStatus {
+  NotReadable = "NOT_READABLE",
+  NotSynced = "NOT_SYNCED",
+  Synced = "SYNCED",
+}
+
+export type GQLRefreshResourcesResponse = {
+  __typename?: "RefreshResourcesResponse";
+  workflowId: Scalars["String"]["output"];
+};
+
+export type GQLRefreshResourcesStatusResponse = {
+  __typename?: "RefreshResourcesStatusResponse";
+  error?: Maybe<Scalars["String"]["output"]>;
+  results?: Maybe<Array<GQLRefreshResourceResult>>;
+  status: GQLRefreshWorkflowStatus;
+};
+
+export enum GQLRefreshWorkflowStatus {
+  Completed = "COMPLETED",
+  Failed = "FAILED",
+  Running = "RUNNING",
+}
+
 export type GQLRegisterDatastoreResponse = {
   __typename?: "RegisterDatastoreResponse";
   error?: Maybe<Scalars["String"]["output"]>;
+  pending: Scalars["Boolean"]["output"];
   success: Scalars["Boolean"]["output"];
 };
 
@@ -2859,6 +2973,7 @@ export type GQLSessionUser = {
 
 export enum GQLSetupAccountUnavailableReason {
   InsufficientPermissions = "INSUFFICIENT_PERMISSIONS",
+  TermsNotAccepted = "TERMS_NOT_ACCEPTED",
 }
 
 export enum GQLShaclSeverity {
@@ -3069,6 +3184,7 @@ export type GQLTeamMember = {
   federated?: Maybe<Scalars["Boolean"]["output"]>;
   id: Scalars["String"]["output"];
   inviteUrl?: Maybe<Scalars["String"]["output"]>;
+  lastSignInAt?: Maybe<Scalars["DateTime"]["output"]>;
   managed?: Maybe<Scalars["Boolean"]["output"]>;
   name?: Maybe<Scalars["String"]["output"]>;
   pending: Scalars["Boolean"]["output"];
@@ -3161,6 +3277,7 @@ export type GQLTriplewhaleProviderInput = {
 
 export type GQLUnlinkedDatastore = {
   __typename?: "UnlinkedDatastore";
+  built: Scalars["Boolean"]["output"];
   id: Scalars["String"]["output"];
 };
 
@@ -3935,6 +4052,30 @@ export type GQLGoogleAnalyticsSetupConnectMutation = {
   };
 };
 
+export type GQLGoogleMerchantCenterSetupConnectMutationVariables = Exact<{
+  accountIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>;
+
+export type GQLGoogleMerchantCenterSetupConnectMutation = {
+  __typename?: "Mutation";
+  googleMerchantCenterSetupConnect: {
+    __typename?: "GoogleMerchantCenterSetupProgress";
+    state: Array<GQLGoogleSetupStateEnum>;
+    accounts?: Array<{
+      __typename?: "GoogleMerchantCenterAccount";
+      id: string;
+      name?: string | null;
+      parent?: string | null;
+    }> | null;
+    lastError?: {
+      __typename?: "GoogleSetupLastError";
+      severity: string;
+      title?: string | null;
+      message: string;
+    } | null;
+  };
+};
+
 export type GQLGoogleSetupConnectMutationVariables = Exact<{
   accountIds: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
 }>;
@@ -4045,6 +4186,7 @@ export type GQLLinkUnlinkedDatastoreMutation = {
     datastoreId?: string | null;
     name?: string | null;
     path?: string | null;
+    pending: boolean;
     providerWarning?: string | null;
   };
 };
@@ -4077,7 +4219,12 @@ export type GQLChangeManualActionAssigneesMutation = {
     manualActionProgress: {
       __typename?: "ManualActionProgressResult";
       state: Array<string>;
-      manualAction?: { __typename?: "ManualActionResult"; status?: string | null; assignees: Array<string> } | null;
+      manualAction?: {
+        __typename?: "ManualActionResult";
+        status?: string | null;
+        assignees: Array<string>;
+        resolvedBy?: string | null;
+      } | null;
     };
   } | null;
 };
@@ -4096,7 +4243,12 @@ export type GQLResolveManualActionMutation = {
     manualActionProgress: {
       __typename?: "ManualActionProgressResult";
       state: Array<string>;
-      manualAction?: { __typename?: "ManualActionResult"; status?: string | null; assignees: Array<string> } | null;
+      manualAction?: {
+        __typename?: "ManualActionResult";
+        status?: string | null;
+        assignees: Array<string>;
+        resolvedBy?: string | null;
+      } | null;
     };
   } | null;
 };
@@ -4265,13 +4417,28 @@ export type GQLReconfirmMemoryMutation = {
   };
 };
 
+export type GQLRefreshResourcesMutationVariables = Exact<{
+  resources: Array<GQLRefreshResourceInput> | GQLRefreshResourceInput;
+}>;
+
+export type GQLRefreshResourcesMutation = {
+  __typename?: "Mutation";
+  refreshResources: { __typename?: "RefreshResourcesResponse"; workflowId: string };
+};
+
 export type GQLRegisterDatastoreMutationVariables = Exact<{
   datastoreId: Scalars["String"]["input"];
+  launchProvisioning?: InputMaybe<Scalars["Boolean"]["input"]>;
 }>;
 
 export type GQLRegisterDatastoreMutation = {
   __typename?: "Mutation";
-  registerDatastore: { __typename?: "RegisterDatastoreResponse"; success: boolean; error?: string | null };
+  registerDatastore: {
+    __typename?: "RegisterDatastoreResponse";
+    success: boolean;
+    error?: string | null;
+    pending: boolean;
+  };
 };
 
 export type GQLReleaseRuleOwnershipMutationVariables = Exact<{
@@ -5368,6 +5535,7 @@ export type GQLDatastoreSubscriptionsQuery = {
     datastoreId: string;
     status: string;
     inGoodStanding: boolean;
+    managed: boolean;
     amount?: number | null;
     currency?: string | null;
     interval?: string | null;
@@ -5500,6 +5668,33 @@ export type GQLGoogleBrandSuggestionsQuery = {
   }>;
 };
 
+export type GQLGoogleMerchantCenterSetupProgressQueryVariables = Exact<{ [key: string]: never }>;
+
+export type GQLGoogleMerchantCenterSetupProgressQuery = {
+  __typename?: "Query";
+  googleMerchantCenterSetupProgress: {
+    __typename?: "GoogleMerchantCenterSetupProgress";
+    state: Array<GQLGoogleSetupStateEnum>;
+    accounts?: Array<{
+      __typename?: "GoogleMerchantCenterAccount";
+      id: string;
+      name?: string | null;
+      parent?: string | null;
+      externalId?: string | null;
+      advanced?: boolean | null;
+      testAccount?: boolean | null;
+      isConnectable?: boolean | null;
+      unavailableReason?: GQLSetupAccountUnavailableReason | null;
+    }> | null;
+    lastError?: {
+      __typename?: "GoogleSetupLastError";
+      severity: string;
+      title?: string | null;
+      message: string;
+    } | null;
+  };
+};
+
 export type GQLGoogleSetupProgressQueryVariables = Exact<{ [key: string]: never }>;
 
 export type GQLGoogleSetupProgressQuery = {
@@ -5598,6 +5793,25 @@ export type GQLLinkedinSetupProgressQuery = {
   } | null;
 };
 
+export type GQLManualActionProgressQueryVariables = Exact<{
+  namedGraphIri: Scalars["String"]["input"];
+  subjectIri: Scalars["String"]["input"];
+}>;
+
+export type GQLManualActionProgressQuery = {
+  __typename?: "Query";
+  manualActionProgress?: {
+    __typename?: "ManualActionProgressResult";
+    state: Array<string>;
+    manualAction?: {
+      __typename?: "ManualActionResult";
+      status?: string | null;
+      assignees: Array<string>;
+      resolvedBy?: string | null;
+    } | null;
+  } | null;
+};
+
 export type GQLMemoriesQueryVariables = Exact<{
   includeArchived?: InputMaybe<Scalars["Boolean"]["input"]>;
   includeOutOfWindow?: InputMaybe<Scalars["Boolean"]["input"]>;
@@ -5738,6 +5952,25 @@ export type GQLMemorySchemasQuery = {
   };
 };
 
+export type GQLMetaInterestSuggestionsQueryVariables = Exact<{
+  adAccountIri: Scalars["IRI"]["input"];
+  term: Scalars["String"]["input"];
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  locale?: InputMaybe<Scalars["String"]["input"]>;
+}>;
+
+export type GQLMetaInterestSuggestionsQuery = {
+  __typename?: "Query";
+  metaInterestSuggestions: Array<{
+    __typename?: "MetaInterestSuggestion";
+    id: string;
+    name: string;
+    path: Array<string>;
+    audienceSizeLowerBound?: number | null;
+    audienceSizeUpperBound?: number | null;
+  }>;
+};
+
 export type GQLMetaSetupProgressQueryVariables = Exact<{ [key: string]: never }>;
 
 export type GQLMetaSetupProgressQuery = {
@@ -5866,6 +6099,37 @@ export type GQLProfileQuery = {
   };
 };
 
+export type GQLRefreshResourceCapabilitiesQueryVariables = Exact<{
+  rdfTypes: Array<Scalars["String"]["input"]> | Scalars["String"]["input"];
+}>;
+
+export type GQLRefreshResourceCapabilitiesQuery = {
+  __typename?: "Query";
+  refreshResourceCapabilities: {
+    __typename?: "RefreshResourceCapabilitiesResponse";
+    capabilities: Array<{ __typename?: "RefreshResourceCapability"; rdfType: string; supportsRefresh: boolean }>;
+  };
+};
+
+export type GQLRefreshResourcesStatusQueryVariables = Exact<{
+  workflowId: Scalars["String"]["input"];
+}>;
+
+export type GQLRefreshResourcesStatusQuery = {
+  __typename?: "Query";
+  refreshResourcesStatus: {
+    __typename?: "RefreshResourcesStatusResponse";
+    status: GQLRefreshWorkflowStatus;
+    error?: string | null;
+    results?: Array<{
+      __typename?: "RefreshResourceResult";
+      iri: string;
+      type: string;
+      refreshStatus: GQLRefreshResourceStatus;
+    }> | null;
+  };
+};
+
 export type GQLRulesQueryVariables = Exact<{
   ruleIri?: InputMaybe<Scalars["IRI"]["input"]>;
   filterByOwner?: InputMaybe<Scalars["String"]["input"]>;
@@ -6129,6 +6393,7 @@ export type GQLTeamMembersQuery = {
       federated?: boolean | null;
       enabled: boolean;
       managed?: boolean | null;
+      lastSignInAt?: Date | string | null;
     }>;
   };
 };
@@ -6163,7 +6428,7 @@ export type GQLUnlinkedDatastoresQueryVariables = Exact<{ [key: string]: never }
 
 export type GQLUnlinkedDatastoresQuery = {
   __typename?: "Query";
-  unlinkedDatastores: Array<{ __typename?: "UnlinkedDatastore"; id: string }>;
+  unlinkedDatastores: Array<{ __typename?: "UnlinkedDatastore"; id: string; built: boolean }>;
 };
 
 export type GQLUserPreferencesQueryVariables = Exact<{ [key: string]: never }>;
@@ -7659,6 +7924,52 @@ export const useGoogleAnalyticsSetupConnectMutation = <TError = unknown, TContex
   });
 };
 
+export const GoogleMerchantCenterSetupConnectDocument = `
+    mutation GoogleMerchantCenterSetupConnect($accountIds: [String!]!) {
+  googleMerchantCenterSetupConnect(accountIds: $accountIds) {
+    state
+    accounts {
+      id
+      name
+      parent
+    }
+    lastError {
+      severity
+      title
+      message
+    }
+  }
+}
+    `;
+
+export const useGoogleMerchantCenterSetupConnectMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<
+    GQLGoogleMerchantCenterSetupConnectMutation,
+    TError,
+    GQLGoogleMerchantCenterSetupConnectMutationVariables,
+    TContext
+  >,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<
+    GQLGoogleMerchantCenterSetupConnectMutation,
+    TError,
+    GQLGoogleMerchantCenterSetupConnectMutationVariables,
+    TContext
+  >({
+    mutationKey: ["GoogleMerchantCenterSetupConnect"],
+    mutationFn: (variables?: GQLGoogleMerchantCenterSetupConnectMutationVariables) =>
+      fetcher<GQLGoogleMerchantCenterSetupConnectMutation, GQLGoogleMerchantCenterSetupConnectMutationVariables>(
+        client,
+        GoogleMerchantCenterSetupConnectDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const GoogleSetupConnectDocument = `
     mutation GoogleSetupConnect($accountIds: [String!]!) {
   googleSetupConnect(accountIds: $accountIds) {
@@ -7877,6 +8188,7 @@ export const LinkUnlinkedDatastoreDocument = `
     datastoreId
     name
     path
+    pending
     providerWarning
   }
 }
@@ -7958,6 +8270,7 @@ export const ChangeManualActionAssigneesDocument = `
       manualAction {
         status
         assignees
+        resolvedBy
       }
     }
   }
@@ -8005,6 +8318,7 @@ export const ResolveManualActionDocument = `
       manualAction {
         status
         assignees
+        resolvedBy
       }
     }
   }
@@ -8303,11 +8617,41 @@ export const useReconfirmMemoryMutation = <TError = unknown, TContext = unknown>
   });
 };
 
+export const RefreshResourcesDocument = `
+    mutation RefreshResources($resources: [RefreshResourceInput!]!) {
+  refreshResources(resources: $resources) {
+    workflowId
+  }
+}
+    `;
+
+export const useRefreshResourcesMutation = <TError = unknown, TContext = unknown>(
+  client: GraphQLClient,
+  options?: UseMutationOptions<GQLRefreshResourcesMutation, TError, GQLRefreshResourcesMutationVariables, TContext>,
+  headers?: RequestInit["headers"],
+) => {
+  return useMutation<GQLRefreshResourcesMutation, TError, GQLRefreshResourcesMutationVariables, TContext>({
+    mutationKey: ["RefreshResources"],
+    mutationFn: (variables?: GQLRefreshResourcesMutationVariables) =>
+      fetcher<GQLRefreshResourcesMutation, GQLRefreshResourcesMutationVariables>(
+        client,
+        RefreshResourcesDocument,
+        variables,
+        headers,
+      )(),
+    ...options,
+  });
+};
+
 export const RegisterDatastoreDocument = `
-    mutation RegisterDatastore($datastoreId: String!) {
-  registerDatastore(datastoreId: $datastoreId) {
+    mutation RegisterDatastore($datastoreId: String!, $launchProvisioning: Boolean) {
+  registerDatastore(
+    datastoreId: $datastoreId
+    launchProvisioning: $launchProvisioning
+  ) {
     success
     error
+    pending
   }
 }
     `;
@@ -10636,6 +10980,7 @@ export const DatastoreSubscriptionsDocument = `
     datastoreId
     status
     inGoodStanding
+    managed
     amount
     currency
     interval
@@ -11092,6 +11437,91 @@ useSuspenseGoogleBrandSuggestionsQuery.getKey = (variables: GQLGoogleBrandSugges
   variables,
 ];
 
+export const GoogleMerchantCenterSetupProgressDocument = `
+    query GoogleMerchantCenterSetupProgress {
+  googleMerchantCenterSetupProgress {
+    state
+    accounts {
+      id
+      name
+      parent
+      externalId
+      advanced
+      testAccount
+      isConnectable
+      unavailableReason
+    }
+    lastError {
+      severity
+      title
+      message
+    }
+  }
+}
+    `;
+
+export const useGoogleMerchantCenterSetupProgressQuery = <
+  TData = GQLGoogleMerchantCenterSetupProgressQuery,
+  TError = unknown,
+>(
+  client: GraphQLClient,
+  variables?: GQLGoogleMerchantCenterSetupProgressQueryVariables,
+  options?: Omit<UseQueryOptions<GQLGoogleMerchantCenterSetupProgressQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLGoogleMerchantCenterSetupProgressQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLGoogleMerchantCenterSetupProgressQuery, TError, TData>({
+    queryKey:
+      variables === undefined
+        ? ["GoogleMerchantCenterSetupProgress"]
+        : ["GoogleMerchantCenterSetupProgress", variables],
+    queryFn: fetcher<GQLGoogleMerchantCenterSetupProgressQuery, GQLGoogleMerchantCenterSetupProgressQueryVariables>(
+      client,
+      GoogleMerchantCenterSetupProgressDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useGoogleMerchantCenterSetupProgressQuery.getKey = (variables?: GQLGoogleMerchantCenterSetupProgressQueryVariables) =>
+  variables === undefined ? ["GoogleMerchantCenterSetupProgress"] : ["GoogleMerchantCenterSetupProgress", variables];
+
+export const useSuspenseGoogleMerchantCenterSetupProgressQuery = <
+  TData = GQLGoogleMerchantCenterSetupProgressQuery,
+  TError = unknown,
+>(
+  client: GraphQLClient,
+  variables?: GQLGoogleMerchantCenterSetupProgressQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLGoogleMerchantCenterSetupProgressQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLGoogleMerchantCenterSetupProgressQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLGoogleMerchantCenterSetupProgressQuery, TError, TData>({
+    queryKey:
+      variables === undefined
+        ? ["GoogleMerchantCenterSetupProgressSuspense"]
+        : ["GoogleMerchantCenterSetupProgressSuspense", variables],
+    queryFn: fetcher<GQLGoogleMerchantCenterSetupProgressQuery, GQLGoogleMerchantCenterSetupProgressQueryVariables>(
+      client,
+      GoogleMerchantCenterSetupProgressDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseGoogleMerchantCenterSetupProgressQuery.getKey = (
+  variables?: GQLGoogleMerchantCenterSetupProgressQueryVariables,
+) =>
+  variables === undefined
+    ? ["GoogleMerchantCenterSetupProgressSuspense"]
+    : ["GoogleMerchantCenterSetupProgressSuspense", variables];
+
 export const GoogleSetupProgressDocument = `
     query GoogleSetupProgress {
   googleSetupProgress {
@@ -11418,6 +11848,69 @@ export const useSuspenseLinkedinSetupProgressQuery = <TData = GQLLinkedinSetupPr
 useSuspenseLinkedinSetupProgressQuery.getKey = (variables?: GQLLinkedinSetupProgressQueryVariables) =>
   variables === undefined ? ["LinkedinSetupProgressSuspense"] : ["LinkedinSetupProgressSuspense", variables];
 
+export const ManualActionProgressDocument = `
+    query ManualActionProgress($namedGraphIri: String!, $subjectIri: String!) {
+  manualActionProgress(namedGraphIri: $namedGraphIri, subjectIri: $subjectIri) {
+    state
+    manualAction {
+      status
+      assignees
+      resolvedBy
+    }
+  }
+}
+    `;
+
+export const useManualActionProgressQuery = <TData = GQLManualActionProgressQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLManualActionProgressQueryVariables,
+  options?: Omit<UseQueryOptions<GQLManualActionProgressQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLManualActionProgressQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLManualActionProgressQuery, TError, TData>({
+    queryKey: ["ManualActionProgress", variables],
+    queryFn: fetcher<GQLManualActionProgressQuery, GQLManualActionProgressQueryVariables>(
+      client,
+      ManualActionProgressDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useManualActionProgressQuery.getKey = (variables: GQLManualActionProgressQueryVariables) => [
+  "ManualActionProgress",
+  variables,
+];
+
+export const useSuspenseManualActionProgressQuery = <TData = GQLManualActionProgressQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLManualActionProgressQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLManualActionProgressQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLManualActionProgressQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLManualActionProgressQuery, TError, TData>({
+    queryKey: ["ManualActionProgressSuspense", variables],
+    queryFn: fetcher<GQLManualActionProgressQuery, GQLManualActionProgressQueryVariables>(
+      client,
+      ManualActionProgressDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseManualActionProgressQuery.getKey = (variables: GQLManualActionProgressQueryVariables) => [
+  "ManualActionProgressSuspense",
+  variables,
+];
+
 export const MemoriesDocument = `
     query Memories($includeArchived: Boolean, $includeOutOfWindow: Boolean) {
   memories(
@@ -11615,6 +12108,73 @@ export const useSuspenseMemorySchemasQuery = <TData = GQLMemorySchemasQuery, TEr
 useSuspenseMemorySchemasQuery.getKey = (variables?: GQLMemorySchemasQueryVariables) =>
   variables === undefined ? ["MemorySchemasSuspense"] : ["MemorySchemasSuspense", variables];
 
+export const MetaInterestSuggestionsDocument = `
+    query MetaInterestSuggestions($adAccountIri: IRI!, $term: String!, $limit: Int, $locale: String) {
+  metaInterestSuggestions(
+    adAccountIri: $adAccountIri
+    term: $term
+    limit: $limit
+    locale: $locale
+  ) {
+    id
+    name
+    path
+    audienceSizeLowerBound
+    audienceSizeUpperBound
+  }
+}
+    `;
+
+export const useMetaInterestSuggestionsQuery = <TData = GQLMetaInterestSuggestionsQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLMetaInterestSuggestionsQueryVariables,
+  options?: Omit<UseQueryOptions<GQLMetaInterestSuggestionsQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLMetaInterestSuggestionsQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLMetaInterestSuggestionsQuery, TError, TData>({
+    queryKey: ["MetaInterestSuggestions", variables],
+    queryFn: fetcher<GQLMetaInterestSuggestionsQuery, GQLMetaInterestSuggestionsQueryVariables>(
+      client,
+      MetaInterestSuggestionsDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useMetaInterestSuggestionsQuery.getKey = (variables: GQLMetaInterestSuggestionsQueryVariables) => [
+  "MetaInterestSuggestions",
+  variables,
+];
+
+export const useSuspenseMetaInterestSuggestionsQuery = <TData = GQLMetaInterestSuggestionsQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLMetaInterestSuggestionsQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLMetaInterestSuggestionsQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLMetaInterestSuggestionsQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLMetaInterestSuggestionsQuery, TError, TData>({
+    queryKey: ["MetaInterestSuggestionsSuspense", variables],
+    queryFn: fetcher<GQLMetaInterestSuggestionsQuery, GQLMetaInterestSuggestionsQueryVariables>(
+      client,
+      MetaInterestSuggestionsDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseMetaInterestSuggestionsQuery.getKey = (variables: GQLMetaInterestSuggestionsQueryVariables) => [
+  "MetaInterestSuggestionsSuspense",
+  variables,
+];
+
 export const MetaSetupProgressDocument = `
     query MetaSetupProgress {
   metaSetupProgress {
@@ -12044,6 +12604,134 @@ export const useSuspenseProfileQuery = <TData = GQLProfileQuery, TError = unknow
 useSuspenseProfileQuery.getKey = (variables?: GQLProfileQueryVariables) =>
   variables === undefined ? ["ProfileSuspense"] : ["ProfileSuspense", variables];
 
+export const RefreshResourceCapabilitiesDocument = `
+    query RefreshResourceCapabilities($rdfTypes: [String!]!) {
+  refreshResourceCapabilities(rdfTypes: $rdfTypes) {
+    capabilities {
+      rdfType
+      supportsRefresh
+    }
+  }
+}
+    `;
+
+export const useRefreshResourceCapabilitiesQuery = <TData = GQLRefreshResourceCapabilitiesQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLRefreshResourceCapabilitiesQueryVariables,
+  options?: Omit<UseQueryOptions<GQLRefreshResourceCapabilitiesQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLRefreshResourceCapabilitiesQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLRefreshResourceCapabilitiesQuery, TError, TData>({
+    queryKey: ["RefreshResourceCapabilities", variables],
+    queryFn: fetcher<GQLRefreshResourceCapabilitiesQuery, GQLRefreshResourceCapabilitiesQueryVariables>(
+      client,
+      RefreshResourceCapabilitiesDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useRefreshResourceCapabilitiesQuery.getKey = (variables: GQLRefreshResourceCapabilitiesQueryVariables) => [
+  "RefreshResourceCapabilities",
+  variables,
+];
+
+export const useSuspenseRefreshResourceCapabilitiesQuery = <
+  TData = GQLRefreshResourceCapabilitiesQuery,
+  TError = unknown,
+>(
+  client: GraphQLClient,
+  variables: GQLRefreshResourceCapabilitiesQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLRefreshResourceCapabilitiesQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLRefreshResourceCapabilitiesQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLRefreshResourceCapabilitiesQuery, TError, TData>({
+    queryKey: ["RefreshResourceCapabilitiesSuspense", variables],
+    queryFn: fetcher<GQLRefreshResourceCapabilitiesQuery, GQLRefreshResourceCapabilitiesQueryVariables>(
+      client,
+      RefreshResourceCapabilitiesDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseRefreshResourceCapabilitiesQuery.getKey = (variables: GQLRefreshResourceCapabilitiesQueryVariables) => [
+  "RefreshResourceCapabilitiesSuspense",
+  variables,
+];
+
+export const RefreshResourcesStatusDocument = `
+    query RefreshResourcesStatus($workflowId: String!) {
+  refreshResourcesStatus(workflowId: $workflowId) {
+    status
+    results {
+      iri
+      type
+      refreshStatus
+    }
+    error
+  }
+}
+    `;
+
+export const useRefreshResourcesStatusQuery = <TData = GQLRefreshResourcesStatusQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLRefreshResourcesStatusQueryVariables,
+  options?: Omit<UseQueryOptions<GQLRefreshResourcesStatusQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseQueryOptions<GQLRefreshResourcesStatusQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useQuery<GQLRefreshResourcesStatusQuery, TError, TData>({
+    queryKey: ["RefreshResourcesStatus", variables],
+    queryFn: fetcher<GQLRefreshResourcesStatusQuery, GQLRefreshResourcesStatusQueryVariables>(
+      client,
+      RefreshResourcesStatusDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useRefreshResourcesStatusQuery.getKey = (variables: GQLRefreshResourcesStatusQueryVariables) => [
+  "RefreshResourcesStatus",
+  variables,
+];
+
+export const useSuspenseRefreshResourcesStatusQuery = <TData = GQLRefreshResourcesStatusQuery, TError = unknown>(
+  client: GraphQLClient,
+  variables: GQLRefreshResourcesStatusQueryVariables,
+  options?: Omit<UseSuspenseQueryOptions<GQLRefreshResourcesStatusQuery, TError, TData>, "queryKey"> & {
+    queryKey?: UseSuspenseQueryOptions<GQLRefreshResourcesStatusQuery, TError, TData>["queryKey"];
+  },
+  headers?: RequestInit["headers"],
+) => {
+  return useSuspenseQuery<GQLRefreshResourcesStatusQuery, TError, TData>({
+    queryKey: ["RefreshResourcesStatusSuspense", variables],
+    queryFn: fetcher<GQLRefreshResourcesStatusQuery, GQLRefreshResourcesStatusQueryVariables>(
+      client,
+      RefreshResourcesStatusDocument,
+      variables,
+      headers,
+    ),
+    ...options,
+  });
+};
+
+useSuspenseRefreshResourcesStatusQuery.getKey = (variables: GQLRefreshResourcesStatusQueryVariables) => [
+  "RefreshResourcesStatusSuspense",
+  variables,
+];
+
 export const RulesDocument = `
     query Rules($ruleIri: IRI, $filterByOwner: String, $namedGraph: IRI, $typeFilter: [IRI!]) {
   rules(
@@ -12679,6 +13367,7 @@ export const TeamMembersDocument = `
       federated
       enabled
       managed
+      lastSignInAt
     }
   }
 }
@@ -12840,6 +13529,7 @@ export const UnlinkedDatastoresDocument = `
     query UnlinkedDatastores {
   unlinkedDatastores {
     id
+    built
   }
 }
     `;