@enfuce/nextgen-sdk 0.0.1

package/dist/oauth/clientCredentials.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clientCredentialsFetcher = clientCredentialsFetcher;
+exports.clientCredentials = clientCredentials;
+/*
+ * Enfuce nextgen SDK — OAuth token-management helper.
+ *
+ * HAND-WRITTEN, NOT GENERATED. This module (src/oauth) is authored by hand and
+ * preserved across SDK regeneration (see scripts/generate.sh). Do not expect
+ * OpenAPI Generator to (re)produce it.
+ */
+const axios_1 = require("axios");
+const tokenManager_1 = require("./tokenManager");
+/**
+ * Builds a {@link TokenFetcher} that performs the OAuth2 `client_credentials`
+ * grant: a form-encoded POST to `config.tokenUrl`, parsing `access_token` and
+ * `expires_in`. Server-side only — never ship a client secret to a browser.
+ */
+function clientCredentialsFetcher(config) {
+    var _a, _b;
+    const http = (_a = config.axiosInstance) !== null && _a !== void 0 ? _a : axios_1.default.create();
+    const style = (_b = config.authStyle) !== null && _b !== void 0 ? _b : 'basic';
+    return () => __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const form = new URLSearchParams();
+        form.set('grant_type', 'client_credentials');
+        if (config.scopes && config.scopes.length > 0) {
+            form.set('scope', config.scopes.join(' '));
+        }
+        for (const [key, value] of Object.entries((_a = config.extraParams) !== null && _a !== void 0 ? _a : {})) {
+            form.set(key, value);
+        }
+        const options = {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        };
+        if (style === 'basic') {
+            options.auth = { username: config.clientId, password: config.clientSecret };
+        }
+        else {
+            form.set('client_id', config.clientId);
+            form.set('client_secret', config.clientSecret);
+        }
+        const response = yield http.post(config.tokenUrl, form.toString(), options);
+        const data = response.data;
+        if (!data || !data.access_token) {
+            throw new Error('token response has no access_token field');
+        }
+        return { accessToken: data.access_token, expiresInSeconds: (_b = data.expires_in) !== null && _b !== void 0 ? _b : 0 };
+    });
+}
+/** Convenience: a caching {@link TokenManager} backed by the client-credentials grant. */
+function clientCredentials(config, skewSeconds = 60) {
+    return new tokenManager_1.TokenManager(clientCredentialsFetcher(config), skewSeconds);
+}

package/dist/oauth/index.d.ts

@@ -0,0 +1,3 @@
+export { AccessToken, TokenFetcher, TokenManager } from './tokenManager';
+export { OAuthConfig, clientCredentials, clientCredentialsFetcher } from './clientCredentials';
+export { createOAuthAxios } from './axios';

package/dist/oauth/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOAuthAxios = exports.clientCredentialsFetcher = exports.clientCredentials = exports.TokenManager = void 0;
+/*
+ * Enfuce nextgen SDK — OAuth token-management helper.
+ *
+ * HAND-WRITTEN, NOT GENERATED. This module (src/oauth) is authored by hand and
+ * preserved across SDK regeneration (see scripts/generate.sh). It is re-exported
+ * from the package barrel as `oauth`:
+ *
+ *   import { oauth, card } from '@enfuce/nextgen-sdk';
+ *
+ *   const tokens = oauth.clientCredentials({
+ *     tokenUrl: 'https://auth.example.com/oauth/token',
+ *     clientId: 'my-id',
+ *     clientSecret: 'my-secret',
+ *     scopes: ['cards:read'],
+ *   });
+ *   const http = oauth.createOAuthAxios(tokens);
+ *   const config = new card.Configuration({ accessToken: () => tokens.getToken() });
+ *   const api = new card.CardApi(config, undefined, http);
+ *
+ * Server-side only — a client secret must never ship to a browser.
+ */
+var tokenManager_1 = require("./tokenManager");
+Object.defineProperty(exports, "TokenManager", { enumerable: true, get: function () { return tokenManager_1.TokenManager; } });
+var clientCredentials_1 = require("./clientCredentials");
+Object.defineProperty(exports, "clientCredentials", { enumerable: true, get: function () { return clientCredentials_1.clientCredentials; } });
+Object.defineProperty(exports, "clientCredentialsFetcher", { enumerable: true, get: function () { return clientCredentials_1.clientCredentialsFetcher; } });
+var axios_1 = require("./axios");
+Object.defineProperty(exports, "createOAuthAxios", { enumerable: true, get: function () { return axios_1.createOAuthAxios; } });

package/dist/oauth/tokenManager.d.ts

@@ -0,0 +1,38 @@
+/** The result of fetching an access token. */
+export interface AccessToken {
+    accessToken: string;
+    /** Lifetime in seconds (OAuth2 `expires_in`); <= 0 means unknown → refetch every call. */
+    expiresInSeconds: number;
+}
+/** Fetches a fresh access token. Supply your own to support any grant/source. */
+export type TokenFetcher = () => Promise<AccessToken>;
+/**
+ * Caches an access token and refreshes it before expiry. Plug it into a generated
+ * client's `Configuration`:
+ *
+ * ```ts
+ * const tokens = new TokenManager(fetcher);
+ * const config = new card.Configuration({ accessToken: () => tokens.getToken() });
+ * ```
+ *
+ * A token is considered expired once the clock passes `expiry - skew`. Concurrent
+ * refreshes share a single in-flight promise, so the token endpoint is hit once.
+ */
+export declare class TokenManager {
+    private readonly fetcher;
+    private readonly skewSeconds;
+    private readonly now;
+    private token?;
+    private expiresAtMs?;
+    private inflight?;
+    constructor(fetcher: TokenFetcher, skewSeconds?: number, now?: () => number);
+    /** Returns a valid access token, refreshing first if necessary. */
+    getToken(): Promise<string>;
+    /**
+     * Forces a refresh. If `staleToken` is given and the cached token has already
+     * changed, returns the current token without refetching — so two concurrent
+     * 401s trigger a single refresh.
+     */
+    forceRefresh(staleToken?: string): Promise<string>;
+    private refresh;
+}

package/dist/oauth/tokenManager.js

@@ -0,0 +1,81 @@
+"use strict";
+/*
+ * Enfuce nextgen SDK — OAuth token-management helper.
+ *
+ * HAND-WRITTEN, NOT GENERATED. This module (src/oauth) is authored by hand and
+ * preserved across SDK regeneration (see scripts/generate.sh). Do not expect
+ * OpenAPI Generator to (re)produce it.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenManager = void 0;
+/**
+ * Caches an access token and refreshes it before expiry. Plug it into a generated
+ * client's `Configuration`:
+ *
+ * ```ts
+ * const tokens = new TokenManager(fetcher);
+ * const config = new card.Configuration({ accessToken: () => tokens.getToken() });
+ * ```
+ *
+ * A token is considered expired once the clock passes `expiry - skew`. Concurrent
+ * refreshes share a single in-flight promise, so the token endpoint is hit once.
+ */
+class TokenManager {
+    constructor(fetcher, skewSeconds = 60, now = Date.now) {
+        this.fetcher = fetcher;
+        this.skewSeconds = skewSeconds;
+        this.now = now;
+    }
+    /** Returns a valid access token, refreshing first if necessary. */
+    getToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.token !== undefined &&
+                this.expiresAtMs !== undefined &&
+                this.now() < this.expiresAtMs - this.skewSeconds * 1000) {
+                return this.token;
+            }
+            return this.refresh();
+        });
+    }
+    /**
+     * Forces a refresh. If `staleToken` is given and the cached token has already
+     * changed, returns the current token without refetching — so two concurrent
+     * 401s trigger a single refresh.
+     */
+    forceRefresh(staleToken) {
+        if (staleToken !== undefined && this.token !== undefined && this.token !== staleToken) {
+            return Promise.resolve(this.token);
+        }
+        return this.refresh();
+    }
+    refresh() {
+        if (this.inflight !== undefined) {
+            return this.inflight;
+        }
+        this.inflight = (() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const fetched = yield this.fetcher();
+                this.token = fetched.accessToken;
+                this.expiresAtMs =
+                    fetched.expiresInSeconds > 0
+                        ? this.now() + fetched.expiresInSeconds * 1000
+                        : undefined;
+                return this.token;
+            }
+            finally {
+                this.inflight = undefined;
+            }
+        }))();
+        return this.inflight;
+    }
+}
+exports.TokenManager = TokenManager;

package/dist/pin/api.d.ts

@@ -0,0 +1,329 @@
+/**
+ * PIN API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { Configuration } from './configuration';
+import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios';
+import type { RequestArgs } from './base';
+import { BaseAPI } from './base';
+/**
+ *
+ * @export
+ * @interface ChangePinRequestBody
+ */
+export interface ChangePinRequestBody {
+    /**
+     * The encrypted PIN block is in ISO Format 1 and is represented in hexadecimal.
+     * @type {string}
+     * @memberof ChangePinRequestBody
+     */
+    'pinBlock': string;
+    /**
+     * Unique identifier of a resource.
+     * @type {string}
+     * @memberof ChangePinRequestBody
+     */
+    'cardId': string;
+    /**
+     * The sequence number of the card version, this value is also known as PSN (pan sequence number)
+     * @type {number}
+     * @memberof ChangePinRequestBody
+     */
+    'sequenceNumber'?: number;
+    /**
+     * Pre-shared ZPK key index number. If it is not specified, the first key is used by default.
+     * @type {number}
+     * @memberof ChangePinRequestBody
+     */
+    'zpkIndex'?: number;
+}
+/**
+ *
+ * @export
+ * @interface ErrorResponse
+ */
+export interface ErrorResponse {
+    /**
+     * The problem type.
+     * @type {string}
+     * @memberof ErrorResponse
+     */
+    'type'?: string;
+    /**
+     * The reason phrase of HttpStatus.
+     * @type {string}
+     * @memberof ErrorResponse
+     */
+    'title'?: string;
+    /**
+     * HTTP problem status.
+     * @type {number}
+     * @memberof ErrorResponse
+     */
+    'status'?: number;
+    /**
+     * The problem detail.
+     * @type {string}
+     * @memberof ErrorResponse
+     */
+    'detail'?: string;
+    /**
+     * The request path.
+     * @type {string}
+     * @memberof ErrorResponse
+     */
+    'instance'?: string;
+    /**
+     * Unique error identifier.
+     * @type {string}
+     * @memberof ErrorResponse
+     */
+    'id'?: string;
+    /**
+     * Date-time when error occurred.
+     * @type {string}
+     * @memberof ErrorResponse
+     */
+    'timestamp'?: string;
+}
+/**
+ *
+ * @export
+ * @interface SetPinRequestBody
+ */
+export interface SetPinRequestBody {
+    /**
+     * The encrypted PIN block is in ISO Format 1 and is represented in hexadecimal.
+     * @type {string}
+     * @memberof SetPinRequestBody
+     */
+    'pinBlock': string;
+    /**
+     * Unique identifier of a resource.
+     * @type {string}
+     * @memberof SetPinRequestBody
+     */
+    'cardId': string;
+    /**
+     * Pre-shared ZPK key index number. If it is not specified, the first key is used by default.
+     * @type {number}
+     * @memberof SetPinRequestBody
+     */
+    'zpkIndex'?: number;
+}
+/**
+ *
+ * @export
+ * @interface ViewPinRequestBody
+ */
+export interface ViewPinRequestBody {
+    /**
+     * Control ID that was returned in the [Request PIN Control Access Token Endpoint](https://nextgen-docs.enfuce.com/api/cards/post-card/create-pin-control-access-token).
+     * @type {string}
+     * @memberof ViewPinRequestBody
+     */
+    'pinControlId': string;
+    /**
+     * RSA 2048 public key in PEM format (X.509 SubjectPublicKeyInfo). The key may contain:   - new lines,   - the PEM headers (\"-----BEGIN PUBLIC KEY-----\" and \"-----END PUBLIC KEY-----\") The key must not contain any spaces.
+     * @type {string}
+     * @memberof ViewPinRequestBody
+     */
+    'pubKey': string;
+}
+/**
+ *
+ * @export
+ * @interface ViewPinResponseBody
+ */
+export interface ViewPinResponseBody {
+    /**
+     * Hex encoded value of the pin block (ISO PIN Block Format 1). It is 3DES (double length key) encrypted with the key from the tzpk field (which is provided in encrypted form).
+     * @type {string}
+     * @memberof ViewPinResponseBody
+     */
+    'pinBlock': string;
+    /**
+     * Terminal Zone PIN Key (TZPK) that decrypts the generated PIN block to retrieve the actual PIN. Hex encoded value, encrypted with the pubKey passed as input. Once decrypted, this is the 3DES key used for decrypting the pin block.
+     * @type {string}
+     * @memberof ViewPinResponseBody
+     */
+    'tzpk': string;
+}
+/**
+ * PINOperationsUsingPKIApi - axios parameter creator
+ * @export
+ */
+export declare const PINOperationsUsingPKIApiAxiosParamCreator: (configuration?: Configuration) => {
+    /**
+     * Send a request to this endpoint to retrieve the card PIN (ISO PIN Block Format 1) encrypted with temporary PIN encryption key (tzpk). The tzpk is encrypted with the provided ephemeral RSA 2048 bit public key. Steps for retrieving the ISO PIN Block Format 1: - Decrypt the tzpk with the RSA private key. Now you have the decrypted 3DES double length key. - Decrypt the PIN block with the decrypted tzpk using 3DES decryption.
+     * @summary Retrieve Encrypted PIN
+     * @param {ViewPinRequestBody} viewPinRequestBody Request payload for successful PIN retrieval.
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    viewPin: (viewPinRequestBody: ViewPinRequestBody, xAuditUser?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+};
+/**
+ * PINOperationsUsingPKIApi - functional programming interface
+ * @export
+ */
+export declare const PINOperationsUsingPKIApiFp: (configuration?: Configuration) => {
+    /**
+     * Send a request to this endpoint to retrieve the card PIN (ISO PIN Block Format 1) encrypted with temporary PIN encryption key (tzpk). The tzpk is encrypted with the provided ephemeral RSA 2048 bit public key. Steps for retrieving the ISO PIN Block Format 1: - Decrypt the tzpk with the RSA private key. Now you have the decrypted 3DES double length key. - Decrypt the PIN block with the decrypted tzpk using 3DES decryption.
+     * @summary Retrieve Encrypted PIN
+     * @param {ViewPinRequestBody} viewPinRequestBody Request payload for successful PIN retrieval.
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    viewPin(viewPinRequestBody: ViewPinRequestBody, xAuditUser?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ViewPinResponseBody>>;
+};
+/**
+ * PINOperationsUsingPKIApi - factory interface
+ * @export
+ */
+export declare const PINOperationsUsingPKIApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
+    /**
+     * Send a request to this endpoint to retrieve the card PIN (ISO PIN Block Format 1) encrypted with temporary PIN encryption key (tzpk). The tzpk is encrypted with the provided ephemeral RSA 2048 bit public key. Steps for retrieving the ISO PIN Block Format 1: - Decrypt the tzpk with the RSA private key. Now you have the decrypted 3DES double length key. - Decrypt the PIN block with the decrypted tzpk using 3DES decryption.
+     * @summary Retrieve Encrypted PIN
+     * @param {ViewPinRequestBody} viewPinRequestBody Request payload for successful PIN retrieval.
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    viewPin(viewPinRequestBody: ViewPinRequestBody, xAuditUser?: string, options?: RawAxiosRequestConfig): AxiosPromise<ViewPinResponseBody>;
+};
+/**
+ * PINOperationsUsingPKIApi - object-oriented interface
+ * @export
+ * @class PINOperationsUsingPKIApi
+ * @extends {BaseAPI}
+ */
+export declare class PINOperationsUsingPKIApi extends BaseAPI {
+    /**
+     * Send a request to this endpoint to retrieve the card PIN (ISO PIN Block Format 1) encrypted with temporary PIN encryption key (tzpk). The tzpk is encrypted with the provided ephemeral RSA 2048 bit public key. Steps for retrieving the ISO PIN Block Format 1: - Decrypt the tzpk with the RSA private key. Now you have the decrypted 3DES double length key. - Decrypt the PIN block with the decrypted tzpk using 3DES decryption.
+     * @summary Retrieve Encrypted PIN
+     * @param {ViewPinRequestBody} viewPinRequestBody Request payload for successful PIN retrieval.
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PINOperationsUsingPKIApi
+     */
+    viewPin(viewPinRequestBody: ViewPinRequestBody, xAuditUser?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ViewPinResponseBody, any, {}>>;
+}
+/**
+ * PINOperationsWithPreSharedKeyApi - axios parameter creator
+ * @export
+ */
+export declare const PINOperationsWithPreSharedKeyApiAxiosParamCreator: (configuration?: Configuration) => {
+    /**
+     * Send a request to this endpoint to change PIN of a specific card version.   <Note><ul><li>Javascript generates an encrypted PIN block in ISO Format 1 from the cardholder-defined PIN. The PIN block is encrypted using a pre-shared double-length 3DES Zone PIN Key (ZPK). If zpkIndex is not specified, the first key is used by default.</li><li>If sequenceNumber is not specified, the latest card version is used by default.</li></ul></Note>
+     * @summary Change PIN
+     * @param {ChangePinRequestBody} changePinRequestBody
+     * @param {string} [xIdempotencyKey]
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    changePin: (changePinRequestBody: ChangePinRequestBody, xIdempotencyKey?: string, xAuditUser?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * Send a request to this endpoint to set PIN for the latest card version.   <Note>Javascript generates an encrypted PIN block in ISO Format 1 from the cardholder-defined PIN. The PIN block is encrypted using a pre-shared double-length 3DES Zone PIN Key (ZPK). If zpkIndex is not specified, the first key is used by default.</Note>
+     * @summary Set PIN
+     * @param {SetPinRequestBody} setPinRequestBody
+     * @param {string} [xIdempotencyKey]
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    setPin: (setPinRequestBody: SetPinRequestBody, xIdempotencyKey?: string, xAuditUser?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+};
+/**
+ * PINOperationsWithPreSharedKeyApi - functional programming interface
+ * @export
+ */
+export declare const PINOperationsWithPreSharedKeyApiFp: (configuration?: Configuration) => {
+    /**
+     * Send a request to this endpoint to change PIN of a specific card version.   <Note><ul><li>Javascript generates an encrypted PIN block in ISO Format 1 from the cardholder-defined PIN. The PIN block is encrypted using a pre-shared double-length 3DES Zone PIN Key (ZPK). If zpkIndex is not specified, the first key is used by default.</li><li>If sequenceNumber is not specified, the latest card version is used by default.</li></ul></Note>
+     * @summary Change PIN
+     * @param {ChangePinRequestBody} changePinRequestBody
+     * @param {string} [xIdempotencyKey]
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    changePin(changePinRequestBody: ChangePinRequestBody, xIdempotencyKey?: string, xAuditUser?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
+    /**
+     * Send a request to this endpoint to set PIN for the latest card version.   <Note>Javascript generates an encrypted PIN block in ISO Format 1 from the cardholder-defined PIN. The PIN block is encrypted using a pre-shared double-length 3DES Zone PIN Key (ZPK). If zpkIndex is not specified, the first key is used by default.</Note>
+     * @summary Set PIN
+     * @param {SetPinRequestBody} setPinRequestBody
+     * @param {string} [xIdempotencyKey]
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    setPin(setPinRequestBody: SetPinRequestBody, xIdempotencyKey?: string, xAuditUser?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
+};
+/**
+ * PINOperationsWithPreSharedKeyApi - factory interface
+ * @export
+ */
+export declare const PINOperationsWithPreSharedKeyApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
+    /**
+     * Send a request to this endpoint to change PIN of a specific card version.   <Note><ul><li>Javascript generates an encrypted PIN block in ISO Format 1 from the cardholder-defined PIN. The PIN block is encrypted using a pre-shared double-length 3DES Zone PIN Key (ZPK). If zpkIndex is not specified, the first key is used by default.</li><li>If sequenceNumber is not specified, the latest card version is used by default.</li></ul></Note>
+     * @summary Change PIN
+     * @param {ChangePinRequestBody} changePinRequestBody
+     * @param {string} [xIdempotencyKey]
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    changePin(changePinRequestBody: ChangePinRequestBody, xIdempotencyKey?: string, xAuditUser?: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
+    /**
+     * Send a request to this endpoint to set PIN for the latest card version.   <Note>Javascript generates an encrypted PIN block in ISO Format 1 from the cardholder-defined PIN. The PIN block is encrypted using a pre-shared double-length 3DES Zone PIN Key (ZPK). If zpkIndex is not specified, the first key is used by default.</Note>
+     * @summary Set PIN
+     * @param {SetPinRequestBody} setPinRequestBody
+     * @param {string} [xIdempotencyKey]
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    setPin(setPinRequestBody: SetPinRequestBody, xIdempotencyKey?: string, xAuditUser?: string, options?: RawAxiosRequestConfig): AxiosPromise<void>;
+};
+/**
+ * PINOperationsWithPreSharedKeyApi - object-oriented interface
+ * @export
+ * @class PINOperationsWithPreSharedKeyApi
+ * @extends {BaseAPI}
+ */
+export declare class PINOperationsWithPreSharedKeyApi extends BaseAPI {
+    /**
+     * Send a request to this endpoint to change PIN of a specific card version.   <Note><ul><li>Javascript generates an encrypted PIN block in ISO Format 1 from the cardholder-defined PIN. The PIN block is encrypted using a pre-shared double-length 3DES Zone PIN Key (ZPK). If zpkIndex is not specified, the first key is used by default.</li><li>If sequenceNumber is not specified, the latest card version is used by default.</li></ul></Note>
+     * @summary Change PIN
+     * @param {ChangePinRequestBody} changePinRequestBody
+     * @param {string} [xIdempotencyKey]
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PINOperationsWithPreSharedKeyApi
+     */
+    changePin(changePinRequestBody: ChangePinRequestBody, xIdempotencyKey?: string, xAuditUser?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any, {}>>;
+    /**
+     * Send a request to this endpoint to set PIN for the latest card version.   <Note>Javascript generates an encrypted PIN block in ISO Format 1 from the cardholder-defined PIN. The PIN block is encrypted using a pre-shared double-length 3DES Zone PIN Key (ZPK). If zpkIndex is not specified, the first key is used by default.</Note>
+     * @summary Set PIN
+     * @param {SetPinRequestBody} setPinRequestBody
+     * @param {string} [xIdempotencyKey]
+     * @param {string} [xAuditUser] Optional audit user header
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof PINOperationsWithPreSharedKeyApi
+     */
+    setPin(setPinRequestBody: SetPinRequestBody, xIdempotencyKey?: string, xAuditUser?: string, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any, {}>>;
+}