@nokinc-flur/sdk 1.0.4 → 1.0.6

package/dist/index.cjs

@@ -26,6 +26,29 @@ __export(index_exports, {
   AccountMembershipSchema: () => AccountMembershipSchema,
   AccountSchema: () => AccountSchema,
   ApiCredentialPublicSchema: () => ApiCredentialPublicSchema,
+  COLLECTION_INTENT_STATUSES: () => COLLECTION_INTENT_STATUSES,
+  COLLECTION_PAYMENT_STATUSES: () => COLLECTION_PAYMENT_STATUSES,
+  CUSTODIAL_MODES: () => CUSTODIAL_MODES,
+  CollectionIntentSchema: () => CollectionIntentSchema,
+  CollectionPaymentResultSchema: () => CollectionPaymentResultSchema,
+  CollectionPaymentSchema: () => CollectionPaymentSchema,
+  CollectionReportSummarySchema: () => CollectionReportSummarySchema,
+  CollectionStatementSchema: () => CollectionStatementSchema,
+  ConsumerOACRecordSchema: () => OACRecordSchema,
+  ConsumerOACSchema: () => ConsumerOACSchema,
+  ConsumerPaymentClaimSchema: () => ConsumerPaymentClaimSchema,
+  ConsumerSettleResultSchema: () => ConsumerSettleResultSchema,
+  ConsumerSettlementSchema: () => ConsumerSettlementSchema,
+  CreateCollectionIntentInputSchema: () => CreateCollectionIntentInputSchema,
+  CreatePayoutDestinationInputSchema: () => CreatePayoutDestinationInputSchema,
+  CreatePayoutInputSchema: () => CreatePayoutInputSchema,
+  CreateWithdrawalInputSchema: () => CreateWithdrawalInputSchema,
+  CreateWithdrawalResultSchema: () => CreateWithdrawalResultSchema,
+  DeviceKeyRecordSchema: () => DeviceKeyRecordSchema,
+  DisableOfflineInputSchema: () => DisableOfflineInputSchema,
+  DisableOfflineResultSchema: () => DisableOfflineResultSchema,
+  EnableOfflineInputSchema: () => EnableOfflineInputSchema,
+  EnableOfflineResultSchema: () => EnableOfflineResultSchema,
   FIELD: () => FIELD,
   FlurApiError: () => FlurApiError,
   FlurCapExceededError: () => FlurCapExceededError,
@@ -33,7 +56,14 @@ __export(index_exports, {
   FlurError: () => FlurError,
   FlurExpiredError: () => FlurExpiredError,
   FlurReplayError: () => FlurReplayError,
+  IngestFundingResultSchema: () => IngestFundingResultSchema,
+  IssueOACInputSchema: () => IssueOACInputSchema,
+  ListPayoutDestinationsResultSchema: () => ListPayoutDestinationsResultSchema,
   MEMBERSHIP_ROLES: () => MEMBERSHIP_ROLES,
+  MERCHANT_PAYOUT_STATUSES: () => MERCHANT_PAYOUT_STATUSES,
+  MERCHANT_PROFILE_STATUSES: () => MERCHANT_PROFILE_STATUSES,
+  MerchantPayoutSchema: () => MerchantPayoutSchema,
+  MerchantProfileSchema: () => MerchantProfileSchema,
   MintedApiCredentialSchema: () => MintedApiCredentialSchema,
   NGN_CURRENCY_CODE: () => NGN_CURRENCY_CODE,
   NG_COUNTRY_CODE: () => NG_COUNTRY_CODE,
@@ -42,25 +72,52 @@ __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_FUNDING_DIRECTIONS: () => PARTNER_FUNDING_DIRECTIONS,
+  PARTNER_FUNDING_STATUSES: () => PARTNER_FUNDING_STATUSES,
+  PARTNER_KINDS: () => PARTNER_KINDS,
+  PARTNER_PROFILE_STATUSES: () => PARTNER_PROFILE_STATUSES,
   PARTNER_SCOPES: () => PARTNER_SCOPES,
   PASS_KINDS: () => PASS_KINDS,
   PASS_STATES: () => PASS_STATES,
   PAYLOAD_FORMAT_INDICATOR_VALUE: () => PAYLOAD_FORMAT_INDICATOR_VALUE,
+  PAYOUT_DESTINATION_STATUSES: () => PAYOUT_DESTINATION_STATUSES,
   POINT_OF_INITIATION: () => POINT_OF_INITIATION,
+  PartnerFundingEventInputSchema: () => PartnerFundingEventInputSchema,
+  PartnerFundingSchema: () => PartnerFundingSchema,
+  PartnerProfileSchema: () => PartnerProfileSchema,
   PassMetadataSchema: () => PassMetadataSchema,
   PassSchema: () => PassSchema,
+  PayCollectionInputSchema: () => PayCollectionInputSchema,
   PaymentClaimSchema: () => PaymentClaimSchema,
+  PayoutDestinationSchema: () => PayoutDestinationSchema,
+  PayoutEventInputSchema: () => PayoutEventInputSchema,
+  ProviderEventInputSchema: () => ProviderEventInputSchema,
+  ProviderEventRecordSchema: () => ProviderEventRecordSchema,
+  PublicCollectionIntentSchema: () => PublicCollectionIntentSchema,
   RECEIPT_CHANNELS: () => RECEIPT_CHANNELS,
   RECEIPT_KINDS: () => RECEIPT_KINDS,
   REPLAY_WINDOW_MS: () => REPLAY_WINDOW_MS,
   ReceiptPayloadSchema: () => ReceiptPayloadSchema,
   ReceiptSchema: () => ReceiptSchema,
+  ReconciliationReportSchema: () => ReconciliationReportSchema,
+  RecordPayoutEventResultSchema: () => RecordPayoutEventResultSchema,
   RedemptionSchema: () => RedemptionSchema,
+  RegisterDeviceKeyInputSchema: () => RegisterDeviceKeyInputSchema,
+  RevokeDeviceKeyInputSchema: () => RevokeDeviceKeyInputSchema,
+  SETTLEMENT_SCHEDULES: () => SETTLEMENT_SCHEDULES,
   SettleResponseSchema: () => SettleResponseSchema,
   SettlementSchema: () => SettlementSchema,
+  SignedConsumerOACSchema: () => SignedConsumerOACSchema,
+  UpsertMerchantProfileInputSchema: () => UpsertMerchantProfileInputSchema,
+  UpsertPartnerProfileInputSchema: () => UpsertPartnerProfileInputSchema,
+  WITHDRAWAL_STATES: () => WITHDRAWAL_STATES,
+  WithdrawalSchema: () => WithdrawalSchema,
   bodySha256Hex: () => bodySha256Hex,
   buildAuthorization: () => buildAuthorization,
   buildOAC: () => buildOAC,
@@ -77,9 +134,16 @@ __export(index_exports, {
   crc16ccittHex: () => crc16ccittHex,
   createAccountsClient: () => createAccountsClient,
   createApiCredentialsAdminClient: () => createApiCredentialsAdminClient,
+  createCollectionsClient: () => createCollectionsClient,
+  createConsumerCollectionsClient: () => createConsumerCollectionsClient,
+  createConsumerWithdrawalsClient: () => createConsumerWithdrawalsClient,
   createFlurPartnerClient: () => createFlurPartnerClient,
   createHmacFetch: () => createHmacFetch,
+  createMeOfflineClient: () => createMeOfflineClient,
   createOfflineSettlementsClient: () => createOfflineSettlementsClient,
+  createPartnerCollectionsClient: () => createPartnerCollectionsClient,
+  createPartnerFundingClient: () => createPartnerFundingClient,
+  createPartnerProfileAdminClient: () => createPartnerProfileAdminClient,
   createPassesClient: () => createPassesClient,
   createReceiptsClient: () => createReceiptsClient,
   decodeAuthorizationQR: () => decodeAuthorizationQR,
@@ -127,7 +191,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/client.ts
-var import_zod3 = require("zod");
+var import_zod4 = require("zod");
 
 // src/contracts.ts
 var import_zod = require("zod");
@@ -169,7 +233,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()
 });
@@ -222,9 +288,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,
@@ -511,6 +579,341 @@ function moneyMinorToNumber(amountMinor) {
   return asNumber;
 }
 
+// src/collections/client.ts
+var import_zod3 = require("zod");
+var MERCHANT_PROFILE_STATUSES = [
+  "pending",
+  "active",
+  "suspended",
+  "closed"
+];
+var SETTLEMENT_SCHEDULES = ["manual", "daily", "t1"];
+var COLLECTION_INTENT_STATUSES = [
+  "created",
+  "pending",
+  "paid",
+  "expired",
+  "cancelled",
+  "failed",
+  "reversed"
+];
+var COLLECTION_PAYMENT_STATUSES = [
+  "pending",
+  "paid",
+  "failed",
+  "reversed"
+];
+var MERCHANT_PAYOUT_STATUSES = [
+  "requested",
+  "processing",
+  "paid",
+  "failed",
+  "cancelled"
+];
+var MoneyKoboSchema = import_zod3.z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var MetadataSchema = import_zod3.z.record(
+  import_zod3.z.union([import_zod3.z.string(), import_zod3.z.number(), import_zod3.z.boolean(), import_zod3.z.null()])
+);
+var CurrencySchema2 = import_zod3.z.string().trim().length(3).transform((value) => value.toUpperCase());
+var ReferenceSchema = import_zod3.z.string().trim().min(6).max(128).regex(/^[A-Za-z0-9._:-]+$/);
+var MerchantProfileSchema = import_zod3.z.object({
+  accountId: import_zod3.z.string().uuid(),
+  legalName: import_zod3.z.string(),
+  tradingName: import_zod3.z.string(),
+  merchantCategoryCode: import_zod3.z.string().regex(/^\d{4}$/),
+  nqrMerchantId: import_zod3.z.string(),
+  settlementBankCode: import_zod3.z.string(),
+  settlementAccountNumber: import_zod3.z.string(),
+  settlementAccountName: import_zod3.z.string(),
+  settlementSchedule: import_zod3.z.enum(SETTLEMENT_SCHEDULES),
+  status: import_zod3.z.enum(MERCHANT_PROFILE_STATUSES),
+  offlineEnabled: import_zod3.z.boolean(),
+  perTxLimitKobo: MoneyKoboSchema,
+  dailyLimitKobo: MoneyKoboSchema,
+  metadata: MetadataSchema,
+  createdAtMs: import_zod3.z.number().int().nonnegative(),
+  updatedAtMs: import_zod3.z.number().int().nonnegative()
+});
+var UpsertMerchantProfileInputSchema = import_zod3.z.object({
+  legalName: import_zod3.z.string().trim().min(1).max(200),
+  tradingName: import_zod3.z.string().trim().min(1).max(25),
+  merchantCategoryCode: import_zod3.z.string().trim().regex(/^\d{4}$/),
+  nqrMerchantId: import_zod3.z.string().trim().min(3).max(64),
+  settlementBankCode: import_zod3.z.string().trim().min(2).max(16),
+  settlementAccountNumber: import_zod3.z.string().trim().min(5).max(32),
+  settlementAccountName: import_zod3.z.string().trim().min(1).max(200),
+  settlementSchedule: import_zod3.z.enum(SETTLEMENT_SCHEDULES).optional(),
+  status: import_zod3.z.enum(MERCHANT_PROFILE_STATUSES).optional(),
+  offlineEnabled: import_zod3.z.boolean().optional(),
+  perTxLimitKobo: MoneyKoboSchema.optional(),
+  dailyLimitKobo: MoneyKoboSchema.optional(),
+  metadata: MetadataSchema.optional()
+});
+var CollectionIntentSchema = import_zod3.z.object({
+  intentId: import_zod3.z.string().uuid(),
+  accountId: import_zod3.z.string().uuid(),
+  terminalId: import_zod3.z.string().uuid().nullable(),
+  reference: import_zod3.z.string(),
+  amountKobo: import_zod3.z.number().int().positive().nullable(),
+  currency: import_zod3.z.string().length(3),
+  status: import_zod3.z.enum(COLLECTION_INTENT_STATUSES),
+  description: import_zod3.z.string().nullable(),
+  nqrPayload: import_zod3.z.string(),
+  provider: import_zod3.z.string(),
+  providerReference: import_zod3.z.string().nullable(),
+  metadata: MetadataSchema,
+  expiresAtMs: import_zod3.z.number().int().nonnegative().nullable(),
+  paidAtMs: import_zod3.z.number().int().nonnegative().nullable(),
+  createdAtMs: import_zod3.z.number().int().nonnegative(),
+  updatedAtMs: import_zod3.z.number().int().nonnegative()
+});
+var CreateCollectionIntentInputSchema = import_zod3.z.object({
+  reference: ReferenceSchema.optional(),
+  amountKobo: MoneyKoboSchema.optional(),
+  currency: CurrencySchema2.optional(),
+  terminalId: import_zod3.z.string().uuid().optional(),
+  terminalLabel: import_zod3.z.string().trim().min(1).max(25).optional(),
+  merchantCity: import_zod3.z.string().trim().min(1).max(15).optional(),
+  description: import_zod3.z.string().trim().min(1).max(280).optional(),
+  expiresAtMs: import_zod3.z.number().int().positive().optional(),
+  provider: import_zod3.z.string().trim().min(1).max(40).optional(),
+  metadata: MetadataSchema.optional()
+});
+var PublicCollectionIntentSchema = import_zod3.z.object({
+  intentId: import_zod3.z.string().uuid(),
+  reference: import_zod3.z.string(),
+  amountKobo: import_zod3.z.number().int().positive().nullable(),
+  currency: import_zod3.z.string().length(3),
+  status: import_zod3.z.enum(COLLECTION_INTENT_STATUSES),
+  merchantAccountId: import_zod3.z.string().uuid(),
+  merchantName: import_zod3.z.string(),
+  merchantCategoryCode: import_zod3.z.string(),
+  description: import_zod3.z.string().nullable(),
+  expiresAtMs: import_zod3.z.number().int().nonnegative().nullable()
+});
+var PayCollectionInputSchema = import_zod3.z.object({
+  reference: ReferenceSchema,
+  amountKobo: MoneyKoboSchema.optional(),
+  currency: CurrencySchema2.optional(),
+  idempotencyKey: import_zod3.z.string().trim().min(8).max(160).optional()
+});
+var CollectionPaymentSchema = import_zod3.z.object({
+  paymentId: import_zod3.z.string().uuid(),
+  intentId: import_zod3.z.string().uuid(),
+  accountId: import_zod3.z.string().uuid(),
+  payerUserId: import_zod3.z.string().uuid().nullable(),
+  merchantOwnerUserId: import_zod3.z.string().uuid(),
+  amountKobo: MoneyKoboSchema,
+  currency: import_zod3.z.string().length(3),
+  status: import_zod3.z.enum(COLLECTION_PAYMENT_STATUSES),
+  provider: import_zod3.z.string(),
+  providerReference: import_zod3.z.string().nullable(),
+  idempotencyKey: import_zod3.z.string().nullable(),
+  ledgerRef: import_zod3.z.string(),
+  failureCode: import_zod3.z.string().nullable(),
+  failureMessage: import_zod3.z.string().nullable(),
+  paidAtMs: import_zod3.z.number().int().nonnegative().nullable(),
+  createdAtMs: import_zod3.z.number().int().nonnegative(),
+  updatedAtMs: import_zod3.z.number().int().nonnegative()
+});
+var CollectionPaymentResultSchema = import_zod3.z.object({
+  payment: CollectionPaymentSchema,
+  intent: CollectionIntentSchema,
+  receipt: import_zod3.z.unknown().optional(),
+  replayed: import_zod3.z.boolean()
+});
+var CollectionReportSummarySchema = import_zod3.z.object({
+  accountId: import_zod3.z.string().uuid(),
+  fromMs: import_zod3.z.number().int().nonnegative(),
+  toMs: import_zod3.z.number().int().nonnegative(),
+  currency: import_zod3.z.string().length(3),
+  paidCount: import_zod3.z.number().int().nonnegative(),
+  paidAmountKobo: import_zod3.z.number().int().nonnegative(),
+  pendingCount: import_zod3.z.number().int().nonnegative(),
+  failedCount: import_zod3.z.number().int().nonnegative(),
+  reversedCount: import_zod3.z.number().int().nonnegative(),
+  availableBalanceKobo: import_zod3.z.number().int().nonnegative()
+});
+var CollectionStatementSchema = import_zod3.z.object({
+  accountId: import_zod3.z.string().uuid(),
+  year: import_zod3.z.number().int(),
+  month: import_zod3.z.number().int().min(1).max(12),
+  currency: import_zod3.z.string().length(3),
+  totalPaidKobo: import_zod3.z.number().int().nonnegative(),
+  items: import_zod3.z.array(CollectionPaymentSchema)
+});
+var CreatePayoutInputSchema = import_zod3.z.object({
+  amountKobo: MoneyKoboSchema,
+  currency: CurrencySchema2.optional(),
+  idempotencyKey: import_zod3.z.string().trim().min(8).max(160)
+});
+var MerchantPayoutSchema = import_zod3.z.object({
+  payoutId: import_zod3.z.string().uuid(),
+  accountId: import_zod3.z.string().uuid(),
+  amountKobo: MoneyKoboSchema,
+  currency: import_zod3.z.string().length(3),
+  status: import_zod3.z.enum(MERCHANT_PAYOUT_STATUSES),
+  idempotencyKey: import_zod3.z.string().nullable(),
+  ledgerRef: import_zod3.z.string(),
+  providerReference: import_zod3.z.string().nullable(),
+  requestedByUserId: import_zod3.z.string().uuid().nullable(),
+  failureCode: import_zod3.z.string().nullable(),
+  failureMessage: import_zod3.z.string().nullable(),
+  createdAtMs: import_zod3.z.number().int().nonnegative(),
+  updatedAtMs: import_zod3.z.number().int().nonnegative()
+});
+var ProviderEventInputSchema = import_zod3.z.object({
+  provider: import_zod3.z.string().trim().min(1).max(80),
+  eventId: import_zod3.z.string().trim().min(1).max(160),
+  eventType: import_zod3.z.string().trim().min(1).max(120),
+  payload: import_zod3.z.record(import_zod3.z.unknown()).optional()
+});
+var ProviderEventRecordSchema = import_zod3.z.object({
+  id: import_zod3.z.string().uuid(),
+  provider: import_zod3.z.string(),
+  eventId: import_zod3.z.string(),
+  eventType: import_zod3.z.string(),
+  signatureVerified: import_zod3.z.boolean(),
+  receivedAtMs: import_zod3.z.number().int().nonnegative(),
+  processedAtMs: import_zod3.z.number().int().nonnegative().nullable()
+});
+function createCollectionsClient(opts) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error(
+      "createCollectionsClient: no fetch implementation available"
+    );
+  }
+  const baseUrl = opts.baseUrl.replace(/\/$/, "");
+  async function call(method, path, body, parser) {
+    const init2 = {
+      method,
+      headers: { accept: "application/json" }
+    };
+    if (body !== void 0) {
+      init2.body = JSON.stringify(body);
+      init2.headers = { ...init2.headers, "content-type": "application/json" };
+    }
+    const resp = await fetchImpl(`${baseUrl}${path}`, init2);
+    const text = await resp.text();
+    let raw;
+    if (text) {
+      try {
+        raw = JSON.parse(text);
+      } catch {
+        raw = text;
+      }
+    }
+    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);
+  }
+  return {
+    upsertMerchantProfile: (accountId, input) => call(
+      "PUT",
+      `/v1/accounts/${encodeURIComponent(accountId)}/merchant-profile`,
+      UpsertMerchantProfileInputSchema.parse(input),
+      (raw) => MerchantProfileSchema.parse(raw)
+    ),
+    getMerchantProfile: (accountId) => call(
+      "GET",
+      `/v1/accounts/${encodeURIComponent(accountId)}/merchant-profile`,
+      void 0,
+      (raw) => MerchantProfileSchema.parse(raw)
+    ),
+    createIntent: (input) => call(
+      "POST",
+      "/v1/collections/intents",
+      CreateCollectionIntentInputSchema.parse(input),
+      (raw) => CollectionIntentSchema.parse(raw)
+    ),
+    getIntent: (intentId) => call(
+      "GET",
+      `/v1/collections/intents/${encodeURIComponent(intentId)}`,
+      void 0,
+      (raw) => CollectionIntentSchema.parse(raw)
+    ),
+    resolveIntent: (reference) => call(
+      "GET",
+      `/v1/collections/resolve/${encodeURIComponent(reference)}`,
+      void 0,
+      (raw) => PublicCollectionIntentSchema.parse(raw)
+    ),
+    pay: (input) => call(
+      "POST",
+      "/v1/collections/pay",
+      PayCollectionInputSchema.parse(input),
+      (raw) => CollectionPaymentResultSchema.parse(raw)
+    ),
+    reportSummary: (input) => {
+      const qs = new URLSearchParams({
+        fromMs: String(input.fromMs),
+        toMs: String(input.toMs)
+      });
+      if (input.currency) qs.set("currency", input.currency);
+      return call(
+        "GET",
+        `/v1/collections/reports/summary?${qs.toString()}`,
+        void 0,
+        (raw) => CollectionReportSummarySchema.parse(raw)
+      );
+    },
+    monthlyStatement: (input) => {
+      const qs = new URLSearchParams({
+        year: String(input.year),
+        month: String(input.month)
+      });
+      if (input.currency) qs.set("currency", input.currency);
+      return call(
+        "GET",
+        `/v1/collections/statements/monthly?${qs.toString()}`,
+        void 0,
+        (raw) => CollectionStatementSchema.parse(raw)
+      );
+    },
+    createPayout: (input) => call(
+      "POST",
+      "/v1/collections/payouts",
+      CreatePayoutInputSchema.parse(input),
+      (raw) => MerchantPayoutSchema.parse(raw)
+    ),
+    getPayout: (payoutId) => call(
+      "GET",
+      `/v1/collections/payouts/${encodeURIComponent(payoutId)}`,
+      void 0,
+      (raw) => MerchantPayoutSchema.parse(raw)
+    ),
+    recordProviderEvent: (input) => call(
+      "POST",
+      "/v1/collections/provider-events",
+      ProviderEventInputSchema.parse(input),
+      (raw) => ProviderEventRecordSchema.parse(raw)
+    )
+  };
+}
+function createPartnerCollectionsClient(opts) {
+  const client = createCollectionsClient(opts);
+  return {
+    createIntent: client.createIntent,
+    getIntent: client.getIntent,
+    reportSummary: client.reportSummary,
+    monthlyStatement: client.monthlyStatement,
+    createPayout: client.createPayout,
+    getPayout: client.getPayout,
+    recordProviderEvent: client.recordProviderEvent
+  };
+}
+function createConsumerCollectionsClient(opts) {
+  const client = createCollectionsClient(opts);
+  return {
+    resolveIntent: client.resolveIntent,
+    pay: client.pay
+  };
+}
+
 // src/client.ts
 var FlurClient = class {
   baseUrl;
@@ -524,10 +927,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(
@@ -672,24 +1085,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(
@@ -740,6 +1162,36 @@ var FlurClient = class {
       }
     );
   }
+  async resolveCollection(reference, options) {
+    return this.requestJson(
+      `/v1/collections/resolve/${encodeURIComponent(reference)}`,
+      {
+        method: "GET",
+        headers: {
+          authorization: `Bearer ${options.accessToken}`
+        }
+      },
+      void 0,
+      PublicCollectionIntentSchema
+    );
+  }
+  async payCollection(input, options) {
+    const idempotencyKey = input.idempotencyKey ?? options.idempotencyKey ?? getSecureRandomUuid();
+    return this.requestJson(
+      "/v1/collections/pay",
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${options.accessToken}`,
+          "x-idempotency-key": idempotencyKey
+        }
+      },
+      PayCollectionInputSchema,
+      CollectionPaymentResultSchema,
+      { ...input, idempotencyKey }
+    );
+  }
   async accountSummary(options) {
     return this.requestJson(
       "/api/v1/account/summary",
@@ -838,7 +1290,7 @@ var FlurClient = class {
     try {
       body = requestSchema ? JSON.stringify(requestSchema.parse(input)) : init2.body;
     } catch (err) {
-      if (err instanceof import_zod3.z.ZodError) {
+      if (err instanceof import_zod4.z.ZodError) {
         throw new FlurError("Invalid request payload", "INVALID_REQUEST", {
           details: err.flatten()
         });
@@ -854,17 +1306,26 @@ 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;
       try {
         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()
-          });
+        if (err instanceof import_zod4.z.ZodError) {
+          throw new FlurError(
+            "SDK contract validation failed",
+            "INVALID_REQUEST",
+            {
+              details: err.flatten()
+            }
+          );
         }
         throw err;
       }
@@ -873,7 +1334,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);
     }
@@ -883,7 +1346,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
@@ -1310,24 +1776,24 @@ function verifyCanonical(value, signature, publicKey) {
 }
 
 // src/offline/oac.ts
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var OAC_DEFAULT_PER_TX_KOBO = 5e5;
 var OAC_DEFAULT_CUMULATIVE_KOBO = 2e6;
 var OAC_DEFAULT_VALIDITY_MS = 24 * 60 * 60 * 1e3;
-var HexString = (length) => import_zod4.z.string().regex(
+var HexString = (length) => import_zod5.z.string().regex(
   new RegExp(`^[0-9a-fA-F]{${length * 2}}$`),
   `expected ${length}-byte hex string`
 );
-var OACSchema = import_zod4.z.object({
-  userId: import_zod4.z.string().min(1),
-  deviceId: import_zod4.z.string().min(1),
+var OACSchema = import_zod5.z.object({
+  userId: import_zod5.z.string().min(1),
+  deviceId: import_zod5.z.string().min(1),
   devicePublicKey: HexString(32),
-  perTxCapKobo: import_zod4.z.number().int().nonnegative(),
-  cumulativeCapKobo: import_zod4.z.number().int().nonnegative(),
-  validFromMs: import_zod4.z.number().int().nonnegative(),
-  validUntilMs: import_zod4.z.number().int().positive(),
-  counterSeed: import_zod4.z.number().int().nonnegative(),
-  nonce: import_zod4.z.string().min(1),
+  perTxCapKobo: import_zod5.z.number().int().nonnegative(),
+  cumulativeCapKobo: import_zod5.z.number().int().nonnegative(),
+  validFromMs: import_zod5.z.number().int().nonnegative(),
+  validUntilMs: import_zod5.z.number().int().positive(),
+  counterSeed: import_zod5.z.number().int().nonnegative(),
+  nonce: import_zod5.z.string().min(1),
   issuerSig: HexString(64)
 }).refine((v) => v.validUntilMs > v.validFromMs, {
   message: "validUntilMs must be greater than validFromMs"
@@ -1434,19 +1900,19 @@ function decodeBase45(s) {
 }
 
 // src/offline/messages.ts
-var import_zod5 = require("zod");
-var HexSig = import_zod5.z.string().regex(/^[0-9a-fA-F]{128}$/, "expected 64-byte hex signature");
-var OfflinePaymentRequestSchema = import_zod5.z.object({
-  reference: import_zod5.z.string().min(1),
-  amountKobo: import_zod5.z.number().int().positive(),
+var import_zod6 = require("zod");
+var HexSig = import_zod6.z.string().regex(/^[0-9a-fA-F]{128}$/, "expected 64-byte hex signature");
+var OfflinePaymentRequestSchema = import_zod6.z.object({
+  reference: import_zod6.z.string().min(1),
+  amountKobo: import_zod6.z.number().int().positive(),
   merchantOAC: OACSchema,
-  expiresAtMs: import_zod5.z.number().int().positive(),
+  expiresAtMs: import_zod6.z.number().int().positive(),
   merchantSig: HexSig
 });
-var OfflinePaymentAuthorizationSchema = import_zod5.z.object({
+var OfflinePaymentAuthorizationSchema = import_zod6.z.object({
   request: OfflinePaymentRequestSchema,
   payerOAC: OACSchema,
-  payerCounter: import_zod5.z.number().int().positive(),
+  payerCounter: import_zod6.z.number().int().positive(),
   payerSig: HexSig
 });
 function buildPaymentRequest(input) {
@@ -1555,56 +2021,56 @@ function decodeAuthorizationQR(s) {
 }
 
 // src/offline/settlements.ts
-var import_zod6 = require("zod");
+var import_zod7 = 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(),
-  issuerAccountId: import_zod6.z.string().uuid(),
-  payerUserId: import_zod6.z.string().uuid(),
-  maxAmountKobo: import_zod6.z.number().int().positive(),
-  currency: import_zod6.z.string().length(3),
-  issuedAtMs: import_zod6.z.number().int().nonnegative(),
-  expiresAtMs: import_zod6.z.number().int().nonnegative(),
-  issuerSig: import_zod6.z.string()
-});
-var PaymentClaimSchema = import_zod6.z.object({
-  encounterId: import_zod6.z.string().regex(/^[0-9a-f]{64}$/i).optional(),
-  tokenSerial: import_zod6.z.string(),
-  payerUserId: import_zod6.z.string().uuid(),
-  payeeUserId: import_zod6.z.string().uuid(),
-  payerNonce: import_zod6.z.string(),
-  payeeNonce: import_zod6.z.string(),
-  amountKobo: import_zod6.z.number().int().positive(),
-  currency: import_zod6.z.string().length(3).default("NGN"),
-  occurredAtMs: import_zod6.z.number().int().nonnegative(),
-  completedAtMs: import_zod6.z.number().int().nonnegative().optional(),
-  contextId: import_zod6.z.string().optional(),
-  payerPubkey: import_zod6.z.string().regex(/^[0-9a-f]{64}$/i),
-  payerSignature: import_zod6.z.string().regex(/^[0-9a-f]+$/i),
-  payeePubkey: import_zod6.z.string().regex(/^[0-9a-f]{64}$/i).optional(),
-  payeeSignature: import_zod6.z.string().regex(/^[0-9a-f]+$/i).optional()
-});
-var SettlementSchema = import_zod6.z.object({
-  settlementId: import_zod6.z.string().uuid(),
-  settlementKey: import_zod6.z.string().regex(/^[0-9a-f]{64}$/i),
-  encounterId: import_zod6.z.string().regex(/^[0-9a-f]{64}$/i),
-  issuerAccountId: import_zod6.z.string().uuid(),
-  tokenSerial: import_zod6.z.string(),
-  payerUserId: import_zod6.z.string().uuid(),
-  payeeUserId: import_zod6.z.string().uuid(),
-  amountKobo: import_zod6.z.number().int().nonnegative(),
-  currency: import_zod6.z.string().length(3),
-  receiptId: import_zod6.z.string().nullable(),
-  status: import_zod6.z.enum(["SETTLED", "REVIEW", "REJECTED"]),
-  issuerSig: import_zod6.z.string(),
-  createdAtMs: import_zod6.z.number().int().nonnegative()
-});
-var SettleResponseSchema = import_zod6.z.object({
+var OfflineTokenSchema = import_zod7.z.object({
+  tokenId: import_zod7.z.string().uuid(),
+  tokenSerial: import_zod7.z.string(),
+  issuerAccountId: import_zod7.z.string().uuid(),
+  payerUserId: import_zod7.z.string().uuid(),
+  maxAmountKobo: import_zod7.z.number().int().positive(),
+  currency: import_zod7.z.string().length(3),
+  issuedAtMs: import_zod7.z.number().int().nonnegative(),
+  expiresAtMs: import_zod7.z.number().int().nonnegative(),
+  issuerSig: import_zod7.z.string()
+});
+var PaymentClaimSchema = import_zod7.z.object({
+  encounterId: import_zod7.z.string().regex(/^[0-9a-f]{64}$/i).optional(),
+  tokenSerial: import_zod7.z.string(),
+  payerUserId: import_zod7.z.string().uuid(),
+  payeeUserId: import_zod7.z.string().uuid(),
+  payerNonce: import_zod7.z.string(),
+  payeeNonce: import_zod7.z.string(),
+  amountKobo: import_zod7.z.number().int().positive(),
+  currency: import_zod7.z.string().length(3).default("NGN"),
+  occurredAtMs: import_zod7.z.number().int().nonnegative(),
+  completedAtMs: import_zod7.z.number().int().nonnegative().optional(),
+  contextId: import_zod7.z.string().optional(),
+  payerPubkey: import_zod7.z.string().regex(/^[0-9a-f]{64}$/i),
+  payerSignature: import_zod7.z.string().regex(/^[0-9a-f]+$/i),
+  payeePubkey: import_zod7.z.string().regex(/^[0-9a-f]{64}$/i).optional(),
+  payeeSignature: import_zod7.z.string().regex(/^[0-9a-f]+$/i).optional()
+});
+var SettlementSchema = import_zod7.z.object({
+  settlementId: import_zod7.z.string().uuid(),
+  settlementKey: import_zod7.z.string().regex(/^[0-9a-f]{64}$/i),
+  encounterId: import_zod7.z.string().regex(/^[0-9a-f]{64}$/i),
+  issuerAccountId: import_zod7.z.string().uuid(),
+  tokenSerial: import_zod7.z.string(),
+  payerUserId: import_zod7.z.string().uuid(),
+  payeeUserId: import_zod7.z.string().uuid(),
+  amountKobo: import_zod7.z.number().int().nonnegative(),
+  currency: import_zod7.z.string().length(3),
+  receiptId: import_zod7.z.string().nullable(),
+  status: import_zod7.z.enum(["SETTLED", "REVIEW", "REJECTED"]),
+  issuerSig: import_zod7.z.string(),
+  createdAtMs: import_zod7.z.number().int().nonnegative()
+});
+var SettleResponseSchema = import_zod7.z.object({
   settlement: SettlementSchema,
-  encounterId: import_zod6.z.string().regex(/^[0-9a-f]{64}$/i),
-  replayed: import_zod6.z.boolean()
+  encounterId: import_zod7.z.string().regex(/^[0-9a-f]{64}$/i),
+  replayed: import_zod7.z.boolean()
 });
 var ENCOUNTER_DOMAIN = "offline:v1:encounter";
 async function sha256Hex(input) {
@@ -1777,126 +2243,344 @@ function createHmacFetch(opts) {
   });
 }
 
-// src/passes/pass.ts
-var import_zod7 = require("zod");
-var PASS_KINDS = [
-  "ride-ticket",
-  "transit-pass",
-  "event-ticket",
-  "voucher",
-  "loyalty",
-  "receipt-link"
-];
-var PASS_STATES = [
-  "issued",
-  "active",
-  "redeemed",
-  "expired",
-  "revoked"
+// src/partner/client.ts
+var import_zod8 = 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",
+  "passes:redeem",
+  "receipts:write",
+  "receipts:read",
+  "offline:issue",
+  "offline:settle",
+  "offline:read",
+  "collections:write",
+  "collections:read",
+  "collections:pay",
+  "collections:webhook",
+  "reports:read",
+  "payouts:write",
+  "payouts:read",
+  "partner:funding:write",
+  "partner:payout:write",
+  "partner:reconciliation:read"
 ];
-var HexString2 = (length) => import_zod7.z.string().regex(
-  new RegExp(`^[0-9a-fA-F]{${length * 2}}$`),
-  `expected ${length}-byte hex string`
-);
-var PassMetadataSchema = import_zod7.z.record(
-  import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number(), import_zod7.z.boolean(), import_zod7.z.null()])
-);
-var PassSchema = import_zod7.z.object({
-  passId: import_zod7.z.string().min(1),
-  /** Optional client/template grouping id (server may omit). */
-  templateId: import_zod7.z.string().min(1).optional(),
-  /** Optional human-facing holder identity (server may omit). The cryptographic binding
-   *  is `holderDevicePubkey` below. */
-  holderUserId: import_zod7.z.string().min(1).optional(),
-  kind: import_zod7.z.enum(PASS_KINDS),
-  issuerId: import_zod7.z.string().min(1),
-  issuedAtMs: import_zod7.z.number().int().nonnegative(),
-  validFromMs: import_zod7.z.number().int().nonnegative(),
-  validUntilMs: import_zod7.z.number().int().positive(),
-  state: import_zod7.z.enum(PASS_STATES),
-  metadata: PassMetadataSchema,
-  nonce: import_zod7.z.string().min(1),
-  /** Device id this pass is bound to (FK to backend `device_keys`). */
-  holderDeviceId: import_zod7.z.string().min(1),
-  /** 32-byte hex Ed25519 public key of the bound device. The redemption signature
-   *  is verified against this key — it is the security-critical binding. */
-  holderDevicePubkey: HexString2(32),
-  /** Optional fixed amount for monetary passes (vouchers, gift cards) in kobo. */
-  amountKobo: import_zod7.z.number().int().nonnegative().optional(),
-  /** ISO-4217-ish currency code; required on the wire. SDK builders default to NGN. */
-  currency: import_zod7.z.string().min(3).max(8),
-  /** Monotonic redemption counter floor. Redemption.counter MUST be > counterSeed. */
-  counterSeed: import_zod7.z.number().int().nonnegative(),
-  /** Optional cumulative spend cap in kobo across all redemptions of this pass. */
-  cumulativeCapKobo: import_zod7.z.number().int().nonnegative().optional(),
-  issuerSig: HexString2(64)
-}).refine((v) => v.validUntilMs > v.validFromMs, {
-  message: "validUntilMs must be greater than validFromMs"
+var ApiCredentialPublicSchema = import_zod8.z.object({
+  id: import_zod8.z.string().uuid(),
+  accountId: import_zod8.z.string().uuid(),
+  keyId: import_zod8.z.string(),
+  scopes: import_zod8.z.array(import_zod8.z.enum(PARTNER_SCOPES)),
+  label: import_zod8.z.string().nullable(),
+  createdAtMs: import_zod8.z.number().int().nonnegative(),
+  lastUsedAtMs: import_zod8.z.number().int().nonnegative().nullable(),
+  revokedAtMs: import_zod8.z.number().int().nonnegative().nullable()
 });
-function buildPass(input) {
-  if (input.validUntilMs <= input.validFromMs) {
-    throw new Error("validUntilMs must be greater than validFromMs");
-  }
-  const out = {
-    passId: input.passId,
-    kind: input.kind,
-    issuerId: input.issuerId,
-    issuedAtMs: input.issuedAtMs,
-    validFromMs: input.validFromMs,
-    validUntilMs: input.validUntilMs,
-    state: input.state,
-    metadata: input.metadata,
-    nonce: input.nonce,
-    holderDeviceId: input.holderDeviceId,
-    holderDevicePubkey: input.holderDevicePubkey,
-    currency: input.currency ?? "NGN",
-    counterSeed: input.counterSeed
-  };
-  if (typeof input.templateId === "string") out.templateId = input.templateId;
-  if (typeof input.holderUserId === "string")
-    out.holderUserId = input.holderUserId;
-  if (typeof input.amountKobo === "number") out.amountKobo = input.amountKobo;
-  if (typeof input.cumulativeCapKobo === "number") {
-    out.cumulativeCapKobo = input.cumulativeCapKobo;
-  }
-  return out;
+var MintedApiCredentialSchema = ApiCredentialPublicSchema.extend({
+  secret: import_zod8.z.string().min(1)
+});
+var enc = new TextEncoder();
+async function sha256Hex2(input) {
+  const data = typeof input === "string" ? enc.encode(input) : input;
+  return (0, import_utils2.bytesToHex)((0, import_sha2563.sha256)(data));
 }
-function signPass(unsigned, issuerPrivateKey) {
-  const issuerSig = bytesToHex(
-    sign(canonicalJSONBytes(unsigned), issuerPrivateKey)
-  );
-  return { ...unsigned, issuerSig };
+async function hmacSha256Hex(keyHex, message) {
+  return (0, import_utils2.bytesToHex)((0, import_hmac4.hmac)(import_sha2563.sha256, enc.encode(keyHex), enc.encode(message)));
 }
-function verifyPass(pass, issuerPublicKey) {
-  try {
-    const parsed = PassSchema.parse(pass);
-    const { issuerSig, ...unsigned } = parsed;
-    return verify(
-      canonicalJSONBytes(unsigned),
-      hexToBytes(issuerSig),
-      issuerPublicKey
-    );
-  } catch {
-    return false;
-  }
+function defaultNonce2() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}`;
 }
-function isPassWithinValidity(pass, nowMs) {
-  return nowMs >= pass.validFromMs && nowMs < pass.validUntilMs;
+function canonical(params) {
+  return [
+    params.method.toUpperCase(),
+    params.path,
+    params.ts,
+    params.nonce,
+    params.bodyHash
+  ].join("\n");
 }
-
+async function signPartnerRequest(params) {
+  const ts = String(Math.floor((params.nowMs ?? Date.now()) / 1e3));
+  const nonce = params.nonce ?? defaultNonce2();
+  const bodyData = typeof params.body === "string" ? enc.encode(params.body) : params.body ?? new Uint8Array();
+  const bodyHash = await sha256Hex2(bodyData);
+  const message = canonical({
+    method: params.method,
+    path: params.path,
+    ts,
+    nonce,
+    bodyHash
+  });
+  const signingKey = await sha256Hex2(params.secret);
+  const sig = await hmacSha256Hex(signingKey, message);
+  return {
+    authorization: `Flur-Hmac key=${params.keyId}, ts=${ts}, nonce=${nonce}, sig=${sig}`,
+    ts,
+    nonce,
+    bodyHash
+  };
+}
+function createFlurPartnerClient(opts) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error(
+      "createFlurPartnerClient: no fetch implementation available"
+    );
+  }
+  const baseUrl = opts.baseUrl.replace(/\/$/, "");
+  const scopeHeader = normalizeScopeHeader(opts.scope);
+  async function makeSignedInit(method, path, body) {
+    const sig = await signPartnerRequest({
+      keyId: opts.keyId,
+      secret: opts.secret,
+      method,
+      path,
+      body: body ?? "",
+      nowMs: opts.nowMs?.(),
+      nonce: opts.nonce?.()
+    });
+    const headers = {
+      authorization: sig.authorization,
+      accept: "application/json"
+    };
+    if (scopeHeader) headers["x-flur-scope"] = scopeHeader;
+    if (body !== void 0) headers["content-type"] = "application/json";
+    const init2 = { method, headers };
+    if (body !== void 0) init2.body = body;
+    return init2;
+  }
+  async function request(opts2) {
+    const bodyStr = opts2.body === void 0 ? void 0 : JSON.stringify(opts2.body);
+    const init2 = await makeSignedInit(opts2.method, opts2.path, bodyStr);
+    const resp = await fetchImpl(`${baseUrl}${opts2.path}`, init2);
+    const text = await resp.text();
+    let raw;
+    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 raw;
+  }
+  const fetchLike = async (input, init2) => {
+    const url = typeof input === "string" ? input : input.toString();
+    const u = new URL(url, baseUrl);
+    const path = `${u.pathname}${u.search}`;
+    const method = (init2?.method ?? "GET").toUpperCase();
+    let bodyStr;
+    if (init2?.body) {
+      bodyStr = typeof init2.body === "string" ? init2.body : init2.body.toString();
+    }
+    const signed = await makeSignedInit(method, path, bodyStr);
+    return fetchImpl(`${baseUrl}${path}`, {
+      ...init2,
+      ...signed,
+      headers: {
+        ...init2?.headers,
+        ...signed.headers
+      }
+    });
+  };
+  return { request, fetch: fetchLike };
+}
+function normalizeScopeHeader(scope) {
+  if (!scope || scope.length === 0) return void 0;
+  const unique = Array.from(new Set(scope));
+  for (const item of unique) {
+    if (!PARTNER_SCOPES.includes(item)) {
+      throw new Error(`unsupported partner scope: ${item}`);
+    }
+  }
+  return unique.join(" ");
+}
+function createApiCredentialsAdminClient(opts) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error(
+      "createApiCredentialsAdminClient: 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;
+    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 listSchema = import_zod8.z.object({
+    items: import_zod8.z.array(ApiCredentialPublicSchema)
+  });
+  return {
+    list: (accountId) => call(
+      "GET",
+      `/v1/accounts/${accountId}/api-credentials`,
+      void 0,
+      (raw) => listSchema.parse(raw)
+    ),
+    mint: (accountId, input) => call(
+      "POST",
+      `/v1/accounts/${accountId}/api-credentials`,
+      input,
+      (raw) => MintedApiCredentialSchema.parse(raw)
+    ),
+    revoke: (accountId, credentialId) => call(
+      "DELETE",
+      `/v1/accounts/${accountId}/api-credentials/${credentialId}`,
+      void 0,
+      (raw) => ApiCredentialPublicSchema.parse(raw)
+    )
+  };
+}
+
+// src/passes/pass.ts
+var import_zod9 = require("zod");
+var PASS_KINDS = [
+  "ride-ticket",
+  "transit-pass",
+  "event-ticket",
+  "voucher",
+  "loyalty",
+  "receipt-link"
+];
+var PASS_STATES = [
+  "issued",
+  "active",
+  "redeemed",
+  "expired",
+  "revoked"
+];
+var HexString2 = (length) => import_zod9.z.string().regex(
+  new RegExp(`^[0-9a-fA-F]{${length * 2}}$`),
+  `expected ${length}-byte hex string`
+);
+var PassMetadataSchema = import_zod9.z.record(
+  import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number(), import_zod9.z.boolean(), import_zod9.z.null()])
+);
+var PassSchema = import_zod9.z.object({
+  passId: import_zod9.z.string().min(1),
+  /** Optional client/template grouping id (server may omit). */
+  templateId: import_zod9.z.string().min(1).optional(),
+  /** Optional human-facing holder identity (server may omit). The cryptographic binding
+   *  is `holderDevicePubkey` below. */
+  holderUserId: import_zod9.z.string().min(1).optional(),
+  kind: import_zod9.z.enum(PASS_KINDS),
+  issuerId: import_zod9.z.string().min(1),
+  issuedAtMs: import_zod9.z.number().int().nonnegative(),
+  validFromMs: import_zod9.z.number().int().nonnegative(),
+  validUntilMs: import_zod9.z.number().int().positive(),
+  state: import_zod9.z.enum(PASS_STATES),
+  metadata: PassMetadataSchema,
+  nonce: import_zod9.z.string().min(1),
+  /** Device id this pass is bound to (FK to backend `device_keys`). */
+  holderDeviceId: import_zod9.z.string().min(1),
+  /** 32-byte hex Ed25519 public key of the bound device. The redemption signature
+   *  is verified against this key — it is the security-critical binding. */
+  holderDevicePubkey: HexString2(32),
+  /** Optional fixed amount for monetary passes (vouchers, gift cards) in kobo. */
+  amountKobo: import_zod9.z.number().int().nonnegative().optional(),
+  /** ISO-4217-ish currency code; required on the wire. SDK builders default to NGN. */
+  currency: import_zod9.z.string().min(3).max(8),
+  /** Monotonic redemption counter floor. Redemption.counter MUST be > counterSeed. */
+  counterSeed: import_zod9.z.number().int().nonnegative(),
+  /** Optional cumulative spend cap in kobo across all redemptions of this pass. */
+  cumulativeCapKobo: import_zod9.z.number().int().nonnegative().optional(),
+  issuerSig: HexString2(64)
+}).refine((v) => v.validUntilMs > v.validFromMs, {
+  message: "validUntilMs must be greater than validFromMs"
+});
+function buildPass(input) {
+  if (input.validUntilMs <= input.validFromMs) {
+    throw new Error("validUntilMs must be greater than validFromMs");
+  }
+  const out = {
+    passId: input.passId,
+    kind: input.kind,
+    issuerId: input.issuerId,
+    issuedAtMs: input.issuedAtMs,
+    validFromMs: input.validFromMs,
+    validUntilMs: input.validUntilMs,
+    state: input.state,
+    metadata: input.metadata,
+    nonce: input.nonce,
+    holderDeviceId: input.holderDeviceId,
+    holderDevicePubkey: input.holderDevicePubkey,
+    currency: input.currency ?? "NGN",
+    counterSeed: input.counterSeed
+  };
+  if (typeof input.templateId === "string") out.templateId = input.templateId;
+  if (typeof input.holderUserId === "string")
+    out.holderUserId = input.holderUserId;
+  if (typeof input.amountKobo === "number") out.amountKobo = input.amountKobo;
+  if (typeof input.cumulativeCapKobo === "number") {
+    out.cumulativeCapKobo = input.cumulativeCapKobo;
+  }
+  return out;
+}
+function signPass(unsigned, issuerPrivateKey) {
+  const issuerSig = bytesToHex(
+    sign(canonicalJSONBytes(unsigned), issuerPrivateKey)
+  );
+  return { ...unsigned, issuerSig };
+}
+function verifyPass(pass, issuerPublicKey) {
+  try {
+    const parsed = PassSchema.parse(pass);
+    const { issuerSig, ...unsigned } = parsed;
+    return verify(
+      canonicalJSONBytes(unsigned),
+      hexToBytes(issuerSig),
+      issuerPublicKey
+    );
+  } catch {
+    return false;
+  }
+}
+function isPassWithinValidity(pass, nowMs) {
+  return nowMs >= pass.validFromMs && nowMs < pass.validUntilMs;
+}
+
 // src/passes/redemption.ts
-var import_zod8 = require("zod");
-var HexSig2 = import_zod8.z.string().regex(/^[0-9a-fA-F]{128}$/, "expected 64-byte hex signature");
-var RedemptionSchema = import_zod8.z.object({
+var import_zod10 = require("zod");
+var HexSig2 = import_zod10.z.string().regex(/^[0-9a-fA-F]{128}$/, "expected 64-byte hex signature");
+var RedemptionSchema = import_zod10.z.object({
   pass: PassSchema,
-  redeemerId: import_zod8.z.string().min(1),
-  redeemedAtMs: import_zod8.z.number().int().nonnegative(),
+  redeemerId: import_zod10.z.string().min(1),
+  redeemedAtMs: import_zod10.z.number().int().nonnegative(),
   /** Strictly monotonic counter scoped to a single pass. Must be > pass.counterSeed
    *  and > the redeemer's lastSeenCounter for this pass. */
-  counter: import_zod8.z.number().int().positive(),
+  counter: import_zod10.z.number().int().positive(),
   /** Amount being redeemed in kobo (0 for non-monetary passes like ride tickets). */
-  amountKobo: import_zod8.z.number().int().nonnegative(),
-  nonce: import_zod8.z.string().min(1),
+  amountKobo: import_zod10.z.number().int().nonnegative(),
+  nonce: import_zod10.z.string().min(1),
   holderSig: HexSig2
 });
 var REDEEMABLE_STATES = /* @__PURE__ */ new Set(["issued", "active"]);
@@ -1982,43 +2666,43 @@ function verifyRedemption(r, issuerPublicKey) {
 }
 
 // src/receipts/receipt.ts
-var import_zod9 = require("zod");
+var import_zod11 = require("zod");
 var RECEIPT_CHANNELS = ["cash", "pass"];
 var RECEIPT_KINDS = RECEIPT_CHANNELS;
-var HexString3 = (length) => import_zod9.z.string().regex(
+var HexString3 = (length) => import_zod11.z.string().regex(
   new RegExp(`^[0-9a-fA-F]{${length * 2}}$`),
   `expected ${length}-byte hex string`
 );
-var ReceiptPayloadSchema = import_zod9.z.record(
-  import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number(), import_zod9.z.boolean(), import_zod9.z.null()])
+var ReceiptPayloadSchema = import_zod11.z.record(
+  import_zod11.z.union([import_zod11.z.string(), import_zod11.z.number(), import_zod11.z.boolean(), import_zod11.z.null()])
 );
-var ReceiptSchema = import_zod9.z.object({
-  receiptId: import_zod9.z.string().min(1),
-  channel: import_zod9.z.enum(RECEIPT_CHANNELS),
+var ReceiptSchema = import_zod11.z.object({
+  receiptId: import_zod11.z.string().min(1),
+  channel: import_zod11.z.enum(RECEIPT_CHANNELS),
   /** Cash-channel: send_intents.id. Required when channel === 'cash'. */
-  intentId: import_zod9.z.string().min(1).optional(),
+  intentId: import_zod11.z.string().min(1).optional(),
   /** Pass-channel: pass_redemptions.id. Required when channel === 'pass'. */
-  passRedemptionId: import_zod9.z.string().min(1).optional(),
-  payerUserId: import_zod9.z.string().min(1),
-  payeeUserId: import_zod9.z.string().min(1),
-  amountKobo: import_zod9.z.number().int().nonnegative(),
-  currency: import_zod9.z.string().min(3).max(8),
-  issuedAtMs: import_zod9.z.number().int().nonnegative(),
-  issuerId: import_zod9.z.string().min(1),
+  passRedemptionId: import_zod11.z.string().min(1).optional(),
+  payerUserId: import_zod11.z.string().min(1),
+  payeeUserId: import_zod11.z.string().min(1),
+  amountKobo: import_zod11.z.number().int().nonnegative(),
+  currency: import_zod11.z.string().min(3).max(8),
+  issuedAtMs: import_zod11.z.number().int().nonnegative(),
+  issuerId: import_zod11.z.string().min(1),
   payload: ReceiptPayloadSchema,
   issuerSig: HexString3(64)
 }).superRefine((v, ctx) => {
   if (v.channel === "cash") {
     if (!v.intentId) {
       ctx.addIssue({
-        code: import_zod9.z.ZodIssueCode.custom,
+        code: import_zod11.z.ZodIssueCode.custom,
         message: "cash receipts require intentId",
         path: ["intentId"]
       });
     }
     if (v.passRedemptionId) {
       ctx.addIssue({
-        code: import_zod9.z.ZodIssueCode.custom,
+        code: import_zod11.z.ZodIssueCode.custom,
         message: "cash receipts must not carry passRedemptionId",
         path: ["passRedemptionId"]
       });
@@ -2026,14 +2710,14 @@ var ReceiptSchema = import_zod9.z.object({
   } else if (v.channel === "pass") {
     if (!v.passRedemptionId) {
       ctx.addIssue({
-        code: import_zod9.z.ZodIssueCode.custom,
+        code: import_zod11.z.ZodIssueCode.custom,
         message: "pass receipts require passRedemptionId",
         path: ["passRedemptionId"]
       });
     }
     if (v.intentId) {
       ctx.addIssue({
-        code: import_zod9.z.ZodIssueCode.custom,
+        code: import_zod11.z.ZodIssueCode.custom,
         message: "pass receipts must not carry intentId",
         path: ["intentId"]
       });
@@ -2284,55 +2968,27 @@ function parseQR(payload) {
   return parseNQR(payload);
 }
 function init(opts) {
-  const signedFetch = createHmacFetch({
-    apiKey: opts.apiKey,
-    apiSecret: opts.apiSecret,
+  const partner = createFlurPartnerClient({
+    baseUrl: opts.baseUrl,
+    keyId: opts.apiKey,
+    secret: opts.apiSecret,
     fetchImpl: opts.fetchImpl,
     scope: opts.scope
   });
+  const signedFetch = partner.fetch;
   const baseUrl = opts.baseUrl.replace(/\/$/, "");
   function subscribeToPayments(s) {
-    const controller = new AbortController();
     let cancelled = false;
-    (async () => {
-      try {
-        const url = `${baseUrl}/v1/payments/subscribe?reference=${encodeURIComponent(s.reference)}`;
-        const resp = await signedFetch(url, {
-          method: "GET",
-          headers: { accept: "text/event-stream" },
-          signal: controller.signal
-        });
-        if (!resp.body) return;
-        const reader = resp.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        while (!cancelled) {
-          const { value, done } = await reader.read();
-          if (done) return;
-          buffer += decoder.decode(value, { stream: true });
-          let idx;
-          while ((idx = buffer.indexOf("\n\n")) >= 0) {
-            const chunk = buffer.slice(0, idx);
-            buffer = buffer.slice(idx + 2);
-            for (const line of chunk.split("\n")) {
-              if (!line.startsWith("data:")) continue;
-              const json = line.slice(5).trim();
-              if (!json) continue;
-              try {
-                s.onEvent(JSON.parse(json));
-              } catch (err) {
-                s.onError?.(err);
-              }
-            }
-          }
-        }
-      } catch (err) {
-        if (!cancelled) s.onError?.(err);
-      }
-    })();
+    queueMicrotask(() => {
+      if (cancelled) return;
+      s.onError?.(
+        new Error(
+          "cash.subscribeToPayments is not available on this backend release; use collections reports or provider webhooks for payment status."
+        )
+      );
+    });
     return () => {
       cancelled = true;
-      controller.abort();
     };
   }
   const cash = {
@@ -2343,6 +2999,10 @@ function init(opts) {
   };
   const passes = createPassesClient({ baseUrl, fetchImpl: signedFetch });
   const receipts = createReceiptsClient({ baseUrl, fetchImpl: signedFetch });
+  const collections = createPartnerCollectionsClient({
+    baseUrl,
+    fetchImpl: signedFetch
+  });
   return {
     // top-level back-compat surface
     generateStaticQR,
@@ -2351,29 +3011,30 @@ function init(opts) {
     subscribeToPayments,
     // namespaces
     cash,
+    collections,
     passes,
     receipts
   };
 }
 
 // src/accounts/client.ts
-var import_zod10 = require("zod");
+var import_zod12 = require("zod");
 var ACCOUNT_TYPES = ["personal", "business", "partner"];
 var ACCOUNT_STATUSES = ["active", "suspended", "closed"];
 var MEMBERSHIP_ROLES = ["owner", "admin", "driver", "staff"];
-var AccountSchema = import_zod10.z.object({
-  accountId: import_zod10.z.string().uuid(),
-  type: import_zod10.z.enum(ACCOUNT_TYPES),
-  displayName: import_zod10.z.string().min(1),
-  status: import_zod10.z.enum(ACCOUNT_STATUSES),
-  ownerUserId: import_zod10.z.string().uuid().nullable(),
-  createdAtMs: import_zod10.z.number().int().nonnegative()
-});
-var AccountMembershipSchema = import_zod10.z.object({
-  accountId: import_zod10.z.string().uuid(),
-  userId: import_zod10.z.string().uuid(),
-  role: import_zod10.z.enum(MEMBERSHIP_ROLES),
-  createdAtMs: import_zod10.z.number().int().nonnegative()
+var AccountSchema = import_zod12.z.object({
+  accountId: import_zod12.z.string().uuid(),
+  type: import_zod12.z.enum(ACCOUNT_TYPES),
+  displayName: import_zod12.z.string().min(1),
+  status: import_zod12.z.enum(ACCOUNT_STATUSES),
+  ownerUserId: import_zod12.z.string().uuid().nullable(),
+  createdAtMs: import_zod12.z.number().int().nonnegative()
+});
+var AccountMembershipSchema = import_zod12.z.object({
+  accountId: import_zod12.z.string().uuid(),
+  userId: import_zod12.z.string().uuid(),
+  role: import_zod12.z.enum(MEMBERSHIP_ROLES),
+  createdAtMs: import_zod12.z.number().int().nonnegative()
 });
 function createAccountsClient(opts) {
   const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
@@ -2406,9 +3067,9 @@ function createAccountsClient(opts) {
     }
     return parser(raw);
   }
-  const itemsSchema = import_zod10.z.object({ items: import_zod10.z.array(AccountSchema) });
-  const memberItemsSchema = import_zod10.z.object({
-    items: import_zod10.z.array(AccountMembershipSchema)
+  const itemsSchema = import_zod12.z.object({ items: import_zod12.z.array(AccountSchema) });
+  const memberItemsSchema = import_zod12.z.object({
+    items: import_zod12.z.array(AccountMembershipSchema)
   });
   return {
     listMyAccounts: () => call(
@@ -2439,110 +3100,182 @@ 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",
-  "passes:redeem",
-  "receipts:write",
-  "receipts:read",
-  "offline:issue",
-  "offline:settle",
-  "offline:read"
-];
-var ApiCredentialPublicSchema = import_zod11.z.object({
-  id: import_zod11.z.string().uuid(),
-  accountId: import_zod11.z.string().uuid(),
-  keyId: import_zod11.z.string(),
-  scopes: import_zod11.z.array(import_zod11.z.enum(PARTNER_SCOPES)),
-  label: import_zod11.z.string().nullable(),
-  createdAtMs: import_zod11.z.number().int().nonnegative(),
-  lastUsedAtMs: import_zod11.z.number().int().nonnegative().nullable(),
-  revokedAtMs: import_zod11.z.number().int().nonnegative().nullable()
+// src/me-offline/client.ts
+var import_zod13 = require("zod");
+var Hex64 = import_zod13.z.string().regex(/^[0-9a-f]{64}$/i);
+var HexAny = import_zod13.z.string().regex(/^[0-9a-f]+$/i);
+var Sha256Hex = import_zod13.z.string().regex(/^[0-9a-f]{64}$/i);
+var RegisterDeviceKeyInputSchema = import_zod13.z.object({
+  deviceId: import_zod13.z.string().min(1).max(128),
+  publicKeyHex: Hex64
 });
-var MintedApiCredentialSchema = ApiCredentialPublicSchema.extend({
-  secret: import_zod11.z.string().min(1)
+var DeviceKeyRecordSchema = import_zod13.z.object({
+  id: import_zod13.z.string().uuid(),
+  userId: import_zod13.z.string().uuid(),
+  deviceId: import_zod13.z.string(),
+  publicKeyHex: Hex64,
+  createdAtMs: import_zod13.z.number().int().nonnegative(),
+  revokedAtMs: import_zod13.z.number().int().nonnegative().nullable()
 });
-var enc = new TextEncoder();
-async function sha256Hex2(input) {
-  const data = typeof input === "string" ? enc.encode(input) : input;
-  return (0, import_utils2.bytesToHex)((0, import_sha2563.sha256)(data));
-}
-async function hmacSha256Hex(keyHex, message) {
-  return (0, import_utils2.bytesToHex)((0, import_hmac4.hmac)(import_sha2563.sha256, enc.encode(keyHex), enc.encode(message)));
-}
-function defaultNonce2() {
-  const c = globalThis.crypto;
-  if (c?.randomUUID) return c.randomUUID();
-  return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}`;
-}
-function canonical(params) {
-  return [
-    params.method.toUpperCase(),
-    params.path,
-    params.ts,
-    params.nonce,
-    params.bodyHash
-  ].join("\n");
-}
-async function signPartnerRequest(params) {
-  const ts = String(Math.floor((params.nowMs ?? Date.now()) / 1e3));
-  const nonce = params.nonce ?? defaultNonce2();
-  const bodyData = typeof params.body === "string" ? enc.encode(params.body) : params.body ?? new Uint8Array();
-  const bodyHash = await sha256Hex2(bodyData);
-  const message = canonical({
-    method: params.method,
-    path: params.path,
-    ts,
-    nonce,
-    bodyHash
-  });
-  const signingKey = await sha256Hex2(params.secret);
-  const sig = await hmacSha256Hex(signingKey, message);
-  return {
-    authorization: `Flur-Hmac key=${params.keyId}, ts=${ts}, nonce=${nonce}, sig=${sig}`,
-    ts,
-    nonce,
-    bodyHash
-  };
-}
-function createFlurPartnerClient(opts) {
+var ConsumerOACSchema = import_zod13.z.object({
+  oacId: import_zod13.z.string().uuid(),
+  issuerId: import_zod13.z.string().min(1).max(64),
+  userId: import_zod13.z.string().uuid(),
+  deviceId: import_zod13.z.string().min(1).max(128),
+  devicePubkeyHex: Hex64,
+  perTxCapKobo: import_zod13.z.number().int().positive(),
+  cumulativeCapKobo: import_zod13.z.number().int().positive(),
+  currency: import_zod13.z.string().length(3),
+  validFromMs: import_zod13.z.number().int().nonnegative(),
+  validUntilMs: import_zod13.z.number().int().nonnegative(),
+  counterSeed: import_zod13.z.number().int().nonnegative(),
+  issuedAtMs: import_zod13.z.number().int().nonnegative()
+});
+var SignedConsumerOACSchema = import_zod13.z.object({
+  oac: ConsumerOACSchema,
+  issuerSig: HexAny,
+  issuerPublicKeyHex: Hex64
+});
+var OACRecordSchema = SignedConsumerOACSchema.extend({
+  currentOfflineSpentKobo: import_zod13.z.number().int().nonnegative(),
+  status: import_zod13.z.enum([
+    "active",
+    "superseded",
+    "expired",
+    "revoked",
+    "disabling",
+    "draining",
+    "closed"
+  ]),
+  supersededAtMs: import_zod13.z.number().int().nonnegative().nullable(),
+  revokedAtMs: import_zod13.z.number().int().nonnegative().nullable(),
+  holdId: import_zod13.z.string().uuid().nullable().optional()
+});
+var IssueOACInputSchema = import_zod13.z.object({
+  deviceId: import_zod13.z.string().min(1).max(128),
+  perTxCapKobo: import_zod13.z.number().int().positive().optional(),
+  cumulativeCapKobo: import_zod13.z.number().int().positive().optional(),
+  ttlMs: import_zod13.z.number().int().min(6e4).max(1e3 * 60 * 60 * 24 * 7).optional(),
+  spendableOnlineKobo: import_zod13.z.number().int().nonnegative().optional()
+});
+var EnableOfflineInputSchema = import_zod13.z.object({
+  deviceId: import_zod13.z.string().min(1).max(128),
+  amountKobo: import_zod13.z.number().int().positive(),
+  perTxCapKobo: import_zod13.z.number().int().positive().optional(),
+  ttlMs: import_zod13.z.number().int().min(6e4).max(1e3 * 60 * 60 * 24 * 7).optional(),
+  installId: import_zod13.z.string().min(1).max(128),
+  partnerId: import_zod13.z.string().min(1).max(64).optional()
+});
+var DisableOfflineInputSchema = import_zod13.z.object({
+  deviceId: import_zod13.z.string().min(1).max(128),
+  installId: import_zod13.z.string().min(1).max(128).optional(),
+  claims: import_zod13.z.array(import_zod13.z.unknown()).max(256).optional()
+});
+var OfflineHoldRecordSchema = import_zod13.z.object({
+  holdId: import_zod13.z.string().uuid(),
+  userId: import_zod13.z.string().uuid(),
+  deviceId: import_zod13.z.string(),
+  partnerId: import_zod13.z.string(),
+  adapterKind: import_zod13.z.string(),
+  externalHoldRef: import_zod13.z.string().nullable(),
+  amountKobo: import_zod13.z.number().int().nonnegative(),
+  capturedKobo: import_zod13.z.number().int().nonnegative(),
+  releasedKobo: import_zod13.z.number().int().nonnegative(),
+  remainingKobo: import_zod13.z.number().int().nonnegative(),
+  currency: import_zod13.z.string().length(3),
+  status: import_zod13.z.enum([
+    "placing",
+    "active",
+    "disabling",
+    "draining",
+    "closed",
+    "revoked",
+    "failed"
+  ]),
+  installId: import_zod13.z.string().nullable(),
+  drainDeadlineMs: import_zod13.z.number().int().nonnegative(),
+  disableRequestedAtMs: import_zod13.z.number().int().nonnegative().nullable(),
+  createdAtMs: import_zod13.z.number().int().nonnegative(),
+  closedAtMs: import_zod13.z.number().int().nonnegative().nullable(),
+  isTrusted: import_zod13.z.boolean().optional()
+});
+var EnableOfflineResultSchema = import_zod13.z.object({
+  hold: OfflineHoldRecordSchema,
+  oac: OACRecordSchema
+});
+var DisableOfflineResultSchema = import_zod13.z.object({
+  hold: OfflineHoldRecordSchema,
+  trusted: import_zod13.z.boolean(),
+  settledClaims: import_zod13.z.number().int().nonnegative()
+});
+var OfflineStatusResultSchema = import_zod13.z.object({
+  hold: OfflineHoldRecordSchema.nullable(),
+  active: OACRecordSchema.nullable()
+});
+var OfflineStateResultSchema = import_zod13.z.object({
+  active: OACRecordSchema.nullable()
+});
+var ConsumerPaymentClaimSchema = import_zod13.z.object({
+  oacId: import_zod13.z.string().uuid(),
+  encounterId: Sha256Hex.optional(),
+  payerUserId: import_zod13.z.string().uuid(),
+  payeeUserId: import_zod13.z.string().uuid(),
+  payerDeviceId: import_zod13.z.string().min(1).max(128),
+  payerNonce: import_zod13.z.string().min(8).max(128),
+  payeeNonce: import_zod13.z.string().min(8).max(128),
+  amountKobo: import_zod13.z.number().int().positive(),
+  currency: import_zod13.z.string().length(3).default("NGN"),
+  occurredAtMs: import_zod13.z.number().int().nonnegative(),
+  completedAtMs: import_zod13.z.number().int().nonnegative().optional(),
+  contextId: import_zod13.z.string().max(128).optional(),
+  payerPubkeyHex: Hex64,
+  payerSignature: HexAny,
+  payeePubkeyHex: Hex64.optional(),
+  payeeSignature: HexAny.optional()
+});
+var ConsumerSettlementSchema = import_zod13.z.object({
+  settlementId: import_zod13.z.string().uuid(),
+  settlementKey: Sha256Hex,
+  encounterId: Sha256Hex,
+  oacId: import_zod13.z.string().uuid(),
+  payerUserId: import_zod13.z.string().uuid(),
+  payeeUserId: import_zod13.z.string().uuid(),
+  amountKobo: import_zod13.z.number().int().positive(),
+  currency: import_zod13.z.string().length(3),
+  status: import_zod13.z.enum(["SETTLED", "REVIEW"]),
+  reviewReason: import_zod13.z.string().nullable(),
+  ledgerRef: import_zod13.z.string().nullable(),
+  issuerSig: HexAny,
+  createdAtMs: import_zod13.z.number().int().nonnegative()
+});
+var ConsumerSettleResultSchema = import_zod13.z.object({
+  settlement: ConsumerSettlementSchema,
+  encounterId: Sha256Hex,
+  replayed: import_zod13.z.boolean()
+});
+var RevokeDeviceKeyInputSchema = import_zod13.z.object({
+  deviceId: import_zod13.z.string().min(1).max(128),
+  /** Step-up token from /api/v1/auth/send/verify with purpose='offline_revoke'. */
+  sendAuthToken: import_zod13.z.string().min(16)
+});
+function createMeOfflineClient(opts) {
   const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
   if (!fetchImpl) {
-    throw new Error(
-      "createFlurPartnerClient: no fetch implementation available"
-    );
+    throw new Error("createMeOfflineClient: no fetch implementation available");
   }
   const baseUrl = opts.baseUrl.replace(/\/$/, "");
-  async function makeSignedInit(method, path, body) {
-    const sig = await signPartnerRequest({
-      keyId: opts.keyId,
-      secret: opts.secret,
+  async function call(method, path, body, parser) {
+    const init2 = {
       method,
-      path,
-      body: body ?? "",
-      nowMs: opts.nowMs?.(),
-      nonce: opts.nonce?.()
-    });
-    const headers = {
-      authorization: sig.authorization,
-      accept: "application/json"
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json"
+      }
     };
-    if (body !== void 0) headers["content-type"] = "application/json";
-    const init2 = { method, headers };
-    if (body !== void 0) init2.body = body;
-    return init2;
-  }
-  async function request(opts2) {
-    const bodyStr = opts2.body === void 0 ? void 0 : JSON.stringify(opts2.body);
-    const init2 = await makeSignedInit(opts2.method, opts2.path, bodyStr);
-    const resp = await fetchImpl(`${baseUrl}${opts2.path}`, init2);
+    if (body !== void 0) init2.body = JSON.stringify(body);
+    const resp = await fetchImpl(`${baseUrl}${path}`, init2);
     const text = await resp.text();
-    let raw;
+    let raw = void 0;
     if (text) {
       try {
         raw = JSON.parse(text);
@@ -2554,46 +3287,290 @@ function createFlurPartnerClient(opts) {
       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 raw;
+    return parser(raw);
   }
-  const fetchLike = async (input, init2) => {
-    const url = typeof input === "string" ? input : input.toString();
-    const u = new URL(url, baseUrl);
-    const path = `${u.pathname}${u.search}`;
-    const method = (init2?.method ?? "GET").toUpperCase();
-    let bodyStr;
-    if (init2?.body) {
-      bodyStr = typeof init2.body === "string" ? init2.body : init2.body.toString();
+  const deviceKeyItems = import_zod13.z.object({ items: import_zod13.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)
+    )
+  };
+}
+
+// src/partner-funding/client.ts
+var import_zod14 = require("zod");
+var MinorString = import_zod14.z.string().regex(/^-?\d+$/);
+var PositiveMinor = import_zod14.z.union([
+  import_zod14.z.number().int().positive(),
+  import_zod14.z.string().regex(/^[1-9]\d{0,18}$/)
+]);
+var Currency = import_zod14.z.string().trim().length(3).transform((v) => v.toUpperCase());
+var Metadata = import_zod14.z.record(import_zod14.z.unknown());
+var PARTNER_KINDS = ["bank", "merchant"];
+var CUSTODIAL_MODES = ["agent_of_bank", "flur_virtual_pool"];
+var PARTNER_PROFILE_STATUSES = [
+  "active",
+  "suspended",
+  "closed"
+];
+var PARTNER_FUNDING_DIRECTIONS = ["credit", "debit"];
+var PARTNER_FUNDING_STATUSES = [
+  "pending",
+  "posted",
+  "failed"
+];
+var PAYOUT_DESTINATION_STATUSES = [
+  "pending",
+  "verified",
+  "disabled"
+];
+var WITHDRAWAL_STATES = [
+  "requested",
+  "submitted",
+  "processing",
+  "paid",
+  "failed",
+  "reversed"
+];
+var PartnerProfileSchema = import_zod14.z.object({
+  partnerAccountId: import_zod14.z.string().uuid(),
+  kind: import_zod14.z.enum(PARTNER_KINDS),
+  custodialMode: import_zod14.z.enum(CUSTODIAL_MODES),
+  displayName: import_zod14.z.string(),
+  bankCode: import_zod14.z.string().nullable(),
+  poolAccountNumber: import_zod14.z.string().nullable(),
+  status: import_zod14.z.enum(PARTNER_PROFILE_STATUSES),
+  metadata: Metadata,
+  createdAtMs: import_zod14.z.number().int().nonnegative(),
+  updatedAtMs: import_zod14.z.number().int().nonnegative()
+});
+var UpsertPartnerProfileInputSchema = import_zod14.z.object({
+  kind: import_zod14.z.enum(PARTNER_KINDS),
+  custodialMode: import_zod14.z.enum(CUSTODIAL_MODES),
+  displayName: import_zod14.z.string().trim().min(1).max(200),
+  bankCode: import_zod14.z.string().trim().min(1).max(64).optional(),
+  poolAccountNumber: import_zod14.z.string().trim().min(1).max(64).optional(),
+  metadata: Metadata.optional()
+});
+var PartnerFundingEventInputSchema = import_zod14.z.object({
+  externalRef: import_zod14.z.string().trim().min(8).max(128),
+  direction: import_zod14.z.enum(PARTNER_FUNDING_DIRECTIONS).optional(),
+  userId: import_zod14.z.string().uuid().optional(),
+  accountId: import_zod14.z.string().uuid().optional(),
+  amountMinor: PositiveMinor,
+  currency: Currency,
+  fundingSource: import_zod14.z.string().trim().min(1).max(64).optional(),
+  providerMetadata: Metadata.optional()
+});
+var PartnerFundingSchema = import_zod14.z.object({
+  fundingId: import_zod14.z.string().uuid(),
+  partnerId: import_zod14.z.string().uuid(),
+  accountId: import_zod14.z.string().uuid(),
+  userId: import_zod14.z.string().uuid().nullable(),
+  direction: import_zod14.z.enum(PARTNER_FUNDING_DIRECTIONS),
+  currency: import_zod14.z.string(),
+  amountMinor: MinorString,
+  externalRef: import_zod14.z.string(),
+  status: import_zod14.z.enum(PARTNER_FUNDING_STATUSES),
+  fundingSource: import_zod14.z.string(),
+  ledgerRef: import_zod14.z.string(),
+  providerMetadata: Metadata,
+  createdAtMs: import_zod14.z.number().int().nonnegative(),
+  updatedAtMs: import_zod14.z.number().int().nonnegative()
+});
+var IngestFundingResultSchema = import_zod14.z.object({
+  funding: PartnerFundingSchema,
+  replayed: import_zod14.z.boolean()
+});
+var PayoutDestinationSchema = import_zod14.z.object({
+  destinationId: import_zod14.z.string().uuid(),
+  accountId: import_zod14.z.string().uuid(),
+  partnerId: import_zod14.z.string().uuid(),
+  bankCode: import_zod14.z.string(),
+  accountNumber: import_zod14.z.string(),
+  accountName: import_zod14.z.string(),
+  status: import_zod14.z.enum(PAYOUT_DESTINATION_STATUSES),
+  verifiedAtMs: import_zod14.z.number().int().nonnegative().nullable(),
+  metadata: Metadata,
+  createdAtMs: import_zod14.z.number().int().nonnegative(),
+  updatedAtMs: import_zod14.z.number().int().nonnegative()
+});
+var CreatePayoutDestinationInputSchema = import_zod14.z.object({
+  partnerId: import_zod14.z.string().uuid(),
+  bankCode: import_zod14.z.string().trim().min(1).max(32),
+  accountNumber: import_zod14.z.string().trim().min(4).max(64),
+  accountName: import_zod14.z.string().trim().min(1).max(200),
+  metadata: Metadata.optional()
+});
+var ListPayoutDestinationsResultSchema = import_zod14.z.object({
+  items: import_zod14.z.array(PayoutDestinationSchema)
+});
+var WithdrawalSchema = import_zod14.z.object({
+  withdrawalId: import_zod14.z.string().uuid(),
+  accountId: import_zod14.z.string().uuid(),
+  userId: import_zod14.z.string().uuid(),
+  partnerId: import_zod14.z.string().uuid(),
+  destinationId: import_zod14.z.string().uuid(),
+  currency: import_zod14.z.string(),
+  amountMinor: MinorString,
+  state: import_zod14.z.enum(WITHDRAWAL_STATES),
+  idempotencyKey: import_zod14.z.string(),
+  providerRef: import_zod14.z.string().nullable(),
+  lastError: import_zod14.z.string().nullable(),
+  ledgerRef: import_zod14.z.string(),
+  reverseLedgerRef: import_zod14.z.string().nullable(),
+  metadata: Metadata,
+  createdAtMs: import_zod14.z.number().int().nonnegative(),
+  updatedAtMs: import_zod14.z.number().int().nonnegative()
+});
+var CreateWithdrawalInputSchema = import_zod14.z.object({
+  destinationId: import_zod14.z.string().uuid(),
+  amountMinor: PositiveMinor,
+  currency: Currency,
+  idempotencyKey: import_zod14.z.string().trim().min(8).max(128),
+  metadata: Metadata.optional()
+});
+var CreateWithdrawalResultSchema = import_zod14.z.object({
+  withdrawal: WithdrawalSchema,
+  replayed: import_zod14.z.boolean()
+});
+var PayoutEventInputSchema = import_zod14.z.object({
+  externalRef: import_zod14.z.string().trim().min(8).max(128),
+  withdrawalId: import_zod14.z.string().uuid().optional(),
+  state: import_zod14.z.enum(["submitted", "processing", "paid", "failed"]),
+  providerRef: import_zod14.z.string().trim().min(1).max(128).optional(),
+  failureCode: import_zod14.z.string().trim().max(64).optional(),
+  failureMessage: import_zod14.z.string().trim().max(512).optional(),
+  providerMetadata: Metadata.optional()
+});
+var RecordPayoutEventResultSchema = import_zod14.z.object({
+  withdrawal: WithdrawalSchema,
+  replayed: import_zod14.z.boolean()
+});
+var ReconciliationReportSchema = import_zod14.z.object({
+  partnerId: import_zod14.z.string().uuid(),
+  currency: import_zod14.z.string(),
+  fromMs: import_zod14.z.number().int().nonnegative(),
+  toMs: import_zod14.z.number().int().nonnegative(),
+  fundingsCreditMinor: MinorString,
+  fundingsDebitMinor: MinorString,
+  withdrawalsPaidMinor: MinorString,
+  withdrawalsReversedMinor: MinorString,
+  withdrawalsInFlightMinor: MinorString,
+  expectedReserveBalanceMinor: MinorString,
+  actualReserveBalanceMinor: MinorString,
+  imbalanceMinor: MinorString,
+  generatedAtMs: import_zod14.z.number().int().nonnegative()
+});
+function createPartnerFundingClient(partner) {
+  return {
+    ingestFunding: async (input) => {
+      const body = PartnerFundingEventInputSchema.parse(input);
+      const raw = await partner.request({
+        method: "POST",
+        path: "/v1/partners/fundings",
+        body
+      });
+      return IngestFundingResultSchema.parse(raw);
+    },
+    recordPayoutEvent: async (input) => {
+      const body = PayoutEventInputSchema.parse(input);
+      const raw = await partner.request({
+        method: "POST",
+        path: "/v1/partners/payouts/events",
+        body
+      });
+      return RecordPayoutEventResultSchema.parse(raw);
+    },
+    reconciliation: async (input) => {
+      const qs = new URLSearchParams({
+        currency: input.currency
+      });
+      if (typeof input.fromMs === "number")
+        qs.set("fromMs", String(input.fromMs));
+      if (typeof input.toMs === "number") qs.set("toMs", String(input.toMs));
+      const raw = await partner.request({
+        method: "GET",
+        path: `/v1/partners/reconciliation/daily?${qs.toString()}`
+      });
+      return ReconciliationReportSchema.parse(raw);
     }
-    const signed = await makeSignedInit(method, path, bodyStr);
-    return fetchImpl(`${baseUrl}${path}`, {
-      ...init2,
-      ...signed,
-      headers: {
-        ...init2?.headers,
-        ...signed.headers
-      }
-    });
   };
-  return { request, fetch: fetchLike };
 }
-function createApiCredentialsAdminClient(opts) {
+function createConsumerWithdrawalsClient(opts) {
   const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
   if (!fetchImpl) {
     throw new Error(
-      "createApiCredentialsAdminClient: no fetch implementation available"
+      "createConsumerWithdrawalsClient: 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"
-      }
+      headers: { accept: "application/json" }
     };
-    if (body !== void 0) init2.body = JSON.stringify(body);
+    if (body !== void 0) {
+      init2.body = JSON.stringify(body);
+      init2.headers = { ...init2.headers, "content-type": "application/json" };
+    }
     const resp = await fetchImpl(`${baseUrl}${path}`, init2);
     const text = await resp.text();
     let raw;
@@ -2601,6 +3578,7 @@ function createApiCredentialsAdminClient(opts) {
       try {
         raw = JSON.parse(text);
       } catch {
+        raw = text;
       }
     }
     if (!resp.ok) {
@@ -2610,30 +3588,85 @@ function createApiCredentialsAdminClient(opts) {
     }
     return parser(raw);
   }
-  const listSchema = import_zod11.z.object({
-    items: import_zod11.z.array(ApiCredentialPublicSchema)
-  });
   return {
-    list: (accountId) => call(
+    listDestinations: () => call(
       "GET",
-      `/v1/accounts/${accountId}/api-credentials`,
+      "/v1/me/payout-destinations",
       void 0,
-      (raw) => listSchema.parse(raw)
+      (raw) => ListPayoutDestinationsResultSchema.parse(raw)
     ),
-    mint: (accountId, input) => call(
+    createDestination: (input) => call(
       "POST",
-      `/v1/accounts/${accountId}/api-credentials`,
-      input,
-      (raw) => MintedApiCredentialSchema.parse(raw)
+      "/v1/me/payout-destinations",
+      CreatePayoutDestinationInputSchema.parse(input),
+      (raw) => PayoutDestinationSchema.parse(raw)
     ),
-    revoke: (accountId, credentialId) => call(
-      "DELETE",
-      `/v1/accounts/${accountId}/api-credentials/${credentialId}`,
+    verifyDestination: (destinationId) => call(
+      "POST",
+      `/v1/me/payout-destinations/${encodeURIComponent(destinationId)}/verify`,
+      {},
+      (raw) => PayoutDestinationSchema.parse(raw)
+    ),
+    disableDestination: (destinationId) => call(
+      "POST",
+      `/v1/me/payout-destinations/${encodeURIComponent(destinationId)}/disable`,
+      {},
+      (raw) => PayoutDestinationSchema.parse(raw)
+    ),
+    createWithdrawal: (input) => call(
+      "POST",
+      "/v1/me/withdrawals",
+      CreateWithdrawalInputSchema.parse(input),
+      (raw) => CreateWithdrawalResultSchema.parse(raw)
+    ),
+    getWithdrawal: (withdrawalId) => call(
+      "GET",
+      `/v1/me/withdrawals/${encodeURIComponent(withdrawalId)}`,
       void 0,
-      (raw) => ApiCredentialPublicSchema.parse(raw)
+      (raw) => WithdrawalSchema.parse(raw)
     )
   };
 }
+function createPartnerProfileAdminClient(opts) {
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error(
+      "createPartnerProfileAdminClient: no fetch implementation available"
+    );
+  }
+  const baseUrl = opts.baseUrl.replace(/\/$/, "");
+  return {
+    upsertProfile: async (partnerAccountId, input) => {
+      const body = {
+        partnerAccountId,
+        ...UpsertPartnerProfileInputSchema.parse(input)
+      };
+      const resp = await fetchImpl(`${baseUrl}/v1/partners/profile`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      const text = await resp.text();
+      let raw;
+      if (text) {
+        try {
+          raw = JSON.parse(text);
+        } catch {
+          raw = text;
+        }
+      }
+      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 PartnerProfileSchema.parse(raw);
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNT_STATUSES,
@@ -2642,6 +3675,29 @@ function createApiCredentialsAdminClient(opts) {
   AccountMembershipSchema,
   AccountSchema,
   ApiCredentialPublicSchema,
+  COLLECTION_INTENT_STATUSES,
+  COLLECTION_PAYMENT_STATUSES,
+  CUSTODIAL_MODES,
+  CollectionIntentSchema,
+  CollectionPaymentResultSchema,
+  CollectionPaymentSchema,
+  CollectionReportSummarySchema,
+  CollectionStatementSchema,
+  ConsumerOACRecordSchema,
+  ConsumerOACSchema,
+  ConsumerPaymentClaimSchema,
+  ConsumerSettleResultSchema,
+  ConsumerSettlementSchema,
+  CreateCollectionIntentInputSchema,
+  CreatePayoutDestinationInputSchema,
+  CreatePayoutInputSchema,
+  CreateWithdrawalInputSchema,
+  CreateWithdrawalResultSchema,
+  DeviceKeyRecordSchema,
+  DisableOfflineInputSchema,
+  DisableOfflineResultSchema,
+  EnableOfflineInputSchema,
+  EnableOfflineResultSchema,
   FIELD,
   FlurApiError,
   FlurCapExceededError,
@@ -2649,7 +3705,14 @@ function createApiCredentialsAdminClient(opts) {
   FlurError,
   FlurExpiredError,
   FlurReplayError,
+  IngestFundingResultSchema,
+  IssueOACInputSchema,
+  ListPayoutDestinationsResultSchema,
   MEMBERSHIP_ROLES,
+  MERCHANT_PAYOUT_STATUSES,
+  MERCHANT_PROFILE_STATUSES,
+  MerchantPayoutSchema,
+  MerchantProfileSchema,
   MintedApiCredentialSchema,
   NGN_CURRENCY_CODE,
   NG_COUNTRY_CODE,
@@ -2658,25 +3721,52 @@ function createApiCredentialsAdminClient(opts) {
   OAC_DEFAULT_CUMULATIVE_KOBO,
   OAC_DEFAULT_PER_TX_KOBO,
   OAC_DEFAULT_VALIDITY_MS,
+  OfflineHoldRecordSchema,
   OfflinePaymentAuthorizationSchema,
   OfflinePaymentRequestSchema,
+  OfflineStateResultSchema,
+  OfflineStatusResultSchema,
   OfflineTokenSchema,
+  PARTNER_FUNDING_DIRECTIONS,
+  PARTNER_FUNDING_STATUSES,
+  PARTNER_KINDS,
+  PARTNER_PROFILE_STATUSES,
   PARTNER_SCOPES,
   PASS_KINDS,
   PASS_STATES,
   PAYLOAD_FORMAT_INDICATOR_VALUE,
+  PAYOUT_DESTINATION_STATUSES,
   POINT_OF_INITIATION,
+  PartnerFundingEventInputSchema,
+  PartnerFundingSchema,
+  PartnerProfileSchema,
   PassMetadataSchema,
   PassSchema,
+  PayCollectionInputSchema,
   PaymentClaimSchema,
+  PayoutDestinationSchema,
+  PayoutEventInputSchema,
+  ProviderEventInputSchema,
+  ProviderEventRecordSchema,
+  PublicCollectionIntentSchema,
   RECEIPT_CHANNELS,
   RECEIPT_KINDS,
   REPLAY_WINDOW_MS,
   ReceiptPayloadSchema,
   ReceiptSchema,
+  ReconciliationReportSchema,
+  RecordPayoutEventResultSchema,
   RedemptionSchema,
+  RegisterDeviceKeyInputSchema,
+  RevokeDeviceKeyInputSchema,
+  SETTLEMENT_SCHEDULES,
   SettleResponseSchema,
   SettlementSchema,
+  SignedConsumerOACSchema,
+  UpsertMerchantProfileInputSchema,
+  UpsertPartnerProfileInputSchema,
+  WITHDRAWAL_STATES,
+  WithdrawalSchema,
   bodySha256Hex,
   buildAuthorization,
   buildOAC,
@@ -2693,9 +3783,16 @@ function createApiCredentialsAdminClient(opts) {
   crc16ccittHex,
   createAccountsClient,
   createApiCredentialsAdminClient,
+  createCollectionsClient,
+  createConsumerCollectionsClient,
+  createConsumerWithdrawalsClient,
   createFlurPartnerClient,
   createHmacFetch,
+  createMeOfflineClient,
   createOfflineSettlementsClient,
+  createPartnerCollectionsClient,
+  createPartnerFundingClient,
+  createPartnerProfileAdminClient,
   createPassesClient,
   createReceiptsClient,
   decodeAuthorizationQR,