@vtex/faststore 0.0.1

package/dist/sdk/session/auth-operations.d.ts

@@ -0,0 +1,47 @@
+import "../cart/operations.js";
+import "./operations.js";
+import { TypedDocumentNode } from "@apollo/client";
+//#region src/sdk/session/auth-operations.d.ts
+/**
+ * Session auth mutation documents (specs/fspg-880-session-action-namespace.md).
+ *
+ * Authored with the hand `gql` tag — the codegen `graphql()` factory is reserved for the reactive
+ * read path (`operations.ts`) — and explicitly excluded from the codegen `documents` glob (see
+ * `codegen.ts`): the `gql` tag alone is still plucked by `graphql-codegen`, which would duplicate
+ * these hand-written types in `sdk/generated/`. The mutations stay hand-typed as
+ * `TypedDocumentNode`s (Decision 3). Login/validate/logout share `SessionLoginPayloadFragment`,
+ * a hand-written fragment selecting the full refreshed payload:
+ * `session` with exactly `SessionFragment`'s field set, `cart` spreading the canonical codegen
+ * `CartFragment` (interpolated as a document), and the full `clientProfile` / `clientPreferences`
+ * slices. All payload entities are normalized Relay Nodes keyed on the orderFormId, so the response
+ * write into the cache *is* the post-login refresh: `SessionRoot`'s reactive read flips with no
+ * refetch and no imperative cache write (Decision 2).
+ *
+ * Failures follow ADR-00007's two-path contract: domain outcomes arrive as payload `userErrors`
+ * (`SessionError`); transport and top-level GraphQL failures are infrastructure, mapped by the
+ * handlers in `use-session-actions.ts` to the one client-synthesized code, `NETWORK_ERROR`.
+ */
+/** A typed login-attempt failure; NETWORK_ERROR is the one client-synthesized code (Decision 5). */
+export type SessionUserError = Readonly<{
+  code: string;
+  message: string;
+}>;
+export type SessionPasswordLoginPayload = Readonly<{
+  email: string;
+  password: string;
+}>;
+export type SessionRequestAccessCodePayload = Readonly<{
+  email: string;
+}>;
+export type SessionValidateAccessCodePayload = Readonly<{
+  email: string;
+  accessCode: string;
+  /** Opaque token from requestAccessCode, handed back unchanged (Decision 4). */
+  authenticationToken: string;
+}>;
+export type SessionAccessCodeRequestResult = Readonly<{
+  authenticationToken: string | null;
+  userErrors: readonly SessionUserError[];
+}>;
+//#endregion
+//# sourceMappingURL=auth-operations.d.ts.map

package/dist/sdk/session/auth-operations.js

@@ -0,0 +1,79 @@
+import { gql } from "../graphql-tag.js";
+import { CartFragment } from "../cart/operations.js";
+//#region src/sdk/session/auth-operations.ts
+/** The shared full-refreshed-payload selection for login/validate/logout; embeds `CartFragment`. */
+const SessionLoginPayloadFragment = gql`
+  fragment SessionLoginPayloadFragment on SessionLoginPayload {
+    __typename
+    session {
+      __typename
+      id
+      loggedIn
+      canEditData
+      isIdentified
+    }
+    cart {
+      ...CartFragment
+    }
+    clientProfile {
+      __typename
+      id
+      email
+      firstName
+      lastName
+      phone
+      document
+    }
+    clientPreferences {
+      __typename
+      id
+      optinNewsLetter
+      savePersonalData
+    }
+    userErrors {
+      code
+      message
+    }
+  }
+  ${CartFragment}
+`;
+const SESSION_LOGIN_WITH_PASSWORD = gql`
+  mutation SessionLoginWithPassword($input: SessionPasswordLoginInput!) {
+    sessionLoginWithPassword(input: $input) {
+      ...SessionLoginPayloadFragment
+    }
+  }
+  ${SessionLoginPayloadFragment}
+`;
+const SESSION_REQUEST_ACCESS_CODE = gql`
+  mutation SessionRequestAccessCode($input: SessionRequestAccessCodeInput!) {
+    sessionRequestAccessCode(input: $input) {
+      __typename
+      authenticationToken
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`;
+const SESSION_VALIDATE_ACCESS_CODE = gql`
+  mutation SessionValidateAccessCode($input: SessionValidateAccessCodeInput!) {
+    sessionValidateAccessCode(input: $input) {
+      ...SessionLoginPayloadFragment
+    }
+  }
+  ${SessionLoginPayloadFragment}
+`;
+const SESSION_LOGOUT = gql`
+  mutation SessionLogout {
+    sessionLogout {
+      ...SessionLoginPayloadFragment
+    }
+  }
+  ${SessionLoginPayloadFragment}
+`;
+//#endregion
+export { SESSION_LOGIN_WITH_PASSWORD, SESSION_LOGOUT, SESSION_REQUEST_ACCESS_CODE, SESSION_VALIDATE_ACCESS_CODE };
+
+//# sourceMappingURL=auth-operations.js.map

package/dist/sdk/session/auth-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-operations.js","names":[],"sources":["../../../src/sdk/session/auth-operations.ts"],"sourcesContent":["import type { TypedDocumentNode } from '@apollo/client';\nimport { type CartEntity, CartFragment } from '../cart/operations.js';\nimport { gql } from '../graphql-tag.js';\nimport type { SessionEntity } from './operations.js';\n\n/**\n * Session auth mutation documents (specs/fspg-880-session-action-namespace.md).\n *\n * Authored with the hand `gql` tag — the codegen `graphql()` factory is reserved for the reactive\n * read path (`operations.ts`) — and explicitly excluded from the codegen `documents` glob (see\n * `codegen.ts`): the `gql` tag alone is still plucked by `graphql-codegen`, which would duplicate\n * these hand-written types in `sdk/generated/`. The mutations stay hand-typed as\n * `TypedDocumentNode`s (Decision 3). Login/validate/logout share `SessionLoginPayloadFragment`,\n * a hand-written fragment selecting the full refreshed payload:\n * `session` with exactly `SessionFragment`'s field set, `cart` spreading the canonical codegen\n * `CartFragment` (interpolated as a document), and the full `clientProfile` / `clientPreferences`\n * slices. All payload entities are normalized Relay Nodes keyed on the orderFormId, so the response\n * write into the cache *is* the post-login refresh: `SessionRoot`'s reactive read flips with no\n * refetch and no imperative cache write (Decision 2).\n *\n * Failures follow ADR-00007's two-path contract: domain outcomes arrive as payload `userErrors`\n * (`SessionError`); transport and top-level GraphQL failures are infrastructure, mapped by the\n * handlers in `use-session-actions.ts` to the one client-synthesized code, `NETWORK_ERROR`.\n */\n\n/** A typed login-attempt failure; NETWORK_ERROR is the one client-synthesized code (Decision 5). */\nexport type SessionUserError = Readonly<{ code: string; message: string }>;\n\nexport type SessionPasswordLoginPayload = Readonly<{ email: string; password: string }>;\n\nexport type SessionRequestAccessCodePayload = Readonly<{ email: string }>;\n\nexport type SessionValidateAccessCodePayload = Readonly<{\n  email: string;\n  accessCode: string;\n  /** Opaque token from requestAccessCode, handed back unchanged (Decision 4). */\n  authenticationToken: string;\n}>;\n\nexport type SessionAccessCodeRequestResult = Readonly<{\n  authenticationToken: string | null;\n  userErrors: readonly SessionUserError[];\n}>;\n\n/** The shopper's profile slice of the login payload; fields are null when unset. */\nexport type ClientProfileEntity = Readonly<{\n  __typename: 'ClientProfile';\n  id: string;\n  email: string | null;\n  firstName: string | null;\n  lastName: string | null;\n  phone: string | null;\n  document: string | null;\n}>;\n\n/** The shopper's preference opt-ins slice of the login payload; fields are null when unset. */\nexport type ClientPreferencesEntity = Readonly<{\n  __typename: 'ClientPreferences';\n  id: string;\n  optinNewsLetter: boolean | null;\n  savePersonalData: boolean | null;\n}>;\n\n/** The full login/logout mutation payload, projected from the one refreshed order form. */\nexport type SessionLoginPayloadEntity = Readonly<{\n  __typename: 'SessionLoginPayload';\n  session: SessionEntity;\n  cart: CartEntity;\n  clientProfile: ClientProfileEntity;\n  clientPreferences: ClientPreferencesEntity;\n  userErrors: readonly SessionUserError[];\n}>;\n\nexport type SessionRequestAccessCodePayloadEntity = Readonly<{\n  __typename: 'SessionRequestAccessCodePayload';\n  authenticationToken: string | null;\n  userErrors: readonly SessionUserError[];\n}>;\n\ntype SessionLoginWithPasswordData = Readonly<{ sessionLoginWithPassword: SessionLoginPayloadEntity }>;\ntype SessionRequestAccessCodeData = Readonly<{ sessionRequestAccessCode: SessionRequestAccessCodePayloadEntity }>;\ntype SessionValidateAccessCodeData = Readonly<{ sessionValidateAccessCode: SessionLoginPayloadEntity }>;\ntype SessionLogoutData = Readonly<{ sessionLogout: SessionLoginPayloadEntity }>;\n\n/** The shared full-refreshed-payload selection for login/validate/logout; embeds `CartFragment`. */\nconst SessionLoginPayloadFragment = gql`\n  fragment SessionLoginPayloadFragment on SessionLoginPayload {\n    __typename\n    session {\n      __typename\n      id\n      loggedIn\n      canEditData\n      isIdentified\n    }\n    cart {\n      ...CartFragment\n    }\n    clientProfile {\n      __typename\n      id\n      email\n      firstName\n      lastName\n      phone\n      document\n    }\n    clientPreferences {\n      __typename\n      id\n      optinNewsLetter\n      savePersonalData\n    }\n    userErrors {\n      code\n      message\n    }\n  }\n  ${CartFragment}\n`;\n\nexport const SESSION_LOGIN_WITH_PASSWORD: TypedDocumentNode<\n  SessionLoginWithPasswordData,\n  { input: SessionPasswordLoginPayload }\n> = gql`\n  mutation SessionLoginWithPassword($input: SessionPasswordLoginInput!) {\n    sessionLoginWithPassword(input: $input) {\n      ...SessionLoginPayloadFragment\n    }\n  }\n  ${SessionLoginPayloadFragment}\n`;\n\nexport const SESSION_REQUEST_ACCESS_CODE: TypedDocumentNode<\n  SessionRequestAccessCodeData,\n  { input: SessionRequestAccessCodePayload }\n> = gql`\n  mutation SessionRequestAccessCode($input: SessionRequestAccessCodeInput!) {\n    sessionRequestAccessCode(input: $input) {\n      __typename\n      authenticationToken\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`;\n\nexport const SESSION_VALIDATE_ACCESS_CODE: TypedDocumentNode<\n  SessionValidateAccessCodeData,\n  { input: SessionValidateAccessCodePayload }\n> = gql`\n  mutation SessionValidateAccessCode($input: SessionValidateAccessCodeInput!) {\n    sessionValidateAccessCode(input: $input) {\n      ...SessionLoginPayloadFragment\n    }\n  }\n  ${SessionLoginPayloadFragment}\n`;\n\nexport const SESSION_LOGOUT: TypedDocumentNode<SessionLogoutData, Record<string, never>> = gql`\n  mutation SessionLogout {\n    sessionLogout {\n      ...SessionLoginPayloadFragment\n    }\n  }\n  ${SessionLoginPayloadFragment}\n`;\n"],"mappings":";;;;AAqFA,MAAM,8BAA8B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiCnC,aAAa;;AAGjB,MAAa,8BAGT,GAAG;;;;;;IAMH,4BAA4B;;AAGhC,MAAa,8BAGT,GAAG;;;;;;;;;;;;AAaP,MAAa,+BAGT,GAAG;;;;;;IAMH,4BAA4B;;AAGhC,MAAa,iBAA8E,GAAG;;;;;;IAM1F,4BAA4B"}

package/dist/sdk/session/operations.d.ts

@@ -0,0 +1,6 @@
+import { SessionFragmentFragment } from "../generated/graphql.js";
+import { TypedDocumentNode } from "@apollo/client";
+//#region src/sdk/session/operations.d.ts
+export type SessionEntity = SessionFragmentFragment;
+//#endregion
+//# sourceMappingURL=operations.d.ts.map

package/dist/sdk/session/use-session-actions.d.ts

@@ -0,0 +1,27 @@
+import "../../core/dist/index.js";
+import { SessionAccessCodeRequestResult, SessionPasswordLoginPayload, SessionRequestAccessCodePayload, SessionUserError, SessionValidateAccessCodePayload } from "./auth-operations.js";
+//#region src/sdk/session/use-session-actions.d.ts
+/**
+ * The `session` action namespace — the one sanctioned client write surface for authentication
+ * (specs/fspg-880-session-action-namespace.md, docs/storefront-core/adr-0010-actions-own-the-write-side.md).
+ *
+ * Every action is async/pessimistic (Decision 1): the handler awaits the mutation and only the
+ * server-confirmed payload changes the cache — authentication cannot be guessed client-side. The
+ * handlers are stateless: no reactive vars, no module state; the access-code `authenticationToken`
+ * is returned to the caller, which owns it as UI flow state (Decision 4). Each action resolves its
+ * payload `userErrors` (empty on success) and never throws for expected outcomes; infrastructure
+ * failures resolve as the synthetic `NETWORK_ERROR` (Decision 5). The credentials pass through
+ * mutation variables only — never logged, never stored.
+ */
+export type SessionActions = Readonly<{
+  /** Password sign-in. Async/pessimistic; resolves the payload userErrors (empty on success). */
+  loginWithPassword: (payload: SessionPasswordLoginPayload) => Promise<readonly SessionUserError[]>;
+  /** Email an access code; resolves the opaque authenticationToken to round-trip into validate. */
+  requestAccessCode: (payload: SessionRequestAccessCodePayload) => Promise<SessionAccessCodeRequestResult>;
+  /** Validate an access code + token; logs the shopper in exactly as a password login would. */
+  validateAccessCode: (payload: SessionValidateAccessCodePayload) => Promise<readonly SessionUserError[]>;
+  /** Sign out. Idempotent for guests. */
+  logout: () => Promise<readonly SessionUserError[]>;
+}>;
+//#endregion
+//# sourceMappingURL=use-session-actions.d.ts.map

package/dist/sdk/session/use-session-actions.js

@@ -0,0 +1,126 @@
+"use client";
+import { defineActions } from "../../core/dist/actions/registry.js";
+import "../../core/dist/index.js";
+import { SESSION_LOGIN_WITH_PASSWORD, SESSION_LOGOUT, SESSION_REQUEST_ACCESS_CODE, SESSION_VALIDATE_ACCESS_CODE } from "./auth-operations.js";
+import { useMutation } from "@apollo/client/react";
+import { useCallback, useMemo } from "react";
+//#region src/sdk/session/use-session-actions.ts
+const NETWORK_USER_ERROR = {
+	code: "NETWORK_ERROR",
+	message: "Unable to complete the request. Please try again."
+};
+/**
+* The `session` namespace hook. Registered with the first-party action registry via `sessionActions`
+* below; the compiler-emitted `SessionActionProvider` calls it and threads the narrowed methods into
+* each consumer's `$actions.session`. Login/validate/logout refresh the session purely through the
+* normalized-cache merge of the mutation response (Decision 2) — no refetch, no imperative write.
+*/
+function useSessionActions() {
+	const [loginMutation] = useMutation(SESSION_LOGIN_WITH_PASSWORD);
+	const [requestMutation] = useMutation(SESSION_REQUEST_ACCESS_CODE);
+	const [validateMutation] = useMutation(SESSION_VALIDATE_ACCESS_CODE);
+	const [logoutMutation] = useMutation(SESSION_LOGOUT);
+	const loginWithPassword = useCallback(async (payload) => {
+		try {
+			return (await loginMutation({ variables: { input: payload } })).data?.sessionLoginWithPassword.userErrors ?? [];
+		} catch (error) {
+			console.error("[session.loginWithPassword] sessionLoginWithPassword failed", error);
+			return [NETWORK_USER_ERROR];
+		}
+	}, [loginMutation]);
+	const requestAccessCode = useCallback(async (payload) => {
+		try {
+			const data = (await requestMutation({ variables: { input: payload } })).data?.sessionRequestAccessCode;
+			return {
+				authenticationToken: data?.authenticationToken ?? null,
+				userErrors: data?.userErrors ?? []
+			};
+		} catch (error) {
+			console.error("[session.requestAccessCode] sessionRequestAccessCode failed", error);
+			return {
+				authenticationToken: null,
+				userErrors: [NETWORK_USER_ERROR]
+			};
+		}
+	}, [requestMutation]);
+	const validateAccessCode = useCallback(async (payload) => {
+		try {
+			return (await validateMutation({ variables: { input: payload } })).data?.sessionValidateAccessCode.userErrors ?? [];
+		} catch (error) {
+			console.error("[session.validateAccessCode] sessionValidateAccessCode failed", error);
+			return [NETWORK_USER_ERROR];
+		}
+	}, [validateMutation]);
+	const logout = useCallback(async () => {
+		try {
+			return (await logoutMutation()).data?.sessionLogout.userErrors ?? [];
+		} catch (error) {
+			console.error("[session.logout] sessionLogout failed", error);
+			return [NETWORK_USER_ERROR];
+		}
+	}, [logoutMutation]);
+	return useMemo(() => ({
+		loginWithPassword,
+		requestAccessCode,
+		validateAccessCode,
+		logout
+	}), [
+		loginWithPassword,
+		requestAccessCode,
+		validateAccessCode,
+		logout
+	]);
+}
+defineActions({
+	namespace: "session",
+	description: "Mutation-backed authentication writes against the VTEX ID session (login, access code, logout).",
+	provider: {
+		name: "SessionActionProvider",
+		importPath: "@vtex/faststore/internal/client"
+	},
+	methods: {
+		loginWithPassword: {
+			description: "Sign in with email and password (async/pessimistic). Resolves the payload userErrors.",
+			payload: [{
+				name: "email",
+				type: "string"
+			}, {
+				name: "password",
+				type: "string"
+			}]
+		},
+		requestAccessCode: {
+			description: "Email the shopper an access code; resolves the opaque authenticationToken to round-trip.",
+			payload: [{
+				name: "email",
+				type: "string"
+			}]
+		},
+		validateAccessCode: {
+			description: "Validate an access code with its authenticationToken (async/pessimistic); logs the shopper in.",
+			payload: [
+				{
+					name: "email",
+					type: "string"
+				},
+				{
+					name: "accessCode",
+					type: "string"
+				},
+				{
+					name: "authenticationToken",
+					type: "string"
+				}
+			]
+		},
+		logout: {
+			description: "Sign out, clearing the auth cookies (async/pessimistic). Idempotent for guests.",
+			payload: []
+		}
+	},
+	use: useSessionActions
+});
+//#endregion
+export { useSessionActions };
+
+//# sourceMappingURL=use-session-actions.js.map

package/dist/sdk/session/use-session-actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-actions.js","names":[],"sources":["../../../src/sdk/session/use-session-actions.ts"],"sourcesContent":["'use client';\n\nimport { useMutation } from '@apollo/client/react';\nimport { defineActions } from '@vtex/fs-core';\nimport { useCallback, useMemo } from 'react';\nimport {\n  SESSION_LOGIN_WITH_PASSWORD,\n  SESSION_LOGOUT,\n  SESSION_REQUEST_ACCESS_CODE,\n  SESSION_VALIDATE_ACCESS_CODE,\n  type SessionAccessCodeRequestResult,\n  type SessionPasswordLoginPayload,\n  type SessionRequestAccessCodePayload,\n  type SessionUserError,\n  type SessionValidateAccessCodePayload,\n} from './auth-operations.js';\n\n/**\n * The `session` action namespace — the one sanctioned client write surface for authentication\n * (specs/fspg-880-session-action-namespace.md, docs/storefront-core/adr-0010-actions-own-the-write-side.md).\n *\n * Every action is async/pessimistic (Decision 1): the handler awaits the mutation and only the\n * server-confirmed payload changes the cache — authentication cannot be guessed client-side. The\n * handlers are stateless: no reactive vars, no module state; the access-code `authenticationToken`\n * is returned to the caller, which owns it as UI flow state (Decision 4). Each action resolves its\n * payload `userErrors` (empty on success) and never throws for expected outcomes; infrastructure\n * failures resolve as the synthetic `NETWORK_ERROR` (Decision 5). The credentials pass through\n * mutation variables only — never logged, never stored.\n */\nexport type SessionActions = Readonly<{\n  /** Password sign-in. Async/pessimistic; resolves the payload userErrors (empty on success). */\n  loginWithPassword: (payload: SessionPasswordLoginPayload) => Promise<readonly SessionUserError[]>;\n  /** Email an access code; resolves the opaque authenticationToken to round-trip into validate. */\n  requestAccessCode: (payload: SessionRequestAccessCodePayload) => Promise<SessionAccessCodeRequestResult>;\n  /** Validate an access code + token; logs the shopper in exactly as a password login would. */\n  validateAccessCode: (payload: SessionValidateAccessCodePayload) => Promise<readonly SessionUserError[]>;\n  /** Sign out. Idempotent for guests. */\n  logout: () => Promise<readonly SessionUserError[]>;\n}>;\n\nconst NETWORK_USER_ERROR: SessionUserError = {\n  code: 'NETWORK_ERROR',\n  message: 'Unable to complete the request. Please try again.',\n};\n\n/**\n * The `session` namespace hook. Registered with the first-party action registry via `sessionActions`\n * below; the compiler-emitted `SessionActionProvider` calls it and threads the narrowed methods into\n * each consumer's `$actions.session`. Login/validate/logout refresh the session purely through the\n * normalized-cache merge of the mutation response (Decision 2) — no refetch, no imperative write.\n */\nexport function useSessionActions(): SessionActions {\n  const [loginMutation] = useMutation(SESSION_LOGIN_WITH_PASSWORD);\n  const [requestMutation] = useMutation(SESSION_REQUEST_ACCESS_CODE);\n  const [validateMutation] = useMutation(SESSION_VALIDATE_ACCESS_CODE);\n  const [logoutMutation] = useMutation(SESSION_LOGOUT);\n\n  const loginWithPassword = useCallback<SessionActions['loginWithPassword']>(\n    async (payload) => {\n      try {\n        const result = await loginMutation({ variables: { input: payload } });\n        return result.data?.sessionLoginWithPassword.userErrors ?? [];\n      } catch (error) {\n        console.error('[session.loginWithPassword] sessionLoginWithPassword failed', error);\n        return [NETWORK_USER_ERROR];\n      }\n    },\n    [loginMutation],\n  );\n\n  const requestAccessCode = useCallback<SessionActions['requestAccessCode']>(\n    async (payload) => {\n      try {\n        const result = await requestMutation({ variables: { input: payload } });\n        const data = result.data?.sessionRequestAccessCode;\n        return { authenticationToken: data?.authenticationToken ?? null, userErrors: data?.userErrors ?? [] };\n      } catch (error) {\n        console.error('[session.requestAccessCode] sessionRequestAccessCode failed', error);\n        return { authenticationToken: null, userErrors: [NETWORK_USER_ERROR] };\n      }\n    },\n    [requestMutation],\n  );\n\n  const validateAccessCode = useCallback<SessionActions['validateAccessCode']>(\n    async (payload) => {\n      try {\n        const result = await validateMutation({ variables: { input: payload } });\n        return result.data?.sessionValidateAccessCode.userErrors ?? [];\n      } catch (error) {\n        console.error('[session.validateAccessCode] sessionValidateAccessCode failed', error);\n        return [NETWORK_USER_ERROR];\n      }\n    },\n    [validateMutation],\n  );\n\n  const logout = useCallback<SessionActions['logout']>(async () => {\n    try {\n      const result = await logoutMutation();\n      return result.data?.sessionLogout.userErrors ?? [];\n    } catch (error) {\n      console.error('[session.logout] sessionLogout failed', error);\n      return [NETWORK_USER_ERROR];\n    }\n  }, [logoutMutation]);\n\n  return useMemo(\n    () => ({ loginWithPassword, requestAccessCode, validateAccessCode, logout }),\n    [loginWithPassword, requestAccessCode, validateAccessCode, logout],\n  );\n}\n\n/**\n * Declares the `session` action namespace — the single source of truth for its method/payload\n * metadata, runtime provider, and `use` hook (mirrors `cartActions`). The native catalog builder\n * (`scripts/build-catalog.mjs`) statically reads this call to emit `actions.json`; at runtime\n * `SessionActionProvider` calls `useSessionActions` directly.\n */\nexport const sessionActions = defineActions({\n  namespace: 'session',\n  description: 'Mutation-backed authentication writes against the VTEX ID session (login, access code, logout).',\n  provider: { name: 'SessionActionProvider', importPath: '@vtex/faststore/internal/client' },\n  methods: {\n    loginWithPassword: {\n      description: 'Sign in with email and password (async/pessimistic). Resolves the payload userErrors.',\n      payload: [\n        { name: 'email', type: 'string' },\n        { name: 'password', type: 'string' },\n      ],\n    },\n    requestAccessCode: {\n      description: 'Email the shopper an access code; resolves the opaque authenticationToken to round-trip.',\n      payload: [{ name: 'email', type: 'string' }],\n    },\n    validateAccessCode: {\n      description: 'Validate an access code with its authenticationToken (async/pessimistic); logs the shopper in.',\n      payload: [\n        { name: 'email', type: 'string' },\n        { name: 'accessCode', type: 'string' },\n        { name: 'authenticationToken', type: 'string' },\n      ],\n    },\n    logout: {\n      description: 'Sign out, clearing the auth cookies (async/pessimistic). Idempotent for guests.',\n      payload: [],\n    },\n  },\n  use: useSessionActions,\n});\n"],"mappings":";;;;;;;AAwCA,MAAM,qBAAuC;CAC3C,MAAM;CACN,SAAS;AACX;;;;;;;AAQA,SAAgB,oBAAoC;CAClD,MAAM,CAAC,iBAAiB,YAAY,2BAA2B;CAC/D,MAAM,CAAC,mBAAmB,YAAY,2BAA2B;CACjE,MAAM,CAAC,oBAAoB,YAAY,4BAA4B;CACnE,MAAM,CAAC,kBAAkB,YAAY,cAAc;CAEnD,MAAM,oBAAoB,YACxB,OAAO,YAAY;EACjB,IAAI;GAEF,QAAO,MADc,cAAc,EAAE,WAAW,EAAE,OAAO,QAAQ,EAAE,CAAC,EAAA,CACtD,MAAM,yBAAyB,cAAc,CAAC;EAC9D,SAAS,OAAO;GACd,QAAQ,MAAM,+DAA+D,KAAK;GAClF,OAAO,CAAC,kBAAkB;EAC5B;CACF,GACA,CAAC,aAAa,CAChB;CAEA,MAAM,oBAAoB,YACxB,OAAO,YAAY;EACjB,IAAI;GAEF,MAAM,QAAO,MADQ,gBAAgB,EAAE,WAAW,EAAE,OAAO,QAAQ,EAAE,CAAC,EAAA,CAClD,MAAM;GAC1B,OAAO;IAAE,qBAAqB,MAAM,uBAAuB;IAAM,YAAY,MAAM,cAAc,CAAC;GAAE;EACtG,SAAS,OAAO;GACd,QAAQ,MAAM,+DAA+D,KAAK;GAClF,OAAO;IAAE,qBAAqB;IAAM,YAAY,CAAC,kBAAkB;GAAE;EACvE;CACF,GACA,CAAC,eAAe,CAClB;CAEA,MAAM,qBAAqB,YACzB,OAAO,YAAY;EACjB,IAAI;GAEF,QAAO,MADc,iBAAiB,EAAE,WAAW,EAAE,OAAO,QAAQ,EAAE,CAAC,EAAA,CACzD,MAAM,0BAA0B,cAAc,CAAC;EAC/D,SAAS,OAAO;GACd,QAAQ,MAAM,iEAAiE,KAAK;GACpF,OAAO,CAAC,kBAAkB;EAC5B;CACF,GACA,CAAC,gBAAgB,CACnB;CAEA,MAAM,SAAS,YAAsC,YAAY;EAC/D,IAAI;GAEF,QAAO,MADc,eAAe,EAAA,CACtB,MAAM,cAAc,cAAc,CAAC;EACnD,SAAS,OAAO;GACd,QAAQ,MAAM,yCAAyC,KAAK;GAC5D,OAAO,CAAC,kBAAkB;EAC5B;CACF,GAAG,CAAC,cAAc,CAAC;CAEnB,OAAO,eACE;EAAE;EAAmB;EAAmB;EAAoB;CAAO,IAC1E;EAAC;EAAmB;EAAmB;EAAoB;CAAM,CACnE;AACF;AAQ8B,cAAc;CAC1C,WAAW;CACX,aAAa;CACb,UAAU;EAAE,MAAM;EAAyB,YAAY;CAAkC;CACzF,SAAS;EACP,mBAAmB;GACjB,aAAa;GACb,SAAS,CACP;IAAE,MAAM;IAAS,MAAM;GAAS,GAChC;IAAE,MAAM;IAAY,MAAM;GAAS,CACrC;EACF;EACA,mBAAmB;GACjB,aAAa;GACb,SAAS,CAAC;IAAE,MAAM;IAAS,MAAM;GAAS,CAAC;EAC7C;EACA,oBAAoB;GAClB,aAAa;GACb,SAAS;IACP;KAAE,MAAM;KAAS,MAAM;IAAS;IAChC;KAAE,MAAM;KAAc,MAAM;IAAS;IACrC;KAAE,MAAM;KAAuB,MAAM;IAAS;GAChD;EACF;EACA,QAAQ;GACN,aAAa;GACb,SAAS,CAAC;EACZ;CACF;CACA,KAAK;AACP,CAAC"}

package/dist/sdk/shipping/cart-operations.d.ts

@@ -0,0 +1,3 @@
+import { CartShippingSimulateInput } from "../generated/graphql.js";
+import { TypedDocumentNode } from "@apollo/client";
+export type { CartShippingSimulateInput };

package/dist/sdk/shipping/cart-operations.js

@@ -0,0 +1,33 @@
+import { graphql } from "../generated/gql.js";
+//#region src/sdk/shipping/cart-operations.ts
+const CART_SHIPPING_SIMULATION = graphql(`
+  query CartShippingSimulation($input: CartShippingSimulateInput!) {
+    cartShippingSimulation(input: $input) {
+      shippingOptions {
+        id
+        name
+        channel
+        shippingEstimate {
+          value
+          unit
+        }
+        price {
+          amount
+          currencyCode
+        }
+        listPrice {
+          amount
+          currencyCode
+        }
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+//#endregion
+export { CART_SHIPPING_SIMULATION };
+
+//# sourceMappingURL=cart-operations.js.map

package/dist/sdk/shipping/cart-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cart-operations.js","names":[],"sources":["../../../src/sdk/shipping/cart-operations.ts"],"sourcesContent":["import type { TypedDocumentNode } from '@apollo/client';\nimport { graphql } from '../generated/gql.js';\nimport type { CartShippingSimulationQuery, CartShippingSimulationQueryVariables } from '../generated/graphql.js';\n\n/**\n * Cart-scoped shipping-simulation GraphQL operation.\n *\n * Authored via the codegen `graphql()` factory so codegen scans this document and generates\n * `CartShippingSimulationQuery`, `CartShippingSimulationQueryVariables`, and the\n * `CartShippingSimulateInput` input type. The input carries a destination only; the cart's items\n * are sourced server-side from the `x-order-form-id` context. The selection set mirrors the PDP\n * operation so `useCartShippingSimulation` reuses the same option/estimate/error mappers.\n */\n\n// ---------------------------------------------------------------------------\n// Input type — direct re-export from codegen\n// ---------------------------------------------------------------------------\n\nexport type { CartShippingSimulateInput } from '../generated/graphql.js';\n\n// ---------------------------------------------------------------------------\n// Query operation\n// ---------------------------------------------------------------------------\n\nexport const CART_SHIPPING_SIMULATION: TypedDocumentNode<\n  CartShippingSimulationQuery,\n  CartShippingSimulationQueryVariables\n> = graphql(`\n  query CartShippingSimulation($input: CartShippingSimulateInput!) {\n    cartShippingSimulation(input: $input) {\n      shippingOptions {\n        id\n        name\n        channel\n        shippingEstimate {\n          value\n          unit\n        }\n        price {\n          amount\n          currencyCode\n        }\n        listPrice {\n          amount\n          currencyCode\n        }\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n"],"mappings":";;AAwBA,MAAa,2BAGT,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BX"}

package/dist/sdk/shipping/operations.d.ts

@@ -0,0 +1,3 @@
+import { ShippingSimulateInput } from "../generated/graphql.js";
+import { TypedDocumentNode } from "@apollo/client";
+export type { ShippingSimulateInput };

package/dist/sdk/shipping/operations.js

@@ -0,0 +1,33 @@
+import { graphql } from "../generated/gql.js";
+//#region src/sdk/shipping/operations.ts
+const SHIPPING_SIMULATION = graphql(`
+  query ShippingSimulation($input: ShippingSimulateInput!) {
+    shippingSimulation(input: $input) {
+      shippingOptions {
+        id
+        name
+        channel
+        shippingEstimate {
+          value
+          unit
+        }
+        price {
+          amount
+          currencyCode
+        }
+        listPrice {
+          amount
+          currencyCode
+        }
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+`);
+//#endregion
+export { SHIPPING_SIMULATION };
+
+//# sourceMappingURL=operations.js.map

package/dist/sdk/shipping/operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","names":[],"sources":["../../../src/sdk/shipping/operations.ts"],"sourcesContent":["import type { TypedDocumentNode } from '@apollo/client';\nimport { graphql } from '../generated/gql.js';\nimport type { ShippingSimulationQuery, ShippingSimulationQueryVariables } from '../generated/graphql.js';\n\n/**\n * Shipping-simulation GraphQL operation (FSPG-815 / specs/fspg-815-minicart-wire-shipping-simulator-pdp.md).\n *\n * Authored via the codegen `graphql()` factory so codegen scans this document and generates\n * `ShippingSimulationQuery`, `ShippingSimulationQueryVariables`, and the `ShippingSimulateInput`\n * input type (Decision 2). The selection set carries exactly the fields the simulator's option\n * leaves consume; `useShippingSimulation` maps it onto the simulator's domain payload.\n */\n\n// ---------------------------------------------------------------------------\n// Input type — direct re-export from codegen\n// ---------------------------------------------------------------------------\n\nexport type { ShippingSimulateInput } from '../generated/graphql.js';\n\n// ---------------------------------------------------------------------------\n// Query operation\n// ---------------------------------------------------------------------------\n\nexport const SHIPPING_SIMULATION: TypedDocumentNode<ShippingSimulationQuery, ShippingSimulationQueryVariables> =\n  graphql(`\n  query ShippingSimulation($input: ShippingSimulateInput!) {\n    shippingSimulation(input: $input) {\n      shippingOptions {\n        id\n        name\n        channel\n        shippingEstimate {\n          value\n          unit\n        }\n        price {\n          amount\n          currencyCode\n        }\n        listPrice {\n          amount\n          currencyCode\n        }\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n`);\n"],"mappings":";;AAuBA,MAAa,sBACX,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BT"}

package/dist/sdk/shipping/option-select-operations.d.ts

@@ -0,0 +1,24 @@
+import "../cart/operations.js";
+import { TypedDocumentNode } from "@apollo/client";
+//#region src/sdk/shipping/option-select-operations.d.ts
+/**
+ * `shippingOptionSelect` mutation document (specs/delivery-options-step.md, T3).
+ *
+ * Authored with the hand `gql` tag — the codegen `graphql()` factory is reserved for the reactive
+ * read path (`shipping/operations.ts`) — and explicitly excluded from the codegen `documents` glob
+ * (see `codegen.ts`): the `gql` tag alone is still plucked by `graphql-codegen`, which would
+ * duplicate these hand-written types in `sdk/generated/`. Mirrors the `session`/`identity`
+ * action-mutation convention (hand-typed `TypedDocumentNode`s).
+ *
+ * Selects `cart { ...CartFragment }` alongside `shipping` so the normalized Apollo cache updates
+ * the cart totalizer in the same round trip (T1 epic note). Both `shipping` and its nested
+ * `options` select `id`/`__typename` so `InMemoryCache` normalizes them as the same entities the
+ * reactive `DeliveryOptionsData` fragment reads — required for the mutation response to flow back
+ * into the reactive UI with no refetch (Decision 1/Decision 5).
+ */
+export type ShippingOptionSelectUserError = Readonly<{
+  code: string;
+  message: string;
+}>;
+//#endregion
+//# sourceMappingURL=option-select-operations.d.ts.map

package/dist/sdk/shipping/option-select-operations.js

@@ -0,0 +1,45 @@
+import { gql } from "../graphql-tag.js";
+import { CartFragment } from "../cart/operations.js";
+//#region src/sdk/shipping/option-select-operations.ts
+const SHIPPING_OPTION_SELECT = gql`
+  mutation ShippingOptionSelect($input: ShippingOptionSelectInput!) {
+    shippingOptionSelect(input: $input) {
+      __typename
+      shipping {
+        __typename
+        id
+        options {
+          __typename
+          id
+          name
+          channel
+          shippingEstimate {
+            value
+            unit
+          }
+          price {
+            amount
+            currencyCode
+          }
+          listPrice {
+            amount
+            currencyCode
+          }
+        }
+        selectedOptionId
+      }
+      cart {
+        ...CartFragment
+      }
+      userErrors {
+        code
+        message
+      }
+    }
+  }
+  ${CartFragment}
+`;
+//#endregion
+export { SHIPPING_OPTION_SELECT };
+
+//# sourceMappingURL=option-select-operations.js.map

package/dist/sdk/shipping/option-select-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"option-select-operations.js","names":[],"sources":["../../../src/sdk/shipping/option-select-operations.ts"],"sourcesContent":["import type { TypedDocumentNode } from '@apollo/client';\nimport { type CartEntity, CartFragment } from '../cart/operations.js';\nimport { gql } from '../graphql-tag.js';\n\n/**\n * `shippingOptionSelect` mutation document (specs/delivery-options-step.md, T3).\n *\n * Authored with the hand `gql` tag — the codegen `graphql()` factory is reserved for the reactive\n * read path (`shipping/operations.ts`) — and explicitly excluded from the codegen `documents` glob\n * (see `codegen.ts`): the `gql` tag alone is still plucked by `graphql-codegen`, which would\n * duplicate these hand-written types in `sdk/generated/`. Mirrors the `session`/`identity`\n * action-mutation convention (hand-typed `TypedDocumentNode`s).\n *\n * Selects `cart { ...CartFragment }` alongside `shipping` so the normalized Apollo cache updates\n * the cart totalizer in the same round trip (T1 epic note). Both `shipping` and its nested\n * `options` select `id`/`__typename` so `InMemoryCache` normalizes them as the same entities the\n * reactive `DeliveryOptionsData` fragment reads — required for the mutation response to flow back\n * into the reactive UI with no refetch (Decision 1/Decision 5).\n */\n\nexport type ShippingOptionSelectUserError = Readonly<{ code: string; message: string }>;\n\nexport type ShippingOptionSelectInput = Readonly<{ optionId: string }>;\n\ntype ShippingOptionEntity = Readonly<{\n  __typename?: 'ShippingOption';\n  id: string;\n  name: string;\n  channel: string;\n  shippingEstimate: Readonly<{ __typename?: 'ShippingEstimate'; value: number; unit: string }>;\n  price: Readonly<{ __typename?: 'Money'; amount: number; currencyCode: string }>;\n  listPrice: Readonly<{ __typename?: 'Money'; amount: number; currencyCode: string }>;\n}>;\n\ntype ShippingEntity = Readonly<{\n  __typename?: 'Shipping';\n  id: string;\n  options: readonly ShippingOptionEntity[];\n  selectedOptionId: string | null;\n}>;\n\ntype ShippingOptionSelectPayloadEntity = Readonly<{\n  __typename?: 'ShippingOptionSelectPayload';\n  shipping: ShippingEntity | null;\n  cart: CartEntity | null;\n  userErrors: readonly ShippingOptionSelectUserError[];\n}>;\n\ntype ShippingOptionSelectMutation = Readonly<{ shippingOptionSelect: ShippingOptionSelectPayloadEntity }>;\n\ntype ShippingOptionSelectMutationVariables = Readonly<{ input: ShippingOptionSelectInput }>;\n\nexport const SHIPPING_OPTION_SELECT: TypedDocumentNode<\n  ShippingOptionSelectMutation,\n  ShippingOptionSelectMutationVariables\n> = gql`\n  mutation ShippingOptionSelect($input: ShippingOptionSelectInput!) {\n    shippingOptionSelect(input: $input) {\n      __typename\n      shipping {\n        __typename\n        id\n        options {\n          __typename\n          id\n          name\n          channel\n          shippingEstimate {\n            value\n            unit\n          }\n          price {\n            amount\n            currencyCode\n          }\n          listPrice {\n            amount\n            currencyCode\n          }\n        }\n        selectedOptionId\n      }\n      cart {\n        ...CartFragment\n      }\n      userErrors {\n        code\n        message\n      }\n    }\n  }\n  ${CartFragment}\n`;\n"],"mappings":";;;AAoDA,MAAa,yBAGT,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoCH,aAAa"}

package/dist/sdk/shipping/request-timeout.js

@@ -0,0 +1,41 @@
+//#region src/sdk/shipping/request-timeout.ts
+/**
+* Bounds the default shipping-simulation SDK request (specs/shipping-simulation-request-timeout.md).
+*
+* The default `useShippingSimulation` / `useCartShippingSimulation` callbacks run an imperative
+* `client.query` with no time bound, so a logistics transport that never settles leaves the
+* simulator Root stuck on `loading` forever. `withRequestTimeout` races the request against a finite
+* timer: when the timer wins it aborts the in-flight request (via the `AbortSignal` threaded into
+* `context.fetchOptions`) and rejects, which each hook's existing `catch` collapses to the same
+* `UNKNOWN` userError as any other failure — so the timeout reuses the established error path and the
+* Root leaves `loading` for `error`.
+*
+* The abort is best-effort: it cancels the network request only when the Apollo link chain honors the
+* signal (`HttpLink` does; `MockLink` in tests does not). Settlement never depends on it — the timer
+* race guarantees the returned promise resolves or rejects within `timeoutMs` regardless.
+*/
+const SHIPPING_SIMULATION_TIMEOUT_MS = 1e4;
+var ShippingSimulationTimeoutError = class extends Error {
+	constructor() {
+		super("Shipping simulation request timed out.");
+		this.name = "ShippingSimulationTimeoutError";
+	}
+};
+function withRequestTimeout(run, timeoutMs = SHIPPING_SIMULATION_TIMEOUT_MS) {
+	const controller = new AbortController();
+	let timer;
+	const timeout = new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			controller.abort();
+			reject(new ShippingSimulationTimeoutError());
+		}, timeoutMs);
+	});
+	const request = (async () => run(controller.signal))();
+	return Promise.race([request, timeout]).finally(() => {
+		clearTimeout(timer);
+	});
+}
+//#endregion
+export { SHIPPING_SIMULATION_TIMEOUT_MS, ShippingSimulationTimeoutError, withRequestTimeout };
+
+//# sourceMappingURL=request-timeout.js.map

package/dist/sdk/shipping/request-timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-timeout.js","names":[],"sources":["../../../src/sdk/shipping/request-timeout.ts"],"sourcesContent":["/**\n * Bounds the default shipping-simulation SDK request (specs/shipping-simulation-request-timeout.md).\n *\n * The default `useShippingSimulation` / `useCartShippingSimulation` callbacks run an imperative\n * `client.query` with no time bound, so a logistics transport that never settles leaves the\n * simulator Root stuck on `loading` forever. `withRequestTimeout` races the request against a finite\n * timer: when the timer wins it aborts the in-flight request (via the `AbortSignal` threaded into\n * `context.fetchOptions`) and rejects, which each hook's existing `catch` collapses to the same\n * `UNKNOWN` userError as any other failure — so the timeout reuses the established error path and the\n * Root leaves `loading` for `error`.\n *\n * The abort is best-effort: it cancels the network request only when the Apollo link chain honors the\n * signal (`HttpLink` does; `MockLink` in tests does not). Settlement never depends on it — the timer\n * race guarantees the returned promise resolves or rejects within `timeoutMs` regardless.\n */\n\n// A generous safety net: well above any healthy round-trip and above the resolver's own upstream\n// budget, so it fires only on a genuine hang, not on a merely slow-but-healthy response.\nexport const SHIPPING_SIMULATION_TIMEOUT_MS = 10_000;\n\nexport class ShippingSimulationTimeoutError extends Error {\n  constructor() {\n    super('Shipping simulation request timed out.');\n    this.name = 'ShippingSimulationTimeoutError';\n  }\n}\n\nexport function withRequestTimeout<T>(\n  run: (signal: AbortSignal) => Promise<T>,\n  // Defaults to the shared constant; no runtime caller overrides it today. Kept as the injection\n  // point for a future per-account configurable timeout, once a per-account config source exists.\n  timeoutMs: number = SHIPPING_SIMULATION_TIMEOUT_MS,\n): Promise<T> {\n  const controller = new AbortController();\n  let timer: ReturnType<typeof setTimeout> | undefined;\n\n  const timeout = new Promise<never>((_, reject) => {\n    timer = setTimeout(() => {\n      controller.abort();\n      reject(new ShippingSimulationTimeoutError());\n    }, timeoutMs);\n  });\n\n  // `run` is invoked inside an async wrapper so a synchronous throw becomes a rejection the race can\n  // observe. Called bare, it would escape before `finally` is attached, leaving the timer armed and\n  // the timeout's own rejection unhandled.\n  const request = (async () => run(controller.signal))();\n\n  return Promise.race([request, timeout]).finally(() => {\n    clearTimeout(timer);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAkBA,MAAa,iCAAiC;AAE9C,IAAa,iCAAb,cAAoD,MAAM;CACxD,cAAc;EACZ,MAAM,wCAAwC;EAC9C,KAAK,OAAO;CACd;AACF;AAEA,SAAgB,mBACd,KAGA,YAAoB,gCACR;CACZ,MAAM,aAAa,IAAI,gBAAgB;CACvC,IAAI;CAEJ,MAAM,UAAU,IAAI,SAAgB,GAAG,WAAW;EAChD,QAAQ,iBAAiB;GACvB,WAAW,MAAM;GACjB,OAAO,IAAI,+BAA+B,CAAC;EAC7C,GAAG,SAAS;CACd,CAAC;CAKD,MAAM,WAAW,YAAY,IAAI,WAAW,MAAM,EAAA,CAAG;CAErD,OAAO,QAAQ,KAAK,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,cAAc;EACpD,aAAa,KAAK;CACpB,CAAC;AACH"}

package/dist/sdk/shipping/shipping-operations.d.ts

@@ -0,0 +1,38 @@
+import "../cart/operations.js";
+import { TypedDocumentNode } from "@apollo/client";
+//#region src/sdk/shipping/shipping-operations.d.ts
+/**
+ * Shipping address mutation documents (specs/shipping-address-step.md, US-7).
+ *
+ * Authored with the hand `gql` tag — the codegen `graphql()` factory is reserved for the reactive
+ * read path (`operations.ts`) — and explicitly excluded from the codegen `documents` glob (see
+ * `codegen.ts`): the `gql` tag alone is still plucked by `graphql-codegen`, which would duplicate
+ * these hand-written types in `sdk/generated/`. The mutation stays hand-typed as a
+ * `TypedDocumentNode` (Decision 3 in the spec). The payload projects the full refreshed `shipping`
+ * and `cart` state, so the response write into the cache *is* the post-update refresh: `Shipping`'s
+ * reactive read flips with no refetch and no imperative cache write.
+ *
+ * Failures follow ADR-00007's two-path contract: domain outcomes arrive as payload `userErrors`
+ * (`ShippingAddressUpdateError`); transport and top-level GraphQL failures are infrastructure,
+ * mapped by the handlers in `use-shipping-actions.ts` to the one client-synthesized code,
+ * `NETWORK_USER_ERROR`.
+ */
+/** A typed address-update failure; NETWORK_USER_ERROR is the one client-synthesized code. */
+export type ShippingAddressUpdateErrorEntity = Readonly<{
+  code: string;
+  message: string;
+}>;
+export type ShippingAddressInput = Readonly<{
+  savedAddressId?: string;
+  recipientName: string;
+  postalCode: string;
+  country: string;
+  street?: string;
+  number?: string;
+  complement?: string;
+  neighborhood?: string;
+  city?: string;
+  state?: string;
+}>;
+//#endregion
+//# sourceMappingURL=shipping-operations.d.ts.map