@evenicanpm/storefront-core 1.2.1 → 1.2.2

package/src/api-manager/datasources/e4/graphqlRequestSdk.ts

@@ -338,6 +338,11 @@ export type AddressWrapper = {
 	value?: Maybe<Array<Maybe<Address>>>;
 };
 
+export enum ApiSource {
+	D365 = "d365",
+	E4 = "e4",
+}
+
 export type Application = {
 	__typename?: "Application";
 	environment: Scalars["String"]["output"];
@@ -1271,6 +1276,52 @@ export type CompleteCartMutationResponse = MutationResponse & {
 	success: Scalars["Boolean"]["output"];
 };
 
+export type ConfigExport = {
+	__typename?: "ConfigExport";
+	DepotGroups?: Maybe<Array<Maybe<DepotGroupExport>>>;
+	Depots?: Maybe<Array<Maybe<DepotExport>>>;
+	Endpoints?: Maybe<Array<Maybe<EndpointExport>>>;
+	Entities?: Maybe<Array<Maybe<EntityExport>>>;
+	Processes?: Maybe<Array<Maybe<ProcessExport>>>;
+};
+
+export type ConfigImport = {
+	CreateIntegrationProc?: InputMaybe<Scalars["Boolean"]["input"]>;
+	DepotGroups?: InputMaybe<Array<InputMaybe<DepotGroupImport>>>;
+	Depots?: InputMaybe<Array<InputMaybe<DepotImport>>>;
+	Endpoints?: InputMaybe<Array<InputMaybe<EndpointImport>>>;
+	Entities?: InputMaybe<Array<InputMaybe<EntityImport>>>;
+	Processes?: InputMaybe<Array<InputMaybe<ProcessImport>>>;
+	RecreateStagingTable?: InputMaybe<Scalars["Boolean"]["input"]>;
+	UseSourceEndpoint?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+
+export type ConfigMerge = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	connectionName?: InputMaybe<Scalars["String"]["input"]>;
+	dataDescription?: InputMaybe<Scalars["String"]["input"]>;
+	directoryPath?: InputMaybe<Scalars["String"]["input"]>;
+	endpointRoute?: InputMaybe<Scalars["String"]["input"]>;
+	fileType?: InputMaybe<Scalars["String"]["input"]>;
+	header?: InputMaybe<Scalars["String"]["input"]>;
+	maxEndpointMessageAttempts?: InputMaybe<Scalars["Int"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	parallelProcessingGroup?: InputMaybe<Scalars["Int"]["input"]>;
+	paramStoredProc?: InputMaybe<Scalars["String"]["input"]>;
+	paramStoredProcVariable?: InputMaybe<Scalars["JSON"]["input"]>;
+	postStoredProc?: InputMaybe<Scalars["String"]["input"]>;
+	preStoredProc?: InputMaybe<Scalars["String"]["input"]>;
+	processId?: InputMaybe<Scalars["ID"]["input"]>;
+	processTemplateId: Scalars["ID"]["input"];
+	properties?: InputMaybe<Scalars["JSON"]["input"]>;
+	requestOptions?: InputMaybe<Scalars["String"]["input"]>;
+	requestType?: InputMaybe<Scalars["String"]["input"]>;
+	seed?: InputMaybe<Scalars["ID"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+	stagedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	subscriptions?: InputMaybe<Scalars["JSON"]["input"]>;
+};
+
 export type Contact = {
 	__typename?: "Contact";
 	account: Account;
@@ -1387,6 +1438,12 @@ export type ContactsConnection = {
 	recordCount?: Maybe<Scalars["Int"]["output"]>;
 };
 
+export type CopiedProcess = {
+	__typename?: "CopiedProcess";
+	process?: Maybe<Process>;
+	processTasks?: Maybe<Array<Maybe<ProcessTask>>>;
+};
+
 export type Country = {
 	__typename?: "Country";
 	created?: Maybe<Scalars["String"]["output"]>;
@@ -1527,6 +1584,25 @@ export type CustomersSettings = {
 	resultsPerPage?: Maybe<Scalars["String"]["output"]>;
 };
 
+export enum DataType {
+	All = "all",
+	Categories = "categories",
+	Cms = "cms",
+	Marketing = "marketing",
+	Products = "products",
+}
+
+export type DateRange = {
+	__typename?: "DateRange";
+	endDate?: Maybe<Scalars["DateTime"]["output"]>;
+	startDate?: Maybe<Scalars["DateTime"]["output"]>;
+};
+
+export type DateRangeInput = {
+	endDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	startDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+};
+
 /**
  * Allows removal of the assets. This is a generic method that
  * removes entity by provided type.
@@ -1545,12 +1621,11 @@ export type DeleteCartLineInput = {
 
 /** Removes document from the search index */
 export type DeleteDocumentInput = {
+	/** Alias name of the active index that should be updated. Defaults to 'products' */
+	alias?: InputMaybe<Scalars["String"]["input"]>;
 	/** Id of the document in the index to remove */
 	id: Scalars["ID"]["input"];
-	/**
-	 * Index name from which the item should be removed.
-	 * Default: products
-	 */
+	/** Index name that should be updated. Used when alias is not provided */
 	index?: InputMaybe<Scalars["String"]["input"]>;
 };
 
@@ -1572,6 +1647,13 @@ export type DeleteRelatedAccount = {
 	relatedAccountId: Scalars["ID"]["input"];
 };
 
+export type DeleteResult = {
+	__typename?: "DeleteResult";
+	message?: Maybe<Scalars["String"]["output"]>;
+	/** 200 if delete successful. 500 if failed. */
+	status: Scalars["Int"]["output"];
+};
+
 export type DeleteSavedCartResponse = MutationResponse & {
 	__typename?: "DeleteSavedCartResponse";
 	code: Scalars["String"]["output"];
@@ -1609,6 +1691,100 @@ export type DeleteWishlistInput = {
 	wishlistId: Scalars["ID"]["input"];
 };
 
+export type DeletedRecord = {
+	__typename?: "DeletedRecord";
+	id: Scalars["ID"]["output"];
+};
+
+export type Depot = {
+	__typename?: "Depot";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	depotGroup?: Maybe<DepotGroup>;
+	endpointType?: Maybe<EndpointType>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	url?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type DepotCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	depotGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type DepotExport = {
+	__typename?: "DepotExport";
+	Depot: Scalars["String"]["output"];
+	DepotGroup?: Maybe<Scalars["String"]["output"]>;
+	DepotId?: Maybe<Scalars["ID"]["output"]>;
+};
+
+export type DepotGroup = {
+	__typename?: "DepotGroup";
+	breadcrumbIds?: Maybe<Scalars["String"]["output"]>;
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	parentId?: Maybe<Scalars["ID"]["output"]>;
+	rootId?: Maybe<Scalars["ID"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	tier?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type DepotGroupCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	/** Specify new group's parent. If null, new group is root. */
+	parentId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type DepotGroupExport = {
+	__typename?: "DepotGroupExport";
+	DepotGroup: Scalars["String"]["output"];
+	DepotGroupId?: Maybe<Scalars["ID"]["output"]>;
+};
+
+export type DepotGroupImport = {
+	DepotGroup: Scalars["String"]["input"];
+	DepotGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type DepotGroupUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type DepotImport = {
+	Depot: Scalars["String"]["input"];
+	DepotGroup?: InputMaybe<Scalars["String"]["input"]>;
+	DepotId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type DepotUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	depotGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	endpointTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+	url?: InputMaybe<Scalars["String"]["input"]>;
+};
+
 export type DetailSavedCartEdge = {
 	__typename?: "DetailSavedCartEdge";
 	cursor?: Maybe<Scalars["String"]["output"]>;
@@ -1674,6 +1850,94 @@ export type Dimensions = {
 	Label?: Maybe<Scalars["String"]["output"]>;
 };
 
+export type Document = {
+	__typename?: "Document";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	documentGroup?: Maybe<DocumentGroup>;
+	documentType: DocumentType;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	metadata?: Maybe<Scalars["String"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type DocumentField = {
+	__typename?: "DocumentField";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	decimalPlaces?: Maybe<Scalars["Int"]["output"]>;
+	document: Document;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	fieldType: FieldType;
+	id: Scalars["ID"]["output"];
+	isOptional?: Maybe<Scalars["Int"]["output"]>;
+	length?: Maybe<Scalars["Int"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	validationFailureAction?: Maybe<ValidationFailureAction>;
+};
+
+export type DocumentFieldCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	decimalPlaces?: InputMaybe<Scalars["Int"]["input"]>;
+	documentId: Scalars["ID"]["input"];
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	fieldTypeId: Scalars["ID"]["input"];
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	isOptional?: InputMaybe<Scalars["Int"]["input"]>;
+	length?: InputMaybe<Scalars["Int"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+	validationFailureActionId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type DocumentFieldUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	decimalPlaces?: InputMaybe<Scalars["Int"]["input"]>;
+	documentId?: InputMaybe<Scalars["ID"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	fieldTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	id: Scalars["ID"]["input"];
+	isOptional?: InputMaybe<Scalars["Int"]["input"]>;
+	length?: InputMaybe<Scalars["Int"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+	validationFailureActionId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type DocumentGroup = {
+	__typename?: "DocumentGroup";
+	breadcrumbIds?: Maybe<Scalars["String"]["output"]>;
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	parentId?: Maybe<Scalars["ID"]["output"]>;
+	rootId?: Maybe<Scalars["ID"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	tier?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type DocumentType = {
+	__typename?: "DocumentType";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	id: Scalars["ID"]["output"];
+	metadataSchema?: Maybe<Scalars["String"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	parentId?: Maybe<Scalars["ID"]["output"]>;
+	rootId?: Maybe<Scalars["ID"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	tier?: Maybe<Scalars["Int"]["output"]>;
+};
+
 export type Email = Node & {
 	__typename?: "Email";
 	contact: Contact;
@@ -1685,10 +1949,403 @@ export type Email = Node & {
 	modifiedBy?: Maybe<Contact>;
 };
 
+export type Endpoint = {
+	__typename?: "Endpoint";
+	code?: Maybe<Scalars["String"]["output"]>;
+	collectionPropertyName?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	defaultProcessTaskType?: Maybe<ProcessTaskType>;
+	depot?: Maybe<Depot>;
+	displayName?: Maybe<Scalars["String"]["output"]>;
+	document?: Maybe<Document>;
+	endpointStatus?: Maybe<EndpointStatus>;
+	endpointType?: Maybe<EndpointType>;
+	entity?: Maybe<Entity>;
+	id: Scalars["ID"]["output"];
+	isPublish?: Maybe<Scalars["Int"]["output"]>;
+	metadata?: Maybe<Scalars["String"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	processTemplate?: Maybe<ProcessTemplate>;
+	stagingTableName?: Maybe<Scalars["String"]["output"]>;
+	stagingTableSchema?: Maybe<Scalars["String"]["output"]>;
+	templateConfig?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type EndpointConnection = {
+	__typename?: "EndpointConnection";
+	edges: Array<EndpointEdge>;
+	nodes?: Maybe<Array<Maybe<Endpoint>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type EndpointCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	collectionPropertyName?: InputMaybe<Scalars["String"]["input"]>;
+	depotId?: InputMaybe<Scalars["ID"]["input"]>;
+	endpointTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	entityId?: InputMaybe<Scalars["ID"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	metadata?: InputMaybe<Scalars["String"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	processTemplateId?: InputMaybe<Scalars["ID"]["input"]>;
+	stagingTableName?: InputMaybe<Scalars["String"]["input"]>;
+	stagingTableSchema?: InputMaybe<Scalars["String"]["input"]>;
+	templateConfig?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type EndpointEdge = {
+	__typename?: "EndpointEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: Endpoint;
+};
+
+export type EndpointExport = {
+	__typename?: "EndpointExport";
+	Depot?: Maybe<Scalars["String"]["output"]>;
+	Endpoint?: Maybe<Scalars["String"]["output"]>;
+	EndpointId?: Maybe<Scalars["ID"]["output"]>;
+	EndpointType?: Maybe<Scalars["String"]["output"]>;
+	Entity?: Maybe<Scalars["String"]["output"]>;
+	Metadata?: Maybe<Scalars["String"]["output"]>;
+	Name?: Maybe<Scalars["String"]["output"]>;
+	ProcessTemplateId?: Maybe<Scalars["ID"]["output"]>;
+	StagingTableName?: Maybe<Scalars["String"]["output"]>;
+	StagingTableSchema?: Maybe<Scalars["String"]["output"]>;
+	Subscriptions?: Maybe<Array<Maybe<EndpointSubscriptionExport>>>;
+	TemplateConfig?: Maybe<Scalars["JSON"]["output"]>;
+};
+
+export type EndpointImport = {
+	Depot?: InputMaybe<Scalars["String"]["input"]>;
+	Endpoint?: InputMaybe<Scalars["String"]["input"]>;
+	EndpointId?: InputMaybe<Scalars["ID"]["input"]>;
+	EndpointType?: InputMaybe<Scalars["String"]["input"]>;
+	Entity?: InputMaybe<Scalars["String"]["input"]>;
+	KeyHint?: InputMaybe<Scalars["String"]["input"]>;
+	Metadata?: InputMaybe<Scalars["String"]["input"]>;
+	Name?: InputMaybe<Scalars["String"]["input"]>;
+	ProcessTemplateId?: InputMaybe<Scalars["ID"]["input"]>;
+	StagingTableName?: InputMaybe<Scalars["String"]["input"]>;
+	StagingTableSchema?: InputMaybe<Scalars["String"]["input"]>;
+	Subscriptions?: InputMaybe<Array<InputMaybe<EndpointSubscriptionImport>>>;
+	TemplateConfig?: InputMaybe<Scalars["JSON"]["input"]>;
+};
+
+export type EndpointQueue = {
+	__typename?: "EndpointQueue";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	endpoint: Endpoint;
+	endpointQueueStatus?: Maybe<EndpointQueueStatus>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type EndpointQueueCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	endpointId?: InputMaybe<Scalars["ID"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type EndpointQueueStatus = {
+	__typename?: "EndpointQueueStatus";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type EndpointQueueUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	endpointId?: InputMaybe<Scalars["ID"]["input"]>;
+	endpointQueueStatusId?: InputMaybe<Scalars["ID"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	name?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type EndpointStatus = {
+	__typename?: "EndpointStatus";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type EndpointSubscription = {
+	__typename?: "EndpointSubscription";
+	created: Scalars["DateTime"]["output"];
+	endpoint: Endpoint;
+	endpointQueue: EndpointQueue;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	subscriptionDate?: Maybe<Scalars["DateTime"]["output"]>;
+};
+
+export type EndpointSubscriptionCreate = {
+	endpointId: Scalars["ID"]["input"];
+	endpointQueueId: Scalars["ID"]["input"];
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	subscriptionDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+};
+
+export type EndpointSubscriptionExport = {
+	__typename?: "EndpointSubscriptionExport";
+	EndpointQueueId?: Maybe<Scalars["ID"]["output"]>;
+	EndpointSubscriptionId?: Maybe<Scalars["ID"]["output"]>;
+	SourceEndpoint?: Maybe<Scalars["String"]["output"]>;
+	TargetEndpoint?: Maybe<Scalars["String"]["output"]>;
+	Transformations?: Maybe<Array<Maybe<TransformationExport>>>;
+};
+
+export type EndpointSubscriptionImport = {
+	EndpointQueueId?: InputMaybe<Scalars["ID"]["input"]>;
+	EndpointSubscriptionId?: InputMaybe<Scalars["ID"]["input"]>;
+	SourceEndpoint?: InputMaybe<Scalars["String"]["input"]>;
+	TargetEndpoint?: InputMaybe<Scalars["String"]["input"]>;
+	Transformations?: InputMaybe<Array<InputMaybe<TransformationImport>>>;
+};
+
+export type EndpointSubscriptionUpdate = {
+	endpointId?: InputMaybe<Scalars["ID"]["input"]>;
+	endpointQueueId?: InputMaybe<Scalars["ID"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	subscriptionDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+};
+
+export type EndpointType = {
+	__typename?: "EndpointType";
+	breadcrumbIds?: Maybe<Scalars["String"]["output"]>;
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	id: Scalars["ID"]["output"];
+	metadataSchema?: Maybe<Scalars["String"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	parentId?: Maybe<Scalars["ID"]["output"]>;
+	rootId?: Maybe<Scalars["ID"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	tier?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type EndpointUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	collectionPropertyName?: InputMaybe<Scalars["String"]["input"]>;
+	defaultProcessTaskTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	depotId?: InputMaybe<Scalars["ID"]["input"]>;
+	displayName?: InputMaybe<Scalars["String"]["input"]>;
+	documentId?: InputMaybe<Scalars["ID"]["input"]>;
+	endpointStatusId?: InputMaybe<Scalars["ID"]["input"]>;
+	endpointTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	entityId?: InputMaybe<Scalars["ID"]["input"]>;
+	id: Scalars["ID"]["input"];
+	isPublish?: InputMaybe<Scalars["Int"]["input"]>;
+	metadata?: InputMaybe<Scalars["String"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	processTemplateId?: InputMaybe<Scalars["ID"]["input"]>;
+	stagingTableName?: InputMaybe<Scalars["String"]["input"]>;
+	stagingTableSchema?: InputMaybe<Scalars["String"]["input"]>;
+	templateConfig?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type Entity = {
+	__typename?: "Entity";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	displayName?: Maybe<Scalars["String"]["output"]>;
+	enableParse?: Maybe<Scalars["Int"]["output"]>;
+	entityGroup?: Maybe<EntityGroup>;
+	entitySchema?: Maybe<Scalars["String"]["output"]>;
+	entityType?: Maybe<EntityType>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	parentId?: Maybe<Scalars["ID"]["output"]>;
+	rootId?: Maybe<Scalars["ID"]["output"]>;
+	sourceEntityName?: Maybe<Scalars["String"]["output"]>;
+	tier?: Maybe<Scalars["Int"]["output"]>;
+};
+
 export type EntityAttribute = {
 	value?: Maybe<Scalars["String"]["output"]>;
 };
 
+export type EntityCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	enableParse?: InputMaybe<Scalars["Int"]["input"]>;
+	entitySchema?: InputMaybe<Scalars["String"]["input"]>;
+	entityTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	sourceEntityName?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type EntityExport = {
+	__typename?: "EntityExport";
+	EnableParse?: Maybe<Scalars["Int"]["output"]>;
+	Entity?: Maybe<Scalars["String"]["output"]>;
+	EntityFields?: Maybe<Array<Maybe<EntityFieldExport>>>;
+	EntityId?: Maybe<Scalars["ID"]["output"]>;
+	EntitySchema?: Maybe<Scalars["String"]["output"]>;
+	EntityType?: Maybe<Scalars["String"]["output"]>;
+	ExtendedFields?: Maybe<Scalars["String"]["output"]>;
+	Name?: Maybe<Scalars["String"]["output"]>;
+	SourceEntityName?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type EntityField = {
+	__typename?: "EntityField";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	decimalPlaces?: Maybe<Scalars["Int"]["output"]>;
+	entity: Entity;
+	enumId?: Maybe<Scalars["ID"]["output"]>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	fieldType: FieldType;
+	id: Scalars["ID"]["output"];
+	isDisplay?: Maybe<Scalars["Int"]["output"]>;
+	isEditable?: Maybe<Scalars["Int"]["output"]>;
+	isKey?: Maybe<Scalars["Int"]["output"]>;
+	isRequired?: Maybe<Scalars["Int"]["output"]>;
+	length?: Maybe<Scalars["Int"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	parentEntityFieldId?: Maybe<Scalars["ID"]["output"]>;
+	path?: Maybe<Scalars["String"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	subEntityId?: Maybe<Scalars["ID"]["output"]>;
+	tier?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type EntityFieldCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	decimalPlaces?: InputMaybe<Scalars["Int"]["input"]>;
+	entityId: Scalars["ID"]["input"];
+	fieldTypeId: Scalars["ID"]["input"];
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	isEditable?: InputMaybe<Scalars["Int"]["input"]>;
+	isKey?: InputMaybe<Scalars["Int"]["input"]>;
+	isRequired?: InputMaybe<Scalars["Int"]["input"]>;
+	length?: InputMaybe<Scalars["Int"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	path?: InputMaybe<Scalars["String"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type EntityFieldExport = {
+	__typename?: "EntityFieldExport";
+	EntityField?: Maybe<Scalars["String"]["output"]>;
+	EntityFieldId?: Maybe<Scalars["ID"]["output"]>;
+	FieldType?: Maybe<Scalars["String"]["output"]>;
+	IsEditable?: Maybe<Scalars["Int"]["output"]>;
+	IsKey?: Maybe<Scalars["Int"]["output"]>;
+	IsRequired?: Maybe<Scalars["Int"]["output"]>;
+	Length?: Maybe<Scalars["Int"]["output"]>;
+	Path?: Maybe<Scalars["String"]["output"]>;
+	Sort?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type EntityFieldImport = {
+	EntityField?: InputMaybe<Scalars["String"]["input"]>;
+	EntityFieldId?: InputMaybe<Scalars["ID"]["input"]>;
+	FieldType?: InputMaybe<Scalars["String"]["input"]>;
+	IsEditable?: InputMaybe<Scalars["Int"]["input"]>;
+	IsKey?: InputMaybe<Scalars["Int"]["input"]>;
+	IsRequired?: InputMaybe<Scalars["Int"]["input"]>;
+	Length?: InputMaybe<Scalars["Int"]["input"]>;
+	Path?: InputMaybe<Scalars["String"]["input"]>;
+	Sort?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type EntityFieldUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	decimalPlaces?: InputMaybe<Scalars["Int"]["input"]>;
+	entityId?: InputMaybe<Scalars["ID"]["input"]>;
+	enumId?: InputMaybe<Scalars["ID"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	fieldTypeID?: InputMaybe<Scalars["ID"]["input"]>;
+	id: Scalars["ID"]["input"];
+	isDisplay?: InputMaybe<Scalars["Int"]["input"]>;
+	isEditable?: InputMaybe<Scalars["Int"]["input"]>;
+	isKey?: InputMaybe<Scalars["Int"]["input"]>;
+	isRequired?: InputMaybe<Scalars["Int"]["input"]>;
+	length?: InputMaybe<Scalars["Int"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	parentEntityFieldId?: InputMaybe<Scalars["ID"]["input"]>;
+	path?: InputMaybe<Scalars["String"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+	subEntityId?: InputMaybe<Scalars["ID"]["input"]>;
+	tier?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type EntityGroup = {
+	__typename?: "EntityGroup";
+	breadcrumbIds?: Maybe<Scalars["String"]["output"]>;
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	parentId?: Maybe<Scalars["ID"]["output"]>;
+	rootId?: Maybe<Scalars["ID"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	tier?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type EntityImport = {
+	EnableParse?: InputMaybe<Scalars["Int"]["input"]>;
+	Entity?: InputMaybe<Scalars["String"]["input"]>;
+	EntityFields?: InputMaybe<Array<InputMaybe<EntityFieldImport>>>;
+	EntityId?: InputMaybe<Scalars["ID"]["input"]>;
+	EntitySchema?: InputMaybe<Scalars["String"]["input"]>;
+	EntityType?: InputMaybe<Scalars["String"]["input"]>;
+	ExtendedFields?: InputMaybe<Scalars["String"]["input"]>;
+	Name?: InputMaybe<Scalars["String"]["input"]>;
+	SourceEntityName?: InputMaybe<Scalars["String"]["input"]>;
+};
+
+export type EntityType = {
+	__typename?: "EntityType";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type EntityUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	displayName?: InputMaybe<Scalars["String"]["input"]>;
+	enableParse?: InputMaybe<Scalars["Int"]["input"]>;
+	entityGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	entitySchema?: InputMaybe<Scalars["String"]["input"]>;
+	entityTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	sourceEntityName?: InputMaybe<Scalars["String"]["input"]>;
+};
+
 export type Enum = {
 	__typename?: "Enum";
 	code?: Maybe<Scalars["String"]["output"]>;
@@ -1716,6 +2373,16 @@ export type Error = {
 	message: Scalars["String"]["output"];
 };
 
+export type ExecutionStatus = {
+	__typename?: "ExecutionStatus";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
 export type FacetFilter = {
 	__typename?: "FacetFilter";
 	attributeId?: Maybe<Scalars["String"]["output"]>;
@@ -1726,11 +2393,31 @@ export type FacetFilter = {
 	sort?: Maybe<Scalars["Int"]["output"]>;
 };
 
+export type FieldType = {
+	__typename?: "FieldType";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	stagingDataType?: Maybe<Scalars["String"]["output"]>;
+};
+
 export type Filter = {
 	age?: InputMaybe<Scalars["Int"]["input"]>;
 	orderType?: InputMaybe<OrderType>;
 };
 
+export type FilterQueryInput = {
+	after?: InputMaybe<Scalars["String"]["input"]>;
+	search?: InputMaybe<Scalars["String"]["input"]>;
+	skip?: InputMaybe<Scalars["Int"]["input"]>;
+	sort?: InputMaybe<Scalars["String"]["input"]>;
+	sortDesc?: InputMaybe<Scalars["Boolean"]["input"]>;
+	top?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
 export type Folder = Node & {
 	__typename?: "Folder";
 	breadcrumb: Array<FolderBreadcrumb>;
@@ -1764,6 +2451,17 @@ export type Font = {
 	family?: Maybe<Scalars["String"]["output"]>;
 };
 
+export type GenerateSitemapInput = {
+	dataType: DataType;
+	generationType?: InputMaybe<GenerationType>;
+	source: ApiSource;
+};
+
+export enum GenerationType {
+	Manual = "MANUAL",
+	Scheduled = "SCHEDULED",
+}
+
 export enum GenericQueryStatus {
 	Active = "ACTIVE",
 	All = "ALL",
@@ -1912,6 +2610,47 @@ export type Image = {
 	id: Scalars["ID"]["output"];
 };
 
+export type ImportRecord = {
+	__typename?: "ImportRecord";
+	created?: Maybe<Scalars["Int"]["output"]>;
+	updated?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ImportRecordEndpoint = {
+	__typename?: "ImportRecordEndpoint";
+	created?: Maybe<Scalars["Int"]["output"]>;
+	queues?: Maybe<ImportRecord>;
+	subscriptions?: Maybe<ImportRecord>;
+	updated?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ImportRecordEntity = {
+	__typename?: "ImportRecordEntity";
+	created?: Maybe<Scalars["Int"]["output"]>;
+	entityFields?: Maybe<ImportRecord>;
+	updated?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ImportRecordProcess = {
+	__typename?: "ImportRecordProcess";
+	created?: Maybe<Scalars["Int"]["output"]>;
+	processScheduleGroups?: Maybe<ImportRecord>;
+	processSchedules?: Maybe<ImportRecord>;
+	processTasks?: Maybe<ImportRecord>;
+	updated?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ImportResult = {
+	__typename?: "ImportResult";
+	depotGroups?: Maybe<ImportRecord>;
+	depots?: Maybe<ImportRecord>;
+	endpoints?: Maybe<ImportRecordEndpoint>;
+	entities?: Maybe<ImportRecordEntity>;
+	message?: Maybe<Scalars["String"]["output"]>;
+	processes?: Maybe<ImportRecordProcess>;
+	success: Scalars["Boolean"]["output"];
+};
+
 export type IndexAttemptResponse = {
 	__typename?: "IndexAttemptResponse";
 	/** Unique id identifying the operation */
@@ -2413,6 +3152,9 @@ export type Mutation = {
 	clearCache?: Maybe<ClearCacheResponse>;
 	clearItemsFromWishlist?: Maybe<Scalars["String"]["output"]>;
 	completeCart?: Maybe<CompleteCartMutationResponse>;
+	configurationImport?: Maybe<ImportResult>;
+	configurationMerge?: Maybe<ImportResult>;
+	copyProcess?: Maybe<CopiedProcess>;
 	createAddress?: Maybe<Address>;
 	createCategories: Array<Category>;
 	createCategoryMediaLink?: Maybe<CreateCategoryMediaLinkMutationResponse>;
@@ -2423,6 +3165,14 @@ export type Mutation = {
 	createClaim?: Maybe<Claim>;
 	createClaimType?: Maybe<ClaimType>;
 	createContact?: Maybe<CreateContactMutationResponse>;
+	createDepot?: Maybe<Depot>;
+	createDepotGroup?: Maybe<DepotGroup>;
+	createDocumentField?: Maybe<DocumentField>;
+	createEndpoint?: Maybe<Endpoint>;
+	createEndpointQueue?: Maybe<EndpointQueue>;
+	createEndpointSubscription?: Maybe<EndpointSubscription>;
+	createEntity?: Maybe<Entity>;
+	createEntityField?: Maybe<EntityField>;
 	createFolder?: Maybe<CreateFolderMutationResponse>;
 	/** Create a new index type. */
 	createIndex: IndexAttemptResponse;
@@ -2430,7 +3180,15 @@ export type Mutation = {
 	createMediaMimeType?: Maybe<MediaMimeType>;
 	createMediaType: MediaType;
 	createNewTheme?: Maybe<ThemeItem>;
+	createNotification?: Maybe<NotificationIntegrate>;
+	createNotificationGroup?: Maybe<NotificationGroup>;
+	createNotificationTemplate?: Maybe<NotificationTemplate>;
 	createOrderAddress?: Maybe<Address>;
+	createProcess?: Maybe<Process>;
+	createProcessSchedule?: Maybe<ProcessSchedule>;
+	createProcessScheduleGroupDetails?: Maybe<ProcessScheduleGroupDetails>;
+	createProcessTask?: Maybe<ProcessTask>;
+	createProcessTaskLink?: Maybe<ProcessTaskLink>;
 	createProduct?: Maybe<ProductMutationResponse>;
 	createProductEntity?: Maybe<ProductEntityMutationResponse>;
 	createProductStatus?: Maybe<ProductStatusMutationResponse>;
@@ -2455,7 +3213,15 @@ export type Mutation = {
 	deleteChannel?: Maybe<Scalars["String"]["output"]>;
 	deleteClaim?: Maybe<Claim>;
 	deleteClaimType?: Maybe<ClaimType>;
+	deleteDepotGroups?: Maybe<Array<Maybe<DepotGroup>>>;
+	deleteDepots?: Maybe<Array<Maybe<Depot>>>;
 	deleteDocument?: Maybe<Scalars["ID"]["output"]>;
+	deleteDocumentFields?: Maybe<Array<Maybe<DocumentField>>>;
+	deleteEndpointQueues?: Maybe<Array<Maybe<EndpointQueue>>>;
+	deleteEndpointSubscriptions?: Maybe<Array<Maybe<EndpointSubscription>>>;
+	deleteEndpoints?: Maybe<Array<Maybe<Endpoint>>>;
+	deleteEntities?: Maybe<Array<Maybe<Entity>>>;
+	deleteEntityFields?: Maybe<Array<Maybe<EntityField>>>;
 	/** Removed specified file by id. */
 	deleteFile?: Maybe<Media>;
 	/** Removes specific folder by provided Id and all the assets inside the folder. */
@@ -2464,15 +3230,23 @@ export type Mutation = {
 	deleteItemFromAllWishlists?: Maybe<Scalars["String"]["output"]>;
 	deleteItemFromWishlist?: Maybe<Scalars["String"]["output"]>;
 	deleteMappingField?: Maybe<Scalars["ID"]["output"]>;
-	deleteMappingFields: Array<MappingField>;
+	deleteMappingFields: Array<DeletedRecord>;
 	deleteMediaType?: Maybe<MediaType>;
+	deleteNotificationGroups?: Maybe<Array<Maybe<NotificationGroup>>>;
+	deleteNotificationTemplates?: Maybe<Array<Maybe<NotificationTemplate>>>;
+	deleteNotifications?: Maybe<Array<Maybe<NotificationIntegrate>>>;
+	deleteProcessScheduleGroup?: Maybe<DeleteResult>;
+	deleteProcessSchedules?: Maybe<Array<Maybe<ProcessSchedule>>>;
+	deleteProcessTaskLinks?: Maybe<Array<Maybe<ProcessTaskLink>>>;
+	deleteProcessTasks?: Maybe<Array<Maybe<ProcessTask>>>;
+	deleteProcesses?: Maybe<Array<Maybe<Process>>>;
 	deleteProduct?: Maybe<ProductMutationResponse>;
 	deleteProductEntity?: Maybe<ProductEntityMutationResponse>;
 	deleteProductStatus?: Maybe<ProductStatusMutationResponse>;
 	deleteRoleClaim?: Maybe<RoleClaim>;
 	deleteSavedCart?: Maybe<DeleteSavedCartResponse>;
-	deleteSearchWord?: Maybe<SearchWord>;
-	deleteSearchWordSynonym?: Maybe<SearchWordSynonym>;
+	deleteSearchWord?: Maybe<Array<Maybe<DeletedRecord>>>;
+	deleteSearchWordSynonym?: Maybe<Array<Maybe<DeletedRecord>>>;
 	deleteStopWord?: Maybe<StopWord>;
 	deleteTheme?: Maybe<DeleteSuccess>;
 	deleteUser: DeleteUserResponse;
@@ -2482,6 +3256,8 @@ export type Mutation = {
 	digitalInstanceDelete?: Maybe<DigitalInstanceMutationResponse>;
 	digitalInstanceUpdate?: Maybe<DigitalInstanceMutationResponse>;
 	exitSoboMode?: Maybe<Scalars["String"]["output"]>;
+	/** Manually generate or refresh sitemap */
+	generateSitemap?: Maybe<SitemapGenerationResponse>;
 	groupSetCreate?: Maybe<GroupSetMutationResponse>;
 	groupSetDelete?: Maybe<GroupSetMutationResponse>;
 	groupSetTypeCreate?: Maybe<GroupSetTypeMutationResponse>;
@@ -2518,6 +3294,7 @@ export type Mutation = {
 	requestResetPassword?: Maybe<RequestResetPasswordMutationResponse>;
 	resetPassword?: Maybe<ResetPasswordMutationResponse>;
 	restoreSavedCart?: Maybe<RestoreSavedCartResponse>;
+	runProcess?: Maybe<RunResult>;
 	saveCart?: Maybe<SaveCartResponse>;
 	saveCategories: Array<Category>;
 	saveCategoryMediaLinks: Array<CategoryMediaLink>;
@@ -2551,10 +3328,26 @@ export type Mutation = {
 	updateClaim?: Maybe<Claim>;
 	updateClaimType?: Maybe<ClaimType>;
 	updateContact?: Maybe<Me>;
+	updateDepot?: Maybe<Depot>;
+	updateDepotGroup?: Maybe<DepotGroup>;
 	updateDocument?: Maybe<Scalars["ID"]["output"]>;
+	updateDocumentField?: Maybe<DocumentField>;
+	updateEndpoint?: Maybe<Endpoint>;
+	updateEndpointQueue?: Maybe<EndpointQueue>;
+	updateEndpointSubscription?: Maybe<EndpointSubscription>;
+	updateEntity?: Maybe<Entity>;
+	updateEntityField?: Maybe<EntityField>;
 	updateMapping: Array<MappingField>;
 	updateMappings: Array<MappingField>;
 	updateMediaType: MediaType;
+	updateNotification?: Maybe<NotificationIntegrate>;
+	updateNotificationGroup?: Maybe<NotificationGroup>;
+	updateNotificationTemplate?: Maybe<NotificationTemplate>;
+	updateProcess?: Maybe<Process>;
+	updateProcessSchedule?: Maybe<ProcessSchedule>;
+	updateProcessScheduleGroupDetails?: Maybe<ProcessScheduleGroupDetails>;
+	updateProcessTask?: Maybe<ProcessTask>;
+	updateProcessTaskLink?: Maybe<ProcessTaskLink>;
 	updateProduct?: Maybe<ProductMutationResponse>;
 	updateProductEntity?: Maybe<ProductEntityMutationResponse>;
 	updateProductStatus?: Maybe<ProductStatusMutationResponse>;
@@ -2564,6 +3357,8 @@ export type Mutation = {
 	updateSearchWord?: Maybe<SearchWord>;
 	updateSearchWordSynonym?: Maybe<SearchWordSynonym>;
 	updateSetting?: Maybe<Array<Maybe<SettingRaw>>>;
+	/** Update sitemap schedule (daily, weekly, etc.) */
+	updateSitemapSchedule?: Maybe<SitemapMutationResponse>;
 	updateUser?: Maybe<Me>;
 	updateWebsite: UpdateWebsiteMutationResponse;
 	updateWishlistItemQuantity: WishList;
@@ -2672,6 +3467,19 @@ export type MutationCompleteCartArgs = {
 	input?: InputMaybe<CompleteCartInput>;
 };
 
+export type MutationConfigurationImportArgs = {
+	config?: InputMaybe<ConfigImport>;
+};
+
+export type MutationConfigurationMergeArgs = {
+	input?: InputMaybe<ProcessConfigMerge>;
+};
+
+export type MutationCopyProcessArgs = {
+	sourceId: Scalars["ID"]["input"];
+	targetId: Scalars["ID"]["input"];
+};
+
 export type MutationCreateAddressArgs = {
 	address: AddressInput;
 };
@@ -2713,6 +3521,38 @@ export type MutationCreateContactArgs = {
 	contactInput?: InputMaybe<ContactInput>;
 };
 
+export type MutationCreateDepotArgs = {
+	input: DepotCreate;
+};
+
+export type MutationCreateDepotGroupArgs = {
+	input: DepotGroupCreate;
+};
+
+export type MutationCreateDocumentFieldArgs = {
+	input?: InputMaybe<DocumentFieldCreate>;
+};
+
+export type MutationCreateEndpointArgs = {
+	input: EndpointCreate;
+};
+
+export type MutationCreateEndpointQueueArgs = {
+	input: EndpointQueueCreate;
+};
+
+export type MutationCreateEndpointSubscriptionArgs = {
+	input: EndpointSubscriptionCreate;
+};
+
+export type MutationCreateEntityArgs = {
+	input: EntityCreate;
+};
+
+export type MutationCreateEntityFieldArgs = {
+	input: EntityFieldCreate;
+};
+
 export type MutationCreateFolderArgs = {
 	input?: InputMaybe<CreateFolderInput>;
 };
@@ -2739,10 +3579,42 @@ export type MutationCreateNewThemeArgs = {
 	themeInput?: InputMaybe<ThemeInput>;
 };
 
+export type MutationCreateNotificationArgs = {
+	input: NotificationCreate;
+};
+
+export type MutationCreateNotificationGroupArgs = {
+	input: NotificationGroupCreate;
+};
+
+export type MutationCreateNotificationTemplateArgs = {
+	input: NotificationTemplateCreate;
+};
+
 export type MutationCreateOrderAddressArgs = {
 	address: AddressInput;
 };
 
+export type MutationCreateProcessArgs = {
+	input: ProcessCreate;
+};
+
+export type MutationCreateProcessScheduleArgs = {
+	input: ProcessScheduleCreate;
+};
+
+export type MutationCreateProcessScheduleGroupDetailsArgs = {
+	input: ProcessScheduleGroupDetailsCreate;
+};
+
+export type MutationCreateProcessTaskArgs = {
+	input: ProcessTaskCreate;
+};
+
+export type MutationCreateProcessTaskLinkArgs = {
+	input: ProcessTaskLinkCreate;
+};
+
 export type MutationCreateProductArgs = {
 	input: CreateProductInput;
 };
@@ -2831,10 +3703,42 @@ export type MutationDeleteClaimTypeArgs = {
 	input?: InputMaybe<ClaimTypeInput>;
 };
 
+export type MutationDeleteDepotGroupsArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteDepotsArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
 export type MutationDeleteDocumentArgs = {
 	input?: InputMaybe<DeleteDocumentInput>;
 };
 
+export type MutationDeleteDocumentFieldsArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteEndpointQueuesArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteEndpointSubscriptionsArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteEndpointsArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteEntitiesArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteEntityFieldsArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
 export type MutationDeleteFileArgs = {
 	id: Scalars["ID"]["input"];
 };
@@ -2867,6 +3771,38 @@ export type MutationDeleteMediaTypeArgs = {
 	id: Scalars["ID"]["input"];
 };
 
+export type MutationDeleteNotificationGroupsArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteNotificationTemplatesArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteNotificationsArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteProcessScheduleGroupArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type MutationDeleteProcessSchedulesArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteProcessTaskLinksArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteProcessTasksArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
+export type MutationDeleteProcessesArgs = {
+	ids: Array<Scalars["ID"]["input"]>;
+};
+
 export type MutationDeleteProductArgs = {
 	id: Scalars["ID"]["input"];
 };
@@ -2927,6 +3863,10 @@ export type MutationDigitalInstanceUpdateArgs = {
 	input?: InputMaybe<DigitalInstanceUpdateInput>;
 };
 
+export type MutationGenerateSitemapArgs = {
+	input: GenerateSitemapInput;
+};
+
 export type MutationGroupSetCreateArgs = {
 	input: GroupSetCreate;
 };
@@ -3035,6 +3975,10 @@ export type MutationRestoreSavedCartArgs = {
 	cartId: Scalars["ID"]["input"];
 };
 
+export type MutationRunProcessArgs = {
+	input?: InputMaybe<ProcessRun>;
+};
+
 export type MutationSaveCartArgs = {
 	title: Scalars["String"]["input"];
 };
@@ -3161,10 +4105,42 @@ export type MutationUpdateContactArgs = {
 	contact?: InputMaybe<UpdateContactInput>;
 };
 
+export type MutationUpdateDepotArgs = {
+	input: DepotUpdate;
+};
+
+export type MutationUpdateDepotGroupArgs = {
+	input: DepotGroupUpdate;
+};
+
 export type MutationUpdateDocumentArgs = {
 	input?: InputMaybe<UpdateDocumentInput>;
 };
 
+export type MutationUpdateDocumentFieldArgs = {
+	input?: InputMaybe<DocumentFieldCreate>;
+};
+
+export type MutationUpdateEndpointArgs = {
+	input: EndpointUpdate;
+};
+
+export type MutationUpdateEndpointQueueArgs = {
+	input: EndpointQueueUpdate;
+};
+
+export type MutationUpdateEndpointSubscriptionArgs = {
+	input: EndpointSubscriptionUpdate;
+};
+
+export type MutationUpdateEntityArgs = {
+	input: EntityUpdate;
+};
+
+export type MutationUpdateEntityFieldArgs = {
+	input: EntityFieldUpdate;
+};
+
 export type MutationUpdateMappingArgs = {
 	mapping: Array<MappingFieldInput>;
 };
@@ -3178,6 +4154,38 @@ export type MutationUpdateMediaTypeArgs = {
 	input?: InputMaybe<MediaTypeInput>;
 };
 
+export type MutationUpdateNotificationArgs = {
+	input: NotificationUpdate;
+};
+
+export type MutationUpdateNotificationGroupArgs = {
+	input: NotificationGroupUpdate;
+};
+
+export type MutationUpdateNotificationTemplateArgs = {
+	input: NotificationTemplateUpdate;
+};
+
+export type MutationUpdateProcessArgs = {
+	input: ProcessUpdate;
+};
+
+export type MutationUpdateProcessScheduleArgs = {
+	input: ProcessScheduleUpdate;
+};
+
+export type MutationUpdateProcessScheduleGroupDetailsArgs = {
+	input: ProcessScheduleGroupDetailsUpdate;
+};
+
+export type MutationUpdateProcessTaskArgs = {
+	input: ProcessTaskUpdate;
+};
+
+export type MutationUpdateProcessTaskLinkArgs = {
+	input: ProcessTaskLinkUpdate;
+};
+
 export type MutationUpdateProductArgs = {
 	input: UpdateProductInput;
 };
@@ -3218,6 +4226,10 @@ export type MutationUpdateSettingArgs = {
 	siteSetting: Array<SiteSettingInput>;
 };
 
+export type MutationUpdateSitemapScheduleArgs = {
+	input: UpdateSitemapScheduleInput;
+};
+
 export type MutationUpdateUserArgs = {
 	user?: InputMaybe<UserInput>;
 };
@@ -3252,6 +4264,13 @@ export type Node = {
 	modifiedBy?: Maybe<Contact>;
 };
 
+export type NonScheduledProcessConnection = {
+	__typename?: "NonScheduledProcessConnection";
+	nodes?: Maybe<Array<Maybe<Process>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
 export type Notification = Node & {
 	__typename?: "Notification";
 	body: Scalars["String"]["output"];
@@ -3275,12 +4294,78 @@ export type NotificationConnection = {
 	recordCount?: Maybe<Scalars["Int"]["output"]>;
 };
 
+export type NotificationCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	notificationGroupId: Scalars["ID"]["input"];
+};
+
 export type NotificationEdge = {
 	__typename?: "NotificationEdge";
 	cursor?: Maybe<Scalars["String"]["output"]>;
 	node?: Maybe<Notification>;
 };
 
+export type NotificationGroup = {
+	__typename?: "NotificationGroup";
+	breadcrumbIds?: Maybe<Scalars["String"]["output"]>;
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	parentId?: Maybe<Scalars["ID"]["output"]>;
+	rootId?: Maybe<Scalars["ID"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	tier?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type NotificationGroupConnection = {
+	__typename?: "NotificationGroupConnection";
+	edges: Array<NotificationGroupEdge>;
+	nodes?: Maybe<Array<Maybe<NotificationGroup>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type NotificationGroupCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	/** Specify new group's parent. If null, new group is root. */
+	parentId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type NotificationGroupEdge = {
+	__typename?: "NotificationGroupEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: NotificationGroup;
+};
+
+export type NotificationGroupTree = {
+	__typename?: "NotificationGroupTree";
+	breadcrumbIds?: Maybe<Scalars["String"]["output"]>;
+	children?: Maybe<Array<Maybe<NotificationGroupTree>>>;
+	code?: Maybe<Scalars["String"]["output"]>;
+	id: Scalars["ID"]["output"];
+	label?: Maybe<Scalars["String"]["output"]>;
+	name?: Maybe<Scalars["String"]["output"]>;
+	parentId?: Maybe<Scalars["ID"]["output"]>;
+	rootId?: Maybe<Scalars["ID"]["output"]>;
+};
+
+export type NotificationGroupUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
 export type NotificationInput = {
 	body: Scalars["String"]["input"];
 	contactId: Array<Scalars["ID"]["input"]>;
@@ -3290,6 +4375,33 @@ export type NotificationInput = {
 	title?: InputMaybe<Scalars["String"]["input"]>;
 };
 
+export type NotificationIntegrate = {
+	__typename?: "NotificationIntegrate";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	displayName?: Maybe<Scalars["String"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	notificationGroup: NotificationGroup;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	status?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type NotificationIntegrateConnection = {
+	__typename?: "NotificationIntegrateConnection";
+	edges: Array<NotificationIntegrateEdge>;
+	nodes?: Maybe<Array<Maybe<NotificationIntegrate>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type NotificationIntegrateEdge = {
+	__typename?: "NotificationIntegrateEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: NotificationIntegrate;
+};
+
 export type NotificationQueryInput = {
 	after?: InputMaybe<Scalars["String"]["input"]>;
 	before?: InputMaybe<Scalars["String"]["input"]>;
@@ -3299,17 +4411,119 @@ export type NotificationQueryInput = {
 	top?: InputMaybe<Scalars["Int"]["input"]>;
 };
 
+export type NotificationTemplate = {
+	__typename?: "NotificationTemplate";
+	attachment?: Maybe<Scalars["String"]["output"]>;
+	body?: Maybe<Scalars["String"]["output"]>;
+	breadcrumbIds?: Maybe<Scalars["String"]["output"]>;
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	displayName?: Maybe<Scalars["String"]["output"]>;
+	emailBcc?: Maybe<Scalars["String"]["output"]>;
+	emailCc?: Maybe<Scalars["String"]["output"]>;
+	emailFrom?: Maybe<Scalars["String"]["output"]>;
+	emailReplyTo?: Maybe<Scalars["String"]["output"]>;
+	emailTo?: Maybe<Scalars["String"]["output"]>;
+	id: Scalars["ID"]["output"];
+	isHtml?: Maybe<Scalars["Int"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	notification: NotificationIntegrate;
+	notificationTemplateType?: Maybe<NotificationTemplateType>;
+	parentId?: Maybe<Scalars["ID"]["output"]>;
+	populateStoredProcedure?: Maybe<Scalars["String"]["output"]>;
+	rootId?: Maybe<Scalars["ID"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	subject?: Maybe<Scalars["String"]["output"]>;
+	textTo?: Maybe<Scalars["String"]["output"]>;
+	tier?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type NotificationTemplateCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	notificationId: Scalars["ID"]["input"];
+	notificationTemplateTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	/** Specify new group's parent. If null, new group is root. */
+	parentId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type NotificationTemplateType = {
+	__typename?: "NotificationTemplateType";
+	created: Scalars["DateTime"]["output"];
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type NotificationTemplateUpdate = {
+	attachment?: InputMaybe<Scalars["String"]["input"]>;
+	body?: InputMaybe<Scalars["String"]["input"]>;
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	displayName?: InputMaybe<Scalars["String"]["input"]>;
+	emailBcc?: InputMaybe<Scalars["String"]["input"]>;
+	emailCc?: InputMaybe<Scalars["String"]["input"]>;
+	emailFrom?: InputMaybe<Scalars["String"]["input"]>;
+	emailReplyTo?: InputMaybe<Scalars["String"]["input"]>;
+	emailTo?: InputMaybe<Scalars["String"]["input"]>;
+	id: Scalars["ID"]["input"];
+	isHtml?: InputMaybe<Scalars["Int"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	notificationId?: InputMaybe<Scalars["ID"]["input"]>;
+	notificationTemplateTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	populateStoredProcedure?: InputMaybe<Scalars["String"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+	subject?: InputMaybe<Scalars["String"]["input"]>;
+	textTo?: InputMaybe<Scalars["String"]["input"]>;
+};
+
 export type NotificationType = {
 	__typename?: "NotificationType";
 	code?: Maybe<Scalars["String"]["output"]>;
 	id: Scalars["ID"]["output"];
 };
 
+export type NotificationUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	displayName?: InputMaybe<Scalars["String"]["input"]>;
+	id: Scalars["ID"]["input"];
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	notificationGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+	status?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
 export type ODataFilter = {
 	key?: InputMaybe<Scalars["String"]["input"]>;
 	value?: InputMaybe<Scalars["String"]["input"]>;
 };
 
+export type OrchestrationType = {
+	__typename?: "OrchestrationType";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type OrchestrationTypeConnection = {
+	__typename?: "OrchestrationTypeConnection";
+	edges: Array<OrchestrationTypeEdge>;
+	nodes?: Maybe<Array<Maybe<OrchestrationType>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type OrchestrationTypeEdge = {
+	__typename?: "OrchestrationTypeEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: OrchestrationType;
+};
+
 export type Order = {
 	__typename?: "Order";
 	account: Account;
@@ -3422,6 +4636,60 @@ export type PageInfo = {
 	top?: Maybe<Scalars["Int"]["output"]>;
 };
 
+/** Extended PageInfo type that includes integrationTags, for ProcessConnection */
+export type PageInfoProcess = {
+	__typename?: "PageInfoProcess";
+	currentPage: Scalars["Int"]["output"];
+	endCursor: Scalars["String"]["output"];
+	hasNextPage: Scalars["Boolean"]["output"];
+	hasPreviousPage: Scalars["Boolean"]["output"];
+	integrationTags?: Maybe<Array<Maybe<Scalars["String"]["output"]>>>;
+	pages: Array<Page>;
+	resultsReturned: Scalars["Int"]["output"];
+	search?: Maybe<Scalars["String"]["output"]>;
+	skip?: Maybe<Scalars["Int"]["output"]>;
+	sort?: Maybe<Scalars["String"]["output"]>;
+	sortDesc?: Maybe<Scalars["Boolean"]["output"]>;
+	startCursor: Scalars["String"]["output"];
+	top?: Maybe<Scalars["Int"]["output"]>;
+};
+
+/** Extended PageInfo type that includes executionStatusIds and dateRange, for ProcessExecutionConnection */
+export type PageInfoProcessExecution = {
+	__typename?: "PageInfoProcessExecution";
+	currentPage: Scalars["Int"]["output"];
+	dateRange?: Maybe<DateRange>;
+	endCursor: Scalars["String"]["output"];
+	executionStatusIds?: Maybe<Array<Maybe<Scalars["ID"]["output"]>>>;
+	hasNextPage: Scalars["Boolean"]["output"];
+	hasPreviousPage: Scalars["Boolean"]["output"];
+	pages: Array<Page>;
+	resultsReturned: Scalars["Int"]["output"];
+	search?: Maybe<Scalars["String"]["output"]>;
+	skip?: Maybe<Scalars["Int"]["output"]>;
+	sort?: Maybe<Scalars["String"]["output"]>;
+	sortDesc?: Maybe<Scalars["Boolean"]["output"]>;
+	startCursor: Scalars["String"]["output"];
+	top?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type PageInfoScheduledProcess = {
+	__typename?: "PageInfoScheduledProcess";
+	currentPage: Scalars["Int"]["output"];
+	daysOfTheWeek?: Maybe<Array<Maybe<Scalars["String"]["output"]>>>;
+	endCursor: Scalars["String"]["output"];
+	hasNextPage: Scalars["Boolean"]["output"];
+	hasPreviousPage: Scalars["Boolean"]["output"];
+	pages: Array<Page>;
+	resultsReturned: Scalars["Int"]["output"];
+	search?: Maybe<Scalars["String"]["output"]>;
+	skip?: Maybe<Scalars["Int"]["output"]>;
+	sort?: Maybe<Scalars["String"]["output"]>;
+	sortDesc?: Maybe<Scalars["Boolean"]["output"]>;
+	startCursor: Scalars["String"]["output"];
+	top?: Maybe<Scalars["Int"]["output"]>;
+};
+
 export type PaginationSettings = {
 	__typename?: "PaginationSettings";
 	resultsPerPage?: Maybe<Scalars["String"]["output"]>;
@@ -3471,6 +4739,30 @@ export type PaymentsSettings = {
 	paymentProviders?: Maybe<Scalars["String"]["output"]>;
 };
 
+export type PerformanceTracker = {
+	__typename?: "PerformanceTracker";
+	interval?: Maybe<Scalars["Int"]["output"]>;
+	/** Unit of interval (e.g. seconds) 0 = s, 1 = m, 2 = h */
+	intervalUnit?: Maybe<Scalars["Int"]["output"]>;
+	performanceTracker?: Maybe<Array<Maybe<PerformanceTrackerUnit>>>;
+	/** e.g. 45m, 24h */
+	period?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type PerformanceTrackerUnit = {
+	__typename?: "PerformanceTrackerUnit";
+	/** Processes created within interval */
+	created?: Maybe<Scalars["Int"]["output"]>;
+	endDate?: Maybe<Scalars["DateTime"]["output"]>;
+	/** Processes executed completely within interval (succeeded + failed) */
+	executed?: Maybe<Scalars["Int"]["output"]>;
+	/** Process executions errored within interval */
+	failed?: Maybe<Scalars["Int"]["output"]>;
+	startDate?: Maybe<Scalars["DateTime"]["output"]>;
+	/** Process executions completed successfully within interval */
+	succeeded?: Maybe<Scalars["Int"]["output"]>;
+};
+
 export type Phone = Node & {
 	__typename?: "Phone";
 	account: Account;
@@ -3586,7 +4878,6 @@ export type PriceGroup = Node & {
 	type?: Maybe<PriceGroupType>;
 };
 
-/** Represents attribute assigned to the product. It's more like fact which means attribute with value. */
 export type PriceGroupListPrice = {
 	__typename?: "PriceGroupListPrice";
 	GroupSetId?: Maybe<Scalars["String"]["output"]>;
@@ -3652,6 +4943,699 @@ export type PriceMethodInput = {
 	top?: InputMaybe<Scalars["Int"]["input"]>;
 };
 
+export type Process = {
+	__typename?: "Process";
+	allowParallelProcessExecution?: Maybe<Scalars["Int"]["output"]>;
+	allowParallelTaskExecution?: Maybe<Scalars["Int"]["output"]>;
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	isScheduled?: Maybe<Scalars["Int"]["output"]>;
+	isTriggered?: Maybe<Scalars["Int"]["output"]>;
+	maxConcurrentExecutions?: Maybe<Scalars["Int"]["output"]>;
+	maxRetryAttempts: Scalars["Int"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	nextExecutionDate?: Maybe<Scalars["DateTime"]["output"]>;
+	orchestratorInstanceId?: Maybe<Scalars["ID"]["output"]>;
+	previousExecutionDate?: Maybe<Scalars["DateTime"]["output"]>;
+	processIcon?: Maybe<Scalars["String"]["output"]>;
+	processScheduleGroup?: Maybe<ProcessScheduleGroup>;
+	processTasks?: Maybe<Array<Maybe<ProcessTask>>>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	timeout?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessConfigMerge = {
+	config?: InputMaybe<Array<InputMaybe<ConfigMerge>>>;
+};
+
+export type ProcessConnection = {
+	__typename?: "ProcessConnection";
+	edges: Array<ProcessEdge>;
+	nodes?: Maybe<Array<Maybe<Process>>>;
+	pageInfo: PageInfoProcess;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessCreate = {
+	allowParallelProcessExecution?: InputMaybe<Scalars["Int"]["input"]>;
+	allowParallelTaskExecution?: InputMaybe<Scalars["Int"]["input"]>;
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	isTriggered?: InputMaybe<Scalars["Boolean"]["input"]>;
+	maxConcurrentExecutions?: InputMaybe<Scalars["Int"]["input"]>;
+	maxRetryAttempts?: InputMaybe<Scalars["Int"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	orchestratorInstanceId?: InputMaybe<Scalars["ID"]["input"]>;
+	processIcon?: InputMaybe<Scalars["String"]["input"]>;
+	processScheduleGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type ProcessEdge = {
+	__typename?: "ProcessEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: Process;
+};
+
+export type ProcessExecution = {
+	__typename?: "ProcessExecution";
+	allowParallelProcessExecution?: Maybe<Scalars["Int"]["output"]>;
+	allowParallelTaskExecution?: Maybe<Scalars["Int"]["output"]>;
+	attempt: Scalars["Int"]["output"];
+	code?: Maybe<Scalars["String"]["output"]>;
+	copyFromId?: Maybe<Scalars["ID"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	endDate?: Maybe<Scalars["DateTime"]["output"]>;
+	executionStatus?: Maybe<ExecutionStatus>;
+	executionStatusMessage?: Maybe<Scalars["String"]["output"]>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	messageSize?: Maybe<Scalars["Float"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	process?: Maybe<Process>;
+	processBatchId?: Maybe<Scalars["ID"]["output"]>;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+	retryProcessBatchId?: Maybe<Scalars["ID"]["output"]>;
+	scheduledDate?: Maybe<Scalars["DateTime"]["output"]>;
+	startDate?: Maybe<Scalars["DateTime"]["output"]>;
+	timeout?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessExecutionConnection = {
+	__typename?: "ProcessExecutionConnection";
+	edges: Array<ProcessExecutionEdge>;
+	nodes?: Maybe<Array<Maybe<ProcessExecution>>>;
+	pageInfo: PageInfoProcessExecution;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessExecutionDetails = {
+	__typename?: "ProcessExecutionDetails";
+	allowParallelProcessExecution?: Maybe<Scalars["Int"]["output"]>;
+	allowParallelTaskExecution?: Maybe<Scalars["Int"]["output"]>;
+	attempt: Scalars["Int"]["output"];
+	code?: Maybe<Scalars["String"]["output"]>;
+	copyFromId?: Maybe<Scalars["ID"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	endDate?: Maybe<Scalars["DateTime"]["output"]>;
+	executionStatus?: Maybe<ExecutionStatus>;
+	executionStatusMessage?: Maybe<Scalars["String"]["output"]>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	messageSize?: Maybe<Scalars["Float"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	processTaskExecutions?: Maybe<Array<Maybe<ProcessTaskExecution>>>;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+	retryProcessBatchId?: Maybe<Scalars["ID"]["output"]>;
+	scheduledDate?: Maybe<Scalars["DateTime"]["output"]>;
+	startDate?: Maybe<Scalars["DateTime"]["output"]>;
+	timeout?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessExecutionEdge = {
+	__typename?: "ProcessExecutionEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: ProcessExecution;
+};
+
+export type ProcessExecutionInput = {
+	after?: InputMaybe<Scalars["String"]["input"]>;
+	dateRange?: InputMaybe<DateRangeInput>;
+	/** Requires IDs in list to be one of [300, 400, 450, 500, 999] */
+	executionStatusIds?: InputMaybe<Array<InputMaybe<Scalars["Int"]["input"]>>>;
+	search?: InputMaybe<Scalars["String"]["input"]>;
+	skip?: InputMaybe<Scalars["Int"]["input"]>;
+	sort?: InputMaybe<Scalars["String"]["input"]>;
+	sortDesc?: InputMaybe<Scalars["Boolean"]["input"]>;
+	top?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type ProcessExport = {
+	__typename?: "ProcessExport";
+	AllowParallelProcessExecution?: Maybe<Scalars["Boolean"]["output"]>;
+	AllowParallelTaskExecution?: Maybe<Scalars["Boolean"]["output"]>;
+	IsTriggered?: Maybe<Scalars["Boolean"]["output"]>;
+	MaxConcurrentExecutions?: Maybe<Scalars["Int"]["output"]>;
+	MaxRetryAttempts?: Maybe<Scalars["Int"]["output"]>;
+	Name?: Maybe<Scalars["String"]["output"]>;
+	OrchestratorInstanceId?: Maybe<Scalars["ID"]["output"]>;
+	Process?: Maybe<Scalars["String"]["output"]>;
+	ProcessIcon?: Maybe<Scalars["String"]["output"]>;
+	ProcessId?: Maybe<Scalars["ID"]["output"]>;
+	ProcessScheduleGroup?: Maybe<ProcessScheduleGroupExport>;
+	ProcessTasks?: Maybe<Array<Maybe<ProcessTaskExport>>>;
+};
+
+export type ProcessImport = {
+	AllowParallelProcessExecution?: InputMaybe<Scalars["Boolean"]["input"]>;
+	AllowParallelTaskExecution?: InputMaybe<Scalars["Boolean"]["input"]>;
+	IsTriggered?: InputMaybe<Scalars["Boolean"]["input"]>;
+	MaxConcurrentExecutions?: InputMaybe<Scalars["Int"]["input"]>;
+	MaxRetryAttempts?: InputMaybe<Scalars["Int"]["input"]>;
+	Name?: InputMaybe<Scalars["String"]["input"]>;
+	OrchestratorInstanceId?: InputMaybe<Scalars["ID"]["input"]>;
+	Process?: InputMaybe<Scalars["String"]["input"]>;
+	ProcessIcon?: InputMaybe<Scalars["String"]["input"]>;
+	ProcessId?: InputMaybe<Scalars["ID"]["input"]>;
+	ProcessScheduleGroup?: InputMaybe<ProcessScheduleGroupImport>;
+	/** If a ProcessTask of a separate Process is included, it is updated to be under this Process. */
+	ProcessTasks?: InputMaybe<Array<InputMaybe<ProcessTaskImport>>>;
+	Sort?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type ProcessInput = {
+	after?: InputMaybe<Scalars["String"]["input"]>;
+	/** Requires that strings in list are one of ['Schedule Pending', 'Scheduled', 'Triggered'] */
+	integrationTags?: InputMaybe<Array<InputMaybe<Scalars["String"]["input"]>>>;
+	search?: InputMaybe<Scalars["String"]["input"]>;
+	skip?: InputMaybe<Scalars["Int"]["input"]>;
+	sort?: InputMaybe<Scalars["String"]["input"]>;
+	sortDesc?: InputMaybe<Scalars["Boolean"]["input"]>;
+	top?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type ProcessRun = {
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	processExecutionId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type ProcessSchedule = {
+	__typename?: "ProcessSchedule";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	description?: Maybe<Scalars["String"]["output"]>;
+	endDate?: Maybe<Scalars["DateTime"]["output"]>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	interval?: Maybe<Scalars["Int"]["output"]>;
+	intervalTypeId?: Maybe<Scalars["ID"]["output"]>;
+	intervalUnit?: Maybe<Scalars["String"]["output"]>;
+	intervalUnitId?: Maybe<Scalars["ID"]["output"]>;
+	isFriday?: Maybe<Scalars["Boolean"]["output"]>;
+	isMonday?: Maybe<Scalars["Boolean"]["output"]>;
+	isSaturday?: Maybe<Scalars["Boolean"]["output"]>;
+	isSunday?: Maybe<Scalars["Boolean"]["output"]>;
+	isThursday?: Maybe<Scalars["Boolean"]["output"]>;
+	isTuesday?: Maybe<Scalars["Boolean"]["output"]>;
+	isWednesday?: Maybe<Scalars["Boolean"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	nextExecutionDate?: Maybe<Scalars["DateTime"]["output"]>;
+	onceDateTime?: Maybe<Scalars["DateTime"]["output"]>;
+	previousExecutionDate?: Maybe<Scalars["DateTime"]["output"]>;
+	process?: Maybe<Process>;
+	processScheduleGroup?: Maybe<ProcessScheduleGroup>;
+	startDate?: Maybe<Scalars["DateTime"]["output"]>;
+};
+
+export type ProcessScheduleConnection = {
+	__typename?: "ProcessScheduleConnection";
+	edges: Array<ProcessScheduleEdge>;
+	nodes?: Maybe<Array<Maybe<ProcessSchedule>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessScheduleCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	description?: InputMaybe<Scalars["String"]["input"]>;
+	endDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	interval?: InputMaybe<Scalars["Int"]["input"]>;
+	intervalTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	intervalUnit?: InputMaybe<Scalars["String"]["input"]>;
+	intervalUnitId?: InputMaybe<Scalars["ID"]["input"]>;
+	isFriday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isMonday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isSaturday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isSunday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isThursday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isTuesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isWednesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	nextExecutionDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	onceDateTime?: InputMaybe<Scalars["DateTime"]["input"]>;
+	previousExecutionDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	processId?: InputMaybe<Scalars["ID"]["input"]>;
+	processScheduleGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	startDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+};
+
+export type ProcessScheduleDetails = {
+	__typename?: "ProcessScheduleDetails";
+	id: Scalars["ID"]["output"];
+	processes?: Maybe<Array<Maybe<Process>>>;
+};
+
+export type ProcessScheduleEdge = {
+	__typename?: "ProcessScheduleEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: ProcessSchedule;
+};
+
+export type ProcessScheduleGroup = {
+	__typename?: "ProcessScheduleGroup";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	id: Scalars["ID"]["output"];
+	isDisabled?: Maybe<Scalars["Int"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type ProcessScheduleGroupDetails = {
+	__typename?: "ProcessScheduleGroupDetails";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	id: Scalars["ID"]["output"];
+	interval?: Maybe<Scalars["Int"]["output"]>;
+	intervalTypeId?: Maybe<Scalars["ID"]["output"]>;
+	intervalUnitId?: Maybe<Scalars["ID"]["output"]>;
+	isDisabled?: Maybe<Scalars["Boolean"]["output"]>;
+	isFriday?: Maybe<Scalars["Boolean"]["output"]>;
+	isMonday?: Maybe<Scalars["Boolean"]["output"]>;
+	isSaturday?: Maybe<Scalars["Boolean"]["output"]>;
+	isSunday?: Maybe<Scalars["Boolean"]["output"]>;
+	isThursday?: Maybe<Scalars["Boolean"]["output"]>;
+	isTuesday?: Maybe<Scalars["Boolean"]["output"]>;
+	isWednesday?: Maybe<Scalars["Boolean"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	processSchedule?: Maybe<ProcessScheduleDetails>;
+	startDate?: Maybe<Scalars["DateTime"]["output"]>;
+};
+
+export type ProcessScheduleGroupDetailsCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	interval?: InputMaybe<Scalars["Int"]["input"]>;
+	intervalTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	intervalUnitId?: InputMaybe<Scalars["ID"]["input"]>;
+	isDisabled?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isFriday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isMonday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isSaturday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isSunday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isThursday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isTuesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isWednesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	/** Requires at least one Process to create a schedule group. */
+	processes: Array<ProcessScheduleGroupDetailsProcessInput>;
+	startDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+};
+
+export type ProcessScheduleGroupDetailsProcessInput = {
+	id: Scalars["ID"]["input"];
+	sort: Scalars["Int"]["input"];
+};
+
+export type ProcessScheduleGroupDetailsUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	id: Scalars["ID"]["input"];
+	interval?: InputMaybe<Scalars["Int"]["input"]>;
+	intervalTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	intervalUnitId?: InputMaybe<Scalars["ID"]["input"]>;
+	isDisabled?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isFriday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isMonday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isSaturday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isSunday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isThursday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isTuesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isWednesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	/** If updating processes, at least one Process must be provided in the list. */
+	processes?: InputMaybe<Array<ProcessScheduleGroupDetailsProcessInput>>;
+	startDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+};
+
+export type ProcessScheduleGroupExport = {
+	__typename?: "ProcessScheduleGroupExport";
+	EndDate?: Maybe<Scalars["DateTime"]["output"]>;
+	IsDisabled?: Maybe<Scalars["Boolean"]["output"]>;
+	IsFriday?: Maybe<Scalars["Boolean"]["output"]>;
+	IsMonday?: Maybe<Scalars["Boolean"]["output"]>;
+	IsSaturday?: Maybe<Scalars["Boolean"]["output"]>;
+	IsSunday?: Maybe<Scalars["Boolean"]["output"]>;
+	IsThursday?: Maybe<Scalars["Boolean"]["output"]>;
+	IsTuesday?: Maybe<Scalars["Boolean"]["output"]>;
+	IsWednesday?: Maybe<Scalars["Boolean"]["output"]>;
+	Name?: Maybe<Scalars["String"]["output"]>;
+	ProcessSchedule?: Maybe<Scalars["String"]["output"]>;
+	ProcessScheduleGroup?: Maybe<Scalars["String"]["output"]>;
+	ProcessScheduleGroupId?: Maybe<Scalars["ID"]["output"]>;
+	ProcessScheduleId?: Maybe<Scalars["ID"]["output"]>;
+	SchedulePeriod?: Maybe<Scalars["String"]["output"]>;
+	Sort?: Maybe<Scalars["Int"]["output"]>;
+	StartDate?: Maybe<Scalars["DateTime"]["output"]>;
+};
+
+export type ProcessScheduleGroupImport = {
+	EndDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	IsDisabled?: InputMaybe<Scalars["Boolean"]["input"]>;
+	IsFriday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	IsMonday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	IsSaturday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	IsSunday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	IsThursday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	IsTuesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	IsWednesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	Name?: InputMaybe<Scalars["String"]["input"]>;
+	ProcessSchedule?: InputMaybe<Scalars["String"]["input"]>;
+	ProcessScheduleGroup?: InputMaybe<Scalars["String"]["input"]>;
+	ProcessScheduleGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	ProcessScheduleId?: InputMaybe<Scalars["ID"]["input"]>;
+	SchedulePeriod?: InputMaybe<Scalars["String"]["input"]>;
+	Sort?: InputMaybe<Scalars["Int"]["input"]>;
+	StartDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+};
+
+export type ProcessScheduleUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	description?: InputMaybe<Scalars["String"]["input"]>;
+	endDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	interval?: InputMaybe<Scalars["Int"]["input"]>;
+	intervalTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	intervalUnit?: InputMaybe<Scalars["String"]["input"]>;
+	intervalUnitId?: InputMaybe<Scalars["ID"]["input"]>;
+	isFriday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isMonday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isSaturday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isSunday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isThursday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isTuesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	isWednesday?: InputMaybe<Scalars["Boolean"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	nextExecutionDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	onceDateTime?: InputMaybe<Scalars["DateTime"]["input"]>;
+	previousExecutionDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	processId?: InputMaybe<Scalars["ID"]["input"]>;
+	processScheduleGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	startDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+};
+
+export type ProcessTask = {
+	__typename?: "ProcessTask";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	endpoint?: Maybe<Endpoint>;
+	executionProcedure?: Maybe<Scalars["String"]["output"]>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	maxEndpointMessageAttempts?: Maybe<Scalars["Int"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	orchestrationType?: Maybe<OrchestrationType>;
+	parallelProcessingGroup?: Maybe<Scalars["Int"]["output"]>;
+	params?: Maybe<Scalars["JSON"]["output"]>;
+	postExecutionProcedure?: Maybe<Scalars["String"]["output"]>;
+	preExecutionProcedure?: Maybe<Scalars["String"]["output"]>;
+	process: Process;
+	processTaskType?: Maybe<ProcessTaskType>;
+	properties?: Maybe<Scalars["JSON"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessTaskConnection = {
+	__typename?: "ProcessTaskConnection";
+	edges: Array<ProcessTaskEdge>;
+	nodes?: Maybe<Array<Maybe<ProcessTask>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessTaskCreate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	endpointId?: InputMaybe<Scalars["ID"]["input"]>;
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	orchestrationTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	parallelProcessingGroup?: InputMaybe<Scalars["Int"]["input"]>;
+	params?: InputMaybe<Scalars["String"]["input"]>;
+	postExecutionProcedure?: InputMaybe<Scalars["String"]["input"]>;
+	preExecutionProcedure?: InputMaybe<Scalars["String"]["input"]>;
+	processId: Scalars["ID"]["input"];
+	processTaskTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type ProcessTaskEdge = {
+	__typename?: "ProcessTaskEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: ProcessTask;
+};
+
+export type ProcessTaskExecution = {
+	__typename?: "ProcessTaskExecution";
+	code?: Maybe<Scalars["String"]["output"]>;
+	copyFromId?: Maybe<Scalars["ID"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	endDate?: Maybe<Scalars["DateTime"]["output"]>;
+	endpoint?: Maybe<Endpoint>;
+	executionStatus?: Maybe<ExecutionStatus>;
+	executionStatusMessage?: Maybe<Scalars["String"]["output"]>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	maxEndpointMessageAttempts?: Maybe<Scalars["Int"]["output"]>;
+	messageSize?: Maybe<Scalars["Int"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	orchestrationType?: Maybe<OrchestrationType>;
+	parallelProcessingGroup?: Maybe<Scalars["Int"]["output"]>;
+	params?: Maybe<Scalars["String"]["output"]>;
+	postExecutionProcedure?: Maybe<Scalars["String"]["output"]>;
+	preExecutionProcedure?: Maybe<Scalars["String"]["output"]>;
+	processExecution?: Maybe<ProcessExecution>;
+	processTask?: Maybe<ProcessTask>;
+	processTaskType?: Maybe<ProcessTaskType>;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	startDate?: Maybe<Scalars["DateTime"]["output"]>;
+};
+
+export type ProcessTaskExport = {
+	__typename?: "ProcessTaskExport";
+	Endpoint?: Maybe<Scalars["String"]["output"]>;
+	Name?: Maybe<Scalars["String"]["output"]>;
+	OrchestrationType?: Maybe<Scalars["String"]["output"]>;
+	ParallelProcessingGroup?: Maybe<Scalars["Int"]["output"]>;
+	Params?: Maybe<Scalars["String"]["output"]>;
+	PostExecutionProcedure?: Maybe<Scalars["String"]["output"]>;
+	PreExecutionProcedure?: Maybe<Scalars["String"]["output"]>;
+	ProcessTask?: Maybe<Scalars["String"]["output"]>;
+	ProcessTaskId?: Maybe<Scalars["ID"]["output"]>;
+	ProcessTaskType?: Maybe<Scalars["String"]["output"]>;
+	Sort?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessTaskImport = {
+	Endpoint?: InputMaybe<Scalars["String"]["input"]>;
+	Name?: InputMaybe<Scalars["String"]["input"]>;
+	OrchestrationType?: InputMaybe<Scalars["String"]["input"]>;
+	ParallelProcessingGroup?: InputMaybe<Scalars["Int"]["input"]>;
+	Params?: InputMaybe<Scalars["String"]["input"]>;
+	PostExecutionProcedure?: InputMaybe<Scalars["String"]["input"]>;
+	PreExecutionProcedure?: InputMaybe<Scalars["String"]["input"]>;
+	ProcessTask?: InputMaybe<Scalars["String"]["input"]>;
+	ProcessTaskId?: InputMaybe<Scalars["ID"]["input"]>;
+	ProcessTaskType?: InputMaybe<Scalars["String"]["input"]>;
+	Properties?: InputMaybe<Scalars["JSON"]["input"]>;
+	Sort?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type ProcessTaskLink = {
+	__typename?: "ProcessTaskLink";
+	created: Scalars["DateTime"]["output"];
+	criteria?: Maybe<Scalars["String"]["output"]>;
+	destinationFlowId?: Maybe<Scalars["ID"]["output"]>;
+	destinationTask?: Maybe<ProcessTask>;
+	extendedFields?: Maybe<Scalars["JSON"]["output"]>;
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	sourceFlowId?: Maybe<Scalars["ID"]["output"]>;
+	sourceTask?: Maybe<ProcessTask>;
+};
+
+export type ProcessTaskLinkConnection = {
+	__typename?: "ProcessTaskLinkConnection";
+	edges: Array<ProcessTaskLinkEdge>;
+	nodes?: Maybe<Array<Maybe<ProcessTaskLink>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessTaskLinkCreate = {
+	destinationTaskId: Scalars["ID"]["input"];
+	/** New entry uses this ID. If omitted, generates a random ID. Make sure the ID is not in use already! */
+	id?: InputMaybe<Scalars["ID"]["input"]>;
+	sourceTaskId: Scalars["ID"]["input"];
+};
+
+export type ProcessTaskLinkEdge = {
+	__typename?: "ProcessTaskLinkEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: ProcessTaskLink;
+};
+
+export type ProcessTaskLinkUpdate = {
+	criteria?: InputMaybe<Scalars["String"]["input"]>;
+	destinationFlowId?: InputMaybe<Scalars["ID"]["input"]>;
+	destinationTaskId?: InputMaybe<Scalars["ID"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+	sourceFlowId?: InputMaybe<Scalars["ID"]["input"]>;
+	sourceTaskId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type ProcessTaskType = {
+	__typename?: "ProcessTaskType";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	paramSchema?: Maybe<Scalars["JSON"]["output"]>;
+};
+
+export type ProcessTaskTypeConnection = {
+	__typename?: "ProcessTaskTypeConnection";
+	edges: Array<ProcessTaskTypeEdge>;
+	nodes?: Maybe<Array<Maybe<ProcessTaskType>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessTaskTypeEdge = {
+	__typename?: "ProcessTaskTypeEdge";
+	cursor?: Maybe<Scalars["String"]["output"]>;
+	node: ProcessTaskType;
+};
+
+export type ProcessTaskUpdate = {
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	endpointId?: InputMaybe<Scalars["ID"]["input"]>;
+	executionProcedure?: InputMaybe<Scalars["String"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	maxEndpointMessageAttempts?: InputMaybe<Scalars["Int"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	orchestrationTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	parallelProcessingGroup?: InputMaybe<Scalars["Int"]["input"]>;
+	params?: InputMaybe<Scalars["JSON"]["input"]>;
+	postExecutionProcedure?: InputMaybe<Scalars["String"]["input"]>;
+	preExecutionProcedure?: InputMaybe<Scalars["String"]["input"]>;
+	processId?: InputMaybe<Scalars["ID"]["input"]>;
+	processTaskTypeId?: InputMaybe<Scalars["ID"]["input"]>;
+	properties?: InputMaybe<Scalars["String"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
+export type ProcessTemplate = {
+	__typename?: "ProcessTemplate";
+	created: Scalars["DateTime"]["output"];
+	id: Scalars["ID"]["output"];
+	isActive?: Maybe<Scalars["Boolean"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	pages?: Maybe<Array<Maybe<ProcessTemplatePage>>>;
+};
+
+export type ProcessTemplateConnection = {
+	__typename?: "ProcessTemplateConnection";
+	nodes?: Maybe<Array<Maybe<ProcessTemplate>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessTemplateFilter = {
+	processTemplateGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	processTemplateId?: InputMaybe<Scalars["ID"]["input"]>;
+};
+
+export type ProcessTemplateGroup = {
+	__typename?: "ProcessTemplateGroup";
+	id: Scalars["ID"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type ProcessTemplateGroupConnection = {
+	__typename?: "ProcessTemplateGroupConnection";
+	nodes?: Maybe<Array<Maybe<ProcessTemplateGroup>>>;
+	pageInfo: PageInfo;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessTemplateInput = {
+	__typename?: "ProcessTemplateInput";
+	created: Scalars["DateTime"]["output"];
+	fieldName?: Maybe<Scalars["String"]["output"]>;
+	helpText?: Maybe<Scalars["String"]["output"]>;
+	id: Scalars["ID"]["output"];
+	inputType?: Maybe<Scalars["String"]["output"]>;
+	isRequired?: Maybe<Scalars["Boolean"]["output"]>;
+	label?: Maybe<Scalars["String"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	placeholder?: Maybe<Scalars["String"]["output"]>;
+	queryName?: Maybe<Scalars["String"]["output"]>;
+	schemas?: Maybe<Array<Maybe<ProcessTemplateInputSchema>>>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	validationRegex?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type ProcessTemplateInputSchema = {
+	__typename?: "ProcessTemplateInputSchema";
+	defaultValue?: Maybe<Scalars["String"]["output"]>;
+	fieldKey?: Maybe<Scalars["String"]["output"]>;
+	id: Scalars["ID"]["output"];
+	inputType?: Maybe<Scalars["String"]["output"]>;
+	isRequired?: Maybe<Scalars["Boolean"]["output"]>;
+	label?: Maybe<Scalars["String"]["output"]>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ProcessTemplatePage = {
+	__typename?: "ProcessTemplatePage";
+	description?: Maybe<Scalars["String"]["output"]>;
+	id: Scalars["ID"]["output"];
+	inputs?: Maybe<Array<Maybe<ProcessTemplateInput>>>;
+	sort?: Maybe<Scalars["Int"]["output"]>;
+	title?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type ProcessUpdate = {
+	allowParallelProcessExecution?: InputMaybe<Scalars["Int"]["input"]>;
+	allowParallelTaskExecution?: InputMaybe<Scalars["Int"]["input"]>;
+	code?: InputMaybe<Scalars["String"]["input"]>;
+	extendedFields?: InputMaybe<Scalars["JSON"]["input"]>;
+	id: Scalars["ID"]["input"];
+	isTriggered?: InputMaybe<Scalars["Boolean"]["input"]>;
+	maxConcurrentExecutions?: InputMaybe<Scalars["Int"]["input"]>;
+	maxRetryAttempts?: InputMaybe<Scalars["Int"]["input"]>;
+	name?: InputMaybe<Scalars["String"]["input"]>;
+	nextExecutionDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	orchestratorInstanceId?: InputMaybe<Scalars["ID"]["input"]>;
+	previousExecutionDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	processIcon?: InputMaybe<Scalars["String"]["input"]>;
+	processScheduleGroupId?: InputMaybe<Scalars["ID"]["input"]>;
+	sort?: InputMaybe<Scalars["Int"]["input"]>;
+	timeout?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
 export type Product = Node & {
 	__typename?: "Product";
 	Available?: Maybe<Scalars["Int"]["output"]>;
@@ -3840,6 +5824,7 @@ export type ProductStatusMutationResponse = MutationResponse & {
 };
 
 export type ProductTypeaheadInput = {
+	categoryId?: InputMaybe<Scalars["String"]["input"]>;
 	orderBy?: InputMaybe<Scalars["String"]["input"]>;
 	search?: InputMaybe<Scalars["String"]["input"]>;
 	skip?: InputMaybe<Scalars["Int"]["input"]>;
@@ -3967,6 +5952,12 @@ export type Query = {
 	claims?: Maybe<Array<Maybe<Claim>>>;
 	claimsByRoleId?: Maybe<Array<Maybe<Claim>>>;
 	claimsByUserId?: Maybe<Array<Maybe<Claim>>>;
+	/**
+	 * Generate and export configuration as an object containing Depots, Entities, Endpoints, Processes.
+	 * processId specifies which Process to generate config for (default exports for all processes).
+	 * includeIds specifies whether to export ids (default does not export ids).
+	 */
+	configurationExport?: Maybe<ConfigExport>;
 	contact?: Maybe<Contact>;
 	contacts?: Maybe<ContactsConnection>;
 	contactsByType?: Maybe<ContactsConnection>;
@@ -3974,8 +5965,32 @@ export type Query = {
 	countries?: Maybe<Array<Country>>;
 	country?: Maybe<Country>;
 	currentPayment?: Maybe<CartPaymentToken>;
+	depotById?: Maybe<Depot>;
+	depotGroupById?: Maybe<DepotGroup>;
 	digitalInstanceList?: Maybe<Array<Maybe<DigitalInstance>>>;
 	digitalInstanceRead?: Maybe<DigitalInstance>;
+	documentById?: Maybe<Document>;
+	documentFieldById?: Maybe<DocumentField>;
+	documentFieldsByDocument?: Maybe<Array<Maybe<DocumentField>>>;
+	documentGroupById?: Maybe<DocumentGroup>;
+	documentTypeById?: Maybe<DocumentType>;
+	endpointById?: Maybe<Endpoint>;
+	endpointQueueById?: Maybe<EndpointQueue>;
+	endpointQueueStatusById?: Maybe<EndpointQueueStatus>;
+	endpointQueues?: Maybe<Array<Maybe<EndpointQueue>>>;
+	endpointStatusById?: Maybe<EndpointStatus>;
+	endpointSubscriptionById?: Maybe<EndpointSubscription>;
+	endpointSubscriptionsByQueue?: Maybe<Array<Maybe<EndpointSubscription>>>;
+	endpointTypeById?: Maybe<EndpointType>;
+	endpoints?: Maybe<EndpointConnection>;
+	entityById?: Maybe<Entity>;
+	entityFieldById?: Maybe<EntityField>;
+	entityFieldsByEntity?: Maybe<Array<Maybe<EntityField>>>;
+	entityGroupById?: Maybe<EntityGroup>;
+	entityTypeById?: Maybe<EntityType>;
+	executionStatusById?: Maybe<ExecutionStatus>;
+	fieldTypeById?: Maybe<FieldType>;
+	fieldTypes?: Maybe<Array<Maybe<FieldType>>>;
 	getAddress?: Maybe<Address>;
 	getAddressCount: Scalars["Int"]["output"];
 	getAddresses: Array<Maybe<Address>>;
@@ -4026,8 +6041,36 @@ export type Query = {
 	linkedAccounts?: Maybe<AccountConnection>;
 	mapping: Array<MappingField>;
 	me?: Maybe<Me>;
+	nonScheduledProcesses?: Maybe<NonScheduledProcessConnection>;
+	notificationById?: Maybe<NotificationIntegrate>;
+	notificationGroupById?: Maybe<NotificationGroup>;
+	notificationGroupTree?: Maybe<NotificationGroupTree>;
+	notificationGroups?: Maybe<NotificationGroupConnection>;
+	/** Get all notification groups in this group's subtree, excluding itself. */
+	notificationGroupsAllChildren?: Maybe<Array<Maybe<NotificationGroup>>>;
+	notificationGroupsByParent?: Maybe<NotificationGroupConnection>;
+	notificationTemplateById?: Maybe<NotificationTemplate>;
+	notificationTemplateTypeById?: Maybe<NotificationTemplateType>;
+	notificationTemplateTypes?: Maybe<Array<Maybe<NotificationTemplateType>>>;
+	notificationTemplates?: Maybe<Array<Maybe<NotificationTemplate>>>;
+	/** Get all notification templates in this template's subtree, excluding itself. */
+	notificationTemplatesAllChildren?: Maybe<Array<Maybe<NotificationTemplate>>>;
+	notificationTemplatesByParent?: Maybe<Array<Maybe<NotificationTemplate>>>;
 	notificationUnReadCount: Scalars["Int"]["output"];
 	notifications?: Maybe<NotificationConnection>;
+	notificationsAll?: Maybe<NotificationIntegrateConnection>;
+	notificationsByGroup?: Maybe<NotificationIntegrateConnection>;
+	orchestrationTypeById?: Maybe<OrchestrationType>;
+	orchestrationTypes?: Maybe<OrchestrationTypeConnection>;
+	/**
+	 * Retrieve performance data of integrations, including number executed, succeeded, failed, etc. over specified period.
+	 * interval is the number of intervalUnits for the period
+	 * intervalUnit is 0, 1, 2 for seconds, minutes, hours, respectively
+	 * E.g. interval = 24, intervalUnit = 2 --> 24h interval
+	 * length is number of intervals to retrieve, > 0
+	 * fromDate specifies the date up to which data is retrieved, null = today
+	 */
+	performanceTracker?: Maybe<PerformanceTracker>;
 	phone?: Maybe<Phone>;
 	phoneList?: Maybe<PhoneConnection>;
 	phoneType?: Maybe<PhoneType>;
@@ -4039,6 +6082,33 @@ export type Query = {
 	priceMethods?: Maybe<PriceMethodConnection>;
 	prices: Array<Price>;
 	primaryAddress?: Maybe<Address>;
+	processById?: Maybe<Process>;
+	processExecutionById?: Maybe<ProcessExecution>;
+	processExecutionDetails?: Maybe<ProcessExecutionDetails>;
+	processExecutions?: Maybe<ProcessExecutionConnection>;
+	processExecutionsByProcess?: Maybe<ProcessExecutionConnection>;
+	processScheduleById?: Maybe<ProcessSchedule>;
+	processScheduleGroupById?: Maybe<ProcessScheduleGroup>;
+	processScheduleGroupDetails?: Maybe<ProcessScheduleGroupDetails>;
+	processSchedules?: Maybe<ProcessScheduleConnection>;
+	processSchedulesByProcess?: Maybe<ProcessScheduleConnection>;
+	processTaskById?: Maybe<ProcessTask>;
+	/** ProcessTaskExecutions of a ProcessExecution ordered by (ParallelProcessingGroup, Sort) */
+	processTaskExecutionsByProcessExecution?: Maybe<
+		Array<Maybe<ProcessTaskExecution>>
+	>;
+	processTaskLinkById?: Maybe<ProcessTaskLink>;
+	processTaskLinks?: Maybe<ProcessTaskLinkConnection>;
+	processTaskLinksByDest?: Maybe<ProcessTaskLinkConnection>;
+	processTaskLinksBySource?: Maybe<ProcessTaskLinkConnection>;
+	processTaskTypeById?: Maybe<ProcessTaskType>;
+	processTaskTypes?: Maybe<ProcessTaskTypeConnection>;
+	processTasks?: Maybe<ProcessTaskConnection>;
+	processTasksByProcess?: Maybe<ProcessTaskConnection>;
+	processTemplate?: Maybe<Array<Maybe<ProcessTemplate>>>;
+	processTemplateGroups?: Maybe<ProcessTemplateGroupConnection>;
+	processTemplates?: Maybe<ProcessTemplateConnection>;
+	processes?: Maybe<ProcessConnection>;
 	product?: Maybe<Product>;
 	productEntities?: Maybe<ProductEntityConnection>;
 	productEntity?: Maybe<ProductEntity>;
@@ -4054,6 +6124,7 @@ export type Query = {
 	role?: Maybe<Role>;
 	roleByName?: Maybe<Role>;
 	roles: Array<Maybe<Role>>;
+	scheduledProcesses?: Maybe<ScheduledProcessConnection>;
 	searchArticles?: Maybe<Scalars["String"]["output"]>;
 	searchMedia?: Maybe<MediaConnection>;
 	searchWords: Array<SearchWord>;
@@ -4070,6 +6141,8 @@ export type Query = {
 	siteCatalog?: Maybe<CategoryConnection>;
 	siteComponent?: Maybe<SiteComponent>;
 	siteComponents?: Maybe<SiteComponentConnection>;
+	sitemap?: Maybe<Sitemap>;
+	sitemapSchedule?: Maybe<SitemapScheduleResponse>;
 	/**
 	 * Returns list of associated accounts.
 	 * accountId is optional and if not provided will equal the current account in session.
@@ -4090,6 +6163,7 @@ export type Query = {
 	unitOfMeasureGroups?: Maybe<UnitOfMeasureGroupConnection>;
 	unitOfMeasures?: Maybe<UnitOfMeasureConnection>;
 	usersInRole: Array<Maybe<Me>>;
+	validationFailureActionById?: Maybe<ValidationFailureAction>;
 	website: Website;
 	websites?: Maybe<WebsiteConnection>;
 	wishList?: Maybe<WishList>;
@@ -4242,6 +6316,12 @@ export type QueryClaimsByUserIdArgs = {
 	userId: Scalars["String"]["input"];
 };
 
+export type QueryConfigurationExportArgs = {
+	includeIds?: InputMaybe<Scalars["Boolean"]["input"]>;
+	processId?: InputMaybe<Scalars["ID"]["input"]>;
+	useSourceEndpoint?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+
 export type QueryContactArgs = {
 	id: Scalars["String"]["input"];
 };
@@ -4268,6 +6348,14 @@ export type QueryCountryArgs = {
 	id: Scalars["String"]["input"];
 };
 
+export type QueryDepotByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryDepotGroupByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
 export type QueryDigitalInstanceListArgs = {
 	input?: InputMaybe<DigitalInstanceListInput>;
 };
@@ -4276,6 +6364,86 @@ export type QueryDigitalInstanceReadArgs = {
 	id: Scalars["ID"]["input"];
 };
 
+export type QueryDocumentByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryDocumentFieldByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryDocumentFieldsByDocumentArgs = {
+	documentId: Scalars["ID"]["input"];
+};
+
+export type QueryDocumentGroupByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryDocumentTypeByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEndpointByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEndpointQueueByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEndpointQueueStatusByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEndpointStatusByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEndpointSubscriptionByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEndpointSubscriptionsByQueueArgs = {
+	endpointQueueId: Scalars["ID"]["input"];
+};
+
+export type QueryEndpointTypeByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEndpointsArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryEntityByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEntityFieldByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEntityFieldsByEntityArgs = {
+	entityId: Scalars["ID"]["input"];
+};
+
+export type QueryEntityGroupByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryEntityTypeByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryExecutionStatusByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryFieldTypeByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
 export type QueryGetAddressArgs = {
 	id?: InputMaybe<Scalars["String"]["input"]>;
 };
@@ -4433,6 +6601,56 @@ export type QueryMappingArgs = {
 	alias: Scalars["String"]["input"];
 };
 
+export type QueryNonScheduledProcessesArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryNotificationByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryNotificationGroupByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryNotificationGroupTreeArgs = {
+	rootId: Scalars["ID"]["input"];
+};
+
+export type QueryNotificationGroupsArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+	rootOnly?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+
+export type QueryNotificationGroupsAllChildrenArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryNotificationGroupsByParentArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+	parentId: Scalars["ID"]["input"];
+};
+
+export type QueryNotificationTemplateByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryNotificationTemplateTypeByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryNotificationTemplatesArgs = {
+	rootOnly?: InputMaybe<Scalars["Boolean"]["input"]>;
+};
+
+export type QueryNotificationTemplatesAllChildrenArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryNotificationTemplatesByParentArgs = {
+	parentId: Scalars["ID"]["input"];
+};
+
 export type QueryNotificationUnReadCountArgs = {
 	contactId?: InputMaybe<Scalars["ID"]["input"]>;
 };
@@ -4445,6 +6663,30 @@ export type QueryNotificationsArgs = {
 	sortDesc?: InputMaybe<Scalars["Boolean"]["input"]>;
 };
 
+export type QueryNotificationsAllArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryNotificationsByGroupArgs = {
+	groupId: Scalars["ID"]["input"];
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryOrchestrationTypeByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryOrchestrationTypesArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryPerformanceTrackerArgs = {
+	fromDate?: InputMaybe<Scalars["DateTime"]["input"]>;
+	interval?: InputMaybe<Scalars["Int"]["input"]>;
+	intervalUnit?: InputMaybe<Scalars["Int"]["input"]>;
+	length?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
 export type QueryPhoneArgs = {
 	id: Scalars["ID"]["input"];
 };
@@ -4473,6 +6715,107 @@ export type QueryPrimaryAddressArgs = {
 	id: Scalars["ID"]["input"];
 };
 
+export type QueryProcessByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryProcessExecutionByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryProcessExecutionDetailsArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryProcessExecutionsArgs = {
+	input?: InputMaybe<ProcessExecutionInput>;
+};
+
+export type QueryProcessExecutionsByProcessArgs = {
+	input?: InputMaybe<ProcessExecutionInput>;
+	processId: Scalars["ID"]["input"];
+};
+
+export type QueryProcessScheduleByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryProcessScheduleGroupByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryProcessScheduleGroupDetailsArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryProcessSchedulesArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryProcessSchedulesByProcessArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+	processId: Scalars["ID"]["input"];
+};
+
+export type QueryProcessTaskByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryProcessTaskExecutionsByProcessExecutionArgs = {
+	processExecutionId: Scalars["ID"]["input"];
+};
+
+export type QueryProcessTaskLinkByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryProcessTaskLinksArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryProcessTaskLinksByDestArgs = {
+	destId: Scalars["ID"]["input"];
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryProcessTaskLinksBySourceArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+	sourceId: Scalars["ID"]["input"];
+};
+
+export type QueryProcessTaskTypeByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
+export type QueryProcessTaskTypesArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryProcessTasksArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryProcessTasksByProcessArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+	processId: Scalars["ID"]["input"];
+};
+
+export type QueryProcessTemplateArgs = {
+	input?: InputMaybe<ProcessTemplateFilter>;
+};
+
+export type QueryProcessTemplateGroupsArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryProcessTemplatesArgs = {
+	input?: InputMaybe<FilterQueryInput>;
+};
+
+export type QueryProcessesArgs = {
+	input?: InputMaybe<ProcessInput>;
+};
+
 export type QueryProductArgs = {
 	id: Scalars["String"]["input"];
 	productLookupType?: ProductLookupType;
@@ -4547,6 +6890,10 @@ export type QueryRolesArgs = {
 	filter?: InputMaybe<CollectionRequestInput>;
 };
 
+export type QueryScheduledProcessesArgs = {
+	input?: InputMaybe<ScheduledProcessInput>;
+};
+
 export type QuerySearchMediaArgs = {
 	input?: InputMaybe<MediaQueryInput>;
 };
@@ -4589,6 +6936,14 @@ export type QuerySiteComponentArgs = {
 	id: Scalars["ID"]["input"];
 };
 
+export type QuerySitemapArgs = {
+	source: ApiSource;
+};
+
+export type QuerySitemapScheduleArgs = {
+	input: SitemapScheduleInput;
+};
+
 export type QuerySoboAccountListArgs = {
 	accountId?: InputMaybe<Scalars["ID"]["input"]>;
 	input?: InputMaybe<SoboAccountListInput>;
@@ -4622,6 +6977,10 @@ export type QueryUsersInRoleArgs = {
 	query: UserInRoleQuery;
 };
 
+export type QueryValidationFailureActionByIdArgs = {
+	id: Scalars["ID"]["input"];
+};
+
 export type QueryWebsiteArgs = {
 	id: Scalars["ID"]["input"];
 };
@@ -4829,6 +7188,13 @@ export type RoleClaimInput = {
 	roleId?: InputMaybe<Scalars["String"]["input"]>;
 };
 
+export type RunResult = {
+	__typename?: "RunResult";
+	id?: Maybe<Scalars["ID"]["output"]>;
+	message?: Maybe<Scalars["String"]["output"]>;
+	status?: Maybe<Scalars["Int"]["output"]>;
+};
+
 export type SalesRep = {
 	__typename?: "SalesRep";
 	AccountId: Scalars["ID"]["output"];
@@ -4859,6 +7225,47 @@ export type SavedCartsListConnection = {
 	recordCount?: Maybe<Scalars["Int"]["output"]>;
 };
 
+export type ScheduledProcess = {
+	__typename?: "ScheduledProcess";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	id: Scalars["ID"]["output"];
+	interval?: Maybe<Scalars["Int"]["output"]>;
+	intervalTypeId?: Maybe<Scalars["ID"]["output"]>;
+	intervalUnitId?: Maybe<Scalars["ID"]["output"]>;
+	isDisabled?: Maybe<Scalars["Boolean"]["output"]>;
+	isFriday?: Maybe<Scalars["Boolean"]["output"]>;
+	isMonday?: Maybe<Scalars["Boolean"]["output"]>;
+	isSaturday?: Maybe<Scalars["Boolean"]["output"]>;
+	isSunday?: Maybe<Scalars["Boolean"]["output"]>;
+	isThursday?: Maybe<Scalars["Boolean"]["output"]>;
+	isTuesday?: Maybe<Scalars["Boolean"]["output"]>;
+	isWednesday?: Maybe<Scalars["Boolean"]["output"]>;
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+	processScheduleGroup?: Maybe<ProcessScheduleGroup>;
+	scheduledIntegrations?: Maybe<Scalars["Int"]["output"]>;
+	startDate?: Maybe<Scalars["DateTime"]["output"]>;
+};
+
+export type ScheduledProcessConnection = {
+	__typename?: "ScheduledProcessConnection";
+	nodes?: Maybe<Array<Maybe<ScheduledProcess>>>;
+	pageInfo?: Maybe<PageInfoScheduledProcess>;
+	recordCount?: Maybe<Scalars["Int"]["output"]>;
+};
+
+export type ScheduledProcessInput = {
+	after?: InputMaybe<Scalars["String"]["input"]>;
+	/** Requires strings in list to be one of ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] */
+	daysOfTheWeek?: InputMaybe<Array<InputMaybe<Scalars["String"]["input"]>>>;
+	search?: InputMaybe<Scalars["String"]["input"]>;
+	skip?: InputMaybe<Scalars["Int"]["input"]>;
+	sort?: InputMaybe<Scalars["String"]["input"]>;
+	sortDesc?: InputMaybe<Scalars["Boolean"]["input"]>;
+	top?: InputMaybe<Scalars["Int"]["input"]>;
+};
+
 /**
  * Used as a routing or pre-defined access point for the alias.
  * Documents are stored in random indexes and accessed via commonly
@@ -4893,7 +7300,7 @@ export type SearchIndex = {
 export type SearchWord = {
 	__typename?: "SearchWord";
 	/** Name of the associated SearchAlias. If not populated then search word is global. */
-	alias: Scalars["String"]["output"];
+	alias?: Maybe<Scalars["String"]["output"]>;
 	/** Time data value when the search word was created */
 	createdAt: Scalars["String"]["output"];
 	/** Id of the user that created the search word */
@@ -5244,6 +7651,45 @@ export type SiteSettingInput = {
 	value?: InputMaybe<Scalars["String"]["input"]>;
 };
 
+export type Sitemap = {
+	__typename?: "Sitemap";
+	lastGenerated: Scalars["String"]["output"];
+	schedule?: Maybe<Scalars["String"]["output"]>;
+	source: ApiSource;
+	status?: Maybe<Scalars["String"]["output"]>;
+	url: Scalars["String"]["output"];
+};
+
+export type SitemapGenerationResponse = {
+	__typename?: "SitemapGenerationResponse";
+	code: Scalars["String"]["output"];
+	dateType: DataType;
+	generationType: GenerationType;
+	id: Scalars["ID"]["output"];
+	message: Scalars["String"]["output"];
+	source: ApiSource;
+};
+
+export type SitemapMutationResponse = MutationResponse & {
+	__typename?: "SitemapMutationResponse";
+	code: Scalars["String"]["output"];
+	message: Scalars["String"]["output"];
+	source: ApiSource;
+	success: Scalars["Boolean"]["output"];
+};
+
+export type SitemapScheduleInput = {
+	source: ApiSource;
+};
+
+export type SitemapScheduleResponse = {
+	__typename?: "SitemapScheduleResponse";
+	lastRunAt?: Maybe<Scalars["DateTime"]["output"]>;
+	nextRunAt?: Maybe<Scalars["DateTime"]["output"]>;
+	schedule: Scalars["String"]["output"];
+	source: ApiSource;
+};
+
 export type Sobo = {
 	__typename?: "Sobo";
 	AccountAttributes?: Maybe<Array<Maybe<AccountAttributes>>>;
@@ -5495,6 +7941,23 @@ export type TransactStatusWrapper = {
 	recordCount: Scalars["Int"]["output"];
 };
 
+export type TransformationExport = {
+	__typename?: "TransformationExport";
+	Enabled?: Maybe<Scalars["Int"]["output"]>;
+	JSLT?: Maybe<Scalars["String"]["output"]>;
+	Params?: Maybe<Scalars["String"]["output"]>;
+	Sort?: Maybe<Scalars["Int"]["output"]>;
+	TransformationType?: Maybe<Scalars["String"]["output"]>;
+};
+
+export type TransformationImport = {
+	Enabled?: InputMaybe<Scalars["Int"]["input"]>;
+	JSLT?: InputMaybe<Scalars["String"]["input"]>;
+	Params?: InputMaybe<Scalars["String"]["input"]>;
+	Sort?: InputMaybe<Scalars["Int"]["input"]>;
+	TransformationType?: InputMaybe<Scalars["String"]["input"]>;
+};
+
 export type Typography = {
 	__typename?: "Typography";
 	fontFamily?: Maybe<Scalars["String"]["output"]>;
@@ -5636,7 +8099,7 @@ export type UpdateCartInput = {
 export type UpdateCartLineInput = {
 	productId: Scalars["ID"]["input"];
 	quantity?: Scalars["Int"]["input"];
-	unitOfMeasureId: Scalars["ID"]["input"];
+	unitOfMeasureId?: InputMaybe<Scalars["ID"]["input"]>;
 };
 
 export type UpdateContactInput = {
@@ -5648,11 +8111,13 @@ export type UpdateContactInput = {
 
 /** Update document in the index */
 export type UpdateDocumentInput = {
+	/** Alias name of the active index that should be updated. Defaults to 'products' */
+	alias?: InputMaybe<Scalars["String"]["input"]>;
 	/** JSON representation of a document to update */
 	document?: InputMaybe<Scalars["GraphQLJSON"]["input"]>;
 	/** Id of the document to update */
 	id: Scalars["ID"]["input"];
-	/** Index name that should be updated. Defaults to 'products' */
+	/** Index name that should be updated. Used when alias is not provided */
 	index?: InputMaybe<Scalars["String"]["input"]>;
 };
 
@@ -5678,6 +8143,12 @@ export type UpdateProductStatusInput = {
 	name?: InputMaybe<Scalars["String"]["input"]>;
 };
 
+/** Input for scheduling automatic sitemap generation */
+export type UpdateSitemapScheduleInput = {
+	frequency: Scalars["String"]["input"];
+	source: ApiSource;
+};
+
 export type UpdateWebsiteMutationResponse = MutationResponse & {
 	__typename?: "UpdateWebsiteMutationResponse";
 	code: Scalars["String"]["output"];
@@ -5724,6 +8195,15 @@ export type UserRoleInput = {
 	userId: Scalars["ID"]["input"];
 };
 
+export type ValidationFailureAction = {
+	__typename?: "ValidationFailureAction";
+	code?: Maybe<Scalars["String"]["output"]>;
+	created: Scalars["DateTime"]["output"];
+	id: Scalars["ID"]["output"];
+	modified: Scalars["DateTime"]["output"];
+	name?: Maybe<Scalars["String"]["output"]>;
+};
+
 export type VariantOptions = {
 	__typename?: "VariantOptions";
 	cdnURL?: Maybe<Scalars["String"]["output"]>;
@@ -11590,7 +14070,7 @@ export type BulkMappingMutation = {
 		sortable: boolean;
 		suggestable: boolean;
 	}>;
-	deleteMappingFields: Array<{ __typename?: "MappingField"; id: string }>;
+	deleteMappingFields: Array<{ __typename?: "DeletedRecord"; id: string }>;
 };
 
 export type ClaimTypesQueryVariables = Exact<{
@@ -12352,7 +14832,7 @@ export type SearchWordsQuery = {
 	searchWords: Array<{
 		__typename?: "SearchWord";
 		id: string;
-		alias: string;
+		alias?: string | null;
 		searchWord: string;
 		status: string;
 		synonyms?: Array<{
@@ -12393,7 +14873,10 @@ export type DeleteSearchWordMutationVariables = Exact<{
 
 export type DeleteSearchWordMutation = {
 	__typename?: "Mutation";
-	deleteSearchWord?: { __typename?: "SearchWord"; id: string } | null;
+	deleteSearchWord?: Array<{
+		__typename?: "DeletedRecord";
+		id: string;
+	} | null> | null;
 };
 
 export type CreateSearchWordSynonymMutationVariables = Exact<{
@@ -12418,13 +14901,10 @@ export type DeleteSearchWordSynonymMutationVariables = Exact<{
 
 export type DeleteSearchWordSynonymMutation = {
 	__typename?: "Mutation";
-	deleteSearchWordSynonym?: {
-		__typename?: "SearchWordSynonym";
+	deleteSearchWordSynonym?: Array<{
+		__typename?: "DeletedRecord";
 		id: string;
-		searchWordId: string;
-		synonym: string;
-		status: string;
-	} | null;
+	} | null> | null;
 };
 
 export type StopWordsQueryVariables = Exact<{
@@ -34975,12 +37455,6 @@ export const DeleteSearchWordSynonymDocument = {
 							kind: "SelectionSet",
 							selections: [
 								{ kind: "Field", name: { kind: "Name", value: "id" } },
-								{
-									kind: "Field",
-									name: { kind: "Name", value: "searchWordId" },
-								},
-								{ kind: "Field", name: { kind: "Name", value: "synonym" } },
-								{ kind: "Field", name: { kind: "Name", value: "status" } },
 							],
 						},
 					},