@smileid/usesmileid-nodejs 12.0.0

package/dist/generated/operations/index.js

@@ -0,0 +1,421 @@
+"use strict";
+/**
+ * Thin per-operation functions (spec §3, §6).
+ *
+ * Generator-owned later: each function takes typed camelCase params, maps them
+ * to the verbatim snake_case wire (headers / query / path / multipart / JSON),
+ * calls the transport, and maps the response back to a public model. All wire
+ * field names are snake_case; the mapping boundary lives here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enhancedKyc = enhancedKyc;
+exports.documentVerification = documentVerification;
+exports.enhancedDocumentVerification = enhancedDocumentVerification;
+exports.biometricKyc = biometricKyc;
+exports.registration = registration;
+exports.authentication = authentication;
+exports.compare = compare;
+exports.verificationStatus = verificationStatus;
+exports.replayCallback = replayCallback;
+exports.reportFraud = reportFraud;
+exports.bankCodes = bankCodes;
+exports.supportedIdTypes = supportedIdTypes;
+exports.supportedDocuments = supportedDocuments;
+exports.idStatus = idStatus;
+const binary_js_1 = require("../../helpers/binary.js");
+const multipart_js_1 = require("../../helpers/multipart.js");
+const case_js_1 = require("../../helpers/case.js");
+const validation_js_1 = require("../../helpers/validation.js");
+const index_js_1 = require("../models/index.js");
+// ---- shared serialization helpers -----------------------------------------
+function consentJson(c) {
+    return JSON.stringify({
+        granted: c.granted,
+        granted_at: c.grantedAt,
+        notice_language: c.noticeLanguage,
+        notice_privacy_policy_url: c.noticePrivacyPolicyUrl,
+    });
+}
+function userDetailsJson(u) {
+    const obj = {
+        given_names: u.givenNames,
+        last_name: u.lastName,
+    };
+    if (u.email !== undefined && u.email !== null)
+        obj.email = u.email;
+    if (u.phoneNumber !== undefined && u.phoneNumber !== null)
+        obj.phone_number = u.phoneNumber;
+    return JSON.stringify(obj);
+}
+function scalar(name, value) {
+    if (value === undefined)
+        return [];
+    const str = typeof value === 'boolean' ? String(value) : String(value);
+    return [{ kind: 'scalar', name, value: str }];
+}
+function jsonPart(name, json) {
+    return json === undefined ? [] : [{ kind: 'json', name, json }];
+}
+function optionalJson(name, value) {
+    if (value === undefined)
+        return [];
+    return [{ kind: 'json', name, json: JSON.stringify(value) }];
+}
+const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+/**
+ * selfie_image / liveness_images / comparison_image parts are always
+ * image/jpeg on the wire (spec §5.3, cross-SDK policy), regardless of any
+ * type carried by the input.
+ */
+async function jpegPart(name, input, defaultName) {
+    const resolved = await (0, binary_js_1.resolveBinary)(input, defaultName, 'image/jpeg');
+    return {
+        kind: 'binary',
+        name,
+        filename: resolved.filename,
+        contentType: 'image/jpeg',
+        bytes: resolved.bytes,
+    };
+}
+/**
+ * document / document_back may be image/jpeg or image/png (spec §5.3). An
+ * explicit type on the input wins; otherwise PNG is detected from the file's
+ * magic bytes and everything else is treated as JPEG.
+ */
+async function documentPart(name, input, defaultName) {
+    const resolved = await (0, binary_js_1.resolveBinary)(input, defaultName, '');
+    const contentType = resolved.contentType !== ''
+        ? resolved.contentType
+        : resolved.bytes.subarray(0, 4).equals(PNG_MAGIC)
+            ? 'image/png'
+            : 'image/jpeg';
+    return {
+        kind: 'binary',
+        name,
+        filename: resolved.filename,
+        contentType,
+        bytes: resolved.bytes,
+    };
+}
+async function livenessParts(images) {
+    // Repeated parts, all named liveness_images — never CSV/indexed (spec §5.3).
+    return Promise.all(images.map((img, i) => jpegPart('liveness_images', img, `liveness${i + 1}.jpg`)));
+}
+function toAccepted(json) {
+    const o = (json ?? {});
+    return new index_js_1.AcceptedResponse({
+        status: typeof o.status === 'string' ? o.status : '',
+        message: typeof o.message === 'string' ? o.message : '',
+        jobId: typeof o.job_id === 'string' ? o.job_id : null,
+        userId: typeof o.user_id === 'string' ? o.user_id : null,
+        createdAt: typeof o.created_at === 'string' ? o.created_at : null,
+    });
+}
+function toJobStatus(json) {
+    const o = (json ?? {});
+    return new index_js_1.JobStatus({
+        status: typeof o.status === 'string' ? o.status : '',
+        jobId: typeof o.job_id === 'string' ? o.job_id : null,
+        userId: typeof o.user_id === 'string' ? o.user_id : null,
+        message: typeof o.message === 'string' ? o.message : null,
+    });
+}
+function effectiveCallback(paramCb, opts, transport) {
+    const callback = paramCb ?? opts?.callbackUrl ?? transport.defaultCallbackUrl ?? undefined;
+    // Fleet standard: callback URLs must be https; checked before any request
+    // (including the token fetch) is made.
+    if (callback !== undefined) {
+        (0, validation_js_1.assertHttpsUrl)(callback, 'callbackUrl');
+    }
+    return callback;
+}
+function planExtras(opts) {
+    return { timeout: opts?.timeout, signal: opts?.signal };
+}
+// ---- entry endpoints -------------------------------------------------------
+async function enhancedKyc(transport, params, opts) {
+    const parts = [
+        ...scalar('country', params.country),
+        ...scalar('id_type', params.idType),
+        ...scalar('id_number', params.idNumber),
+        ...scalar('bank_code', params.bankCode),
+        ...scalar('operator', params.operator),
+        ...scalar('callback_url', effectiveCallback(params.callbackUrl, opts, transport)),
+        ...jsonPart('user_details', userDetailsJson(params.userDetails)),
+        ...jsonPart('consent', consentJson(params.consent)),
+        ...optionalJson('partner_params', params.partnerParams),
+        ...optionalJson('metadata', params.metadata),
+    ];
+    const result = await transport.execute({
+        method: 'POST',
+        path: '/v3/enhanced_kyc',
+        authenticated: true,
+        needsPartnerIdHeader: false,
+        idempotent: false,
+        headers: { 'User-ID': params.userId },
+        multipart: (0, multipart_js_1.buildMultipart)(parts),
+        ...planExtras(opts),
+    });
+    return toAccepted(result.json);
+}
+async function documentVerification(transport, params, opts) {
+    const parts = [
+        ...scalar('country', params.country),
+        ...scalar('id_type', params.idType),
+        ...scalar('callback_url', effectiveCallback(params.callbackUrl, opts, transport)),
+        await jpegPart('selfie_image', params.selfieImage, 'selfie.jpg'),
+        ...(await livenessParts(params.livenessImages)),
+        await documentPart('document', params.document, 'document.jpg'),
+        ...(params.documentBack
+            ? [await documentPart('document_back', params.documentBack, 'document_back.jpg')]
+            : []),
+        ...jsonPart('user_details', userDetailsJson(params.userDetails)),
+        ...jsonPart('consent', consentJson(params.consent)),
+        ...optionalJson('partner_params', params.partnerParams),
+        ...optionalJson('metadata', params.metadata),
+    ];
+    const result = await transport.execute({
+        method: 'POST',
+        path: '/v3/document_verification',
+        authenticated: true,
+        needsPartnerIdHeader: true,
+        idempotent: false,
+        headers: { 'User-ID': params.userId },
+        multipart: (0, multipart_js_1.buildMultipart)(parts),
+        ...planExtras(opts),
+    });
+    return toAccepted(result.json);
+}
+async function enhancedDocumentVerification(transport, params, opts) {
+    const parts = [
+        ...scalar('country', params.country),
+        ...scalar('id_type', params.idType),
+        ...scalar('callback_url', effectiveCallback(params.callbackUrl, opts, transport)),
+        await jpegPart('selfie_image', params.selfieImage, 'selfie.jpg'),
+        ...(await livenessParts(params.livenessImages)),
+        await documentPart('document', params.document, 'document.jpg'),
+        ...(params.documentBack
+            ? [await documentPart('document_back', params.documentBack, 'document_back.jpg')]
+            : []),
+        ...jsonPart('user_details', userDetailsJson(params.userDetails)),
+        ...jsonPart('consent', consentJson(params.consent)),
+        ...optionalJson('partner_params', params.partnerParams),
+        ...optionalJson('metadata', params.metadata),
+    ];
+    const result = await transport.execute({
+        method: 'POST',
+        path: '/v3/enhanced_document_verification',
+        authenticated: true,
+        needsPartnerIdHeader: true,
+        idempotent: false,
+        headers: { 'User-ID': params.userId },
+        multipart: (0, multipart_js_1.buildMultipart)(parts),
+        ...planExtras(opts),
+    });
+    return toAccepted(result.json);
+}
+async function biometricKyc(transport, params, opts) {
+    const parts = [
+        ...scalar('country', params.country),
+        ...scalar('id_type', params.idType),
+        ...scalar('id_number', params.idNumber),
+        ...scalar('sandbox_result', params.sandboxResult),
+        ...scalar('callback_url', effectiveCallback(params.callbackUrl, opts, transport)),
+        await jpegPart('selfie_image', params.selfieImage, 'selfie.jpg'),
+        ...(await livenessParts(params.livenessImages)),
+        ...jsonPart('user_details', userDetailsJson(params.userDetails)),
+        ...jsonPart('consent', consentJson(params.consent)),
+        ...optionalJson('partner_params', params.partnerParams),
+        ...optionalJson('metadata', params.metadata),
+    ];
+    const result = await transport.execute({
+        method: 'POST',
+        path: '/v3/biometric_kyc',
+        authenticated: true,
+        needsPartnerIdHeader: true,
+        idempotent: false,
+        headers: { 'User-ID': params.userId },
+        multipart: (0, multipart_js_1.buildMultipart)(parts),
+        ...planExtras(opts),
+    });
+    return toAccepted(result.json);
+}
+async function registration(transport, params, opts) {
+    const parts = [
+        ...scalar('allow_new_enroll', params.allowNewEnroll),
+        ...scalar('sandbox_result', params.sandboxResult),
+        ...scalar('callback_url', effectiveCallback(params.callbackUrl, opts, transport)),
+        await jpegPart('selfie_image', params.selfieImage, 'selfie.jpg'),
+        ...(await livenessParts(params.livenessImages)),
+        ...jsonPart('user_details', userDetailsJson(params.userDetails)),
+        ...jsonPart('consent', consentJson(params.consent)),
+        ...optionalJson('partner_params', params.partnerParams),
+        ...optionalJson('metadata', params.metadata),
+    ];
+    const result = await transport.execute({
+        method: 'POST',
+        path: '/v3/registration',
+        authenticated: true,
+        needsPartnerIdHeader: false,
+        idempotent: false,
+        headers: { 'User-ID': params.userId },
+        multipart: (0, multipart_js_1.buildMultipart)(parts),
+        ...planExtras(opts),
+    });
+    return toAccepted(result.json);
+}
+async function authentication(transport, params, opts) {
+    // user_id is a body field here (required), not the User-ID header (spec §6.6).
+    const parts = [
+        ...scalar('user_id', params.userId),
+        ...scalar('use_enrolled_image', params.useEnrolledImage),
+        ...scalar('sandbox_result', params.sandboxResult),
+        ...scalar('callback_url', effectiveCallback(params.callbackUrl, opts, transport)),
+        ...(params.selfieImage
+            ? [await jpegPart('selfie_image', params.selfieImage, 'selfie.jpg')]
+            : []),
+        ...(params.livenessImages ? await livenessParts(params.livenessImages) : []),
+        ...jsonPart('user_details', userDetailsJson(params.userDetails)),
+        ...jsonPart('consent', consentJson(params.consent)),
+        ...optionalJson('partner_params', params.partnerParams),
+        ...optionalJson('metadata', params.metadata),
+    ];
+    const result = await transport.execute({
+        method: 'POST',
+        path: '/v3/authentication',
+        authenticated: true,
+        needsPartnerIdHeader: false,
+        idempotent: false,
+        multipart: (0, multipart_js_1.buildMultipart)(parts),
+        ...planExtras(opts),
+    });
+    return toAccepted(result.json);
+}
+async function compare(transport, params, opts) {
+    // user_id is an optional body field here (spec §6.7).
+    const parts = [
+        ...scalar('comparison_image_type', params.comparisonImageType),
+        ...scalar('allow_new_enroll', params.allowNewEnroll),
+        ...scalar('user_id', params.userId),
+        ...scalar('sandbox_result', params.sandboxResult),
+        ...scalar('callback_url', effectiveCallback(params.callbackUrl, opts, transport)),
+        await jpegPart('selfie_image', params.selfieImage, 'selfie.jpg'),
+        await jpegPart('comparison_image', params.comparisonImage, 'comparison.jpg'),
+        ...(params.livenessImages ? await livenessParts(params.livenessImages) : []),
+        ...jsonPart('user_details', userDetailsJson(params.userDetails)),
+        ...jsonPart('consent', consentJson(params.consent)),
+        ...optionalJson('partner_params', params.partnerParams),
+        ...optionalJson('metadata', params.metadata),
+    ];
+    const result = await transport.execute({
+        method: 'POST',
+        path: '/v3/compare',
+        authenticated: true,
+        needsPartnerIdHeader: false,
+        idempotent: false,
+        multipart: (0, multipart_js_1.buildMultipart)(parts),
+        ...planExtras(opts),
+    });
+    return toAccepted(result.json);
+}
+// ---- status / replay / fraud ----------------------------------------------
+async function verificationStatus(transport, jobId, opts) {
+    const result = await transport.execute({
+        method: 'GET',
+        path: `/v3/status/${encodeURIComponent(jobId)}`,
+        authenticated: true,
+        needsPartnerIdHeader: false,
+        idempotent: true,
+        allow404: true, // 404 returns a JobStatus body (spec §6.8), never raises.
+        ...planExtras(opts),
+    });
+    return toJobStatus(result.json);
+}
+async function replayCallback(transport, jobId, params, opts) {
+    const callbackUrl = effectiveCallback(params?.callbackUrl, opts, transport);
+    const result = await transport.execute({
+        method: 'POST',
+        path: `/v3/replay/${encodeURIComponent(jobId)}`,
+        authenticated: true,
+        needsPartnerIdHeader: false,
+        idempotent: false, // never auto-retried (spec §2.6, §6.10)
+        // Multipart per the corrected replay spec (other content types get a 415);
+        // no override means no body at all.
+        ...(callbackUrl
+            ? { multipart: (0, multipart_js_1.buildMultipart)([{ kind: 'scalar', name: 'callback_url', value: callbackUrl }]) }
+            : {}),
+        ...planExtras(opts),
+    });
+    return toAccepted(result.json);
+}
+async function reportFraud(transport, userId, params, opts) {
+    const parts = [
+        ...scalar('is_fraud', params.isFraud),
+        ...scalar('reported_by', params.reportedBy),
+        ...scalar('reason', params.reason),
+        ...scalar('notes', params.notes),
+    ];
+    const result = await transport.execute({
+        method: 'POST',
+        path: `/v3/users/${encodeURIComponent(userId)}/report_fraud`,
+        authenticated: true,
+        needsPartnerIdHeader: false,
+        idempotent: false, // never auto-retried (spec §2.6)
+        multipart: (0, multipart_js_1.buildMultipart)(parts),
+        ...planExtras(opts),
+    });
+    return toAccepted(result.json);
+}
+// ---- services --------------------------------------------------------------
+async function bankCodes(transport, params, opts) {
+    const result = await transport.execute({
+        method: 'GET',
+        path: '/v3/services/bank_codes',
+        authenticated: false,
+        needsPartnerIdHeader: false,
+        idempotent: true,
+        query: { country: params?.country },
+        ...planExtras(opts),
+    });
+    return (0, case_js_1.camelizeKeys)(result.json);
+}
+async function supportedIdTypes(transport, params, opts) {
+    const result = await transport.execute({
+        method: 'GET',
+        path: '/v3/services/supported_id_types',
+        authenticated: false,
+        needsPartnerIdHeader: false,
+        idempotent: true,
+        query: { country: params?.country },
+        ...planExtras(opts),
+    });
+    return (0, case_js_1.camelizeKeys)(result.json);
+}
+async function supportedDocuments(transport, params, opts) {
+    const result = await transport.execute({
+        method: 'GET',
+        path: '/v3/services/supported_documents',
+        authenticated: false,
+        needsPartnerIdHeader: false,
+        idempotent: true,
+        query: {
+            continent: params?.continent,
+            country_code: params?.countryCode,
+            locale: params?.locale,
+        },
+        ...planExtras(opts),
+    });
+    return (0, case_js_1.camelizeKeys)(result.json);
+}
+async function idStatus(transport, params, opts) {
+    const result = await transport.execute({
+        method: 'GET',
+        path: '/v3/services/id_status',
+        authenticated: true,
+        needsPartnerIdHeader: false,
+        idempotent: true,
+        query: { country: params.country, id_type: params.idType },
+        ...planExtras(opts),
+    });
+    return (0, case_js_1.camelizeKeys)(result.json);
+}

package/dist/helpers/binary.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Resolve a {@link BinaryInput} to raw bytes plus a filename and content type
+ * for a multipart part (spec §5.3, §8).
+ *
+ * Accepts a filesystem path, a Buffer/Uint8Array, a Blob, a readable stream, or
+ * a wrapper `{ data, filename?, contentType? }` to override the defaults.
+ */
+import type { BinaryInput } from '../generated/models/index.js';
+/** A binary part ready to serialize. */
+export interface ResolvedBinary {
+    bytes: Buffer;
+    filename: string;
+    contentType: string;
+}
+/**
+ * Resolve a binary input to bytes + filename + content type.
+ *
+ * @param input        the caller-supplied binary
+ * @param defaultName  filename to use when the input does not carry one
+ * @param defaultType  content type to use when the input does not carry one
+ */
+export declare function resolveBinary(input: BinaryInput, defaultName: string, defaultType: string): Promise<ResolvedBinary>;

package/dist/helpers/binary.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Resolve a {@link BinaryInput} to raw bytes plus a filename and content type
+ * for a multipart part (spec §5.3, §8).
+ *
+ * Accepts a filesystem path, a Buffer/Uint8Array, a Blob, a readable stream, or
+ * a wrapper `{ data, filename?, contentType? }` to override the defaults.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBinary = resolveBinary;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+function isReadable(value) {
+    return (value instanceof node_stream_1.Readable ||
+        (typeof value === 'object' &&
+            value !== null &&
+            typeof value.pipe === 'function'));
+}
+async function streamToBuffer(stream) {
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+}
+async function resolveData(data) {
+    if (typeof data === 'string') {
+        return { bytes: await (0, promises_1.readFile)(data), filename: (0, node_path_1.basename)(data) };
+    }
+    if (Buffer.isBuffer(data)) {
+        return { bytes: data };
+    }
+    if (data instanceof Uint8Array) {
+        return { bytes: Buffer.from(data) };
+    }
+    if (typeof Blob !== 'undefined' && data instanceof Blob) {
+        const buf = Buffer.from(await data.arrayBuffer());
+        return { bytes: buf, contentType: data.type || undefined };
+    }
+    if (isReadable(data)) {
+        return { bytes: await streamToBuffer(data) };
+    }
+    throw new TypeError('Unsupported binary input type.');
+}
+/**
+ * Resolve a binary input to bytes + filename + content type.
+ *
+ * @param input        the caller-supplied binary
+ * @param defaultName  filename to use when the input does not carry one
+ * @param defaultType  content type to use when the input does not carry one
+ */
+async function resolveBinary(input, defaultName, defaultType) {
+    if (typeof input === 'object' &&
+        input !== null &&
+        'data' in input &&
+        !Buffer.isBuffer(input) &&
+        !(input instanceof Uint8Array) &&
+        !(typeof Blob !== 'undefined' && input instanceof Blob) &&
+        !isReadable(input)) {
+        const wrapper = input;
+        const resolved = await resolveData(wrapper.data);
+        return {
+            bytes: resolved.bytes,
+            filename: wrapper.filename ?? resolved.filename ?? defaultName,
+            contentType: wrapper.contentType ?? resolved.contentType ?? defaultType,
+        };
+    }
+    const resolved = await resolveData(input);
+    return {
+        bytes: resolved.bytes,
+        filename: resolved.filename ?? defaultName,
+        contentType: resolved.contentType ?? defaultType,
+    };
+}

package/dist/helpers/case.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snake_case ↔ camelCase conversion at the (de)serialization boundary (spec §8).
+ *
+ * The public API is camelCase; the wire is always snake_case. Requests map
+ * explicitly per field in the operation functions; responses are converted
+ * generically here.
+ */
+/** Convert a single snake_case key to camelCase. */
+export declare function snakeToCamel(key: string): string;
+/** Recursively convert every object key in a parsed response to camelCase. */
+export declare function camelizeKeys(value: unknown): unknown;

package/dist/helpers/case.js

@@ -0,0 +1,29 @@
+"use strict";
+/**
+ * snake_case ↔ camelCase conversion at the (de)serialization boundary (spec §8).
+ *
+ * The public API is camelCase; the wire is always snake_case. Requests map
+ * explicitly per field in the operation functions; responses are converted
+ * generically here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snakeToCamel = snakeToCamel;
+exports.camelizeKeys = camelizeKeys;
+/** Convert a single snake_case key to camelCase. */
+function snakeToCamel(key) {
+    return key.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+/** Recursively convert every object key in a parsed response to camelCase. */
+function camelizeKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map(camelizeKeys);
+    }
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[snakeToCamel(k)] = camelizeKeys(v);
+        }
+        return out;
+    }
+    return value;
+}

package/dist/helpers/consent.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Consent builder (spec §5.1, §8).
+ *
+ * `Consent.granted(...)` sets `granted: true` and normalizes the timestamp to
+ * an ISO 8601 string with milliseconds.
+ */
+import type { Consent as ConsentShape } from '../generated/models/index.js';
+/** Arguments to {@link Consent.granted}. */
+export interface ConsentGrantedArgs {
+    /** A Date or an ISO 8601 string. */
+    grantedAt: Date | string;
+    /** ISO 639-1 language code, uppercase (e.g. "EN"). */
+    noticeLanguage: string;
+    noticePrivacyPolicyUrl: string;
+}
+/** Namespace object exposing the `granted` builder. */
+export declare const Consent: {
+    /** Build a granted consent block (`granted: true`). */
+    granted(args: ConsentGrantedArgs): ConsentShape;
+};

package/dist/helpers/consent.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Consent builder (spec §5.1, §8).
+ *
+ * `Consent.granted(...)` sets `granted: true` and normalizes the timestamp to
+ * an ISO 8601 string with milliseconds.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Consent = void 0;
+/** Namespace object exposing the `granted` builder. */
+exports.Consent = {
+    /** Build a granted consent block (`granted: true`). */
+    granted(args) {
+        const grantedAt = args.grantedAt instanceof Date ? args.grantedAt.toISOString() : args.grantedAt;
+        return {
+            granted: true,
+            grantedAt,
+            noticeLanguage: args.noticeLanguage,
+            noticePrivacyPolicyUrl: args.noticePrivacyPolicyUrl,
+        };
+    },
+};

package/dist/helpers/jwt.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Minimal JWT `exp` decoding for the token lifecycle (spec §2.3).
+ *
+ * The token response carries no explicit expiry, so the `exp` claim is the only
+ * signal. This reads it without verifying the signature (the SDK is the token's
+ * consumer, not its validator). Returns null when the claim cannot be decoded,
+ * which the caller treats as "refresh on the next call".
+ */
+/** Decode the `exp` claim (seconds since epoch) from a JWT, or null. */
+export declare function decodeJwtExp(jwt: string): number | null;

package/dist/helpers/jwt.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Minimal JWT `exp` decoding for the token lifecycle (spec §2.3).
+ *
+ * The token response carries no explicit expiry, so the `exp` claim is the only
+ * signal. This reads it without verifying the signature (the SDK is the token's
+ * consumer, not its validator). Returns null when the claim cannot be decoded,
+ * which the caller treats as "refresh on the next call".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeJwtExp = decodeJwtExp;
+/** Decode the `exp` claim (seconds since epoch) from a JWT, or null. */
+function decodeJwtExp(jwt) {
+    const parts = jwt.split('.');
+    if (parts.length < 2)
+        return null;
+    try {
+        const payload = Buffer.from(parts[1], 'base64url').toString('utf8');
+        const claims = JSON.parse(payload);
+        if (claims && typeof claims === 'object') {
+            const exp = claims.exp;
+            if (typeof exp === 'number' && Number.isFinite(exp))
+                return exp;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}