@nokinc-flur/sdk 1.0.3 → 1.0.5

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -36,6 +26,16 @@ __export(index_exports, {
   AccountMembershipSchema: () => AccountMembershipSchema,
   AccountSchema: () => AccountSchema,
   ApiCredentialPublicSchema: () => ApiCredentialPublicSchema,
+  ConsumerOACRecordSchema: () => OACRecordSchema,
+  ConsumerOACSchema: () => ConsumerOACSchema,
+  ConsumerPaymentClaimSchema: () => ConsumerPaymentClaimSchema,
+  ConsumerSettleResultSchema: () => ConsumerSettleResultSchema,
+  ConsumerSettlementSchema: () => ConsumerSettlementSchema,
+  DeviceKeyRecordSchema: () => DeviceKeyRecordSchema,
+  DisableOfflineInputSchema: () => DisableOfflineInputSchema,
+  DisableOfflineResultSchema: () => DisableOfflineResultSchema,
+  EnableOfflineInputSchema: () => EnableOfflineInputSchema,
+  EnableOfflineResultSchema: () => EnableOfflineResultSchema,
   FIELD: () => FIELD,
   FlurApiError: () => FlurApiError,
   FlurCapExceededError: () => FlurCapExceededError,
@@ -43,6 +43,7 @@ __export(index_exports, {
   FlurError: () => FlurError,
   FlurExpiredError: () => FlurExpiredError,
   FlurReplayError: () => FlurReplayError,
+  IssueOACInputSchema: () => IssueOACInputSchema,
   MEMBERSHIP_ROLES: () => MEMBERSHIP_ROLES,
   MintedApiCredentialSchema: () => MintedApiCredentialSchema,
   NGN_CURRENCY_CODE: () => NGN_CURRENCY_CODE,
@@ -52,8 +53,11 @@ __export(index_exports, {
   OAC_DEFAULT_CUMULATIVE_KOBO: () => OAC_DEFAULT_CUMULATIVE_KOBO,
   OAC_DEFAULT_PER_TX_KOBO: () => OAC_DEFAULT_PER_TX_KOBO,
   OAC_DEFAULT_VALIDITY_MS: () => OAC_DEFAULT_VALIDITY_MS,
+  OfflineHoldRecordSchema: () => OfflineHoldRecordSchema,
   OfflinePaymentAuthorizationSchema: () => OfflinePaymentAuthorizationSchema,
   OfflinePaymentRequestSchema: () => OfflinePaymentRequestSchema,
+  OfflineStateResultSchema: () => OfflineStateResultSchema,
+  OfflineStatusResultSchema: () => OfflineStatusResultSchema,
   OfflineTokenSchema: () => OfflineTokenSchema,
   PARTNER_SCOPES: () => PARTNER_SCOPES,
   PASS_KINDS: () => PASS_KINDS,
@@ -69,8 +73,11 @@ __export(index_exports, {
   ReceiptPayloadSchema: () => ReceiptPayloadSchema,
   ReceiptSchema: () => ReceiptSchema,
   RedemptionSchema: () => RedemptionSchema,
+  RegisterDeviceKeyInputSchema: () => RegisterDeviceKeyInputSchema,
+  RevokeDeviceKeyInputSchema: () => RevokeDeviceKeyInputSchema,
   SettleResponseSchema: () => SettleResponseSchema,
   SettlementSchema: () => SettlementSchema,
+  SignedConsumerOACSchema: () => SignedConsumerOACSchema,
   bodySha256Hex: () => bodySha256Hex,
   buildAuthorization: () => buildAuthorization,
   buildOAC: () => buildOAC,
@@ -89,6 +96,7 @@ __export(index_exports, {
   createApiCredentialsAdminClient: () => createApiCredentialsAdminClient,
   createFlurPartnerClient: () => createFlurPartnerClient,
   createHmacFetch: () => createHmacFetch,
+  createMeOfflineClient: () => createMeOfflineClient,
   createOfflineSettlementsClient: () => createOfflineSettlementsClient,
   createPassesClient: () => createPassesClient,
   createReceiptsClient: () => createReceiptsClient,
@@ -179,7 +187,9 @@ var OnboardingCompleteResponseSchema = import_zod.z.object({
   sessionToken: import_zod.z.string().min(1),
   userId: UuidSchema,
   restricted: import_zod.z.boolean(),
-  risk_reasons: import_zod.z.array(import_zod.z.enum(["SIM_SWAP_RECENT", "ROAMING", "CARRIER_CHANGED"])),
+  risk_reasons: import_zod.z.array(
+    import_zod.z.enum(["SIM_SWAP_RECENT", "ROAMING", "CARRIER_CHANGED"])
+  ),
   stepUpRequired: import_zod.z.boolean().optional(),
   riskStatus: import_zod.z.enum(["ok", "unavailable"]).optional()
 });
@@ -232,9 +242,11 @@ var RegisterSendDeviceKeyRequestSchema = import_zod.z.object({
   deviceId: import_zod.z.string().min(3),
   publicKey: import_zod.z.string().min(32)
 });
+var SEND_AUTH_PURPOSES = ["send_money", "offline_revoke"];
 var SendChallengeRequestSchema = import_zod.z.object({
   userId: UuidSchema,
-  deviceId: import_zod.z.string().min(3)
+  deviceId: import_zod.z.string().min(3),
+  purpose: import_zod.z.enum(SEND_AUTH_PURPOSES).optional()
 });
 var SendChallengeResponseSchema = import_zod.z.object({
   challengeId: UuidSchema,
@@ -534,10 +546,20 @@ var FlurClient = class {
     this.getExtraHeaders = opts.getExtraHeaders;
   }
   async health() {
-    return this.requestJson("/health", { method: "GET" }, void 0, HealthResponseSchema);
+    return this.requestJson(
+      "/health",
+      { method: "GET" },
+      void 0,
+      HealthResponseSchema
+    );
   }
   async welcome() {
-    return this.requestJson("/welcome", { method: "GET" }, void 0, WelcomeResponseSchema);
+    return this.requestJson(
+      "/welcome",
+      { method: "GET" },
+      void 0,
+      WelcomeResponseSchema
+    );
   }
   async onboardingStart(input) {
     return this.requestJson(
@@ -682,24 +704,33 @@ var FlurClient = class {
   }
   async registerBiometricDeviceKey(input) {
     const publicKey = await input.signer.getOrCreateKeyPair(input.deviceId);
-    return this.registerSendDeviceKey({
-      userId: input.userId,
-      deviceId: input.deviceId,
-      publicKey
-    }, { accessToken: input.accessToken });
+    return this.registerSendDeviceKey(
+      {
+        userId: input.userId,
+        deviceId: input.deviceId,
+        publicKey
+      },
+      { accessToken: input.accessToken }
+    );
   }
   async authorizeSendWithBiometric(input) {
-    const challenge = await this.createSendChallenge({
-      userId: input.userId,
-      deviceId: input.deviceId
-    }, { accessToken: input.accessToken });
+    const challenge = await this.createSendChallenge(
+      {
+        userId: input.userId,
+        deviceId: input.deviceId
+      },
+      { accessToken: input.accessToken }
+    );
     const signature = await input.signer.sign(challenge.nonce);
-    return this.verifySendChallenge({
-      userId: input.userId,
-      deviceId: input.deviceId,
-      challengeId: challenge.challengeId,
-      signature
-    }, { accessToken: input.accessToken });
+    return this.verifySendChallenge(
+      {
+        userId: input.userId,
+        deviceId: input.deviceId,
+        challengeId: challenge.challengeId,
+        signature
+      },
+      { accessToken: input.accessToken }
+    );
   }
   async resolveRecipient(input, options) {
     return this.requestJson(
@@ -864,7 +895,12 @@ var FlurClient = class {
         ...init2.headers,
         ...extraHeaders
       };
-      const res = await this.fetchImpl(url, { ...init2, headers: finalHeaders, body, signal: controller.signal });
+      const res = await this.fetchImpl(url, {
+        ...init2,
+        headers: finalHeaders,
+        body,
+        signal: controller.signal
+      });
       if (!res.ok) throw await mapToFlurError(res);
       const payload = await res.json();
       if (!responseSchema) return payload;
@@ -872,9 +908,13 @@ var FlurClient = class {
         return responseSchema.parse(payload);
       } catch (err) {
         if (err instanceof import_zod3.z.ZodError) {
-          throw new FlurError("SDK contract validation failed", "INVALID_REQUEST", {
-            details: err.flatten()
-          });
+          throw new FlurError(
+            "SDK contract validation failed",
+            "INVALID_REQUEST",
+            {
+              details: err.flatten()
+            }
+          );
         }
         throw err;
       }
@@ -883,7 +923,9 @@ var FlurClient = class {
         throw new FlurError("Request timed out", "TIMEOUT");
       }
       if (err instanceof FlurError) throw err;
-      throw new FlurError("Network error", "NETWORK_ERROR", { details: String(err) });
+      throw new FlurError("Network error", "NETWORK_ERROR", {
+        details: String(err)
+      });
     } finally {
       clearTimeout(t);
     }
@@ -893,7 +935,10 @@ function getSecureRandomUuid() {
   if (typeof globalThis.crypto?.randomUUID === "function") {
     return globalThis.crypto.randomUUID();
   }
-  throw new FlurError("Secure UUID generator unavailable; provide idempotencyKey", "INVALID_REQUEST");
+  throw new FlurError(
+    "Secure UUID generator unavailable; provide idempotencyKey",
+    "INVALID_REQUEST"
+  );
 }
 
 // src/nqr/fields.ts
@@ -1566,6 +1611,8 @@ function decodeAuthorizationQR(s) {
 
 // src/offline/settlements.ts
 var import_zod6 = require("zod");
+var import_sha256 = require("@noble/hashes/sha256");
+var import_utils = require("@noble/hashes/utils");
 var OfflineTokenSchema = import_zod6.z.object({
   tokenId: import_zod6.z.string().uuid(),
   tokenSerial: import_zod6.z.string(),
@@ -1616,14 +1663,7 @@ var SettleResponseSchema = import_zod6.z.object({
 });
 var ENCOUNTER_DOMAIN = "offline:v1:encounter";
 async function sha256Hex(input) {
-  const subtle = globalThis.crypto?.subtle;
-  const enc2 = new TextEncoder().encode(input);
-  if (subtle) {
-    const buf = await subtle.digest("SHA-256", enc2);
-    return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
-  }
-  const mod = await import("crypto");
-  return mod.createHash("sha256").update(input).digest("hex");
+  return (0, import_utils.bytesToHex)((0, import_sha256.sha256)(new TextEncoder().encode(input)));
 }
 async function computeEncounterId(input) {
   return sha256Hex(
@@ -1671,8 +1711,8 @@ function createOfflineSettlementsClient(partner) {
 
 // src/auth/hmac.ts
 var import_hmac = require("@noble/hashes/hmac");
-var import_sha256 = require("@noble/hashes/sha256");
-function bytesToHex2(b) {
+var import_sha2562 = require("@noble/hashes/sha256");
+function bytesToHex3(b) {
   let s = "";
   for (let i = 0; i < b.length; i++) s += b[i].toString(16).padStart(2, "0");
   return s;
@@ -1684,7 +1724,7 @@ function constantTimeStringEqual(a, b) {
   return diff === 0;
 }
 function bodySha256Hex(body) {
-  return bytesToHex2((0, import_sha256.sha256)(new TextEncoder().encode(body)));
+  return bytesToHex3((0, import_sha2562.sha256)(new TextEncoder().encode(body)));
 }
 function canonicalRequestString(input) {
   return [
@@ -1696,8 +1736,8 @@ function canonicalRequestString(input) {
   ].join("\n");
 }
 function signRequestHMAC(input) {
-  return bytesToHex2(
-    (0, import_hmac.hmac)(import_sha256.sha256, input.apiSecret, canonicalRequestString(input))
+  return bytesToHex3(
+    (0, import_hmac.hmac)(import_sha2562.sha256, input.apiSecret, canonicalRequestString(input))
   );
 }
 function verifyRequestHMAC(input) {
@@ -2456,6 +2496,9 @@ function createAccountsClient(opts) {
 
 // src/partner/client.ts
 var import_zod11 = require("zod");
+var import_sha2563 = require("@noble/hashes/sha256");
+var import_hmac4 = require("@noble/hashes/hmac");
+var import_utils2 = require("@noble/hashes/utils");
 var PARTNER_SCOPES = [
   "passes:write",
   "passes:read",
@@ -2479,39 +2522,13 @@ var ApiCredentialPublicSchema = import_zod11.z.object({
 var MintedApiCredentialSchema = ApiCredentialPublicSchema.extend({
   secret: import_zod11.z.string().min(1)
 });
-async function getSubtle() {
-  const c = globalThis.crypto;
-  if (c?.subtle) return c.subtle;
-  const mod = await import("crypto");
-  return mod.webcrypto.subtle;
-}
 var enc = new TextEncoder();
-function bytesToHex3(buf) {
-  const u = new Uint8Array(buf);
-  let s = "";
-  for (let i = 0; i < u.length; i++) {
-    s += u[i].toString(16).padStart(2, "0");
-  }
-  return s;
-}
 async function sha256Hex2(input) {
-  const subtle = await getSubtle();
   const data = typeof input === "string" ? enc.encode(input) : input;
-  const buffer = data.byteOffset === 0 && data.byteLength === data.buffer.byteLength ? data.buffer : data.slice().buffer;
-  const buf = await subtle.digest("SHA-256", buffer);
-  return bytesToHex3(buf);
+  return (0, import_utils2.bytesToHex)((0, import_sha2563.sha256)(data));
 }
 async function hmacSha256Hex(keyHex, message) {
-  const subtle = await getSubtle();
-  const key = await subtle.importKey(
-    "raw",
-    enc.encode(keyHex),
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"]
-  );
-  const sig = await subtle.sign("HMAC", key, enc.encode(message));
-  return bytesToHex3(sig);
+  return (0, import_utils2.bytesToHex)((0, import_hmac4.hmac)(import_sha2563.sha256, enc.encode(keyHex), enc.encode(message)));
 }
 function defaultNonce2() {
   const c = globalThis.crypto;
@@ -2672,6 +2689,260 @@ function createApiCredentialsAdminClient(opts) {
     )
   };
 }
+
+// src/me-offline/client.ts
+var import_zod12 = require("zod");
+var Hex64 = import_zod12.z.string().regex(/^[0-9a-f]{64}$/i);
+var HexAny = import_zod12.z.string().regex(/^[0-9a-f]+$/i);
+var Sha256Hex = import_zod12.z.string().regex(/^[0-9a-f]{64}$/i);
+var RegisterDeviceKeyInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  publicKeyHex: Hex64
+});
+var DeviceKeyRecordSchema = import_zod12.z.object({
+  id: import_zod12.z.string().uuid(),
+  userId: import_zod12.z.string().uuid(),
+  deviceId: import_zod12.z.string(),
+  publicKeyHex: Hex64,
+  createdAtMs: import_zod12.z.number().int().nonnegative(),
+  revokedAtMs: import_zod12.z.number().int().nonnegative().nullable()
+});
+var ConsumerOACSchema = import_zod12.z.object({
+  oacId: import_zod12.z.string().uuid(),
+  issuerId: import_zod12.z.string().min(1).max(64),
+  userId: import_zod12.z.string().uuid(),
+  deviceId: import_zod12.z.string().min(1).max(128),
+  devicePubkeyHex: Hex64,
+  perTxCapKobo: import_zod12.z.number().int().positive(),
+  cumulativeCapKobo: import_zod12.z.number().int().positive(),
+  currency: import_zod12.z.string().length(3),
+  validFromMs: import_zod12.z.number().int().nonnegative(),
+  validUntilMs: import_zod12.z.number().int().nonnegative(),
+  counterSeed: import_zod12.z.number().int().nonnegative(),
+  issuedAtMs: import_zod12.z.number().int().nonnegative()
+});
+var SignedConsumerOACSchema = import_zod12.z.object({
+  oac: ConsumerOACSchema,
+  issuerSig: HexAny,
+  issuerPublicKeyHex: Hex64
+});
+var OACRecordSchema = SignedConsumerOACSchema.extend({
+  currentOfflineSpentKobo: import_zod12.z.number().int().nonnegative(),
+  status: import_zod12.z.enum([
+    "active",
+    "superseded",
+    "expired",
+    "revoked",
+    "disabling",
+    "draining",
+    "closed"
+  ]),
+  supersededAtMs: import_zod12.z.number().int().nonnegative().nullable(),
+  revokedAtMs: import_zod12.z.number().int().nonnegative().nullable(),
+  holdId: import_zod12.z.string().uuid().nullable().optional()
+});
+var IssueOACInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  perTxCapKobo: import_zod12.z.number().int().positive().optional(),
+  cumulativeCapKobo: import_zod12.z.number().int().positive().optional(),
+  ttlMs: import_zod12.z.number().int().min(6e4).max(1e3 * 60 * 60 * 24 * 7).optional(),
+  spendableOnlineKobo: import_zod12.z.number().int().nonnegative().optional()
+});
+var EnableOfflineInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  amountKobo: import_zod12.z.number().int().positive(),
+  perTxCapKobo: import_zod12.z.number().int().positive().optional(),
+  ttlMs: import_zod12.z.number().int().min(6e4).max(1e3 * 60 * 60 * 24 * 7).optional(),
+  installId: import_zod12.z.string().min(1).max(128),
+  partnerId: import_zod12.z.string().min(1).max(64).optional()
+});
+var DisableOfflineInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  installId: import_zod12.z.string().min(1).max(128).optional(),
+  claims: import_zod12.z.array(import_zod12.z.unknown()).max(256).optional()
+});
+var OfflineHoldRecordSchema = import_zod12.z.object({
+  holdId: import_zod12.z.string().uuid(),
+  userId: import_zod12.z.string().uuid(),
+  deviceId: import_zod12.z.string(),
+  partnerId: import_zod12.z.string(),
+  adapterKind: import_zod12.z.string(),
+  externalHoldRef: import_zod12.z.string().nullable(),
+  amountKobo: import_zod12.z.number().int().nonnegative(),
+  capturedKobo: import_zod12.z.number().int().nonnegative(),
+  releasedKobo: import_zod12.z.number().int().nonnegative(),
+  remainingKobo: import_zod12.z.number().int().nonnegative(),
+  currency: import_zod12.z.string().length(3),
+  status: import_zod12.z.enum([
+    "placing",
+    "active",
+    "disabling",
+    "draining",
+    "closed",
+    "revoked",
+    "failed"
+  ]),
+  installId: import_zod12.z.string().nullable(),
+  drainDeadlineMs: import_zod12.z.number().int().nonnegative(),
+  disableRequestedAtMs: import_zod12.z.number().int().nonnegative().nullable(),
+  createdAtMs: import_zod12.z.number().int().nonnegative(),
+  closedAtMs: import_zod12.z.number().int().nonnegative().nullable(),
+  isTrusted: import_zod12.z.boolean().optional()
+});
+var EnableOfflineResultSchema = import_zod12.z.object({
+  hold: OfflineHoldRecordSchema,
+  oac: OACRecordSchema
+});
+var DisableOfflineResultSchema = import_zod12.z.object({
+  hold: OfflineHoldRecordSchema,
+  trusted: import_zod12.z.boolean(),
+  settledClaims: import_zod12.z.number().int().nonnegative()
+});
+var OfflineStatusResultSchema = import_zod12.z.object({
+  hold: OfflineHoldRecordSchema.nullable(),
+  active: OACRecordSchema.nullable()
+});
+var OfflineStateResultSchema = import_zod12.z.object({
+  active: OACRecordSchema.nullable()
+});
+var ConsumerPaymentClaimSchema = import_zod12.z.object({
+  oacId: import_zod12.z.string().uuid(),
+  encounterId: Sha256Hex.optional(),
+  payerUserId: import_zod12.z.string().uuid(),
+  payeeUserId: import_zod12.z.string().uuid(),
+  payerDeviceId: import_zod12.z.string().min(1).max(128),
+  payerNonce: import_zod12.z.string().min(8).max(128),
+  payeeNonce: import_zod12.z.string().min(8).max(128),
+  amountKobo: import_zod12.z.number().int().positive(),
+  currency: import_zod12.z.string().length(3).default("NGN"),
+  occurredAtMs: import_zod12.z.number().int().nonnegative(),
+  completedAtMs: import_zod12.z.number().int().nonnegative().optional(),
+  contextId: import_zod12.z.string().max(128).optional(),
+  payerPubkeyHex: Hex64,
+  payerSignature: HexAny,
+  payeePubkeyHex: Hex64.optional(),
+  payeeSignature: HexAny.optional()
+});
+var ConsumerSettlementSchema = import_zod12.z.object({
+  settlementId: import_zod12.z.string().uuid(),
+  settlementKey: Sha256Hex,
+  encounterId: Sha256Hex,
+  oacId: import_zod12.z.string().uuid(),
+  payerUserId: import_zod12.z.string().uuid(),
+  payeeUserId: import_zod12.z.string().uuid(),
+  amountKobo: import_zod12.z.number().int().positive(),
+  currency: import_zod12.z.string().length(3),
+  status: import_zod12.z.enum(["SETTLED", "REVIEW"]),
+  reviewReason: import_zod12.z.string().nullable(),
+  ledgerRef: import_zod12.z.string().nullable(),
+  issuerSig: HexAny,
+  createdAtMs: import_zod12.z.number().int().nonnegative()
+});
+var ConsumerSettleResultSchema = import_zod12.z.object({
+  settlement: ConsumerSettlementSchema,
+  encounterId: Sha256Hex,
+  replayed: import_zod12.z.boolean()
+});
+var RevokeDeviceKeyInputSchema = import_zod12.z.object({
+  deviceId: import_zod12.z.string().min(1).max(128),
+  /** Step-up token from /api/v1/auth/send/verify with purpose='offline_revoke'. */
+  sendAuthToken: import_zod12.z.string().min(16)
+});
+function createMeOfflineClient(opts) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("createMeOfflineClient: no fetch implementation available");
+  }
+  const baseUrl = opts.baseUrl.replace(/\/$/, "");
+  async function call(method, path, body, parser) {
+    const init2 = {
+      method,
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json"
+      }
+    };
+    if (body !== void 0) init2.body = JSON.stringify(body);
+    const resp = await fetchImpl(`${baseUrl}${path}`, init2);
+    const text = await resp.text();
+    let raw = void 0;
+    if (text) {
+      try {
+        raw = JSON.parse(text);
+      } catch {
+      }
+    }
+    if (!resp.ok) {
+      const code = raw && typeof raw === "object" && "code" in raw && typeof raw.code === "string" ? raw.code : `http_${resp.status}`;
+      const message = raw && typeof raw === "object" && "message" in raw && typeof raw.message === "string" ? raw.message : `request failed with status ${resp.status}`;
+      throw new FlurApiError(resp.status, code, message, raw);
+    }
+    return parser(raw);
+  }
+  const deviceKeyItems = import_zod12.z.object({ items: import_zod12.z.array(DeviceKeyRecordSchema) });
+  return {
+    registerDeviceKey: (input) => call(
+      "POST",
+      "/v1/me/offline/keys",
+      RegisterDeviceKeyInputSchema.parse(input),
+      (raw) => DeviceKeyRecordSchema.parse(raw)
+    ),
+    listDeviceKeys: () => call(
+      "GET",
+      "/v1/me/offline/keys",
+      void 0,
+      (raw) => deviceKeyItems.parse(raw)
+    ),
+    revokeDeviceKey: (input) => call(
+      "POST",
+      "/v1/me/offline/keys/revoke",
+      RevokeDeviceKeyInputSchema.parse(input),
+      () => void 0
+    ),
+    enable: (input) => call(
+      "POST",
+      "/v1/me/offline/enable",
+      EnableOfflineInputSchema.parse(input),
+      (raw) => EnableOfflineResultSchema.parse(raw)
+    ),
+    refresh: (input) => call(
+      "POST",
+      "/v1/me/offline/refresh",
+      IssueOACInputSchema.parse(input),
+      (raw) => OACRecordSchema.parse(raw)
+    ),
+    disable: (input) => call(
+      "POST",
+      "/v1/me/offline/disable",
+      DisableOfflineInputSchema.parse(input),
+      (raw) => DisableOfflineResultSchema.parse(raw)
+    ),
+    getStatus: (deviceId) => {
+      const qs = deviceId ? `?deviceId=${encodeURIComponent(deviceId)}` : "";
+      return call(
+        "GET",
+        `/v1/me/offline/status${qs}`,
+        void 0,
+        (raw) => OfflineStatusResultSchema.parse(raw)
+      );
+    },
+    getState: (deviceId) => {
+      const qs = deviceId ? `?deviceId=${encodeURIComponent(deviceId)}` : "";
+      return call(
+        "GET",
+        `/v1/me/offline/state${qs}`,
+        void 0,
+        (raw) => OfflineStateResultSchema.parse(raw)
+      );
+    },
+    submitClaim: (claim) => call(
+      "POST",
+      "/v1/me/offline/claims",
+      ConsumerPaymentClaimSchema.parse(claim),
+      (raw) => ConsumerSettleResultSchema.parse(raw)
+    )
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNT_STATUSES,
@@ -2680,6 +2951,16 @@ function createApiCredentialsAdminClient(opts) {
   AccountMembershipSchema,
   AccountSchema,
   ApiCredentialPublicSchema,
+  ConsumerOACRecordSchema,
+  ConsumerOACSchema,
+  ConsumerPaymentClaimSchema,
+  ConsumerSettleResultSchema,
+  ConsumerSettlementSchema,
+  DeviceKeyRecordSchema,
+  DisableOfflineInputSchema,
+  DisableOfflineResultSchema,
+  EnableOfflineInputSchema,
+  EnableOfflineResultSchema,
   FIELD,
   FlurApiError,
   FlurCapExceededError,
@@ -2687,6 +2968,7 @@ function createApiCredentialsAdminClient(opts) {
   FlurError,
   FlurExpiredError,
   FlurReplayError,
+  IssueOACInputSchema,
   MEMBERSHIP_ROLES,
   MintedApiCredentialSchema,
   NGN_CURRENCY_CODE,
@@ -2696,8 +2978,11 @@ function createApiCredentialsAdminClient(opts) {
   OAC_DEFAULT_CUMULATIVE_KOBO,
   OAC_DEFAULT_PER_TX_KOBO,
   OAC_DEFAULT_VALIDITY_MS,
+  OfflineHoldRecordSchema,
   OfflinePaymentAuthorizationSchema,
   OfflinePaymentRequestSchema,
+  OfflineStateResultSchema,
+  OfflineStatusResultSchema,
   OfflineTokenSchema,
   PARTNER_SCOPES,
   PASS_KINDS,
@@ -2713,8 +2998,11 @@ function createApiCredentialsAdminClient(opts) {
   ReceiptPayloadSchema,
   ReceiptSchema,
   RedemptionSchema,
+  RegisterDeviceKeyInputSchema,
+  RevokeDeviceKeyInputSchema,
   SettleResponseSchema,
   SettlementSchema,
+  SignedConsumerOACSchema,
   bodySha256Hex,
   buildAuthorization,
   buildOAC,
@@ -2733,6 +3021,7 @@ function createApiCredentialsAdminClient(opts) {
   createApiCredentialsAdminClient,
   createFlurPartnerClient,
   createHmacFetch,
+  createMeOfflineClient,
   createOfflineSettlementsClient,
   createPassesClient,
   createReceiptsClient,