@drawbridge/drawbridge-utils 0.0.175 → 0.0.177

package/dist/admin-C3HtEM6h.d.ts

@@ -0,0 +1,697 @@
+import { request } from './http.js';
+import { SHOPIFY_ADMIN_API_VERSION } from './shopify/constants.js';
+
+const adminUrl = ( domain ) =>
+	`https://${ domain }/admin/api/${ SHOPIFY_ADMIN_API_VERSION }`;
+
+// Admin GraphQL wrapper. Throws on top-level `errors`; user-input
+// validation errors come back inside the operation's `userErrors` field
+// and must be checked at the call site (see getOrCreateCustomer).
+const adminFetch = async ({ adminAccessToken, domain, fetcher, query, variables }) => {
+
+	const { data, errors } = await request({
+		fetcher,
+		method : 'POST',
+		url : adminUrl( domain ) + '/graphql.json',
+		headers : {
+			'X-Shopify-Access-Token' : adminAccessToken
+		},
+		body : {
+			query,
+			...( variables && { variables } )
+		}
+	});
+
+	if( errors ){
+
+		throw new Error( 'Shopify GraphQL error: ' + errors[ 0 ]?.message );
+
+	}
+	return data;
+
+};
+
+// WHAT MAKES A DISCOUNT UNUSABLE, fetched so the picker can say so instead of
+// handing a merchant a code that silently never applies. All four code-discount
+// types carry this same field set in 2026-04 (verified per type in
+// shopify.dev/docs/api/admin-graphql/2026-04/objects/DiscountCode{Basic,Bxgy,
+// FreeShipping,App}, fetched 2026-09-11), so one shape repeats rather than four
+// different ones drifting apart.
+//
+// `context` OVER `customerSelection`: the latter is deprecated in 2026-04, the
+// former is not. Only `__typename` is selected from it — it is a union, and
+// naming its members in inline fragments would make this query fail the day
+// Shopify adds one. `DiscountBuyerSelectionAll` is the only member that means
+// "anyone can redeem this"; every other member is a restriction, whatever it is
+// called, and that is the whole question being asked.
+//
+// `asyncUsageCount` is documented as possibly LAGGING the true count, so it is
+// only ever compared as a lower bound: count >= limit means genuinely exhausted,
+// never a false block.
+const DISCOUNT_FIELDS = `
+	title
+	status
+	startsAt
+	endsAt
+	usageLimit
+	asyncUsageCount
+	appliesOncePerCustomer
+	context { __typename }
+`;
+
+const discountsQuery = ( search, cursor, limit ) => `{
+	codeDiscountNodes(first: ${ limit }${ search ? `, query: "title:*${ search }*"` : '' }${ cursor ? `, after: "${ cursor }"` : '' }) {
+		edges {
+			node {
+				id
+				codeDiscount {
+					... on DiscountCodeBasic { ${ DISCOUNT_FIELDS } }
+					... on DiscountCodeBxgy { ${ DISCOUNT_FIELDS } }
+					... on DiscountCodeFreeShipping { ${ DISCOUNT_FIELDS } }
+					... on DiscountCodeApp { ${ DISCOUNT_FIELDS } }
+				}
+			}
+		}
+		pageInfo {
+			endCursor
+			hasNextPage
+			hasPreviousPage
+			startCursor
+		}
+	}
+}`;
+
+const getDiscounts = async ({ fetcher, adminAccessToken, domain, search, cursor, limit }) => {
+
+	const data = await adminFetch({
+		fetcher,
+		adminAccessToken,
+		domain,
+		query : discountsQuery( search, cursor, limit )
+	});
+
+	return data?.codeDiscountNodes;
+
+};
+
+// Discount ids: the api's discounts endpoint strips the DiscountCodeNode
+// GID to its bare numeric tail before it reaches the picker, so workflow
+// step settings store numerics — but GraphQL wants the full GID
+// (DRAWBRIDGE-SYNC-AQ). Accept either and normalize, same pattern as
+// billing's toShopGid.
+const discountGid = ( id ) =>
+	String( id ).startsWith( 'gid://' ) ? String( id ) : 'gid://shopify/DiscountCodeNode/' + id;
+
+// Adds a code to an existing code discount. `discountId` is the
+// DiscountCodeNode id in either GID or bare numeric form (see discountGid).
+// discountRedeemCodeBulkAdd is asynchronous: it returns a bulk-creation
+// job, not the created code, so we poll the job until done to read the
+// redeem code's id back. The code string itself is caller-generated — the
+// id is the only Shopify-issued value here. Requires the write_discounts
+// scope.
+const createDiscountCode = async ({ fetcher, adminAccessToken, domain, discountId, code }) => {
+
+	const added = await adminFetch({
+		fetcher,
+		adminAccessToken,
+		domain,
+		query : `
+			mutation DiscountRedeemCodeBulkAdd($discountId: ID!, $codes: [DiscountRedeemCodeInput!]!) {
+				discountRedeemCodeBulkAdd(discountId: $discountId, codes: $codes) {
+					bulkCreation {
+						id
+					}
+					userErrors {
+						field
+						message
+					}
+				}
+			}
+		`,
+		variables : {
+			codes : [ { code } ],
+			discountId : discountGid( discountId )
+		}
+	});
+
+	const addErrors = added?.discountRedeemCodeBulkAdd?.userErrors;
+
+	if( addErrors?.length ){
+
+		throw new Error( 'Shopify discount code create failed: ' + addErrors[ 0 ].message );
+
+	}
+	const bulkCreationId = added?.discountRedeemCodeBulkAdd?.bulkCreation?.id;
+
+	if( ! bulkCreationId ){
+
+		throw new Error( 'Shopify discount code create failed: no bulk creation id returned' );
+
+	}
+	// Single-code jobs settle in a second or two; the cap keeps a stuck job
+	// from hanging the worker to its full budget — the step fails and the
+	// queue's retry semantics take over.
+	for( let attempt = 0; attempt < 15; attempt++ ){
+
+		await new Promise( ( resolve ) => setTimeout( resolve, 1000 ) );
+
+		const polled = await adminFetch({
+		fetcher,
+			adminAccessToken,
+			domain,
+			query : `
+				query DiscountRedeemCodeBulkCreationPoll($id: ID!) {
+					discountRedeemCodeBulkCreation(id: $id) {
+						done
+						codes(first: 1) {
+							nodes {
+								code
+								discountRedeemCode {
+									id
+								}
+								errors {
+									message
+								}
+							}
+						}
+					}
+				}
+			`,
+			variables : {
+				id : bulkCreationId
+			}
+		});
+
+		const creation = polled?.discountRedeemCodeBulkCreation;
+
+		if( ! creation?.done ) continue;
+
+		const node = creation.codes?.nodes?.[ 0 ];
+
+		if( ! node?.discountRedeemCode?.id ){
+
+			throw new Error( 'Shopify discount code create failed: ' + ( node?.errors?.[ 0 ]?.message || 'code was not created' ) );
+
+		}
+		return {
+			code : node.code,
+			// Numeric tail keeps the stored shopifyDiscountId in the shape the
+			// legacy REST endpoint returned — it feeds a merchant-visible
+			// workflow template variable, so no gid:// leakage.
+			id : node.discountRedeemCode.id.split( '/' ).pop()
+		};
+
+	}
+	throw new Error( 'Shopify discount code create timed out waiting for bulk creation ' + bulkCreationId );
+
+};
+
+// Per-connection webhook registration lived here — get / find / create / delete
+// WebhookSubscription, plus the gid and topic-enum helpers they needed.
+//
+// It is gone because Shopify webhooks are DECLARATIVE now: the topics and their
+// uri are declared in shopify.app.production.toml and `shopify app deploy`
+// applies them to every install. Nothing called these.
+//
+// Do not bring them back to "fix" a webhook. findWebhookSubscription matched on
+// topic AND uri, so a changed uri returned null and the caller created a SECOND
+// subscription while the old one kept firing. Alongside Shopify-managed
+// subscriptions that is a duplicate delivery, not a repair. Change the toml and
+// deploy the app version instead.
+
+
+// Idempotent customer lookup-or-create. Shopify rejects duplicate emails
+// on customerCreate, so we lookup first; on a race where two callers
+// hit customerCreate simultaneously, the "Email has already been taken"
+// userError triggers a second lookup to recover the now-existing record.
+const getOrCreateCustomer = async ({ fetcher, adminAccessToken, domain, email, firstName, lastName, source }) => {
+
+	// Values are passed as GraphQL variables (not interpolated) so names with
+	// apostrophes (e.g. O'Brien) can't break the query or inject.
+	const lookupQuery = `
+		query customerByEmail( $query : String! ) {
+			customers( first : 1, query : $query ) {
+				edges {
+					node {
+						id
+					}
+				}
+			}
+		}
+	`;
+
+	const data = await adminFetch({
+		fetcher,
+		adminAccessToken,
+		domain,
+		query : lookupQuery,
+		variables : { query : 'email:' + email }
+	});
+
+	const existing = data?.customers?.edges?.[ 0 ]?.node;
+
+	if( existing ) return existing;
+
+	// Name + provenance metafield only apply here, on genuine create — an
+	// existing customer is returned untouched above.
+	const input = { email };
+
+	if( firstName ) input.firstName = firstName;
+	if( lastName ) input.lastName = lastName;
+
+	if( source ){
+
+		input.metafields = [{
+			namespace : 'drwbrdg',
+			key       : 'source',
+			type      : 'single_line_text_field',
+			value     : source
+		}];
+
+	}
+	const result = await adminFetch({
+		fetcher,
+		adminAccessToken,
+		domain,
+		query : `
+			mutation customerCreate( $input : CustomerInput! ) {
+				customerCreate( input : $input ) {
+					customer {
+						id
+					}
+					userErrors {
+						field
+						message
+					}
+				}
+			}
+		`,
+		variables : { input }
+	});
+
+	const userErrors = result?.customerCreate?.userErrors;
+
+	if( userErrors?.length ){
+
+		const emailTaken = userErrors.some( ( e ) => e.message?.includes( 'Email has already been taken' ) );
+
+		if( emailTaken ){
+
+			const retry = await adminFetch({
+		fetcher,
+				adminAccessToken,
+				domain,
+				query : lookupQuery,
+				variables : { query : 'email:' + email }
+			});
+
+			const found = retry?.customers?.edges?.[ 0 ]?.node;
+
+			if( found ) return found;
+
+		}
+		throw new Error( 'Shopify customer create failed: ' + userErrors[ 0 ].message );
+
+	}
+	return result?.customerCreate?.customer;
+
+};
+
+// Returns the store's currently-active app subscriptions (App Pricing
+// plans the merchant has approved) via `currentAppInstallation`. Shopify
+// scopes `activeSubscriptions` to THIS app for the shop the admin token
+// authenticates against — it only ever lists ACTIVE subscriptions, so a
+// non-empty array means the merchant has an approved paid/usage plan for
+// our app. Also returns `shopDomain` (the app installation's shop) so the
+// caller can confirm the token resolved to the expected store. Used by the
+// OAuth activate route to gate connection activation on real plan approval.
+//
+// Each subscription carries `metered`: whether the APPROVAL the merchant sits
+// on includes a usage component. Per Shopify's AppSubscriptionLineItem
+// contract, a subscription with both recurring and usage pricing has two line
+// items — one AppRecurringPricing, one AppUsagePricing. A meter added to the
+// plan config is NEVER retroactive: it bills only for merchants who approved
+// the plan version that carries it, so an ACTIVE subscription whose line items
+// show no AppUsagePricing is a store whose usage events are silently ingested
+// as plain custom events — accepted with a 202 and never billed. `metered` is
+// what lets a caller detect that state and ask the merchant to re-approve.
+const getActiveAppSubscriptions = async ({ fetcher, adminAccessToken, domain }) => {
+
+	const data = await adminFetch({
+		fetcher,
+		adminAccessToken,
+		domain,
+		query : `{
+			currentAppInstallation {
+				activeSubscriptions {
+					id
+					name
+					status
+					test
+					lineItems {
+						id
+						plan {
+							pricingDetails {
+								__typename
+							}
+						}
+					}
+				}
+			}
+			shop {
+				myshopifyDomain
+			}
+		}`
+	});
+
+	return {
+		shopDomain : data?.shop?.myshopifyDomain || null,
+		subscriptions : ( data?.currentAppInstallation?.activeSubscriptions || [] ).map( ( subscription ) => ({
+			...subscription,
+			metered : ( subscription?.lineItems || [] ).some(
+				( item ) => item?.plan?.pricingDetails?.__typename === 'AppUsagePricing'
+			),
+			// The usage line's own id — the address appUsageRecordCreate charges
+			// against. Null when the approval carries no usage component.
+			usageLineItemId : ( subscription?.lineItems || [] ).find(
+				( item ) => item?.plan?.pricingDetails?.__typename === 'AppUsagePricing'
+			)?.id || null
+		}) )
+	};
+
+};
+
+// Creates the app's own subscription for a store: a $0 recurring line plus a
+// usage line, via the GA Billing API — NOT the managed-pricing meter system.
+// Shopify returns a confirmationUrl; the merchant approves there (charge
+// consent is always Shopify-hosted), and on approval the subscription goes
+// ACTIVE carrying the usage line appUsageRecordCreate charges against.
+//
+// This is both the connect-time path and the heal path: because the pricing
+// rides IN the subscription we create, a store can always be fixed by minting
+// a fresh subscription and having the owner approve it — no dashboard-
+// configured meter anywhere in the loop. Note Shopify refuses this mutation
+// while the app has managed pricing (Shopify App Pricing) enabled: the
+// userErrors say so verbatim, and the fix is the one-time pricing-model
+// switch in the app's dashboard settings.
+//
+// `terms` is merchant-visible on the approval screen and REQUIRED for usage
+// pricing. `cappedAmount` bounds a cycle's usage charges; a record that would
+// exceed it errors synchronously, and only the merchant can raise it.
+// `test : true` marks a test subscription nothing can ever charge.
+const createUsageSubscription = async ({ fetcher, adminAccessToken, cappedAmount, currencyCode = 'USD', domain, name, recurringPrice = 0, returnUrl, terms, test = false }) => {
+
+	if( ! name || ! returnUrl || ! terms || ! ( Number( cappedAmount ) > 0 ) ){
+
+		throw new Error( 'createUsageSubscription requires name, returnUrl, terms, and a positive cappedAmount' );
+
+	}
+	const data = await adminFetch({
+		fetcher,
+		adminAccessToken,
+		domain,
+		query : `mutation createUsageSubscription( $lineItems : [AppSubscriptionLineItemInput!]!, $name : String!, $returnUrl : URL!, $test : Boolean ) {
+			appSubscriptionCreate( lineItems : $lineItems, name : $name, returnUrl : $returnUrl, test : $test ) {
+				appSubscription { id name status test lineItems { id plan { pricingDetails { __typename } } } }
+				confirmationUrl
+				userErrors { field message }
+			}
+		}`,
+		variables : {
+			lineItems : [
+				{
+					plan : {
+						appRecurringPricingDetails : {
+							interval : 'EVERY_30_DAYS',
+							price : { amount : Number( recurringPrice ), currencyCode }
+						}
+					}
+				},
+				{
+					plan : {
+						appUsagePricingDetails : {
+							cappedAmount : { amount : Number( cappedAmount ), currencyCode },
+							terms
+						}
+					}
+				}
+			],
+			name,
+			returnUrl,
+			test
+		}
+	});
+
+	const payload = data?.appSubscriptionCreate;
+	const userErrors = payload?.userErrors || [];
+
+	if( userErrors.length ){
+
+		throw new Error( 'Shopify subscription create failed: ' + userErrors.map( ( entry ) => entry.message ).join( '; ' ) );
+
+	}
+	if( ! payload?.confirmationUrl ){
+
+		throw new Error( 'Shopify subscription create failed: no confirmation url returned' );
+
+	}
+	return {
+		confirmationUrl : payload.confirmationUrl,
+		subscription : payload.appSubscription
+	};
+
+};
+
+// Charges one usage amount against a subscription's usage line — the actual
+// billing call under the Billing API model, replacing the App Events send.
+// Unlike that 202-and-pray API, this answers synchronously: a created record
+// id is a receipt, a cap overrun or dead line item is an error the caller can
+// retry or surface. `idempotencyKey` (e.g. the order id) makes a retried
+// charge safe.
+const createUsageRecord = async ({ fetcher, adminAccessToken, amount, currencyCode = 'USD', description, domain, idempotencyKey, subscriptionLineItemId }) => {
+
+	if( ! subscriptionLineItemId || ! description || ! ( Number( amount ) > 0 ) ){
+
+		throw new Error( 'createUsageRecord requires subscriptionLineItemId, description, and a positive amount' );
+
+	}
+	const data = await adminFetch({
+		fetcher,
+		adminAccessToken,
+		domain,
+		query : `mutation createUsageRecord( $description : String!, $idempotencyKey : String, $price : MoneyInput!, $subscriptionLineItemId : ID! ) {
+			appUsageRecordCreate( description : $description, idempotencyKey : $idempotencyKey, price : $price, subscriptionLineItemId : $subscriptionLineItemId ) {
+				appUsageRecord { id }
+				userErrors { field message }
+			}
+		}`,
+		variables : {
+			description,
+			idempotencyKey : idempotencyKey ? String( idempotencyKey ) : null,
+			price : { amount : Number( amount ), currencyCode },
+			subscriptionLineItemId
+		}
+	});
+
+	const payload = data?.appUsageRecordCreate;
+	const userErrors = payload?.userErrors || [];
+
+	if( userErrors.length || ! payload?.appUsageRecord?.id ){
+
+		throw new Error( 'Shopify usage record failed: ' + ( userErrors.map( ( entry ) => entry.message ).join( '; ' ) || 'no record returned' ) );
+
+	}
+	return { id : payload.appUsageRecord.id };
+
+};
+
+// Returns a { id: quantity } map for every variant on the product
+// (keyed by variant external id). Inventory comes from Admin API
+// (Storefront doesn't expose inventory counts) so this requires the
+// admin token, not storefront.
+const getProductInventory = async ({ fetcher, adminAccessToken, domain, productId }) => {
+
+	const data = await adminFetch({
+		fetcher,
+		adminAccessToken,
+		domain,
+		query : `{
+			product( id : "${ productId }" ) {
+				variants( first : 100 ) {
+					edges {
+						node {
+							id
+							inventoryQuantity
+						}
+					}
+				}
+			}
+		}`
+	});
+
+	const edges = data?.product?.variants?.edges || [];
+
+	return edges.reduce( ( accumulator, edge ) => {
+
+		const id = edge?.node?.id;
+		const quantity = edge?.node?.inventoryQuantity;
+
+		if( id ){
+
+			accumulator[ id ] = Number.isFinite( quantity ) ? quantity : 0;
+
+		}
+		return accumulator;
+
+	}, {} );
+
+};
+
+// Shopify versions product feedback on the product's OWN updatedAt and rejects
+// a payload that looks stale ('Feedback for a later version of this resource was
+// already accepted'), so the timestamp has to be forwarded, never invented — a
+// `new Date()` here reads as a version far ahead of the product, and every later
+// send is then refused as older than the version Shopify recorded.
+//
+// Deliberately only `updatedAt`: it needs read_products, which every install
+// already grants. Reading publication state here instead would need either
+// read_product_listings (publishedOnCurrentPublication — also deprecated) or the
+// channel/publication join, and neither is worth a re-consent prompt to learn
+// something the mutation below already reports.
+const getProductUpdatedAt = async ({ adminAccessToken, domain, fetcher, productId }) => {
+
+	const data = await adminFetch({
+		fetcher,
+		adminAccessToken,
+		domain,
+		query : `
+			query ProductUpdatedAt($id: ID!) {
+				product(id: $id) {
+					updatedAt
+				}
+			}
+		`,
+		variables : { id : productId }
+	});
+
+	return data?.product?.updatedAt || null;
+
+};
+
+// Shopify carries product feedback only for a product published to the calling
+// app's channel; for anything else it refuses with this. Matched rather than
+// thrown because it is an expected state, not a fault — see the caller note.
+const NOT_ON_CHANNEL = 'not available to the channel';
+
+// Shopify versions feedback on the product's updatedAt and refuses a version
+// older than the one it already holds. Before 0.0.30 the SEND TIME went out as
+// that version, so every product accepted then sits on a version from the
+// future, and its real updatedAt is refused until the merchant next edits it —
+// while the stale banner stays up. Matched so the send can be repeated once at
+// the send time, which Shopify takes.
+const OUTDATED_FEEDBACK = 'later version';
+
+// Product ResourceFeedback — surfaces required-action messages on the product
+// page in Shopify admin (sales-channel requirement: communicate product issues
+// through the ResourceFeedback API). `state` is 'REQUIRES_ACTION' or
+// 'ACCEPTED'; ACCEPTED clears the product's active feedback. Sending replaces
+// whatever feedback this app previously sent for the product. Requires the
+// write_resource_feedbacks scope.
+//
+// Returns null when there is nothing to attach feedback to. That is a normal
+// outcome, not a failure, and callers must not report it as one.
+const sendProductResourceFeedback = async ({ fetcher, adminAccessToken, domain, productId, state, messages = [] }) => {
+
+	const productUpdatedAt = await getProductUpdatedAt({ adminAccessToken, domain, fetcher, productId });
+
+	// Deleted between the sync job reading it and this call.
+	if( ! productUpdatedAt ) return null;
+
+	const now = new Date().toISOString();
+
+	const submit = async ( version ) => {
+
+		const data = await adminFetch({
+		fetcher,
+			adminAccessToken,
+			domain,
+			query : `
+				mutation ProductFeedback($feedbackInput: [ProductResourceFeedbackInput!]!) {
+					bulkProductResourceFeedbackCreate(feedbackInput: $feedbackInput) {
+						feedback {
+							productId
+							state
+						}
+						userErrors {
+							field
+							message
+						}
+					}
+				}
+			`,
+			variables : {
+				feedbackInput : [
+					{
+						productId,
+						state,
+						feedbackGeneratedAt : now,
+						productUpdatedAt : version,
+						messages
+					}
+				]
+			}
+		});
+
+		return data?.bulkProductResourceFeedbackCreate;
+
+	};
+
+	let result = await submit( productUpdatedAt );
+
+	// A product poisoned by the pre-0.0.30 version stamp: resend once at the
+	// send time so the banner clears now rather than at the merchant's next
+	// edit. The resend's answer is final either way.
+	if( ( result?.userErrors?.[ 0 ]?.message || '' ).toLowerCase().includes( OUTDATED_FEEDBACK ) ){
+
+		result = await submit( now );
+
+	}
+	const feedbackErrors = result?.userErrors;
+
+	if( feedbackErrors?.length ){
+
+		const message = feedbackErrors[ 0 ].message || '';
+
+		// The 2026-08-12 QA finding: a product unpublished from the channel (or
+		// drafted, which also removes it) is exactly when REQUIRES_ACTION is worth
+		// saying and exactly when Shopify won't carry it — there is no Drawbridge
+		// section on that product page to render it in. Every send failed this way
+		// since the channel shipped. It is a state, not a fault: the embedded app's
+		// publishing section lists these products instead (App Store 5.7.8/5.7.11).
+		//
+		// Matching Shopify's wording is the trade for not spending a re-consent on
+		// read_product_listings just to pre-check. If they reword it this starts
+		// throwing, which now reaches Sentry Issues — loud, not silent.
+		if( message.toLowerCase().includes( NOT_ON_CHANNEL ) ) return null;
+
+		throw new Error( 'Shopify product feedback failed: ' + message );
+
+	}
+	return result?.feedback?.[ 0 ] || null;
+
+};
+
+declare const shopifyAdmin_adminFetch: typeof adminFetch;
+declare const shopifyAdmin_createDiscountCode: typeof createDiscountCode;
+declare const shopifyAdmin_createUsageRecord: typeof createUsageRecord;
+declare const shopifyAdmin_createUsageSubscription: typeof createUsageSubscription;
+declare const shopifyAdmin_getActiveAppSubscriptions: typeof getActiveAppSubscriptions;
+declare const shopifyAdmin_getDiscounts: typeof getDiscounts;
+declare const shopifyAdmin_getOrCreateCustomer: typeof getOrCreateCustomer;
+declare const shopifyAdmin_getProductInventory: typeof getProductInventory;
+declare const shopifyAdmin_sendProductResourceFeedback: typeof sendProductResourceFeedback;
+declare namespace shopifyAdmin {
+  export { shopifyAdmin_adminFetch as adminFetch, shopifyAdmin_createDiscountCode as createDiscountCode, shopifyAdmin_createUsageRecord as createUsageRecord, shopifyAdmin_createUsageSubscription as createUsageSubscription, shopifyAdmin_getActiveAppSubscriptions as getActiveAppSubscriptions, shopifyAdmin_getDiscounts as getDiscounts, shopifyAdmin_getOrCreateCustomer as getOrCreateCustomer, shopifyAdmin_getProductInventory as getProductInventory, shopifyAdmin_sendProductResourceFeedback as sendProductResourceFeedback };
+}
+
+export { adminFetch as a, createUsageRecord as b, createDiscountCode as c, createUsageSubscription as d, getDiscounts as e, getOrCreateCustomer as f, getActiveAppSubscriptions as g, getProductInventory as h, shopifyAdmin as i, sendProductResourceFeedback as s };