@keystrokehq/shopify 0.0.11 → 0.0.16-integration-id-canonicalization.0

package/dist/update-shopify-product.operation-ByYhZggW.mjs

@@ -0,0 +1,1972 @@
+import { S as shopifyShopSchema, b as shopifyProductSchema, c as shopifyGlobalIdSchema, d as shopifyInventoryItemSchema, f as shopifyInventoryLevelSchema, i as shopifyConnectionNodesSchema, l as shopifyGraphqlErrorSchema, m as shopifyLocationSchema, n as shopifyBlogSchema, o as shopifyCustomerSchema, p as shopifyJobSchema, r as shopifyCollectionSchema, s as shopifyFulfillmentSchema, t as shopifyArticleSchema, v as shopifyOrderSchema, w as shopifyUserErrorSchema } from "./common-JZyHdK6p.mjs";
+import { t as shopifyCredentialSet } from "./shopify.credential-set-CaxST3GP.mjs";
+import { Operation } from "@keystrokehq/core";
+import { z } from "zod";
+import { CredentialRevokedError } from "@keystrokehq/core/errors";
+import { createAdminApiClient, createAdminRestApiClient } from "@shopify/admin-api-client";
+
+//#region src/schemas/collections.ts
+const collectionSelection = `
+  id
+  title
+  handle
+  descriptionHtml
+  updatedAt
+  image {
+    url
+    altText
+  }
+  seo {
+    title
+    description
+  }
+`;
+const collectionMutationInputSchema = z.object({
+	title: z.string().min(1).optional(),
+	handle: z.string().min(1).optional(),
+	descriptionHtml: z.string().optional(),
+	seo: z.object({
+		title: z.string().optional(),
+		description: z.string().optional()
+	}).optional()
+});
+const collectionMutationResponseSchema = z.object({
+	collection: shopifyCollectionSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const listCollectionsResponseSchema = z.object({ collections: shopifyConnectionNodesSchema(shopifyCollectionSchema) });
+const getCollectionResponseSchema = z.object({ collection: shopifyCollectionSchema.nullable() });
+const deleteCollectionResponseSchema = z.object({
+	deletedCollectionId: shopifyGlobalIdSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const removeProductsResponseSchema = z.object({
+	job: shopifyJobSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+
+//#endregion
+//#region src/utils/client.ts
+const DEFAULT_SHOPIFY_API_VERSION = "2025-01";
+function normalizeShopifyError(error, methodPath) {
+	if (error instanceof CredentialRevokedError) return error;
+	if (error instanceof Error) {
+		const maybeStatus = error;
+		const status = maybeStatus.status ?? maybeStatus.response?.status;
+		if (status === 401 || status === 403) return new CredentialRevokedError("shopify", `Shopify authentication failed while calling \`${methodPath}\`. The stored credentials for shopify may be revoked or expired.`);
+		if (status === 429) return new Error(`Shopify API throttled while calling \`${methodPath}\`: ${error.message}`, { cause: error });
+		return new Error(`Shopify API call failed while calling \`${methodPath}\`: ${error.message}`, { cause: error });
+	}
+	return /* @__PURE__ */ new Error(`Shopify API call failed while calling \`${methodPath}\`.`);
+}
+function createShopifyCredentialError(methodPath) {
+	return new CredentialRevokedError("shopify", `Shopify authentication failed while calling \`${methodPath}\`. The stored credentials for shopify may be revoked or expired.`);
+}
+function assertGraphqlSuccess(response, methodPath) {
+	const status = response.errors?.networkStatusCode;
+	if (status === 401 || status === 403) throw createShopifyCredentialError(methodPath);
+	if (status === 429) throw new Error(`Shopify API throttled while calling \`${methodPath}\`: ${response.errors?.message ?? "rate limited"}`);
+	if (response.errors?.graphQLErrors?.length) {
+		const messages = response.errors.graphQLErrors.map((error) => shopifyGraphqlErrorSchema.parse(error).message).join("; ");
+		throw new Error(`Shopify GraphQL errors while calling \`${methodPath}\`: ${messages}`);
+	}
+	if (response.errors?.message) throw new Error(`Shopify API call failed while calling \`${methodPath}\`: ${response.errors.message}`);
+	if (response.data === void 0) throw new Error(`Shopify API call returned no data while calling \`${methodPath}\`.`);
+}
+async function parseRestResponse(response, schema, methodPath) {
+	if (response.status === 401 || response.status === 403) throw createShopifyCredentialError(methodPath);
+	if (response.status === 429) throw new Error(`Shopify API throttled while calling \`${methodPath}\`.`);
+	const payload = response.status === 204 ? null : await response.json();
+	if (!response.ok) throw new Error(`Shopify REST API call failed while calling \`${methodPath}\`: HTTP ${response.status}`);
+	return schema.parse(payload);
+}
+function createShopifyClient(credentials) {
+	const graphqlClient = createAdminApiClient({
+		storeDomain: credentials.SHOPIFY_STORE_DOMAIN,
+		accessToken: credentials.SHOPIFY_ACCESS_TOKEN,
+		apiVersion: DEFAULT_SHOPIFY_API_VERSION
+	});
+	const restClient = createAdminRestApiClient({
+		storeDomain: credentials.SHOPIFY_STORE_DOMAIN,
+		accessToken: credentials.SHOPIFY_ACCESS_TOKEN,
+		apiVersion: DEFAULT_SHOPIFY_API_VERSION
+	});
+	async function rawGraphql(query, variables) {
+		try {
+			return await graphqlClient.request(query, { variables });
+		} catch (error) {
+			throw normalizeShopifyError(error, "graphql");
+		}
+	}
+	async function graphql(query, schema, options) {
+		const response = await rawGraphql(query, options?.variables);
+		assertGraphqlSuccess(response, "graphql");
+		return schema.parse(response.data);
+	}
+	async function rest(method, path, schema, options) {
+		const methodPath = `${method} ${path}`;
+		try {
+			switch (method) {
+				case "GET": return await parseRestResponse(await restClient.get(path, options), schema, methodPath);
+				case "POST": return await parseRestResponse(await restClient.post(path, {
+					...options,
+					data: options?.data ?? {}
+				}), schema, methodPath);
+				case "PUT": return await parseRestResponse(await restClient.put(path, {
+					...options,
+					data: options?.data ?? {}
+				}), schema, methodPath);
+				case "DELETE": return await parseRestResponse(await restClient.delete(path, options), schema, methodPath);
+			}
+		} catch (error) {
+			throw normalizeShopifyError(error, methodPath);
+		}
+	}
+	return {
+		rawGraphql,
+		graphql,
+		rest
+	};
+}
+
+//#endregion
+//#region src/utils/graphql-helpers.ts
+const shopifyPageInputSchema = z.object({
+	first: z.number().int().min(1).max(100).optional().default(25),
+	after: z.string().optional(),
+	query: z.string().optional()
+});
+const shopifyProductIdsInputSchema = z.array(shopifyGlobalIdSchema).min(1).max(250);
+function assertNoUserErrors(userErrors) {
+	if (userErrors.length === 0) return;
+	const message = userErrors.map((error) => error.field && error.field.length > 0 ? `${error.field.join(".")}: ${error.message}` : error.message).join("; ");
+	throw new Error(`Shopify mutation returned user errors: ${message}`);
+}
+function omitUndefined(input) {
+	return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+
+//#endregion
+//#region src/operations/add-products-to-shopify-collection.operation.ts
+const addProductsToCollectionOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.add-products-to-shopify-collection",
+	name: "Add Products To Shopify Collection",
+	description: "Add products to a manual Shopify collection.",
+	needsApproval: true,
+	input: z.object({
+		id: shopifyGlobalIdSchema,
+		productIds: shopifyProductIdsInputSchema
+	}),
+	output: shopifyCollectionSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation AddProductsToCollection($id: ID!, $productIds: [ID!]!) {
+          collectionAddProducts(id: $id, productIds: $productIds) {
+            collection {
+              ${collectionSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ collectionAddProducts: collectionMutationResponseSchema }), { variables: {
+			id: input.id,
+			productIds: input.productIds
+		} });
+		assertNoUserErrors(response.collectionAddProducts.userErrors);
+		if (!response.collectionAddProducts.collection) throw new Error(`Shopify did not return the updated collection: ${input.id}`);
+		return response.collectionAddProducts.collection;
+	}
+});
+
+//#endregion
+//#region src/schemas/inventory.ts
+const inventoryItemSelection = `
+  id
+  sku
+  tracked
+`;
+const inventoryLevelSelection = `
+  id
+  quantities(names: ["available", "committed", "incoming", "on_hand", "reserved"]) {
+    name
+    quantity
+  }
+  item {
+    ${inventoryItemSelection}
+  }
+  location {
+    id
+    name
+    isActive
+    fulfillsOnlineOrders
+  }
+`;
+const listInventoryItemsResponseSchema = z.object({ inventoryItems: shopifyConnectionNodesSchema(shopifyInventoryItemSchema) });
+const getInventoryItemResponseSchema = z.object({ inventoryItem: shopifyInventoryItemSchema.nullable() });
+const inventoryLevelsResponseSchema = z.object({ inventoryItem: z.object({ inventoryLevels: shopifyConnectionNodesSchema(shopifyInventoryLevelSchema) }).nullable() });
+const inventoryAdjustmentResponseSchema = z.object({
+	inventoryAdjustmentGroup: z.object({
+		createdAt: z.iso.datetime().optional(),
+		reason: z.string(),
+		referenceDocumentUri: z.string().nullable().optional(),
+		changes: z.array(z.object({
+			name: z.string(),
+			delta: z.number()
+		}))
+	}).nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+
+//#endregion
+//#region src/operations/adjust-shopify-inventory-quantities.operation.ts
+const adjustInventoryQuantitiesOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.adjust-shopify-inventory-quantities",
+	name: "Adjust Shopify Inventory Quantities",
+	description: "Adjust inventory quantities at specific Shopify locations.",
+	needsApproval: true,
+	input: z.object({
+		name: z.string().min(1).default("available"),
+		reason: z.string().min(1),
+		referenceDocumentUri: z.string().optional(),
+		changes: z.array(z.object({
+			inventoryItemId: shopifyGlobalIdSchema,
+			locationId: shopifyGlobalIdSchema,
+			delta: z.number().int()
+		})).min(1)
+	}),
+	output: z.object({
+		createdAt: z.iso.datetime().optional(),
+		reason: z.string(),
+		referenceDocumentUri: z.string().nullable().optional(),
+		changes: z.array(z.object({
+			name: z.string(),
+			delta: z.number()
+		}))
+	}),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation AdjustInventoryQuantities($input: InventoryAdjustQuantitiesInput!) {
+          inventoryAdjustQuantities(input: $input) {
+            inventoryAdjustmentGroup {
+              createdAt
+              reason
+              referenceDocumentUri
+              changes {
+                name
+                delta
+              }
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ inventoryAdjustQuantities: inventoryAdjustmentResponseSchema }), { variables: { input: {
+			name: input.name,
+			reason: input.reason,
+			referenceDocumentUri: input.referenceDocumentUri,
+			changes: input.changes
+		} } });
+		assertNoUserErrors(response.inventoryAdjustQuantities.userErrors);
+		if (!response.inventoryAdjustQuantities.inventoryAdjustmentGroup) throw new Error("Shopify did not return the inventory adjustment group.");
+		return response.inventoryAdjustQuantities.inventoryAdjustmentGroup;
+	}
+});
+
+//#endregion
+//#region src/schemas/orders.ts
+const orderSelection$1 = `
+  id
+  name
+  createdAt
+  updatedAt
+  cancelledAt
+  email
+  note
+  tags
+  displayFinancialStatus
+  displayFulfillmentStatus
+  currentTotalPriceSet {
+    shopMoney {
+      amount
+      currencyCode
+    }
+  }
+  customer {
+    id
+    displayName
+    firstName
+    lastName
+    email
+    phone
+    createdAt
+    updatedAt
+  }
+`;
+const orderLineItemVariantSchema = z.object({
+	variantId: shopifyGlobalIdSchema,
+	quantity: z.number().int().min(1)
+});
+const orderLineItemCustomSchema = z.object({
+	title: z.string().min(1),
+	quantity: z.number().int().min(1),
+	price: z.number().positive()
+});
+const orderCreateLineItemSchema = z.union([orderLineItemVariantSchema, orderLineItemCustomSchema]);
+const orderAddressSchema = z.object({
+	address1: z.string().min(1),
+	address2: z.string().optional(),
+	city: z.string().min(1),
+	province: z.string().optional(),
+	country: z.string().min(1),
+	zip: z.string().optional(),
+	firstName: z.string().optional(),
+	lastName: z.string().optional(),
+	phone: z.string().optional()
+});
+const orderMutationResponseSchema = z.object({
+	order: shopifyOrderSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const orderCreateUserErrorSchema = shopifyUserErrorSchema.extend({ code: z.string().optional() });
+const orderCancelUserErrorSchema = shopifyUserErrorSchema.extend({ code: z.string().optional() });
+const listOrdersResponseSchema = z.object({ orders: shopifyConnectionNodesSchema(shopifyOrderSchema) });
+const getOrderResponseSchema = z.object({ order: shopifyOrderSchema.nullable() });
+const createOrderResponseSchema = z.object({
+	order: shopifyOrderSchema.nullable(),
+	userErrors: z.array(orderCreateUserErrorSchema)
+});
+const cancelOrderResponseSchema = z.object({
+	job: shopifyJobSchema.nullable(),
+	orderCancelUserErrors: z.array(orderCancelUserErrorSchema)
+});
+const orderCreateInputSchema = z.object({
+	currency: z.string().length(3),
+	email: z.email().optional(),
+	note: z.string().optional(),
+	tags: z.array(z.string()).optional(),
+	customerId: shopifyGlobalIdSchema.optional(),
+	lineItems: z.array(orderCreateLineItemSchema).min(1)
+});
+const orderUpdateInputSchema = z.object({
+	id: shopifyGlobalIdSchema,
+	email: z.email().optional(),
+	note: z.string().optional(),
+	tags: z.array(z.string()).optional(),
+	shippingAddress: orderAddressSchema.optional()
+});
+const orderCancelReasonSchema = z.enum([
+	"CUSTOMER",
+	"DECLINED",
+	"FRAUD",
+	"INVENTORY",
+	"OTHER",
+	"STAFF"
+]);
+function buildOrderCreateLineItems(lineItems, currency) {
+	return lineItems.map((lineItem) => {
+		if ("variantId" in lineItem) return {
+			variantId: lineItem.variantId,
+			quantity: lineItem.quantity
+		};
+		return {
+			title: lineItem.title,
+			quantity: lineItem.quantity,
+			priceSet: { shopMoney: {
+				amount: lineItem.price,
+				currencyCode: currency
+			} }
+		};
+	});
+}
+
+//#endregion
+//#region src/operations/cancel-shopify-order.operation.ts
+const cancelOrderOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.cancel-shopify-order",
+	name: "Cancel Shopify Order",
+	description: "Cancel a Shopify order and return the asynchronous cancellation job.",
+	needsApproval: true,
+	input: z.object({
+		orderId: shopifyGlobalIdSchema,
+		reason: orderCancelReasonSchema,
+		restock: z.boolean(),
+		notifyCustomer: z.boolean().optional(),
+		staffNote: z.string().max(255).optional(),
+		refundMethod: z.object({ originalPaymentMethodsRefund: z.boolean().optional() }).optional()
+	}),
+	output: shopifyJobSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation CancelOrder(
+          $orderId: ID!
+          $reason: OrderCancelReason!
+          $restock: Boolean!
+          $notifyCustomer: Boolean
+          $staffNote: String
+          $refundMethod: OrderCancelRefundMethodInput
+        ) {
+          orderCancel(
+            orderId: $orderId
+            reason: $reason
+            restock: $restock
+            notifyCustomer: $notifyCustomer
+            staffNote: $staffNote
+            refundMethod: $refundMethod
+          ) {
+            job {
+              id
+              done
+            }
+            orderCancelUserErrors {
+              field
+              message
+              code
+            }
+          }
+        }
+      `, z.object({ orderCancel: cancelOrderResponseSchema }), { variables: omitUndefined(input) });
+		assertNoUserErrors(response.orderCancel.orderCancelUserErrors);
+		if (!response.orderCancel.job) throw new Error(`Shopify did not return a cancellation job for order: ${input.orderId}`);
+		return response.orderCancel.job;
+	}
+});
+
+//#endregion
+//#region src/schemas/articles.ts
+const blogSelection$1 = `
+  id
+  title
+  handle
+  createdAt
+  updatedAt
+  commentPolicy
+  templateSuffix
+`;
+const articleSelection = `
+  id
+  title
+  handle
+  blog {
+    ${blogSelection$1}
+  }
+  author {
+    name
+  }
+  body
+  summary
+  tags
+  image {
+    url
+    altText
+  }
+  publishedAt
+  updatedAt
+`;
+const articleMutationInputSchema = z.object({
+	blogId: shopifyGlobalIdSchema.optional(),
+	title: z.string().min(1).optional(),
+	handle: z.string().min(1).optional(),
+	body: z.string().optional(),
+	summary: z.string().optional(),
+	authorName: z.string().optional(),
+	isPublished: z.boolean().optional(),
+	publishDate: z.iso.datetime().optional(),
+	tags: z.array(z.string()).optional()
+});
+const articleResponseSchema = z.object({
+	id: shopifyGlobalIdSchema,
+	title: z.string(),
+	handle: z.string(),
+	blog: z.object({
+		id: shopifyGlobalIdSchema,
+		title: z.string(),
+		handle: z.string(),
+		createdAt: z.iso.datetime().optional(),
+		updatedAt: z.iso.datetime().optional(),
+		commentPolicy: z.string().nullable().optional(),
+		templateSuffix: z.string().nullable().optional()
+	}).nullable().optional(),
+	author: z.object({ name: z.string().nullable().optional() }).nullable().optional(),
+	body: z.string().nullable().optional(),
+	summary: z.string().nullable().optional(),
+	tags: z.array(z.string()).optional(),
+	image: z.object({
+		url: z.url(),
+		altText: z.string().nullable().optional()
+	}).nullable().optional(),
+	publishedAt: z.iso.datetime().nullable().optional(),
+	updatedAt: z.iso.datetime().optional()
+});
+const articleMutationPayloadSchema = z.object({
+	article: articleResponseSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema.extend({ code: z.string().optional() }))
+});
+const listArticlesResponseSchema = z.object({ articles: shopifyConnectionNodesSchema(articleResponseSchema) });
+const getArticleResponseSchema = z.object({ article: articleResponseSchema.nullable() });
+const deleteArticleResponseSchema = z.object({
+	deletedArticleId: shopifyGlobalIdSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema.extend({ code: z.string().optional() }))
+});
+function normalizeArticle(article) {
+	return {
+		id: article.id,
+		title: article.title,
+		handle: article.handle,
+		blog: article.blog ?? null,
+		author: article.author?.name ?? null,
+		body: article.body ?? null,
+		summary: article.summary ?? null,
+		tags: article.tags,
+		image: article.image ?? null,
+		publishedAt: article.publishedAt ?? null,
+		updatedAt: article.updatedAt
+	};
+}
+function buildArticleInput(input) {
+	return omitUndefined({
+		blogId: input.blogId,
+		title: input.title,
+		handle: input.handle,
+		body: input.body,
+		summary: input.summary,
+		author: input.authorName ? { name: input.authorName } : void 0,
+		isPublished: input.isPublished,
+		publishDate: input.publishDate,
+		tags: input.tags
+	});
+}
+
+//#endregion
+//#region src/operations/create-shopify-article.operation.ts
+const createArticleOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.create-shopify-article",
+	name: "Create Shopify Article",
+	description: "Create an article in the connected Shopify store.",
+	needsApproval: true,
+	input: articleMutationInputSchema.extend({
+		blogId: shopifyGlobalIdSchema,
+		title: z.string().min(1)
+	}),
+	output: shopifyArticleSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation CreateArticle($article: ArticleCreateInput!) {
+          articleCreate(article: $article) {
+            article {
+              ${articleSelection}
+            }
+            userErrors {
+              code
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ articleCreate: articleMutationPayloadSchema }), { variables: { article: buildArticleInput(input) } });
+		assertNoUserErrors(response.articleCreate.userErrors);
+		if (!response.articleCreate.article) throw new Error("Shopify did not return the created article.");
+		return normalizeArticle(response.articleCreate.article);
+	}
+});
+
+//#endregion
+//#region src/schemas/blogs.ts
+const blogSelection = `
+  id
+  title
+  handle
+  createdAt
+  updatedAt
+  commentPolicy
+  templateSuffix
+`;
+const blogCommentPolicySchema = z.enum([
+	"DISABLED",
+	"HIDDEN",
+	"MODERATED",
+	"OPEN"
+]);
+const blogMutationInputSchema = z.object({
+	title: z.string().min(1).optional(),
+	handle: z.string().min(1).optional(),
+	templateSuffix: z.string().optional(),
+	commentPolicy: blogCommentPolicySchema.optional()
+});
+const blogMutationResponseSchema = z.object({
+	blog: shopifyBlogSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema.extend({ code: z.string().optional() }))
+});
+const listBlogsResponseSchema = z.object({ blogs: shopifyConnectionNodesSchema(shopifyBlogSchema) });
+const getBlogResponseSchema = z.object({ blog: shopifyBlogSchema.nullable() });
+const deleteBlogResponseSchema = z.object({
+	deletedBlogId: shopifyGlobalIdSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema.extend({ code: z.string().optional() }))
+});
+
+//#endregion
+//#region src/operations/create-shopify-blog.operation.ts
+const createBlogOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.create-shopify-blog",
+	name: "Create Shopify Blog",
+	description: "Create a blog in the connected Shopify store.",
+	needsApproval: true,
+	input: blogMutationInputSchema.extend({ title: z.string().min(1) }),
+	output: shopifyBlogSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation CreateBlog($blog: BlogCreateInput!) {
+          blogCreate(blog: $blog) {
+            blog {
+              ${blogSelection}
+            }
+            userErrors {
+              code
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ blogCreate: blogMutationResponseSchema }), { variables: { blog: omitUndefined(input) } });
+		assertNoUserErrors(response.blogCreate.userErrors);
+		if (!response.blogCreate.blog) throw new Error("Shopify did not return the created blog.");
+		return response.blogCreate.blog;
+	}
+});
+
+//#endregion
+//#region src/operations/create-shopify-collection.operation.ts
+const createCollectionOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.create-shopify-collection",
+	name: "Create Shopify Collection",
+	description: "Create a collection in the connected Shopify store.",
+	needsApproval: true,
+	input: collectionMutationInputSchema.extend({ title: z.string().min(1) }),
+	output: shopifyCollectionSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation CreateCollection($input: CollectionInput!) {
+          collectionCreate(input: $input) {
+            collection {
+              ${collectionSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ collectionCreate: collectionMutationResponseSchema }), { variables: { input: omitUndefined(input) } });
+		assertNoUserErrors(response.collectionCreate.userErrors);
+		if (!response.collectionCreate.collection) throw new Error("Shopify did not return the created collection.");
+		return response.collectionCreate.collection;
+	}
+});
+
+//#endregion
+//#region src/schemas/customers.ts
+const customerSelection = `
+  id
+  displayName
+  firstName
+  lastName
+  email
+  phone
+  createdAt
+  updatedAt
+`;
+const orderSelection = `
+  id
+  name
+  createdAt
+  updatedAt
+  cancelledAt
+  email
+  note
+  tags
+  displayFinancialStatus
+  displayFulfillmentStatus
+  currentTotalPriceSet {
+    shopMoney {
+      amount
+      currencyCode
+    }
+  }
+  customer {
+    id
+    displayName
+    firstName
+    lastName
+    email
+    phone
+    createdAt
+    updatedAt
+  }
+`;
+const customerMutationInputSchema = z.object({
+	email: z.email().optional(),
+	firstName: z.string().optional(),
+	lastName: z.string().optional(),
+	phone: z.string().optional(),
+	note: z.string().optional(),
+	tags: z.array(z.string()).optional()
+});
+const customerMutationResponseSchema = z.object({
+	customer: shopifyCustomerSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const listCustomersResponseSchema = z.object({ customers: shopifyConnectionNodesSchema(shopifyCustomerSchema) });
+const getCustomerResponseSchema = z.object({ customer: shopifyCustomerSchema.nullable() });
+const customerDeleteResponseSchema = z.object({
+	deletedCustomerId: shopifyGlobalIdSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const customerOrdersResponseSchema = z.object({ customer: z.object({ orders: shopifyConnectionNodesSchema(shopifyOrderSchema) }).nullable() });
+
+//#endregion
+//#region src/operations/create-shopify-customer.operation.ts
+const createCustomerOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.create-shopify-customer",
+	name: "Create Shopify Customer",
+	description: "Create a customer in the connected Shopify store.",
+	needsApproval: true,
+	input: customerMutationInputSchema.refine((input) => input.email !== void 0 || input.phone !== void 0 || input.firstName !== void 0, { message: "At least one identifying customer field must be provided." }),
+	output: shopifyCustomerSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation CreateCustomer($input: CustomerInput!) {
+          customerCreate(input: $input) {
+            customer {
+              ${customerSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ customerCreate: customerMutationResponseSchema }), { variables: { input: omitUndefined(input) } });
+		assertNoUserErrors(response.customerCreate.userErrors);
+		if (!response.customerCreate.customer) throw new Error("Shopify did not return the created customer.");
+		return response.customerCreate.customer;
+	}
+});
+
+//#endregion
+//#region src/schemas/fulfillments.ts
+const fulfillmentSelection = `
+  id
+  status
+  trackingInfo {
+    number
+    url
+  }
+`;
+const fulfillmentOrderLineItemSchema = z.object({
+	id: shopifyGlobalIdSchema,
+	remainingQuantity: z.number().int(),
+	lineItem: z.object({
+		id: shopifyGlobalIdSchema,
+		name: z.string(),
+		quantity: z.number().int()
+	}).nullable().optional()
+});
+const fulfillmentOrderSchema = z.object({
+	id: shopifyGlobalIdSchema,
+	status: z.string(),
+	assignedLocation: z.object({ location: shopifyLocationSchema.nullable().optional() }).nullable().optional(),
+	lineItems: shopifyConnectionNodesSchema(fulfillmentOrderLineItemSchema)
+});
+const fulfillmentOrderConnectionSchema = z.object({ order: z.object({ fulfillmentOrders: shopifyConnectionNodesSchema(fulfillmentOrderSchema) }).nullable() });
+const fulfillmentResponseSchema = z.object({ fulfillment: shopifyFulfillmentSchema.nullable() });
+const fulfillmentCreatePayloadSchema = z.object({
+	fulfillment: shopifyFulfillmentSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+
+//#endregion
+//#region src/operations/create-shopify-fulfillment.operation.ts
+const createFulfillmentOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.create-shopify-fulfillment",
+	name: "Create Shopify Fulfillment",
+	description: "Create a fulfillment from one or more Shopify fulfillment orders.",
+	needsApproval: true,
+	input: z.object({
+		lineItemsByFulfillmentOrder: z.array(z.object({
+			fulfillmentOrderId: shopifyGlobalIdSchema,
+			fulfillmentOrderLineItems: z.array(z.object({
+				id: shopifyGlobalIdSchema,
+				quantity: z.number().int().min(1)
+			})).optional()
+		})).min(1),
+		notifyCustomer: z.boolean().optional(),
+		message: z.string().optional(),
+		trackingInfo: z.object({
+			company: z.string().optional(),
+			number: z.string().optional(),
+			url: z.url().optional()
+		}).optional()
+	}),
+	output: shopifyFulfillmentSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation CreateFulfillment($fulfillment: FulfillmentInput!, $message: String) {
+          fulfillmentCreate(fulfillment: $fulfillment, message: $message) {
+            fulfillment {
+              ${fulfillmentSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ fulfillmentCreate: fulfillmentCreatePayloadSchema }), { variables: {
+			fulfillment: {
+				lineItemsByFulfillmentOrder: input.lineItemsByFulfillmentOrder,
+				notifyCustomer: input.notifyCustomer,
+				trackingInfo: input.trackingInfo
+			},
+			...input.message ? { message: input.message } : {}
+		} });
+		assertNoUserErrors(response.fulfillmentCreate.userErrors);
+		if (!response.fulfillmentCreate.fulfillment) throw new Error("Shopify did not return the created fulfillment.");
+		return response.fulfillmentCreate.fulfillment;
+	}
+});
+
+//#endregion
+//#region src/operations/create-shopify-order.operation.ts
+const createOrderOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.create-shopify-order",
+	name: "Create Shopify Order",
+	description: "Create an order in the connected Shopify store.",
+	needsApproval: true,
+	input: orderCreateInputSchema,
+	output: shopifyOrderSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation CreateOrder($order: OrderCreateOrderInput!) {
+          orderCreate(order: $order) {
+            order {
+              ${orderSelection$1}
+            }
+            userErrors {
+              field
+              message
+              code
+            }
+          }
+        }
+      `, z.object({ orderCreate: createOrderResponseSchema }), { variables: { order: {
+			...omitUndefined({
+				currency: input.currency,
+				email: input.email,
+				note: input.note,
+				tags: input.tags,
+				customerId: input.customerId
+			}),
+			lineItems: buildOrderCreateLineItems(input.lineItems, input.currency)
+		} } });
+		assertNoUserErrors(response.orderCreate.userErrors);
+		if (!response.orderCreate.order) throw new Error("Shopify did not return the created order.");
+		return response.orderCreate.order;
+	}
+});
+
+//#endregion
+//#region src/schemas/products.ts
+const productSelection = `
+  id
+  title
+  handle
+  status
+  productType
+  vendor
+  descriptionHtml
+  onlineStoreUrl
+  createdAt
+  updatedAt
+  tags
+  featuredImage {
+    url
+    altText
+  }
+  seo {
+    title
+    description
+  }
+`;
+const productMutationInputSchema = z.object({
+	title: z.string().min(1).optional(),
+	handle: z.string().min(1).optional(),
+	descriptionHtml: z.string().optional(),
+	vendor: z.string().optional(),
+	productType: z.string().optional(),
+	tags: z.array(z.string()).optional()
+});
+const listProductsResponseSchema = z.object({ products: shopifyConnectionNodesSchema(shopifyProductSchema) });
+const getProductResponseSchema = z.object({ product: shopifyProductSchema.nullable() });
+const productMutationResponseSchema = z.object({
+	product: shopifyProductSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const deleteProductResponseSchema = z.object({
+	deletedProductId: shopifyGlobalIdSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+
+//#endregion
+//#region src/operations/create-shopify-product.operation.ts
+const createProductOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.create-shopify-product",
+	name: "Create Shopify Product",
+	description: "Create a product in the connected Shopify store.",
+	needsApproval: true,
+	input: productMutationInputSchema.extend({ title: z.string().min(1) }),
+	output: shopifyProductSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation CreateProduct($product: ProductCreateInput!) {
+          productCreate(product: $product) {
+            product {
+              ${productSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ productCreate: productMutationResponseSchema }), { variables: { product: omitUndefined(input) } });
+		assertNoUserErrors(response.productCreate.userErrors);
+		if (!response.productCreate.product) throw new Error("Shopify did not return the created product.");
+		return response.productCreate.product;
+	}
+});
+
+//#endregion
+//#region src/operations/delete-shopify-article.operation.ts
+const deleteArticleOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.delete-shopify-article",
+	name: "Delete Shopify Article",
+	description: "Delete a Shopify article by its global ID.",
+	needsApproval: true,
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: z.object({ deletedArticleId: shopifyGlobalIdSchema }),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation DeleteArticle($id: ID!) {
+          articleDelete(id: $id) {
+            deletedArticleId
+            userErrors {
+              code
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ articleDelete: deleteArticleResponseSchema }), { variables: { id: input.id } });
+		assertNoUserErrors(response.articleDelete.userErrors);
+		if (!response.articleDelete.deletedArticleId) throw new Error(`Shopify did not confirm article deletion: ${input.id}`);
+		return { deletedArticleId: response.articleDelete.deletedArticleId };
+	}
+});
+
+//#endregion
+//#region src/operations/delete-shopify-blog.operation.ts
+const deleteBlogOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.delete-shopify-blog",
+	name: "Delete Shopify Blog",
+	description: "Delete a Shopify blog by its global ID.",
+	needsApproval: true,
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: z.object({ deletedBlogId: shopifyGlobalIdSchema }),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation DeleteBlog($id: ID!) {
+          blogDelete(id: $id) {
+            deletedBlogId
+            userErrors {
+              code
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ blogDelete: deleteBlogResponseSchema }), { variables: { id: input.id } });
+		assertNoUserErrors(response.blogDelete.userErrors);
+		if (!response.blogDelete.deletedBlogId) throw new Error(`Shopify did not confirm blog deletion: ${input.id}`);
+		return { deletedBlogId: response.blogDelete.deletedBlogId };
+	}
+});
+
+//#endregion
+//#region src/operations/delete-shopify-collection.operation.ts
+const deleteCollectionOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.delete-shopify-collection",
+	name: "Delete Shopify Collection",
+	description: "Delete a Shopify collection by its global ID.",
+	needsApproval: true,
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: z.object({ deletedCollectionId: shopifyGlobalIdSchema }),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation DeleteCollection($input: CollectionDeleteInput!) {
+          collectionDelete(input: $input) {
+            deletedCollectionId
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ collectionDelete: deleteCollectionResponseSchema }), { variables: { input: { id: input.id } } });
+		assertNoUserErrors(response.collectionDelete.userErrors);
+		if (!response.collectionDelete.deletedCollectionId) throw new Error(`Shopify did not confirm collection deletion: ${input.id}`);
+		return { deletedCollectionId: response.collectionDelete.deletedCollectionId };
+	}
+});
+
+//#endregion
+//#region src/operations/delete-shopify-customer.operation.ts
+const deleteCustomerOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.delete-shopify-customer",
+	name: "Delete Shopify Customer",
+	description: "Delete a Shopify customer who has no placed orders.",
+	needsApproval: true,
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: z.object({ deletedCustomerId: shopifyGlobalIdSchema }),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation DeleteCustomer($id: ID!) {
+          customerDelete(input: { id: $id }) {
+            deletedCustomerId
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ customerDelete: customerDeleteResponseSchema }), { variables: { id: input.id } });
+		assertNoUserErrors(response.customerDelete.userErrors);
+		if (!response.customerDelete.deletedCustomerId) throw new Error(`Shopify did not confirm customer deletion: ${input.id}`);
+		return { deletedCustomerId: response.customerDelete.deletedCustomerId };
+	}
+});
+
+//#endregion
+//#region src/operations/delete-shopify-product.operation.ts
+const deleteProductOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.delete-shopify-product",
+	name: "Delete Shopify Product",
+	description: "Delete a Shopify product by its global ID.",
+	needsApproval: true,
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: z.object({ deletedProductId: shopifyGlobalIdSchema }),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation DeleteProduct($input: ProductDeleteInput!) {
+          productDelete(input: $input) {
+            deletedProductId
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ productDelete: deleteProductResponseSchema }), { variables: { input: { id: input.id } } });
+		assertNoUserErrors(response.productDelete.userErrors);
+		if (!response.productDelete.deletedProductId) throw new Error(`Shopify did not confirm product deletion: ${input.id}`);
+		return { deletedProductId: response.productDelete.deletedProductId };
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-article.operation.ts
+const getArticleOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-article",
+	name: "Get Shopify Article",
+	description: "Retrieve a single Shopify article by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyArticleSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetArticle($id: ID!) {
+          article(id: $id) {
+            ${articleSelection}
+          }
+        }
+      `, getArticleResponseSchema, { variables: { id: input.id } });
+		if (!response.article) throw new Error(`Shopify article not found: ${input.id}`);
+		return normalizeArticle(response.article);
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-blog.operation.ts
+const getBlogOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-blog",
+	name: "Get Shopify Blog",
+	description: "Retrieve a single Shopify blog by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyBlogSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetBlog($id: ID!) {
+          blog(id: $id) {
+            ${blogSelection}
+          }
+        }
+      `, getBlogResponseSchema, { variables: { id: input.id } });
+		if (!response.blog) throw new Error(`Shopify blog not found: ${input.id}`);
+		return response.blog;
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-collection.operation.ts
+const getCollectionOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-collection",
+	name: "Get Shopify Collection",
+	description: "Retrieve a single Shopify collection by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyCollectionSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetCollection($id: ID!) {
+          collection(id: $id) {
+            ${collectionSelection}
+          }
+        }
+      `, getCollectionResponseSchema, { variables: { id: input.id } });
+		if (!response.collection) throw new Error(`Shopify collection not found: ${input.id}`);
+		return response.collection;
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-customer.operation.ts
+const getCustomerOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-customer",
+	name: "Get Shopify Customer",
+	description: "Retrieve a single Shopify customer by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyCustomerSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetCustomer($id: ID!) {
+          customer(id: $id) {
+            ${customerSelection}
+          }
+        }
+      `, getCustomerResponseSchema, { variables: { id: input.id } });
+		if (!response.customer) throw new Error(`Shopify customer not found: ${input.id}`);
+		return response.customer;
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-customer-orders.operation.ts
+const getCustomerOrdersOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-customer-orders",
+	name: "Get Shopify Customer Orders",
+	description: "Retrieve orders for a specific Shopify customer.",
+	input: z.object({
+		id: shopifyGlobalIdSchema,
+		first: z.number().int().min(1).max(100).optional().default(25),
+		after: z.string().optional()
+	}),
+	output: shopifyConnectionNodesSchema(shopifyOrderSchema),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetCustomerOrders($id: ID!, $first: Int!, $after: String) {
+          customer(id: $id) {
+            orders(first: $first, after: $after) {
+              nodes {
+                ${orderSelection}
+              }
+              pageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+              }
+            }
+          }
+        }
+      `, customerOrdersResponseSchema, { variables: {
+			id: input.id,
+			first: input.first,
+			...input.after ? { after: input.after } : {}
+		} });
+		if (!response.customer) throw new Error(`Shopify customer not found for orders lookup: ${input.id}`);
+		return response.customer.orders;
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-fulfillment.operation.ts
+const getFulfillmentOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-fulfillment",
+	name: "Get Shopify Fulfillment",
+	description: "Retrieve a single Shopify fulfillment by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyFulfillmentSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetFulfillment($id: ID!) {
+          fulfillment(id: $id) {
+            ${fulfillmentSelection}
+          }
+        }
+      `, fulfillmentResponseSchema, { variables: { id: input.id } });
+		if (!response.fulfillment) throw new Error(`Shopify fulfillment not found: ${input.id}`);
+		return response.fulfillment;
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-inventory-item.operation.ts
+const getInventoryItemOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-inventory-item",
+	name: "Get Shopify Inventory Item",
+	description: "Retrieve a single Shopify inventory item by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyInventoryItemSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetInventoryItem($id: ID!) {
+          inventoryItem(id: $id) {
+            ${inventoryItemSelection}
+          }
+        }
+      `, getInventoryItemResponseSchema, { variables: { id: input.id } });
+		if (!response.inventoryItem) throw new Error(`Shopify inventory item not found: ${input.id}`);
+		return response.inventoryItem;
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-inventory-levels-for-item.operation.ts
+const getInventoryLevelsForItemOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-inventory-levels-for-item",
+	name: "Get Shopify Inventory Levels For Item",
+	description: "Retrieve inventory levels for a specific Shopify inventory item.",
+	input: z.object({
+		inventoryItemId: shopifyGlobalIdSchema,
+		first: z.number().int().min(1).max(100).optional().default(25),
+		after: z.string().optional()
+	}),
+	output: shopifyConnectionNodesSchema(shopifyInventoryLevelSchema),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetInventoryLevelsForItem($id: ID!, $first: Int!, $after: String) {
+          inventoryItem(id: $id) {
+            inventoryLevels(first: $first, after: $after) {
+              nodes {
+                ${inventoryLevelSelection}
+              }
+              pageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+              }
+            }
+          }
+        }
+      `, inventoryLevelsResponseSchema, { variables: {
+			id: input.inventoryItemId,
+			first: input.first,
+			...input.after ? { after: input.after } : {}
+		} });
+		if (!response.inventoryItem) throw new Error(`Shopify inventory item not found for inventory levels lookup: ${input.inventoryItemId}`);
+		return response.inventoryItem.inventoryLevels;
+	}
+});
+
+//#endregion
+//#region src/schemas/locations.ts
+const locationSelection = `
+  id
+  name
+  isActive
+  fulfillsOnlineOrders
+`;
+const listLocationsResponseSchema = z.object({ locations: shopifyConnectionNodesSchema(shopifyLocationSchema) });
+const getLocationResponseSchema = z.object({ location: shopifyLocationSchema.nullable() });
+
+//#endregion
+//#region src/operations/get-shopify-location.operation.ts
+const getLocationOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-location",
+	name: "Get Shopify Location",
+	description: "Retrieve a single Shopify location by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyLocationSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetLocation($id: ID!) {
+          location(id: $id) {
+            ${locationSelection}
+          }
+        }
+      `, getLocationResponseSchema, { variables: { id: input.id } });
+		if (!response.location) throw new Error(`Shopify location not found: ${input.id}`);
+		return response.location;
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-order.operation.ts
+const getOrderOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-order",
+	name: "Get Shopify Order",
+	description: "Retrieve a single Shopify order by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyOrderSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetOrder($id: ID!) {
+          order(id: $id) {
+            ${orderSelection$1}
+          }
+        }
+      `, getOrderResponseSchema, { variables: { id: input.id } });
+		if (!response.order) throw new Error(`Shopify order not found: ${input.id}`);
+		return response.order;
+	}
+});
+
+//#endregion
+//#region src/operations/get-shopify-product.operation.ts
+const getProductOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-product",
+	name: "Get Shopify Product",
+	description: "Retrieve a single Shopify product by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyProductSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query GetProduct($id: ID!) {
+          product(id: $id) {
+            ${productSelection}
+          }
+        }
+      `, getProductResponseSchema, { variables: { id: input.id } });
+		if (!response.product) throw new Error(`Shopify product not found: ${input.id}`);
+		return response.product;
+	}
+});
+
+//#endregion
+//#region src/schemas/shop.ts
+const getShopResponseSchema = z.object({ shop: shopifyShopSchema });
+const getShopQuery = `
+  query GetShop {
+    shop {
+      id
+      name
+      myshopifyDomain
+      contactEmail
+      currencyCode
+    }
+  }
+`;
+
+//#endregion
+//#region src/operations/get-shopify-shop.operation.ts
+const getShopOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.get-shopify-shop",
+	name: "Get Shopify Shop",
+	description: "Retrieve high-level details about the connected Shopify store.",
+	input: z.object({}),
+	output: shopifyShopSchema,
+	run: async (_input, context) => {
+		return (await createShopifyClient(context.credentials.shopify).graphql(getShopQuery, getShopResponseSchema)).shop;
+	}
+});
+
+//#endregion
+//#region src/operations/list-shopify-articles.operation.ts
+const listArticlesOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.list-shopify-articles",
+	name: "List Shopify Articles",
+	description: "List blog articles from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyArticleSchema),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query ListArticles($first: Int!, $after: String, $query: String) {
+          articles(first: $first, after: $after, query: $query) {
+            nodes {
+              ${articleSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listArticlesResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} });
+		return {
+			nodes: response.articles.nodes.map(normalizeArticle),
+			pageInfo: response.articles.pageInfo
+		};
+	}
+});
+
+//#endregion
+//#region src/operations/list-shopify-blogs.operation.ts
+const listBlogsOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.list-shopify-blogs",
+	name: "List Shopify Blogs",
+	description: "List blogs from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyBlogSchema),
+	run: async (input, context) => {
+		return (await createShopifyClient(context.credentials.shopify).graphql(`
+        query ListBlogs($first: Int!, $after: String, $query: String) {
+          blogs(first: $first, after: $after, query: $query) {
+            nodes {
+              ${blogSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listBlogsResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} })).blogs;
+	}
+});
+
+//#endregion
+//#region src/operations/list-shopify-collections.operation.ts
+const listCollectionsOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.list-shopify-collections",
+	name: "List Shopify Collections",
+	description: "List collections from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyCollectionSchema),
+	run: async (input, context) => {
+		return (await createShopifyClient(context.credentials.shopify).graphql(`
+        query ListCollections($first: Int!, $after: String, $query: String) {
+          collections(first: $first, after: $after, query: $query) {
+            nodes {
+              ${collectionSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listCollectionsResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} })).collections;
+	}
+});
+
+//#endregion
+//#region src/operations/list-shopify-customers.operation.ts
+const listCustomersOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.list-shopify-customers",
+	name: "List Shopify Customers",
+	description: "List customers from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyCustomerSchema),
+	run: async (input, context) => {
+		return (await createShopifyClient(context.credentials.shopify).graphql(`
+        query ListCustomers($first: Int!, $after: String, $query: String) {
+          customers(first: $first, after: $after, query: $query) {
+            nodes {
+              ${customerSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listCustomersResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} })).customers;
+	}
+});
+
+//#endregion
+//#region src/operations/list-shopify-fulfillment-orders-for-order.operation.ts
+const listFulfillmentOrdersForOrderOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.list-shopify-fulfillment-orders-for-order",
+	name: "List Shopify Fulfillment Orders For Order",
+	description: "List fulfillment orders for a Shopify order so they can be fulfilled.",
+	input: z.object({
+		orderId: shopifyGlobalIdSchema,
+		first: z.number().int().min(1).max(100).optional().default(25),
+		after: z.string().optional()
+	}),
+	output: shopifyConnectionNodesSchema(fulfillmentOrderSchema),
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        query ListFulfillmentOrdersForOrder($id: ID!, $first: Int!, $after: String) {
+          order(id: $id) {
+            fulfillmentOrders(first: $first, after: $after) {
+              nodes {
+                id
+                status
+                assignedLocation {
+                  location {
+                    id
+                    name
+                    isActive
+                    fulfillsOnlineOrders
+                  }
+                }
+                lineItems(first: 50) {
+                  nodes {
+                    id
+                    remainingQuantity
+                    lineItem {
+                      id
+                      name
+                      quantity
+                    }
+                  }
+                  pageInfo {
+                    hasNextPage
+                    hasPreviousPage
+                    startCursor
+                    endCursor
+                  }
+                }
+              }
+              pageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+              }
+            }
+          }
+        }
+      `, fulfillmentOrderConnectionSchema, { variables: {
+			id: input.orderId,
+			first: input.first,
+			...input.after ? { after: input.after } : {}
+		} });
+		if (!response.order) throw new Error(`Shopify order not found for fulfillment orders lookup: ${input.orderId}`);
+		return response.order.fulfillmentOrders;
+	}
+});
+
+//#endregion
+//#region src/operations/list-shopify-inventory-items.operation.ts
+const listInventoryItemsOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.list-shopify-inventory-items",
+	name: "List Shopify Inventory Items",
+	description: "List inventory items from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyInventoryItemSchema),
+	run: async (input, context) => {
+		return (await createShopifyClient(context.credentials.shopify).graphql(`
+        query ListInventoryItems($first: Int!, $after: String, $query: String) {
+          inventoryItems(first: $first, after: $after, query: $query) {
+            nodes {
+              ${inventoryItemSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listInventoryItemsResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} })).inventoryItems;
+	}
+});
+
+//#endregion
+//#region src/operations/list-shopify-locations.operation.ts
+const listLocationsOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.list-shopify-locations",
+	name: "List Shopify Locations",
+	description: "List locations from the connected Shopify store.",
+	input: shopifyPageInputSchema.extend({
+		includeInactive: z.boolean().optional(),
+		includeLegacy: z.boolean().optional()
+	}),
+	output: shopifyConnectionNodesSchema(shopifyLocationSchema),
+	run: async (input, context) => {
+		return (await createShopifyClient(context.credentials.shopify).graphql(`
+        query ListLocations(
+          $first: Int!
+          $after: String
+          $query: String
+          $includeInactive: Boolean
+          $includeLegacy: Boolean
+        ) {
+          locations(
+            first: $first
+            after: $after
+            query: $query
+            includeInactive: $includeInactive
+            includeLegacy: $includeLegacy
+          ) {
+            nodes {
+              ${locationSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listLocationsResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {},
+			...input.includeInactive !== void 0 ? { includeInactive: input.includeInactive } : {},
+			...input.includeLegacy !== void 0 ? { includeLegacy: input.includeLegacy } : {}
+		} })).locations;
+	}
+});
+
+//#endregion
+//#region src/operations/list-shopify-orders.operation.ts
+const listOrdersOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.list-shopify-orders",
+	name: "List Shopify Orders",
+	description: "List orders from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyOrderSchema),
+	run: async (input, context) => {
+		return (await createShopifyClient(context.credentials.shopify).graphql(`
+        query ListOrders($first: Int!, $after: String, $query: String) {
+          orders(first: $first, after: $after, query: $query) {
+            nodes {
+              ${orderSelection$1}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listOrdersResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} })).orders;
+	}
+});
+
+//#endregion
+//#region src/operations/list-shopify-products.operation.ts
+const listProductsOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.list-shopify-products",
+	name: "List Shopify Products",
+	description: "List products from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyProductSchema),
+	run: async (input, context) => {
+		return (await createShopifyClient(context.credentials.shopify).graphql(`
+        query ListProducts($first: Int!, $after: String, $query: String) {
+          products(first: $first, after: $after, query: $query) {
+            nodes {
+              ${productSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listProductsResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} })).products;
+	}
+});
+
+//#endregion
+//#region src/operations/remove-products-from-shopify-collection.operation.ts
+const removeProductsFromCollectionOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.remove-products-from-shopify-collection",
+	name: "Remove Products From Shopify Collection",
+	description: "Remove products from a manual Shopify collection.",
+	needsApproval: true,
+	input: z.object({
+		id: shopifyGlobalIdSchema,
+		productIds: shopifyProductIdsInputSchema
+	}),
+	output: shopifyJobSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation RemoveProductsFromCollection($id: ID!, $productIds: [ID!]!) {
+          collectionRemoveProducts(id: $id, productIds: $productIds) {
+            job {
+              id
+              done
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ collectionRemoveProducts: removeProductsResponseSchema }), { variables: {
+			id: input.id,
+			productIds: input.productIds
+		} });
+		assertNoUserErrors(response.collectionRemoveProducts.userErrors);
+		if (!response.collectionRemoveProducts.job) throw new Error(`Shopify did not return a removal job for collection: ${input.id}`);
+		return response.collectionRemoveProducts.job;
+	}
+});
+
+//#endregion
+//#region src/operations/update-shopify-article.operation.ts
+const updateArticleOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.update-shopify-article",
+	name: "Update Shopify Article",
+	description: "Update a Shopify article by its global ID.",
+	needsApproval: true,
+	input: articleMutationInputSchema.extend({
+		id: shopifyGlobalIdSchema,
+		redirectNewHandle: z.boolean().optional()
+	}),
+	output: shopifyArticleSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation UpdateArticle($id: ID!, $article: ArticleUpdateInput!) {
+          articleUpdate(id: $id, article: $article) {
+            article {
+              ${articleSelection}
+            }
+            userErrors {
+              code
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ articleUpdate: articleMutationPayloadSchema }), { variables: {
+			id: input.id,
+			article: omitUndefined({
+				...buildArticleInput(input),
+				redirectNewHandle: input.redirectNewHandle
+			})
+		} });
+		assertNoUserErrors(response.articleUpdate.userErrors);
+		if (!response.articleUpdate.article) throw new Error(`Shopify did not return the updated article: ${input.id}`);
+		return normalizeArticle(response.articleUpdate.article);
+	}
+});
+
+//#endregion
+//#region src/operations/update-shopify-blog.operation.ts
+const updateBlogOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.update-shopify-blog",
+	name: "Update Shopify Blog",
+	description: "Update a Shopify blog by its global ID.",
+	needsApproval: true,
+	input: blogMutationInputSchema.extend({ id: shopifyGlobalIdSchema }),
+	output: shopifyBlogSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation UpdateBlog($id: ID!, $blog: BlogUpdateInput!) {
+          blogUpdate(id: $id, blog: $blog) {
+            blog {
+              ${blogSelection}
+            }
+            userErrors {
+              code
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ blogUpdate: blogMutationResponseSchema }), { variables: {
+			id: input.id,
+			blog: omitUndefined({
+				title: input.title,
+				handle: input.handle,
+				templateSuffix: input.templateSuffix,
+				commentPolicy: input.commentPolicy
+			})
+		} });
+		assertNoUserErrors(response.blogUpdate.userErrors);
+		if (!response.blogUpdate.blog) throw new Error(`Shopify did not return the updated blog: ${input.id}`);
+		return response.blogUpdate.blog;
+	}
+});
+
+//#endregion
+//#region src/operations/update-shopify-customer.operation.ts
+const updateCustomerOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.update-shopify-customer",
+	name: "Update Shopify Customer",
+	description: "Update a Shopify customer by its global ID.",
+	needsApproval: true,
+	input: customerMutationInputSchema.extend({ id: shopifyGlobalIdSchema }),
+	output: shopifyCustomerSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation UpdateCustomer($input: CustomerInput!) {
+          customerUpdate(input: $input) {
+            customer {
+              ${customerSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ customerUpdate: customerMutationResponseSchema }), { variables: { input: omitUndefined(input) } });
+		assertNoUserErrors(response.customerUpdate.userErrors);
+		if (!response.customerUpdate.customer) throw new Error(`Shopify did not return the updated customer: ${input.id}`);
+		return response.customerUpdate.customer;
+	}
+});
+
+//#endregion
+//#region src/operations/update-shopify-order.operation.ts
+const updateOrderOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.update-shopify-order",
+	name: "Update Shopify Order",
+	description: "Update simple order attributes such as note, tags, email, or shipping address.",
+	needsApproval: true,
+	input: orderUpdateInputSchema,
+	output: shopifyOrderSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation UpdateOrder($input: OrderInput!) {
+          orderUpdate(input: $input) {
+            order {
+              ${orderSelection$1}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ orderUpdate: orderMutationResponseSchema }), { variables: { input: omitUndefined(input) } });
+		assertNoUserErrors(response.orderUpdate.userErrors);
+		if (!response.orderUpdate.order) throw new Error(`Shopify did not return the updated order: ${input.id}`);
+		return response.orderUpdate.order;
+	}
+});
+
+//#endregion
+//#region src/operations/update-shopify-product.operation.ts
+const updateProductOperation = new Operation({
+	credentialSets: [shopifyCredentialSet],
+	id: "shopify.update-shopify-product",
+	name: "Update Shopify Product",
+	description: "Update a Shopify product by its global ID.",
+	needsApproval: true,
+	input: productMutationInputSchema.extend({ id: shopifyGlobalIdSchema }),
+	output: shopifyProductSchema,
+	run: async (input, context) => {
+		const response = await createShopifyClient(context.credentials.shopify).graphql(`
+        mutation UpdateProduct($product: ProductUpdateInput!) {
+          productUpdate(product: $product) {
+            product {
+              ${productSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ productUpdate: productMutationResponseSchema }), { variables: { product: omitUndefined(input) } });
+		assertNoUserErrors(response.productUpdate.userErrors);
+		if (!response.productUpdate.product) throw new Error(`Shopify did not return the updated product: ${input.id}`);
+		return response.productUpdate.product;
+	}
+});
+
+//#endregion
+export { deleteCollectionOperation as A, cancelOrderOperation as B, getCustomerOrdersOperation as C, getArticleOperation as D, getBlogOperation as E, createFulfillmentOperation as F, addProductsToCollectionOperation as H, createCustomerOperation as I, createCollectionOperation as L, deleteArticleOperation as M, createProductOperation as N, deleteProductOperation as O, createOrderOperation as P, createBlogOperation as R, getFulfillmentOperation as S, getCollectionOperation as T, adjustInventoryQuantitiesOperation as V, getProductOperation as _, updateArticleOperation as a, getInventoryLevelsForItemOperation as b, listOrdersOperation as c, listFulfillmentOrdersForOrderOperation as d, listCustomersOperation as f, getShopOperation as g, listArticlesOperation as h, updateBlogOperation as i, deleteBlogOperation as j, deleteCustomerOperation as k, listLocationsOperation as l, listBlogsOperation as m, updateOrderOperation as n, removeProductsFromCollectionOperation as o, listCollectionsOperation as p, updateCustomerOperation as r, listProductsOperation as s, updateProductOperation as t, listInventoryItemsOperation as u, getOrderOperation as v, getCustomerOperation as w, getInventoryItemOperation as x, getLocationOperation as y, createArticleOperation as z };