@sixtyninecommerce/admin 0.8.0 → 0.10.0

package/dist/stock/transfers.js

@@ -0,0 +1,437 @@
+import { pageFromVendureList, readOffsetCursor, } from '@sixtyninecommerce/core';
+import { decodeBase64, MYPARCEL_LABEL_TIMEOUT_MS, toUnretractedShipments, UNRETRACTED_SHIPMENT_FIELDS, } from '../fulfillments/index.js';
+const TRANSFER_FIELDS = /* GraphQL */ `
+  id
+  code
+  kind
+  state
+  sourceLocation { id name }
+  destinationLocation { id name }
+  label
+  note
+  carrier
+  trackingCode
+  estimatedArrivalAt
+  shippedAt
+  receivedAt
+  cancelledAt
+  cancelReason
+  deliveryAddress {
+    contactName
+    company
+    streetLine1
+    streetLine2
+    city
+    province
+    postalCode
+    countryCode
+    phoneNumber
+  }
+  createdAt
+  updatedAt
+  items {
+    id
+    productVariant { id sku }
+    quantity
+    receivedQuantity
+    lostQuantity
+    outstandingQuantity
+  }
+  totalQuantity
+  totalReceivedQuantity
+  totalLostQuantity
+`;
+export const STOCK_TRANSFERS_QUERY = /* GraphQL */ `
+  query StockTransfers($options: StockTransferListOptions) {
+    stockTransfers(options: $options) { items { ${TRANSFER_FIELDS} } totalItems }
+  }
+`;
+export const STOCK_TRANSFER_QUERY = /* GraphQL */ `
+  query StockTransfer($id: ID!) { stockTransfer(id: $id) { ${TRANSFER_FIELDS} } }
+`;
+export const CREATE_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
+  mutation CreateStockTransfer($input: CreateStockTransferInput!) {
+    createStockTransfer(input: $input) { ${TRANSFER_FIELDS} }
+  }
+`;
+export const UPDATE_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
+  mutation UpdateStockTransfer($id: ID!, $input: UpdateStockTransferInput!) {
+    updateStockTransfer(id: $id, input: $input) { ${TRANSFER_FIELDS} }
+  }
+`;
+export const SHIP_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
+  mutation ShipStockTransfer($id: ID!, $input: ShipStockTransferInput) {
+    shipStockTransfer(id: $id, input: $input) { ${TRANSFER_FIELDS} }
+  }
+`;
+export const POST_STOCK_TRANSFER_CONSUMPTION_MUTATION = /* GraphQL */ `
+  mutation PostStockTransferConsumption($id: ID!) {
+    postStockTransferConsumption(id: $id) { ${TRANSFER_FIELDS} }
+  }
+`;
+export const RECEIVE_STOCK_TRANSFER_LINES_MUTATION = /* GraphQL */ `
+  mutation ReceiveStockTransferLines($id: ID!, $lines: [ReceiveStockTransferLineInput!]!) {
+    receiveStockTransferLines(id: $id, lines: $lines) { ${TRANSFER_FIELDS} }
+  }
+`;
+export const CLOSE_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
+  mutation CloseStockTransfer($id: ID!, $acceptShortfallAsLost: Boolean) {
+    closeStockTransfer(id: $id, acceptShortfallAsLost: $acceptShortfallAsLost) { ${TRANSFER_FIELDS} }
+  }
+`;
+/**
+ * Its own document: it declares `$shortfall`, which an engine without per-line
+ * dispositions refuses as a whole. A close without dispositions keeps sending
+ * the document above.
+ */
+export const CLOSE_STOCK_TRANSFER_WITH_SHORTFALL_MUTATION = /* GraphQL */ `
+  mutation CloseStockTransferWithShortfall(
+    $id: ID!
+    $acceptShortfallAsLost: Boolean
+    $shortfall: [StockTransferShortfallLineInput!]!
+  ) {
+    closeStockTransfer(
+      id: $id
+      acceptShortfallAsLost: $acceptShortfallAsLost
+      shortfall: $shortfall
+    ) { ${TRANSFER_FIELDS} }
+  }
+`;
+export const CANCEL_STOCK_TRANSFER_MUTATION = /* GraphQL */ `
+  mutation CancelStockTransfer($id: ID!, $reason: String) {
+    cancelStockTransfer(id: $id, reason: $reason) { ${TRANSFER_FIELDS} }
+  }
+`;
+export const CREATE_STOCK_TRANSFER_RETURN_MUTATION = /* GraphQL */ `
+  mutation CreateStockTransferReturn($id: ID!, $input: CreateStockTransferReturnInput!) {
+    createStockTransferReturn(id: $id, input: $input) { ${TRANSFER_FIELDS} }
+  }
+`;
+/**
+ * The return fields, in a document of their own like the parcel fields below:
+ * `get`/`list` keep working against an engine without them.
+ */
+const RETURN_REF_FIELDS = /* GraphQL */ `
+  id
+  code
+  state
+  label
+  sourceLocation { id name }
+  destinationLocation { id name }
+  createdAt
+  totalQuantity
+`;
+export const STOCK_TRANSFER_RETURNS_QUERY = /* GraphQL */ `
+  query StockTransferReturns($id: ID!) {
+    stockTransfer(id: $id) {
+      returnOfTransferId
+      returnOf { ${RETURN_REF_FIELDS} }
+      returns { ${RETURN_REF_FIELDS} }
+      returnableLines {
+        productVariantId
+        productVariant { name sku }
+        receivedQuantity
+        returnedQuantity
+        returnableQuantity
+      }
+    }
+  }
+`;
+/** The per-line settlement fields, in a document of their own like the return fields. */
+export const STOCK_TRANSFER_SHORTFALL_QUERY = /* GraphQL */ `
+  query StockTransferShortfall($id: ID!) {
+    stockTransfer(id: $id) {
+      id
+      state
+      items {
+        id
+        productVariant { id sku }
+        quantity
+        receivedQuantity
+        lostQuantity
+        returnedToSourceQuantity
+        outstandingQuantity
+      }
+      totalLostQuantity
+      totalReturnedToSourceQuantity
+    }
+  }
+`;
+function toShortfall(raw) {
+    return {
+        transferId: raw.id,
+        state: raw.state,
+        lines: raw.items.map(({ id, productVariant, ...quantities }) => ({
+            lineId: id,
+            variantId: productVariant.id,
+            sku: productVariant.sku,
+            ...quantities,
+        })),
+        totalLostQuantity: raw.totalLostQuantity,
+        totalReturnedToSourceQuantity: raw.totalReturnedToSourceQuantity,
+    };
+}
+/**
+ * The cancellation fields, in a document of their own like the return and
+ * parcel fields: `cancelledBy` is newer than the transfer module, and
+ * `get`/`list`/`cancel` keep working against an engine without it.
+ */
+export const STOCK_TRANSFER_CANCELLATION_QUERY = /* GraphQL */ `
+  query StockTransferCancellation($id: ID!) {
+    stockTransfer(id: $id) {
+      id
+      state
+      cancelledAt
+      cancelReason
+      cancelledBy { id firstName lastName }
+      fulfillmentHandlerCode
+      hendriksRemotePath
+      hendriksBluJayOrderNumber
+    }
+  }
+`;
+/**
+ * The parcel fields, in documents of their own: `TRANSFER_FIELDS` stays what
+ * every engine since the transfer module answers, so `get`/`list` keep working
+ * against an engine one version behind.
+ */
+const PARCEL_FIELDS = /* GraphQL */ `
+  id
+  state
+  fulfillmentHandlerCode
+  parcelCount
+  myparcelParcels { ordinal shipmentId barcode labelReady lastError }
+  trackingCodes
+  myparcelBarcode
+  myparcelLastError
+  myparcelUnretractedShipments { ${UNRETRACTED_SHIPMENT_FIELDS} }
+`;
+export const STOCK_TRANSFER_PARCELS_QUERY = /* GraphQL */ `
+  query StockTransferParcels($id: ID!) { stockTransfer(id: $id) { ${PARCEL_FIELDS} } }
+`;
+export const RETRY_STOCK_TRANSFER_MYPARCEL_SHIPMENTS_MUTATION = /* GraphQL */ `
+  mutation RetryStockTransferMyparcelShipments($id: ID!) {
+    retryStockTransferMyparcelShipments(id: $id) { ${PARCEL_FIELDS} }
+  }
+`;
+export const LABEL_STOCK_TRANSFER_MYPARCEL_PARCELS_MUTATION = /* GraphQL */ `
+  mutation LabelStockTransferMyparcelParcels($id: ID!) {
+    labelStockTransferMyparcelParcels(id: $id) { ${PARCEL_FIELDS} }
+  }
+`;
+export const MYPARCEL_STOCK_TRANSFER_LABEL_MUTATION = /* GraphQL */ `
+  mutation MyparcelStockTransferLabel($transferId: ID!, $format: StockTransferLabelFormat!) {
+    getMyparcelStockTransferLabel(transferId: $transferId, format: $format) {
+      format
+      base64
+      contentType
+      filename
+    }
+  }
+`;
+const MYPARCEL_HANDLER_CODE = 'myparcel';
+/**
+ * A MyParcel ship and its retry book every parcel at MyParcel before they
+ * answer (per parcel an adopt-by-reference lookup of up to 3 × 10s plus two
+ * capped waits, and a 30s POST), and a cancel voids every parcel there. The
+ * default 15s aborted calls the engine went on to finish, so the caller saw a
+ * failure for a ship, booking or cancel that succeeded.
+ */
+const CARRIER_CALL_TIMEOUT_MS = 120_000;
+/**
+ * A transfer shipped before per-parcel labels keeps no parcel map: its label
+ * job records the one barcode on the transfer (`myparcelBarcode`) only, so the
+ * engine lists its single parcel without one for ever. Fold it in — for a
+ * single parcel only: with several, `myparcelBarcode` may be ANOTHER parcel's
+ * (the first one known).
+ */
+function withLegacyBarcode(parcels, trackingCodes, transferBarcode) {
+    const only = parcels.length === 1 ? parcels[0] : undefined;
+    const barcode = transferBarcode?.trim();
+    if (!only || only.barcode || !barcode)
+        return { parcels, trackingCodes };
+    return {
+        parcels: [{ ...only, barcode }],
+        trackingCodes: trackingCodes.includes(barcode) ? trackingCodes : [barcode, ...trackingCodes],
+    };
+}
+function toParcels(raw) {
+    const { parcels, trackingCodes } = withLegacyBarcode([...(raw.myparcelParcels ?? [])].sort((a, b) => a.ordinal - b.ordinal), raw.trackingCodes ?? [], raw.myparcelBarcode);
+    // The engine stores what was ASKED; a count below the parcels actually
+    // booked (a row an older writer left) must not hide one of them.
+    const hasShipment = raw.fulfillmentHandlerCode === MYPARCEL_HANDLER_CODE ||
+        parcels.length > 0 ||
+        raw.parcelCount !== null;
+    return {
+        transferId: raw.id,
+        state: raw.state,
+        fulfillmentHandlerCode: raw.fulfillmentHandlerCode,
+        parcelCount: hasShipment ? Math.max(raw.parcelCount ?? 1, parcels.length) : null,
+        parcels,
+        trackingCodes,
+        lastError: raw.myparcelLastError,
+        unretractedShipments: toUnretractedShipments(raw.myparcelUnretractedShipments),
+    };
+}
+const HENDRIKS_HANDLER_CODE = 'hendriks-3pl';
+function toCancellation(raw) {
+    // The engine's own rule (its cancel warning): an export is on record only
+    // with its remote path. A removed shipment clears the path but keeps the
+    // BluJay number for a re-ship, so the number alone proves no export.
+    const exported = raw.fulfillmentHandlerCode === HENDRIKS_HANDLER_CODE && Boolean(raw.hendriksRemotePath);
+    return {
+        transferId: raw.id,
+        state: raw.state,
+        cancelledAt: raw.cancelledAt,
+        cancelReason: raw.cancelReason,
+        cancelledBy: raw.cancelledBy,
+        hendriksExport: exported ? { bluJayOrderNumber: raw.hendriksBluJayOrderNumber } : null,
+    };
+}
+function toTransfer(raw) {
+    return {
+        ...raw,
+        items: raw.items.map(({ productVariant, ...line }) => ({
+            ...line,
+            variantId: productVariant.id,
+            sku: productVariant.sku,
+        })),
+    };
+}
+function toReturns(raw) {
+    return {
+        returnOfTransferId: raw.returnOfTransferId,
+        returnOf: raw.returnOf,
+        returns: raw.returns,
+        returnableLines: raw.returnableLines.map(({ productVariantId, productVariant, ...quantities }) => ({
+            variantId: productVariantId,
+            sku: productVariant.sku,
+            variantName: productVariant.name,
+            ...quantities,
+        })),
+    };
+}
+const toLines = (lines) => lines.map((line) => ({ productVariantId: line.variantId, quantity: line.quantity }));
+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]);
+    };
+    const listPage = async (skip, take, filter) => {
+        const data = await transport.graphql({
+            api: 'admin',
+            query: STOCK_TRANSFERS_QUERY,
+            variables: {
+                options: {
+                    skip,
+                    take,
+                    locationId: filter?.locationId,
+                    sourceLocationId: filter?.sourceLocationId,
+                    destinationLocationId: filter?.destinationLocationId,
+                    state: filter?.state,
+                    dateFrom: filter?.dateFrom,
+                    dateTo: filter?.dateTo,
+                    search: filter?.search,
+                    // Only when set: an engine without returns refuses an unknown
+                    // input field, which would fail every list against it.
+                    ...(filter?.returnOfTransferId === undefined
+                        ? {}
+                        : { returnOfTransferId: filter.returnOfTransferId }),
+                    ...(filter?.isReturn === undefined ? {} : { isReturn: filter.isReturn }),
+                },
+            },
+        }, filter);
+        return pageFromVendureList({
+            items: data.stockTransfers.items.map(toTransfer),
+            totalItems: data.stockTransfers.totalItems,
+        }, skip, take, (cursor) => listPage(readOffsetCursor(cursor), take, filter));
+    };
+    return {
+        list(filter) {
+            const take = filter?.limit ?? DEFAULT_PAGE_SIZE;
+            const skip = filter?.after === undefined ? 0 : readOffsetCursor(filter.after);
+            return listPage(skip, take, filter);
+        },
+        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);
+        },
+        create(input, options) {
+            const { lines, ...rest } = input;
+            return one('createStockTransfer', CREATE_STOCK_TRANSFER_MUTATION, { input: { ...rest, lines: toLines(lines) } }, options);
+        },
+        update(id, input, options) {
+            const { lines, ...rest } = input;
+            return one('updateStockTransfer', UPDATE_STOCK_TRANSFER_MUTATION, { id, input: { ...rest, ...(lines === undefined ? {} : { lines: toLines(lines) }) } }, options);
+        },
+        ship(id, input, options) {
+            return one('shipStockTransfer', SHIP_STOCK_TRANSFER_MUTATION, { id, input }, { timeoutMs: CARRIER_CALL_TIMEOUT_MS, ...options });
+        },
+        postConsumption(id, options) {
+            return one('postStockTransferConsumption', POST_STOCK_TRANSFER_CONSUMPTION_MUTATION, { id }, options);
+        },
+        receive(id, lines, options) {
+            return one('receiveStockTransferLines', RECEIVE_STOCK_TRANSFER_LINES_MUTATION, { id, lines }, options);
+        },
+        close(id, options) {
+            const shortfall = options?.shortfall ?? [];
+            if (shortfall.length === 0) {
+                return one('closeStockTransfer', CLOSE_STOCK_TRANSFER_MUTATION, { id, acceptShortfallAsLost: options?.acceptShortfallAsLost }, options);
+            }
+            return one('closeStockTransfer', CLOSE_STOCK_TRANSFER_WITH_SHORTFALL_MUTATION, {
+                id,
+                acceptShortfallAsLost: options?.acceptShortfallAsLost,
+                shortfall: shortfall.map(({ lineId, disposition }) => ({ lineId, disposition })),
+            }, options);
+        },
+        cancel(id, options) {
+            return one('cancelStockTransfer', CANCEL_STOCK_TRANSFER_MUTATION, { id, reason: options?.reason }, { timeoutMs: CARRIER_CALL_TIMEOUT_MS, ...options });
+        },
+        createReturn(id, input, options) {
+            const { lines, ...rest } = input;
+            return one('createStockTransferReturn', CREATE_STOCK_TRANSFER_RETURN_MUTATION, { id, input: { ...rest, lines: toLines(lines) } }, options);
+        },
+        async returns(id, options) {
+            const data = await transport.graphql({ api: 'admin', query: STOCK_TRANSFER_RETURNS_QUERY, variables: { id } }, options);
+            return data.stockTransfer === null ? null : toReturns(data.stockTransfer);
+        },
+        async shortfall(id, options) {
+            const data = await transport.graphql({ api: 'admin', query: STOCK_TRANSFER_SHORTFALL_QUERY, variables: { id } }, options);
+            return data.stockTransfer === null ? null : toShortfall(data.stockTransfer);
+        },
+        async cancellation(id, options) {
+            const data = await transport.graphql({ api: 'admin', query: STOCK_TRANSFER_CANCELLATION_QUERY, variables: { id } }, options);
+            return data.stockTransfer === null ? null : toCancellation(data.stockTransfer);
+        },
+        async parcels(id, options) {
+            const data = await transport.graphql({ api: 'admin', query: STOCK_TRANSFER_PARCELS_QUERY, variables: { id } }, options);
+            return data.stockTransfer === null ? null : toParcels(data.stockTransfer);
+        },
+        async retryMyparcelShipments(id, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: RETRY_STOCK_TRANSFER_MYPARCEL_SHIPMENTS_MUTATION,
+                variables: { id },
+            }, { timeoutMs: CARRIER_CALL_TIMEOUT_MS, ...options });
+            return toParcels(data.retryStockTransferMyparcelShipments);
+        },
+        async labelMyparcelParcels(id, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: LABEL_STOCK_TRANSFER_MYPARCEL_PARCELS_MUTATION,
+                variables: { id },
+            }, options);
+            return toParcels(data.labelStockTransferMyparcelParcels);
+        },
+        async myparcelLabel(id, format, options) {
+            const data = await transport.graphql({
+                api: 'admin',
+                query: MYPARCEL_STOCK_TRANSFER_LABEL_MUTATION,
+                variables: { transferId: id, format },
+            }, { timeoutMs: MYPARCEL_LABEL_TIMEOUT_MS, ...options });
+            const { base64, ...document } = data.getMyparcelStockTransferLabel;
+            return { ...document, bytes: decodeBase64(base64) };
+        },
+    };
+}

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

@@ -0,0 +1,154 @@
+import type { Transport } from '@sixtyninecommerce/core';
+import type { Call } from '../types.js';
+/**
+ * Stored value (incentives program decisions 1 and 2): gift cards, store credit and points on one
+ * ledger. A balance is the sum of its entries, never a stored figure, and is spent as a PAYMENT on
+ * an order (`redeem`), never as a discount.
+ *
+ * Every amount is in minor units of the account's `unit` (an ISO 4217 code, or `PTS` for points).
+ * Refusals arrive as coded errors (`STORED_VALUE_*`); an id of another store is not found.
+ */
+export interface StoredValueAccount {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    kind: 'gift_card' | 'store_credit' | 'points';
+    unit: string;
+    customerId: string | null;
+    codeLast4: string | null;
+    /** The instant the value stops being spendable (start of the day after `expiresOn`). */
+    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';
+    balance: number;
+    /** What can be spent now: the balance less expired value the daily job has not booked yet. */
+    spendable: number;
+}
+export interface StoredValueEntry {
+    id: string;
+    createdAt: string;
+    occurredAt: string;
+    entryType: 'issue' | 'redeem' | 'reversal' | 'adjustment' | 'expiry' | 'forfeit';
+    /** Signed: credits positive, debits negative. */
+    amount: number;
+    balanceAfter: number;
+    unit: string;
+    sourceType: string;
+    sourceId: string | null;
+    paymentId: string | null;
+    orderId: string | null;
+    locationId: string | null;
+    actorType: string;
+    actorId: string | null;
+    onBehalfOfRef: string | null;
+    deviceRef: string | null;
+    reason: string | null;
+}
+export interface StoredValueStatement {
+    account: StoredValueAccount;
+    openingBalance: number;
+    closingBalance: number;
+    entries: StoredValueEntry[];
+    totalItems: number;
+}
+/** `outstanding = issued − redeemed + reversed + adjusted − expired − forfeited`. */
+export interface StoredValueLiability {
+    unit: string;
+    kind: string;
+    accounts: number;
+    issued: number;
+    redeemed: number;
+    reversed: number;
+    adjusted: number;
+    expired: number;
+    forfeited: number;
+    outstanding: number;
+}
+export interface IssueStoredValueInput {
+    /** Credit this account; omit to credit the customer's wallet of `kind` and `unit`. */
+    accountId?: string;
+    customerId?: string;
+    kind?: 'gift_card' | 'store_credit' | 'points';
+    unit?: string;
+    amount: number;
+    reason: string;
+    /** Sets the account's expiry: valid through this day (`YYYY-MM-DD`) in the store's time zone. */
+    expiresOn?: string;
+}
+export interface RedeemStoredValueInput {
+    orderId: string;
+    accountId: string;
+    /** Minor units of the order's currency, which must be the account's unit. */
+    amount: number;
+    /** The code of the store's payment method on the `stored-value` handler. */
+    method: string;
+}
+export interface StoredValueModule {
+    accounts(filter?: {
+        customerId?: string;
+        kind?: string;
+        take?: number;
+        skip?: number;
+    }, options?: Call): Promise<{
+        items: StoredValueAccount[];
+        totalItems: number;
+    }>;
+    account(id: string, options?: Call): Promise<StoredValueAccount | null>;
+    statement(accountId: string, window?: {
+        from?: string;
+        to?: string;
+        take?: number;
+        skip?: number;
+    }, options?: Call): Promise<StoredValueStatement>;
+    liability(
+    /** `locationId`: only redemptions and refunds of orders sold at that stock location. */
+    filter?: {
+        at?: string;
+        kind?: string;
+        locationId?: string;
+    }, options?: Call): Promise<StoredValueLiability[]>;
+    /** Requires ManageStoredValue. Send an `idempotencyKey`: a repeat returns the first result. */
+    issue(input: IssueStoredValueInput, options?: Call): Promise<StoredValueAccount>;
+    /** Requires ManageStoredValue. Signed; a debit may not take the balance below zero. */
+    adjust(input: {
+        accountId: string;
+        amount: number;
+        reason: string;
+        expiresOn?: string;
+    }, options?: Call): Promise<StoredValueAccount>;
+    /**
+     * 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.
+     */
+    setExpiry(id: string, expiresOn: string | null, reason: string, options?: Call): Promise<StoredValueAccount>;
+    block(id: string, reason: string, options?: Call): Promise<StoredValueAccount>;
+    unblock(id: string, reason: string, options?: Call): Promise<StoredValueAccount>;
+    /**
+     * Pay part (or all) of an order from an account (`redeemStoredValue`), through the platform's
+     * payment position: the order lock, the outstanding bound and the store's deposit policy apply,
+     * and the ledger is debited in the payment's own transaction. Requires UpdateOrder. Answers the
+     * payment the SERVER recorded for this call; a repeat under the same key answers the same one.
+     */
+    redeem(input: RedeemStoredValueInput, options?: Call): Promise<StoredValueRedemption>;
+}
+/** What a redemption recorded: the order, the payment this call created, the account and amount. */
+export interface StoredValueRedemption {
+    orderId: string;
+    paymentId: string;
+    accountId: string;
+    /** Minor units of the order's currency. Read the account itself with `account` (ReadStoredValue). */
+    amount: number;
+}
+export declare const STORED_VALUE_ACCOUNTS_QUERY = "\n  query StoredValueAccounts($customerId: ID, $kind: String, $take: Int, $skip: Int) {\n    storedValueAccounts(customerId: $customerId, kind: $kind, take: $take, skip: $skip) {\n      items { \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      totalItems\n    }\n  }\n";
+export declare const STORED_VALUE_ACCOUNT_QUERY = "\n  query StoredValueAccount($id: ID!) {\n    storedValueAccount(id: $id) { \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 STORED_VALUE_STATEMENT_QUERY = "\n  query StoredValueStatement($accountId: ID!, $from: DateTime, $to: DateTime, $take: Int, $skip: Int) {\n    storedValueStatement(accountId: $accountId, from: $from, to: $to, take: $take, skip: $skip) {\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      openingBalance\n      closingBalance\n      totalItems\n      entries {\n        id createdAt occurredAt entryType amount balanceAfter unit sourceType sourceId paymentId\n        orderId locationId actorType actorId onBehalfOfRef deviceRef reason\n      }\n    }\n  }\n";
+export declare const STORED_VALUE_LIABILITY_QUERY = "\n  query StoredValueLiability($at: DateTime, $kind: String, $locationId: ID) {\n    storedValueLiability(at: $at, kind: $kind, locationId: $locationId) {\n      unit kind accounts issued redeemed reversed adjusted expired forfeited outstanding\n    }\n  }\n";
+export declare const ISSUE_STORED_VALUE_MUTATION = "\n  mutation IssueStoredValue($input: IssueStoredValueInput!, $idempotencyKey: String) {\n    issueStoredValue(input: $input, idempotencyKey: $idempotencyKey) { \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 ADJUST_STORED_VALUE_MUTATION = "\n  mutation AdjustStoredValue($input: AdjustStoredValueInput!, $idempotencyKey: String) {\n    adjustStoredValue(input: $input, idempotencyKey: $idempotencyKey) { \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 BLOCK_STORED_VALUE_MUTATION = "\n  mutation BlockStoredValueAccount($id: ID!, $reason: String!) {\n    blockStoredValueAccount(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 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 function createStoredValueModule(transport: Transport): StoredValueModule;