@sixtyninecommerce/admin 0.9.0 → 0.11.0

package/dist/stock/transfers.js

@@ -29,14 +29,74 @@ const TRANSFER_FIELDS = /* GraphQL */ `
   }
   createdAt
   updatedAt
+  initiatedBy { id firstName lastName }
   items {
     id
-    productVariant { id sku }
+    productVariant { id name sku }
     quantity
     receivedQuantity
     lostQuantity
     outstandingQuantity
   }
+  totalLines
+  totalQuantity
+  totalReceivedQuantity
+  totalLostQuantity
+`;
+/**
+ * What `get` and every write answer. Every field is one the transfer module has always served
+ * (the dashboard's own transfer pages read them all), so no engine refuses it.
+ */
+const TRANSFER_DETAIL_FIELDS = /* GraphQL */ `
+  id
+  code
+  kind
+  state
+  sourceLocation { id name }
+  destinationLocation { id name customFields { address } }
+  label
+  note
+  carrier
+  trackingCode
+  estimatedArrivalAt
+  shippedAt
+  receivedAt
+  cancelledAt
+  cancelReason
+  deliveryAddress {
+    contactName
+    company
+    streetLine1
+    streetLine2
+    city
+    province
+    postalCode
+    countryCode
+    phoneNumber
+  }
+  createdAt
+  updatedAt
+  initiatedBy { id firstName lastName }
+  shippedBy { id firstName lastName }
+  receivedBy { id firstName lastName }
+  consumptionTotalValue
+  consumptionHasUnpricedLines
+  pdfStorageKey
+  fulfillmentHandlerCode
+  handlerArgs
+  myparcelShipmentId
+  myparcelBarcode
+  hendriksRemotePath
+  items {
+    id
+    productVariant { id name sku }
+    quantity
+    receivedQuantity
+    lostQuantity
+    outstandingQuantity
+    unitCost
+  }
+  totalLines
   totalQuantity
   totalReceivedQuantity
   totalLostQuantity
@@ -47,36 +107,36 @@ export const STOCK_TRANSFERS_QUERY = /* GraphQL */ `
   }
 `;
 export const STOCK_TRANSFER_QUERY = /* GraphQL */ `
-  query StockTransfer($id: ID!) { stockTransfer(id: $id) { ${TRANSFER_FIELDS} } }
+  query StockTransfer($id: ID!) { stockTransfer(id: $id) { ${TRANSFER_DETAIL_FIELDS} } }
 `;
 export const CREATE_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
   mutation CreateStockTransfer($input: CreateStockTransferInput!) {
-    createStockTransfer(input: $input) { ${TRANSFER_FIELDS} }
+    createStockTransfer(input: $input) { ${TRANSFER_DETAIL_FIELDS} }
   }
 `;
 export const UPDATE_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
   mutation UpdateStockTransfer($id: ID!, $input: UpdateStockTransferInput!) {
-    updateStockTransfer(id: $id, input: $input) { ${TRANSFER_FIELDS} }
+    updateStockTransfer(id: $id, input: $input) { ${TRANSFER_DETAIL_FIELDS} }
   }
 `;
 export const SHIP_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
   mutation ShipStockTransfer($id: ID!, $input: ShipStockTransferInput) {
-    shipStockTransfer(id: $id, input: $input) { ${TRANSFER_FIELDS} }
+    shipStockTransfer(id: $id, input: $input) { ${TRANSFER_DETAIL_FIELDS} }
   }
 `;
 export const POST_STOCK_TRANSFER_CONSUMPTION_MUTATION = /* GraphQL */ `
   mutation PostStockTransferConsumption($id: ID!) {
-    postStockTransferConsumption(id: $id) { ${TRANSFER_FIELDS} }
+    postStockTransferConsumption(id: $id) { ${TRANSFER_DETAIL_FIELDS} }
   }
 `;
 export const RECEIVE_STOCK_TRANSFER_LINES_MUTATION = /* GraphQL */ `
   mutation ReceiveStockTransferLines($id: ID!, $lines: [ReceiveStockTransferLineInput!]!) {
-    receiveStockTransferLines(id: $id, lines: $lines) { ${TRANSFER_FIELDS} }
+    receiveStockTransferLines(id: $id, lines: $lines) { ${TRANSFER_DETAIL_FIELDS} }
   }
 `;
 export const CLOSE_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
   mutation CloseStockTransfer($id: ID!, $acceptShortfallAsLost: Boolean) {
-    closeStockTransfer(id: $id, acceptShortfallAsLost: $acceptShortfallAsLost) { ${TRANSFER_FIELDS} }
+    closeStockTransfer(id: $id, acceptShortfallAsLost: $acceptShortfallAsLost) { ${TRANSFER_DETAIL_FIELDS} }
   }
 `;
 /**
@@ -94,17 +154,17 @@ export const CLOSE_STOCK_TRANSFER_WITH_SHORTFALL_MUTATION = /* GraphQL */ `
       id: $id
       acceptShortfallAsLost: $acceptShortfallAsLost
       shortfall: $shortfall
-    ) { ${TRANSFER_FIELDS} }
+    ) { ${TRANSFER_DETAIL_FIELDS} }
   }
 `;
 export const CANCEL_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
   mutation CancelStockTransfer($id: ID!, $reason: String) {
-    cancelStockTransfer(id: $id, reason: $reason) { ${TRANSFER_FIELDS} }
+    cancelStockTransfer(id: $id, reason: $reason) { ${TRANSFER_DETAIL_FIELDS} }
   }
 `;
 export const CREATE_STOCK_TRANSFER_RETURN_MUTATION = /* GraphQL */ `
   mutation CreateStockTransferReturn($id: ID!, $input: CreateStockTransferReturnInput!) {
-    createStockTransferReturn(id: $id, input: $input) { ${TRANSFER_FIELDS} }
+    createStockTransferReturn(id: $id, input: $input) { ${TRANSFER_DETAIL_FIELDS} }
   }
 `;
 /**
@@ -295,7 +355,71 @@ function toTransfer(raw) {
             ...line,
             variantId: productVariant.id,
             sku: productVariant.sku,
+            variantName: productVariant.name,
+        })),
+    };
+}
+const ADDRESS_KEYS = [
+    'contactName',
+    'company',
+    'streetLine1',
+    'streetLine2',
+    'city',
+    'province',
+    'postalCode',
+    'countryCode',
+    'phoneNumber',
+];
+/**
+ * A location's `customFields.address`: JSON text earlier writers filled freely. Only its string
+ * fields are taken. Text that is not a JSON object, or one with no string field, reads as no
+ * address; the engine reads such a column the same way, and refuses to address a parcel to it.
+ */
+function locationAddress(raw) {
+    if (!raw?.trim())
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        return null;
+    const source = parsed;
+    const address = {};
+    let any = false;
+    for (const key of ADDRESS_KEYS) {
+        const value = source[key];
+        address[key] = typeof value === 'string' ? value : null;
+        any ||= typeof value === 'string' && value.trim() !== '';
+    }
+    return any ? address : null;
+}
+function toHandlerArgs(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (raw && typeof raw === 'object')
+        return raw;
+    return null;
+}
+function toDetail(raw) {
+    const { destinationLocation, items, handlerArgs, ...rest } = raw;
+    return {
+        ...rest,
+        destinationLocation: destinationLocation && {
+            id: destinationLocation.id,
+            name: destinationLocation.name,
+            address: locationAddress(destinationLocation.customFields?.address),
+        },
+        items: items.map(({ productVariant, ...line }) => ({
+            ...line,
+            variantId: productVariant.id,
+            sku: productVariant.sku,
+            variantName: productVariant.name,
         })),
+        handlerArgs: toHandlerArgs(handlerArgs),
     };
 }
 function toReturns(raw) {
@@ -316,7 +440,7 @@ const DEFAULT_PAGE_SIZE = 25;
 export function createStockTransfersModule(transport) {
     const one = async (field, query, variables, options) => {
         const data = await transport.graphql({ api: 'admin', query, variables }, options);
-        return toTransfer(data[field]);
+        return toDetail(data[field]);
     };
     const listPage = async (skip, take, filter) => {
         const data = await transport.graphql({
@@ -333,6 +457,9 @@ export function createStockTransfersModule(transport) {
                     dateFrom: filter?.dateFrom,
                     dateTo: filter?.dateTo,
                     search: filter?.search,
+                    // Only when set, as the return filters below: a caller that never names a mode
+                    // keeps sending the document every engine since the transfer module accepts.
+                    ...(filter?.searchMode === undefined ? {} : { searchMode: filter.searchMode }),
                     // Only when set: an engine without returns refuses an unknown
                     // input field, which would fail every list against it.
                     ...(filter?.returnOfTransferId === undefined
@@ -355,7 +482,7 @@ export function createStockTransfersModule(transport) {
         },
         async get(id, options) {
             const data = await transport.graphql({ api: 'admin', query: STOCK_TRANSFER_QUERY, variables: { id } }, options);
-            return data.stockTransfer === null ? null : toTransfer(data.stockTransfer);
+            return data.stockTransfer === null ? null : toDetail(data.stockTransfer);
         },
         create(input, options) {
             const { lines, ...rest } = input;

package/dist/stored-value/index.d.ts

@@ -20,7 +20,11 @@ export interface StoredValueAccount {
     expiresAt: string | null;
     /** The last day (`YYYY-MM-DD`, store zone) the value is valid through; refund lots never expire. */
     expiresOn: string | null;
-    status: 'active' | 'blocked';
+    /**
+     * `voided`: a gift card a void blocked for good (`giftCards.void`); it is never blocked or
+     * unblocked again. Treat any other value this version does not know as not spendable.
+     */
+    status: 'active' | 'blocked' | 'voided';
     balance: number;
     /** What can be spent now: the balance less expired value the daily job has not booked yet. */
     spendable: number;
@@ -75,6 +79,37 @@ export interface IssueStoredValueInput {
     reason: string;
     /** Sets the account's expiry: valid through this day (`YYYY-MM-DD`) in the store's time zone. */
     expiresOn?: string;
+    /**
+     * Goodwill FOR this order of the store: linked on the statement; it moves none of the order's
+     * money. Another store's order is not found; an account takes goodwill only for its owner's
+     * order (`STORED_VALUE_OWNER_MISMATCH`). Needs an engine that knows the field (incentives
+     * sprint 8): an older one refuses the whole call.
+     */
+    orderId?: string;
+}
+/**
+ * Whether the store may put an order's money in its customers' store-credit wallets instead of
+ * refunding it (incentives sprint 8).
+ */
+export interface StoreCreditSettings {
+    /** The store's switch. Off until the store turns it on. */
+    refundToCredit: boolean;
+    /**
+     * Where the store keeps what it owes its customers now: `AR` (its own accounts receivable, which
+     * then holds every customer credit), `STORE_CREDIT` (a wallet each: the Stored Value grant, the
+     * switch on, a stored-value method enabled) or `NONE` (neither). Treat any other value as no
+     * store credit.
+     */
+    book: 'AR' | 'STORE_CREDIT' | 'NONE' | (string & {});
+    /** Usable now: the book is `STORE_CREDIT`. */
+    available: boolean;
+    /**
+     * Why the book is not `STORE_CREDIT` (null exactly when it is):
+     * `STORE_CREDIT_STORE_KEEPS_ACCOUNTS`, `STORE_CREDIT_NOT_GRANTED`, `STORE_CREDIT_NOT_ENABLED` or
+     * `STORE_CREDIT_METHOD_REQUIRED`.
+     */
+    code: string | null;
+    message: string | null;
 }
 export interface RedeemStoredValueInput {
     orderId: string;
@@ -108,9 +143,17 @@ export interface StoredValueModule {
         kind?: string;
         locationId?: string;
     }, options?: Call): Promise<StoredValueLiability[]>;
-    /** Requires ManageStoredValue. Send an `idempotencyKey`: a repeat returns the first result. */
+    /**
+     * Requires ManageStoredValue. Send an `idempotencyKey`: a repeat returns the first result. A
+     * gift card sold on an order is never credited (`STORED_VALUE_GIFT_CARD_CREDIT_NOT_ALLOWED`),
+     * nor is a voided one (`STORED_VALUE_GIFT_CARD_VOIDED`).
+     */
     issue(input: IssueStoredValueInput, options?: Call): Promise<StoredValueAccount>;
-    /** Requires ManageStoredValue. Signed; a debit may not take the balance below zero. */
+    /**
+     * Requires ManageStoredValue. Signed; a debit may not take the balance below zero. A voided gift
+     * card takes no credit and no `expiresOn` (`STORED_VALUE_GIFT_CARD_VOIDED`); a plain debit of it
+     * is allowed.
+     */
     adjust(input: {
         accountId: string;
         amount: number;
@@ -120,10 +163,13 @@ export interface StoredValueModule {
     /**
      * Requires ManageStoredValue. The account's value is valid through `expiresOn` (`YYYY-MM-DD`,
      * store zone); `null` clears it. A day already over is refused (`STORED_VALUE_EXPIRY_INVALID`);
-     * value the job already booked as expired stays booked.
+     * value the job already booked as expired stays booked. A voided gift card's expiry never changes
+     * (`STORED_VALUE_GIFT_CARD_VOIDED`).
      */
     setExpiry(id: string, expiresOn: string | null, reason: string, options?: Call): Promise<StoredValueAccount>;
+    /** A voided gift card is refused (`STORED_VALUE_GIFT_CARD_VOIDED`): it is blocked for good. */
     block(id: string, reason: string, options?: Call): Promise<StoredValueAccount>;
+    /** A voided gift card is refused (`STORED_VALUE_GIFT_CARD_VOIDED`): it is blocked for good. */
     unblock(id: string, reason: string, options?: Call): Promise<StoredValueAccount>;
     /**
      * Pay part (or all) of an order from an account (`redeemStoredValue`), through the platform's
@@ -132,6 +178,159 @@ export interface StoredValueModule {
      * payment the SERVER recorded for this call; a repeat under the same key answers the same one.
      */
     redeem(input: RedeemStoredValueInput, options?: Call): Promise<StoredValueRedemption>;
+    /**
+     * Requires ReadStoredValue. The store's refund-to-credit switch and whether it is usable now.
+     * Needs an engine that serves `storeCreditSettings` (incentives sprint 8).
+     */
+    storeCreditSettings(options?: Call): Promise<StoreCreditSettings>;
+    /**
+     * Requires ManageStoredValue. Switch refund to store credit on or off: whether "credit the
+     * customer" may put an order's money in the customer's store-credit wallet instead of refunding
+     * it. Turning it on is refused `STORE_CREDIT_STORE_KEEPS_ACCOUNTS` (the store keeps its
+     * customers' balances on their accounts), `STORE_CREDIT_NOT_GRANTED` (no Stored Value grant)
+     * and `STORE_CREDIT_METHOD_REQUIRED` (no enabled stored-value payment method); turning it off
+     * always works. A setting written whole: no key.
+     */
+    updateStoreCreditSettings(input: {
+        refundToCredit: boolean;
+    }, options?: Call): Promise<StoreCreditSettings>;
+    /** Gift cards: sold on orders, one per paid unit, or issued by staff; each its own account. */
+    giftCards: GiftCardModule;
+}
+/**
+ * A gift card. Its code is never readable: the card is found by id, by order, or by the code
+ * itself (`byCode`, which answers it masked).
+ */
+export interface GiftCard {
+    /** The card's account id. */
+    id: string;
+    createdAt: string;
+    account: StoredValueAccount;
+    /**
+     * `sale`: sold on an order, one card per paid unit. `staff`: issued by staff with no sale
+     * (`giftCards.issue`), on no order.
+     */
+    origin: 'sale' | 'staff';
+    orderId: string | null;
+    orderLineId: string | null;
+    /** The 0-based unit of the order line this card was issued for. */
+    unitIndex: number | null;
+    productVariantId: string | null;
+    /** What the unit was paid, or what staff issued, minor units of the account's unit. */
+    faceValue: number;
+    /** The code's last four characters behind a mask. */
+    maskedCode: string;
+    /** A void blocked the card for good (its account `status` is `voided`); see `void`. */
+    voided: boolean;
+}
+/**
+ * A gift card and the code it was just given. `code` (`XXXX-XXXX-XXXX-XXXX`) is shown ONCE: it is
+ * null when the code went to the buyer by email, and on a repeat under the same `idempotencyKey`
+ * (the server keeps the card's id, never the code).
+ */
+export interface IssuedGiftCard {
+    giftCard: GiftCard;
+    code: string | null;
+}
+/** A gift card staff issue with no sale (`giftCards.issue`). */
+export interface IssueGiftCardInput {
+    /** Minor units, greater than zero. */
+    amount: number;
+    /** An ISO 4217 currency the store sells. */
+    currencyCode: string;
+    reason: string;
+    /** Valid through this day (`YYYY-MM-DD`) in the store's time zone; omitted or null: never expires. */
+    expiresOn?: string | null;
+}
+/** A variant this store sells as a gift card. */
+export interface GiftCardVariant {
+    productVariantId: string;
+    /** A sold card is valid this many calendar months from its issue day; null: never expires. */
+    validityMonths: number | null;
+    createdAt: string;
+}
+export interface GiftCardModule {
+    /** Requires ReadStoredValue. Newest first; `orderId` lists the cards an order sold. */
+    list(filter?: {
+        orderId?: string;
+        origin?: 'sale' | 'staff';
+        take?: number;
+        skip?: number;
+    }, options?: Call): Promise<{
+        items: GiftCard[];
+        totalItems: number;
+    }>;
+    get(id: string, options?: Call): Promise<GiftCard | null>;
+    /**
+     * Requires ReadStoredValue. This store's card for a code, masked, or null: an unknown,
+     * malformed or other store's code answers the same null. Sent as a POST (a code never goes in a
+     * URL), one lookup per request, and budgeted per token: past the budget it is refused
+     * `RATE_LIMITED` with a wait.
+     */
+    byCode(code: string, options?: Call): Promise<GiftCard | null>;
+    /** Requires ReadStoredValue. Which of these variants the store sells as gift cards. */
+    variants(productVariantIds: string[], options?: Call): Promise<GiftCardVariant[]>;
+    /**
+     * Requires ReadStoredValue. How many of this store's orders would issue a gift card of the
+     * variant once paid in full, and so issue none once it is switched off: what the "stop selling"
+     * confirmation names. The engine's issuing rule: an order of this store alone, not cancelled and
+     * not imported, with a unit of the variant priced above zero that has no card yet, and not paid
+     * in full (no settled payment yet, or its settled money below what it bills). Carts, drafts and
+     * placed orders not yet paid in full count alike. `null` when the store does not sell the
+     * variant as a gift card. Read now, without a lock.
+     *
+     * Its own document rather than a field of {@link variants}, so the tab's read pays for no count
+     * and a release of this SDK reading an older engine fails only this call. Needs an engine that
+     * serves `GiftCardVariant.unpaidOrders`.
+     */
+    variantUnpaidOrders(productVariantId: string, options?: Call): Promise<number | null>;
+    /**
+     * Requires ManageStoredValue. Sell a variant as a gift card (or stop: `enabled: false` answers
+     * null). Turning it on is refused once the variant has sold as an ordinary product.
+     * `validityMonths` omitted keeps the validity already set; `null` means no expiry.
+     */
+    setVariant(productVariantId: string, enabled: boolean, validityMonths?: number | null, options?: Call): Promise<GiftCardVariant | null>;
+    /**
+     * Requires ManageStoredValue, or no Stored Value grant at all for a card the store sold. The
+     * step before refunding a gift card's sale: blocks the card for good (status `voided`) and
+     * withdraws what it can still spend, which releases that much of its order's money for a refund (never what the card spent,
+     * never value past its expiry). A second void takes only what became spendable since (a refund
+     * credited back to the card). Send an `idempotencyKey`: a
+     * repeat answers the card as it is then and voids nothing again. A card of another store is not
+     * found; a voided card is never unblocked (`STORED_VALUE_GIFT_CARD_VOIDED`).
+     */
+    void(id: string, reason: string, options?: Call): Promise<GiftCard>;
+    /**
+     * Requires ManageStoredValue (an app installation is refused). A new code for a live gift card:
+     * the old code stops working at once; the balance, expiry, statement and status stay. The code
+     * goes to ONE place:
+     * - `notify: true` emails it to the buyer of a card sold on an order, and `code` is null. A card
+     *   no email can reach (issued with no sale, no email delivery, a buyer whose address cannot
+     *   receive it) is refused `STORED_VALUE_GIFT_CARD_NOT_MAILABLE`, nothing changed;
+     * - `notify: false` answers it in `code`, once, for staff to hand over.
+     *
+     * Send an `idempotencyKey`: a repeat answers the card with `code: null` and changes nothing
+     * again. The first answer is the only copy of a code it shows: a lost one is replaced by another
+     * reissue under a NEW key. A voided card is refused (`STORED_VALUE_GIFT_CARD_VOIDED`); a card of
+     * another store is not found.
+     */
+    reissueCode(id: string, input: {
+        reason: string;
+        notify: boolean;
+    }, options?: Call): Promise<IssuedGiftCard>;
+    /**
+     * Requires ManageStoredValue (an app installation is refused). A bearer gift card with no sale
+     * (goodwill): value created without payment, booked as liability with `origin: 'staff'`. No email
+     * is sent: `code` is in the answer ONCE, for staff to hand over.
+     *
+     * Send an `idempotencyKey`: a repeat answers the card with `code: null` and issues nothing again.
+     * The first answer is the only copy of the code: a lost one is replaced by `reissueCode` on the
+     * card (`notify: false`). Refusals: `STORED_VALUE_ROOT_CHANNEL_NOT_ALLOWED`,
+     * `STORED_VALUE_REASON_REQUIRED`, `STORED_VALUE_AMOUNT_INVALID`, `STORED_VALUE_UNIT_INVALID` (a
+     * currency the store does not sell), `STORED_VALUE_GIFT_CARD_NOT_CONFIGURED`,
+     * `STORED_VALUE_EXPIRY_INVALID` (not a day, or a day already over), `STORED_VALUE_POSTING_CONFLICT`.
+     */
+    issue(input: IssueGiftCardInput, options?: Call): Promise<IssuedGiftCard>;
 }
 /** What a redemption recorded: the order, the payment this call created, the account and amount. */
 export interface StoredValueRedemption {
@@ -151,4 +350,15 @@ export declare const BLOCK_STORED_VALUE_MUTATION = "\n  mutation BlockStoredValu
 export declare const UNBLOCK_STORED_VALUE_MUTATION = "\n  mutation UnblockStoredValueAccount($id: ID!, $reason: String!) {\n    unblockStoredValueAccount(id: $id, reason: $reason) { \n  id\n  createdAt\n  updatedAt\n  kind\n  unit\n  customerId\n  codeLast4\n  expiresAt\n  expiresOn\n  status\n  balance\n  spendable\n }\n  }\n";
 export declare const SET_STORED_VALUE_EXPIRY_MUTATION = "\n  mutation SetStoredValueAccountExpiry(\n    $id: ID!\n    $expiresOn: String\n    $reason: String!\n    $idempotencyKey: String\n  ) {\n    setStoredValueAccountExpiry(\n      id: $id\n      expiresOn: $expiresOn\n      reason: $reason\n      idempotencyKey: $idempotencyKey\n    ) { \n  id\n  createdAt\n  updatedAt\n  kind\n  unit\n  customerId\n  codeLast4\n  expiresAt\n  expiresOn\n  status\n  balance\n  spendable\n }\n  }\n";
 export declare const REDEEM_STORED_VALUE_MUTATION = "\n  mutation RedeemStoredValue($input: RedeemStoredValueInput!, $idempotencyKey: String) {\n    redeemStoredValue(input: $input, idempotencyKey: $idempotencyKey) {\n      orderId\n      paymentId\n      accountId\n      amount\n    }\n  }\n";
+export declare const STORE_CREDIT_SETTINGS_QUERY = "\n  query StoreCreditSettings {\n    storeCreditSettings { \n  refundToCredit\n  book\n  available\n  code\n  message\n }\n  }\n";
+export declare const UPDATE_STORE_CREDIT_SETTINGS_MUTATION = "\n  mutation UpdateStoreCreditSettings($input: UpdateStoreCreditSettingsInput!) {\n    updateStoreCreditSettings(input: $input) { \n  refundToCredit\n  book\n  available\n  code\n  message\n }\n  }\n";
+export declare const GIFT_CARDS_QUERY = "\n  query GiftCards($orderId: ID, $origin: String, $take: Int, $skip: Int) {\n    giftCards(orderId: $orderId, origin: $origin, take: $take, skip: $skip) {\n      items { \n  id\n  createdAt\n  account { \n  id\n  createdAt\n  updatedAt\n  kind\n  unit\n  customerId\n  codeLast4\n  expiresAt\n  expiresOn\n  status\n  balance\n  spendable\n }\n  origin\n  orderId\n  orderLineId\n  unitIndex\n  productVariantId\n  faceValue\n  maskedCode\n  voided\n }\n      totalItems\n    }\n  }\n";
+export declare const GIFT_CARD_QUERY = "\n  query GiftCard($id: ID!) {\n    giftCard(id: $id) { \n  id\n  createdAt\n  account { \n  id\n  createdAt\n  updatedAt\n  kind\n  unit\n  customerId\n  codeLast4\n  expiresAt\n  expiresOn\n  status\n  balance\n  spendable\n }\n  origin\n  orderId\n  orderLineId\n  unitIndex\n  productVariantId\n  faceValue\n  maskedCode\n  voided\n }\n  }\n";
+export declare const GIFT_CARD_BY_CODE_QUERY = "\n  query GiftCardByCode($code: String!) {\n    giftCardByCode(code: $code) { \n  id\n  createdAt\n  account { \n  id\n  createdAt\n  updatedAt\n  kind\n  unit\n  customerId\n  codeLast4\n  expiresAt\n  expiresOn\n  status\n  balance\n  spendable\n }\n  origin\n  orderId\n  orderLineId\n  unitIndex\n  productVariantId\n  faceValue\n  maskedCode\n  voided\n }\n  }\n";
+export declare const GIFT_CARD_VARIANTS_QUERY = "\n  query GiftCardVariants($productVariantIds: [ID!]!) {\n    giftCardVariants(productVariantIds: $productVariantIds) {\n      productVariantId\n      validityMonths\n      createdAt\n    }\n  }\n";
+export declare const GIFT_CARD_VARIANT_UNPAID_ORDERS_QUERY = "\n  query GiftCardVariantUnpaidOrders($productVariantIds: [ID!]!) {\n    giftCardVariants(productVariantIds: $productVariantIds) {\n      productVariantId\n      unpaidOrders\n    }\n  }\n";
+export declare const SET_GIFT_CARD_VARIANT_MUTATION = "\n  mutation SetGiftCardVariant($productVariantId: ID!, $enabled: Boolean!, $validityMonths: Int) {\n    setGiftCardVariant(\n      productVariantId: $productVariantId\n      enabled: $enabled\n      validityMonths: $validityMonths\n    ) {\n      productVariantId\n      validityMonths\n      createdAt\n    }\n  }\n";
+export declare const VOID_GIFT_CARD_MUTATION = "\n  mutation VoidGiftCard($id: ID!, $reason: String!, $idempotencyKey: String) {\n    voidGiftCard(id: $id, reason: $reason, idempotencyKey: $idempotencyKey) { \n  id\n  createdAt\n  account { \n  id\n  createdAt\n  updatedAt\n  kind\n  unit\n  customerId\n  codeLast4\n  expiresAt\n  expiresOn\n  status\n  balance\n  spendable\n }\n  origin\n  orderId\n  orderLineId\n  unitIndex\n  productVariantId\n  faceValue\n  maskedCode\n  voided\n }\n  }\n";
+export declare const REISSUE_GIFT_CARD_CODE_MUTATION = "\n  mutation ReissueGiftCardCode(\n    $id: ID!\n    $reason: String!\n    $notify: Boolean!\n    $idempotencyKey: String\n  ) {\n    reissueGiftCardCode(\n      id: $id\n      reason: $reason\n      notify: $notify\n      idempotencyKey: $idempotencyKey\n    ) {\n      giftCard { \n  id\n  createdAt\n  account { \n  id\n  createdAt\n  updatedAt\n  kind\n  unit\n  customerId\n  codeLast4\n  expiresAt\n  expiresOn\n  status\n  balance\n  spendable\n }\n  origin\n  orderId\n  orderLineId\n  unitIndex\n  productVariantId\n  faceValue\n  maskedCode\n  voided\n }\n      code\n    }\n  }\n";
+export declare const ISSUE_GIFT_CARD_MUTATION = "\n  mutation IssueGiftCard($input: IssueGiftCardInput!, $idempotencyKey: String) {\n    issueGiftCard(input: $input, idempotencyKey: $idempotencyKey) {\n      giftCard { \n  id\n  createdAt\n  account { \n  id\n  createdAt\n  updatedAt\n  kind\n  unit\n  customerId\n  codeLast4\n  expiresAt\n  expiresOn\n  status\n  balance\n  spendable\n }\n  origin\n  orderId\n  orderLineId\n  unitIndex\n  productVariantId\n  faceValue\n  maskedCode\n  voided\n }\n      code\n    }\n  }\n";
 export declare function createStoredValueModule(transport: Transport): StoredValueModule;

package/dist/stored-value/index.js

@@ -91,6 +91,115 @@ export const REDEEM_STORED_VALUE_MUTATION = /* GraphQL */ `
     }
   }
 `;
+const STORE_CREDIT_SETTINGS_FIELDS = `
+  refundToCredit
+  book
+  available
+  code
+  message
+`;
+export const STORE_CREDIT_SETTINGS_QUERY = /* GraphQL */ `
+  query StoreCreditSettings {
+    storeCreditSettings { ${STORE_CREDIT_SETTINGS_FIELDS} }
+  }
+`;
+export const UPDATE_STORE_CREDIT_SETTINGS_MUTATION = /* GraphQL */ `
+  mutation UpdateStoreCreditSettings($input: UpdateStoreCreditSettingsInput!) {
+    updateStoreCreditSettings(input: $input) { ${STORE_CREDIT_SETTINGS_FIELDS} }
+  }
+`;
+const GIFT_CARD_FIELDS = `
+  id
+  createdAt
+  account { ${ACCOUNT_FIELDS} }
+  origin
+  orderId
+  orderLineId
+  unitIndex
+  productVariantId
+  faceValue
+  maskedCode
+  voided
+`;
+export const GIFT_CARDS_QUERY = /* GraphQL */ `
+  query GiftCards($orderId: ID, $origin: String, $take: Int, $skip: Int) {
+    giftCards(orderId: $orderId, origin: $origin, take: $take, skip: $skip) {
+      items { ${GIFT_CARD_FIELDS} }
+      totalItems
+    }
+  }
+`;
+export const GIFT_CARD_QUERY = /* GraphQL */ `
+  query GiftCard($id: ID!) {
+    giftCard(id: $id) { ${GIFT_CARD_FIELDS} }
+  }
+`;
+export const GIFT_CARD_BY_CODE_QUERY = /* GraphQL */ `
+  query GiftCardByCode($code: String!) {
+    giftCardByCode(code: $code) { ${GIFT_CARD_FIELDS} }
+  }
+`;
+export const GIFT_CARD_VARIANTS_QUERY = /* GraphQL */ `
+  query GiftCardVariants($productVariantIds: [ID!]!) {
+    giftCardVariants(productVariantIds: $productVariantIds) {
+      productVariantId
+      validityMonths
+      createdAt
+    }
+  }
+`;
+export const GIFT_CARD_VARIANT_UNPAID_ORDERS_QUERY = /* GraphQL */ `
+  query GiftCardVariantUnpaidOrders($productVariantIds: [ID!]!) {
+    giftCardVariants(productVariantIds: $productVariantIds) {
+      productVariantId
+      unpaidOrders
+    }
+  }
+`;
+export const SET_GIFT_CARD_VARIANT_MUTATION = /* GraphQL */ `
+  mutation SetGiftCardVariant($productVariantId: ID!, $enabled: Boolean!, $validityMonths: Int) {
+    setGiftCardVariant(
+      productVariantId: $productVariantId
+      enabled: $enabled
+      validityMonths: $validityMonths
+    ) {
+      productVariantId
+      validityMonths
+      createdAt
+    }
+  }
+`;
+export const VOID_GIFT_CARD_MUTATION = /* GraphQL */ `
+  mutation VoidGiftCard($id: ID!, $reason: String!, $idempotencyKey: String) {
+    voidGiftCard(id: $id, reason: $reason, idempotencyKey: $idempotencyKey) { ${GIFT_CARD_FIELDS} }
+  }
+`;
+export const REISSUE_GIFT_CARD_CODE_MUTATION = /* GraphQL */ `
+  mutation ReissueGiftCardCode(
+    $id: ID!
+    $reason: String!
+    $notify: Boolean!
+    $idempotencyKey: String
+  ) {
+    reissueGiftCardCode(
+      id: $id
+      reason: $reason
+      notify: $notify
+      idempotencyKey: $idempotencyKey
+    ) {
+      giftCard { ${GIFT_CARD_FIELDS} }
+      code
+    }
+  }
+`;
+export const ISSUE_GIFT_CARD_MUTATION = /* GraphQL */ `
+  mutation IssueGiftCard($input: IssueGiftCardInput!, $idempotencyKey: String) {
+    issueGiftCard(input: $input, idempotencyKey: $idempotencyKey) {
+      giftCard { ${GIFT_CARD_FIELDS} }
+      code
+    }
+  }
+`;
 export function createStoredValueModule(transport) {
     const read = async (query, variables, options) => transport.graphql({ api: 'admin', query, variables }, options);
     // The key is an ARGUMENT on the Admin API; `undefined` keeps an omitted key off the wire.
@@ -126,5 +235,48 @@ export function createStoredValueModule(transport) {
         async redeem(input, options) {
             return (await write(REDEEM_STORED_VALUE_MUTATION, { input }, options)).redeemStoredValue;
         },
+        async storeCreditSettings(options) {
+            return (await read(STORE_CREDIT_SETTINGS_QUERY, {}, options)).storeCreditSettings;
+        },
+        async updateStoreCreditSettings(input, options) {
+            return (await read(UPDATE_STORE_CREDIT_SETTINGS_MUTATION, { input: { refundToCredit: input.refundToCredit } }, options)).updateStoreCreditSettings;
+        },
+        giftCards: {
+            async list(filter = {}, options) {
+                return (await read(GIFT_CARDS_QUERY, filter, options)).giftCards;
+            },
+            async get(id, options) {
+                return (await read(GIFT_CARD_QUERY, { id }, options))
+                    .giftCard;
+            },
+            // A GraphQL call is always a POST body: the code never reaches a URL (the engine refuses a
+            // GET lookup, `STORED_VALUE_GIFT_CARD_LOOKUP_POST_ONLY`).
+            async byCode(code, options) {
+                return (await read(GIFT_CARD_BY_CODE_QUERY, { code }, options)).giftCardByCode;
+            },
+            async variants(productVariantIds, options) {
+                return (await read(GIFT_CARD_VARIANTS_QUERY, { productVariantIds }, options)).giftCardVariants;
+            },
+            async variantUnpaidOrders(productVariantId, options) {
+                const [variant] = (await read(GIFT_CARD_VARIANT_UNPAID_ORDERS_QUERY, { productVariantIds: [productVariantId] }, options)).giftCardVariants;
+                return variant ? variant.unpaidOrders : null;
+            },
+            async setVariant(productVariantId, enabled, validityMonths, options) {
+                return (await read(SET_GIFT_CARD_VARIANT_MUTATION, {
+                    productVariantId,
+                    enabled,
+                    ...(validityMonths === undefined ? {} : { validityMonths }),
+                }, options)).setGiftCardVariant;
+            },
+            async void(id, reason, options) {
+                return (await write(VOID_GIFT_CARD_MUTATION, { id, reason }, options)).voidGiftCard;
+            },
+            async reissueCode(id, input, options) {
+                return (await write(REISSUE_GIFT_CARD_CODE_MUTATION, { id, reason: input.reason, notify: input.notify }, options)).reissueGiftCardCode;
+            },
+            async issue(input, options) {
+                return (await write(ISSUE_GIFT_CARD_MUTATION, { input }, options)).issueGiftCard;
+            },
+        },
     };
 }