@fastermessage/sdk 0.0.0-stage → 0.1.2

package/dist/cjs/resources.d.ts

@@ -0,0 +1,60 @@
+import type { RequestOptions, Requester } from './http.js';
+import type { Balance, Contact, ContactBatchResult, ContactGroup, ContactQuery, CreateContactBatchParams, CreateContactGroupParams, CreateContactParams, CreditMovement, CreditQuery, Message, MessageQuery, Otp, Page, PageQuery, RequestOtpParams, SendEmailParams, SendMessageParams, SendSmsBatchParams, SendSmsParams, SmsBatchResult, UpdateContactGroupParams, UpdateContactParams } from './types.js';
+export declare class Sms {
+    #private;
+    constructor(http: Requester);
+    send(params: SendSmsParams, options?: RequestOptions): Promise<Message>;
+    /** Jusqu'à 500 lignes. Lisez toujours `errors` : un retour normal ne garantit pas que toutes soient parties. */
+    sendBatch(params: SendSmsBatchParams, options?: RequestOptions): Promise<SmsBatchResult>;
+}
+export declare class Email {
+    #private;
+    constructor(http: Requester);
+    send(params: SendEmailParams, options?: RequestOptions): Promise<Message>;
+}
+export declare class Messages {
+    #private;
+    constructor(http: Requester);
+    /** Envoi avec le canal en paramètre. WhatsApp et la voix répondent aujourd'hui `501`. */
+    send(params: SendMessageParams, options?: RequestOptions): Promise<Message>;
+    get(id: string): Promise<Message>;
+    list(query?: MessageQuery): Promise<Page<Message>>;
+    all(query?: MessageQuery): AsyncGenerator<Message, void, undefined>;
+}
+export declare class OtpResource {
+    #private;
+    constructor(http: Requester);
+    request(params: RequestOtpParams, options?: RequestOptions): Promise<Otp>;
+    verify(id: string, code: string): Promise<Otp>;
+}
+export declare class Contacts {
+    #private;
+    constructor(http: Requester);
+    create(params: CreateContactParams): Promise<Contact>;
+    /** Crée jusqu'à 500 contacts dans un groupe. */
+    createBatch(params: CreateContactBatchParams, options?: RequestOptions): Promise<ContactBatchResult>;
+    get(id: string): Promise<Contact>;
+    list(query?: ContactQuery): Promise<Page<Contact>>;
+    all(query?: ContactQuery): AsyncGenerator<Contact, void, undefined>;
+    update(id: string, params: UpdateContactParams): Promise<Contact>;
+    /** Suppression définitive. Ce n'est pas un désabonnement : pour cela, `consent: 'out'`. */
+    delete(id: string): Promise<void>;
+}
+export declare class ContactGroups {
+    #private;
+    constructor(http: Requester);
+    create(params: CreateContactGroupParams): Promise<ContactGroup>;
+    get(id: string): Promise<ContactGroup>;
+    list(query?: PageQuery): Promise<Page<ContactGroup>>;
+    all(query?: PageQuery): AsyncGenerator<ContactGroup, void, undefined>;
+    update(id: string, params: UpdateContactGroupParams): Promise<ContactGroup>;
+    /** Refusé en `409` tant que le groupe contient des contacts. */
+    delete(id: string): Promise<void>;
+}
+export declare class Account {
+    #private;
+    constructor(http: Requester);
+    balance(): Promise<Balance[]>;
+    credits(query?: CreditQuery): Promise<Page<CreditMovement>>;
+    allCredits(query?: CreditQuery): AsyncGenerator<CreditMovement, void, undefined>;
+}

package/dist/cjs/resources.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Account = exports.ContactGroups = exports.Contacts = exports.OtpResource = exports.Messages = exports.Email = exports.Sms = void 0;
+function segment(id) {
+    // `..` changerait la route visée, et un identifiant vide viserait la collection.
+    if (id === '' || id === '.' || id === '..')
+        throw new TypeError('Identifiant de ressource invalide.');
+    return encodeURIComponent(id);
+}
+/** Parcourt toutes les pages, en demandant la suivante seulement quand il le faut. */
+async function* paginate(http, path, query) {
+    let cursor = query.cursor;
+    for (;;) {
+        const page = await http.request('GET', path, { query: { ...query, cursor } });
+        yield* page.data ?? [];
+        cursor = page.next_cursor;
+        if (page.has_more !== true || cursor === null || cursor === undefined)
+            return;
+    }
+}
+class Sms {
+    #http;
+    constructor(http) { this.#http = http; }
+    send(params, options) {
+        return this.#http.request('POST', '/v2/sms/send', { body: params, options });
+    }
+    /** Jusqu'à 500 lignes. Lisez toujours `errors` : un retour normal ne garantit pas que toutes soient parties. */
+    sendBatch(params, options) {
+        return this.#http.request('POST', '/v2/sms/batch', { body: params, options });
+    }
+}
+exports.Sms = Sms;
+class Email {
+    #http;
+    constructor(http) { this.#http = http; }
+    send(params, options) {
+        return this.#http.request('POST', '/v2/email/send', { body: params, options });
+    }
+}
+exports.Email = Email;
+class Messages {
+    #http;
+    constructor(http) { this.#http = http; }
+    /** Envoi avec le canal en paramètre. WhatsApp et la voix répondent aujourd'hui `501`. */
+    send(params, options) {
+        return this.#http.request('POST', '/v2/messages', { body: params, options });
+    }
+    get(id) {
+        return this.#http.request('GET', `/v2/messages/${segment(id)}`);
+    }
+    list(query = {}) {
+        return this.#http.request('GET', '/v2/messages', { query });
+    }
+    all(query = {}) {
+        return paginate(this.#http, '/v2/messages', query);
+    }
+}
+exports.Messages = Messages;
+class OtpResource {
+    #http;
+    constructor(http) { this.#http = http; }
+    request(params, options) {
+        return this.#http.request('POST', '/v2/otp', { body: { channel: 'sms', ...params }, options });
+    }
+    verify(id, code) {
+        return this.#http.request('POST', '/v2/otp/verify', { body: { id, code } });
+    }
+}
+exports.OtpResource = OtpResource;
+class Contacts {
+    #http;
+    constructor(http) { this.#http = http; }
+    create(params) {
+        return this.#http.request('POST', '/v2/contacts', { body: params });
+    }
+    /** Crée jusqu'à 500 contacts dans un groupe. */
+    createBatch(params, options) {
+        return this.#http.request('POST', '/v2/contacts/batch', { body: params, options });
+    }
+    get(id) {
+        return this.#http.request('GET', `/v2/contacts/${segment(id)}`);
+    }
+    list(query = {}) {
+        return this.#http.request('GET', '/v2/contacts', { query });
+    }
+    all(query = {}) {
+        return paginate(this.#http, '/v2/contacts', query);
+    }
+    update(id, params) {
+        return this.#http.request('PATCH', `/v2/contacts/${segment(id)}`, { body: params });
+    }
+    /** Suppression définitive. Ce n'est pas un désabonnement : pour cela, `consent: 'out'`. */
+    async delete(id) {
+        await this.#http.request('DELETE', `/v2/contacts/${segment(id)}`);
+    }
+}
+exports.Contacts = Contacts;
+class ContactGroups {
+    #http;
+    constructor(http) { this.#http = http; }
+    create(params) {
+        return this.#http.request('POST', '/v2/contact-groups', { body: params });
+    }
+    get(id) {
+        return this.#http.request('GET', `/v2/contact-groups/${segment(id)}`);
+    }
+    list(query = {}) {
+        return this.#http.request('GET', '/v2/contact-groups', { query });
+    }
+    all(query = {}) {
+        return paginate(this.#http, '/v2/contact-groups', query);
+    }
+    update(id, params) {
+        return this.#http.request('PATCH', `/v2/contact-groups/${segment(id)}`, { body: params });
+    }
+    /** Refusé en `409` tant que le groupe contient des contacts. */
+    async delete(id) {
+        await this.#http.request('DELETE', `/v2/contact-groups/${segment(id)}`);
+    }
+}
+exports.ContactGroups = ContactGroups;
+class Account {
+    #http;
+    constructor(http) { this.#http = http; }
+    async balance() {
+        const { balances } = await this.#http.request('GET', '/v2/balance');
+        return balances ?? [];
+    }
+    credits(query = {}) {
+        return this.#http.request('GET', '/v2/credits', { query });
+    }
+    allCredits(query = {}) {
+        return paginate(this.#http, '/v2/credits', query);
+    }
+}
+exports.Account = Account;

package/dist/cjs/types.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Les réponses gardent les noms de champs de l'API. La signature ouverte de chaque
+ * ressource rend disponible un champ ajouté par l'API sans mise à jour du SDK.
+ */
+export interface OpenRecord {
+    [field: string]: unknown;
+}
+export type Channel = 'sms' | 'email' | 'whatsapp' | 'voice';
+export type Consent = 'in' | 'out' | (string & {});
+export interface Page<T> extends OpenRecord {
+    data: T[];
+    has_more: boolean;
+    next_cursor: string | null;
+}
+export interface PageQuery {
+    limit?: number;
+    cursor?: string;
+}
+export interface MessageError extends OpenRecord {
+    code: string;
+    message: string;
+    provider_code: string | null;
+}
+export interface MessageRefund extends OpenRecord {
+    amount: number;
+    currency: string;
+    refunded_at: string;
+}
+export interface FallbackOutcome extends OpenRecord {
+    will_run: boolean;
+    reason: string | null;
+    message: string;
+    requested: Channel[];
+}
+export interface Message extends OpenRecord {
+    id: string;
+    channel: Channel;
+    status: string;
+    to: string;
+    from: string;
+    units: number;
+    price: number | null;
+    currency: string;
+    refund: MessageRefund | null;
+    client_reference: string | null;
+    fallback_of: string | null;
+    fallback?: FallbackOutcome | null;
+    error: MessageError | null;
+    created_at: string;
+    scheduled_at: string | null;
+    sent_at: string | null;
+    delivered_at: string | null;
+}
+interface SendCommon extends OpenRecord {
+    to: string;
+    fallback?: unknown[];
+    callback_url?: string;
+    scheduled_at?: string;
+    client_reference?: string;
+}
+export interface SendSmsParams extends SendCommon {
+    /** Sender ID approuvé : obligatoire, sans repli. */
+    from: string;
+    content: string | OpenRecord;
+}
+export interface EmailContent extends OpenRecord {
+    subject: string;
+    text?: string;
+    html?: string;
+}
+export interface SendEmailParams extends SendCommon {
+    from?: string;
+    content: EmailContent;
+}
+export interface SendMessageParams extends SendCommon {
+    channel: Channel;
+    from?: string;
+    content: unknown;
+}
+export interface SmsBatchLine extends OpenRecord {
+    to: string;
+    content?: string | OpenRecord;
+    from?: string;
+    client_reference?: string;
+    scheduled_at?: string;
+    callback_url?: string;
+}
+export interface SendSmsBatchParams extends OpenRecord {
+    /** De 1 à 500 lignes. */
+    messages: SmsBatchLine[];
+    from?: string;
+    content?: string | OpenRecord;
+    scheduled_at?: string;
+    callback_url?: string;
+}
+export interface BatchLineError extends OpenRecord {
+    index: number;
+    code: string;
+    message: string;
+    param?: string;
+    to?: string;
+}
+export interface SmsBatchResult extends OpenRecord {
+    total: number;
+    accepted: number;
+    rejected: number;
+    data: (Message & {
+        index: number;
+    })[];
+    /** Une entrée par ligne refusée : le reste du lot est bien parti. */
+    errors: BatchLineError[];
+}
+export interface MessageQuery extends PageQuery {
+    channel?: Channel;
+    status?: string;
+    [filter: string]: unknown;
+}
+export interface RequestOtpParams extends OpenRecord {
+    to: string;
+    /** `sms` par défaut. */
+    channel?: Channel;
+    from?: string;
+    length?: number;
+    ttl_seconds?: number;
+    template?: string;
+    client_reference?: string;
+}
+export interface Otp extends OpenRecord {
+    id: string;
+    status: string;
+    attempts_remaining: number;
+}
+export interface ContactFields extends OpenRecord {
+    email?: string;
+    whatsapp?: boolean;
+    consent?: Consent;
+    fields?: string[];
+}
+export interface CreateContactParams extends ContactFields {
+    group_id: string;
+    phone_number: string;
+}
+export interface UpdateContactParams extends OpenRecord {
+    group_id?: string;
+    phone_number?: string;
+    email?: string | null;
+    whatsapp?: boolean;
+    consent?: Consent;
+    fields?: string[];
+}
+export interface CreateContactBatchParams extends OpenRecord {
+    group_id: string;
+    /** De 1 à 500 lignes. */
+    contacts: (ContactFields & {
+        phone_number: string;
+    })[];
+    on_duplicate?: string;
+}
+export interface Contact extends OpenRecord {
+    id: string;
+    group_id: string;
+    phone_number: string;
+    consent: Consent;
+}
+export interface ContactBatchResult extends OpenRecord {
+    created: number;
+    invalid: number;
+}
+export interface ContactQuery extends PageQuery {
+    group_id?: string;
+    consent?: Consent;
+    search?: string;
+}
+export interface CreateContactGroupParams extends OpenRecord {
+    name: string;
+    fields?: string[];
+}
+export interface UpdateContactGroupParams extends OpenRecord {
+    name?: string;
+    fields?: string[];
+}
+export interface ContactGroup extends OpenRecord {
+    id: string;
+    name: string;
+    contacts_count: number;
+    fields: string[];
+}
+export interface Balance extends OpenRecord {
+    channel: Channel;
+    amount: number;
+    currency: string;
+}
+export interface CreditMovement extends OpenRecord {
+    id: string;
+    type: 'credit' | 'debit' | 'refund';
+    channel: Channel;
+    amount: number;
+    currency: string;
+}
+export interface CreditQuery extends PageQuery {
+    type?: 'credit' | 'debit' | 'refund';
+    [filter: string]: unknown;
+}
+export {};

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/webhook.d.ts

@@ -0,0 +1,11 @@
+/** Vérification des rappels reçus sur votre serveur. */
+export declare const Webhook: {
+    /**
+     * Vrai si le rappel vient bien de la plateforme.
+     *
+     * @param rawBody   le corps BRUT, avant tout décodage JSON
+     * @param signature l'en-tête `X-Fastermessage-Signature`
+     * @param secret    le secret généré dans « Intégration & API »
+     */
+    isGenuine(rawBody: string | Uint8Array, signature: string | null | undefined, secret: string): boolean;
+};

package/dist/cjs/webhook.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Webhook = void 0;
+const node_crypto_1 = require("node:crypto");
+/** Vérification des rappels reçus sur votre serveur. */
+exports.Webhook = {
+    /**
+     * Vrai si le rappel vient bien de la plateforme.
+     *
+     * @param rawBody   le corps BRUT, avant tout décodage JSON
+     * @param signature l'en-tête `X-Fastermessage-Signature`
+     * @param secret    le secret généré dans « Intégration & API »
+     */
+    isGenuine(rawBody, signature, secret) {
+        if (typeof signature !== 'string' || !secret)
+            return false;
+        const expected = Buffer.from(`sha256=${(0, node_crypto_1.createHmac)('sha256', secret).update(rawBody).digest('hex')}`);
+        const received = Buffer.from(signature.trim());
+        return expected.length === received.length && (0, node_crypto_1.timingSafeEqual)(expected, received);
+    },
+};

package/dist/esm/client.d.ts

@@ -0,0 +1,34 @@
+import { Account, ContactGroups, Contacts, Email, Messages, OtpResource, Sms } from './resources.js';
+export declare const DEFAULT_BASE_URL = "https://api.fastermessage.com";
+export interface FasterMessageOptions {
+    /** Identifiant d'API, compte débité. */
+    username: string;
+    /** Mot de passe d'API. */
+    password: string;
+    /** Clé `fm_live_…` (réel) ou `fm_test_…` (simulé). */
+    apiKey: string;
+    /** Le domaine d'API de votre marque, le cas échéant. */
+    baseUrl?: string;
+    /** Délai de chaque tentative, en millisecondes. 30 000 par défaut. */
+    timeout?: number;
+    /** Nombre de reprises après la première tentative. 2 par défaut. */
+    maxRetries?: number;
+    /** Remplace `fetch`, par exemple pour passer par un proxy ou pour vos tests. */
+    fetch?: typeof globalThis.fetch;
+    /** Remplace l'attente entre deux reprises, surtout utile dans vos tests. */
+    sleep?: (milliseconds: number) => Promise<void>;
+}
+/** Point d'entrée du SDK. Côté serveur seulement : il porte vos identifiants. */
+export declare class FasterMessage {
+    #private;
+    readonly sms: Sms;
+    readonly email: Email;
+    readonly messages: Messages;
+    readonly otp: OtpResource;
+    readonly contacts: Contacts;
+    readonly contactGroups: ContactGroups;
+    readonly account: Account;
+    constructor(options: FasterMessageOptions);
+    /** Vrai avec une clé de test : messages et OTP simulés, mais contacts et soldes réels. */
+    get testMode(): boolean;
+}

package/dist/esm/client.js

@@ -0,0 +1,68 @@
+import { Requester } from './http.js';
+import { Account, ContactGroups, Contacts, Email, Messages, OtpResource, Sms } from './resources.js';
+export const DEFAULT_BASE_URL = 'https://api.fastermessage.com';
+const LOCAL_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+/** Les identifiants ne partent qu'en https, sauf vers la machine locale. */
+function checkedBaseUrl(value) {
+    const message = 'baseUrl doit être une adresse https, sans identifiants (http seulement vers la machine locale).';
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new TypeError(message);
+    }
+    const allowed = url.protocol === 'https:' || (url.protocol === 'http:' && LOCAL_HOSTS.has(url.hostname));
+    if (!allowed || !url.hostname || url.username || url.password || url.search || url.hash)
+        throw new TypeError(message);
+    return `${url.origin}${url.pathname}`.replace(/\/+$/, '');
+}
+/** Point d'entrée du SDK. Côté serveur seulement : il porte vos identifiants. */
+export class FasterMessage {
+    sms;
+    email;
+    messages;
+    otp;
+    contacts;
+    contactGroups;
+    account;
+    #testMode;
+    constructor(options) {
+        const { username, password, apiKey } = options ?? {};
+        if (!username || !password || !apiKey) {
+            throw new TypeError("L'identifiant, le mot de passe et la clé d'API sont tous obligatoires.");
+        }
+        if ('window' in globalThis && 'document' in globalThis) {
+            throw new Error('Le SDK FasterMessage ne s’utilise pas dans un navigateur : vos identifiants y seraient publics.');
+        }
+        if (!/^[\x21-\x7e]+$/.test(apiKey)) {
+            // Le message ne cite jamais la valeur : il finirait dans vos journaux.
+            throw new TypeError('La clé d’API contient des caractères invalides : vérifiez son copier-coller.');
+        }
+        this.#testMode = apiKey.includes('_test_');
+        const http = new Requester({
+            authorization: `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`,
+            apiKey,
+            baseUrl: checkedBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL),
+            timeout: options.timeout ?? 30_000,
+            maxRetries: Math.max(0, options.maxRetries ?? 2),
+            ...(options.fetch ? { fetch: options.fetch } : {}),
+            ...(options.sleep ? { sleep: options.sleep } : {}),
+        });
+        this.sms = new Sms(http);
+        this.email = new Email(http);
+        this.messages = new Messages(http);
+        this.otp = new OtpResource(http);
+        this.contacts = new Contacts(http);
+        this.contactGroups = new ContactGroups(http);
+        this.account = new Account(http);
+    }
+    /** Vrai avec une clé de test : messages et OTP simulés, mais contacts et soldes réels. */
+    get testMode() {
+        return this.#testMode;
+    }
+    /** Évite d'écrire le moindre détail du client dans un journal par `console.log`. */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return `FasterMessage { testMode: ${this.#testMode} }`;
+    }
+}

package/dist/esm/errors.d.ts

@@ -0,0 +1,59 @@
+/** Toute erreur levée par le SDK. */
+export declare class FasterMessageError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export interface ApiErrorDetails {
+    status: number;
+    code: string;
+    type?: string;
+    param?: string | null;
+    requestId?: string | null;
+    retryAfter?: number | null;
+}
+/**
+ * Refus de l'API. Testez `code`, qui est stable : `message` est un libellé en
+ * anglais, susceptible d'être reformulé.
+ */
+export declare class ApiError extends FasterMessageError {
+    readonly status: number;
+    readonly code: string;
+    readonly type: string;
+    readonly param: string | null;
+    readonly requestId: string | null;
+    readonly retryAfter: number | null;
+    constructor(message: string, details: ApiErrorDetails);
+}
+/** 400 : la requête est à corriger. */
+export declare class InvalidRequestError extends ApiError {
+}
+/** 401 : identifiant, mot de passe ou clé refusés. */
+export declare class AuthenticationError extends ApiError {
+}
+/** 402 : solde insuffisant, le compte débité est à recharger. */
+export declare class InsufficientBalanceError extends ApiError {
+}
+/** 403 : opération interdite à ce compte. */
+export declare class PermissionError extends ApiError {
+}
+/** 404 : ressource introuvable. */
+export declare class NotFoundError extends ApiError {
+}
+/** 409 : conflit, par exemple un groupe non vide ou une clé d'idempotence réutilisée. */
+export declare class ConflictError extends ApiError {
+}
+/** 429 : débit dépassé, voir `retryAfter`. */
+export declare class RateLimitError extends ApiError {
+}
+/** 501 : fonction déclarée au contrat mais pas encore servie. */
+export declare class NotImplementedError extends ApiError {
+}
+/** 5xx : panne côté API. */
+export declare class ServerError extends ApiError {
+}
+/**
+ * Coupure réseau ou délai dépassé. L'appel a pu aboutir : rejouez avec
+ * `idempotencyKey`, jamais avec une nouvelle clé.
+ */
+export declare class ConnectionError extends FasterMessageError {
+    idempotencyKey: string | null;
+}

package/dist/esm/errors.js

@@ -0,0 +1,62 @@
+/** Toute erreur levée par le SDK. */
+export class FasterMessageError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = new.target.name;
+    }
+}
+/**
+ * Refus de l'API. Testez `code`, qui est stable : `message` est un libellé en
+ * anglais, susceptible d'être reformulé.
+ */
+export class ApiError extends FasterMessageError {
+    status;
+    code;
+    type;
+    param;
+    requestId;
+    retryAfter;
+    constructor(message, details) {
+        super(message);
+        this.status = details.status;
+        this.code = details.code;
+        this.type = details.type ?? '';
+        this.param = details.param ?? null;
+        this.requestId = details.requestId ?? null;
+        this.retryAfter = details.retryAfter ?? null;
+    }
+}
+/** 400 : la requête est à corriger. */
+export class InvalidRequestError extends ApiError {
+}
+/** 401 : identifiant, mot de passe ou clé refusés. */
+export class AuthenticationError extends ApiError {
+}
+/** 402 : solde insuffisant, le compte débité est à recharger. */
+export class InsufficientBalanceError extends ApiError {
+}
+/** 403 : opération interdite à ce compte. */
+export class PermissionError extends ApiError {
+}
+/** 404 : ressource introuvable. */
+export class NotFoundError extends ApiError {
+}
+/** 409 : conflit, par exemple un groupe non vide ou une clé d'idempotence réutilisée. */
+export class ConflictError extends ApiError {
+}
+/** 429 : débit dépassé, voir `retryAfter`. */
+export class RateLimitError extends ApiError {
+}
+/** 501 : fonction déclarée au contrat mais pas encore servie. */
+export class NotImplementedError extends ApiError {
+}
+/** 5xx : panne côté API. */
+export class ServerError extends ApiError {
+}
+/**
+ * Coupure réseau ou délai dépassé. L'appel a pu aboutir : rejouez avec
+ * `idempotencyKey`, jamais avec une nouvelle clé.
+ */
+export class ConnectionError extends FasterMessageError {
+    idempotencyKey = null;
+}