@dynamic-labs/sdk-api 0.0.188 → 0.0.190

package/src/apis/SDKApi.cjs

@@ -0,0 +1,1355 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var runtime = require('../runtime.cjs');
+require('../models/AuthModeEnum.cjs');
+require('../models/BillingSubscriptionPlanTypeEnum.cjs');
+require('../models/ChainEnum.cjs');
+require('../models/ChainalysisCheckResultEnum.cjs');
+var ConnectRequest = require('../models/ConnectRequest.cjs');
+require('../models/TimeUnitEnum.cjs');
+require('../models/WalletProviderEnum.cjs');
+require('../models/JwtVerifiedCredentialFormatEnum.cjs');
+require('../models/ProviderEnum.cjs');
+var EmailVerificationCreateRequest = require('../models/EmailVerificationCreateRequest.cjs');
+var EmailVerificationCreateResponse = require('../models/EmailVerificationCreateResponse.cjs');
+var EmailVerificationRetryRequest = require('../models/EmailVerificationRetryRequest.cjs');
+var EmailVerificationVerifyRequest = require('../models/EmailVerificationVerifyRequest.cjs');
+require('../models/EnvironmentEnum.cjs');
+var ProjectSettings = require('../models/ProjectSettings.cjs');
+require('../models/InviteStatusEnum.cjs');
+var JwksResponse = require('../models/JwksResponse.cjs');
+var NetworkConfigurationResponse = require('../models/NetworkConfigurationResponse.cjs');
+require('../models/NextViewEnum.cjs');
+var NonceResponse = require('../models/NonceResponse.cjs');
+var OauthRequest = require('../models/OauthRequest.cjs');
+var PrefetchRequest = require('../models/PrefetchRequest.cjs');
+require('../models/SocialSignInProviderEnum.cjs');
+var PublishEvents = require('../models/PublishEvents.cjs');
+require('../models/PublishEventsEvents.cjs');
+require('../models/RoleEnum.cjs');
+require('../models/SubscriptionAdvancedScopeEnum.cjs');
+require('../models/SubscriptionFreeScopeEnum.cjs');
+var SupportedOnrampsResponse = require('../models/SupportedOnrampsResponse.cjs');
+require('../models/UnprocessableEntityErrorCode.cjs');
+var UpdateSelfResponse = require('../models/UpdateSelfResponse.cjs');
+var UserFields = require('../models/UserFields.cjs');
+require('../models/UserFilterableFieldsEnum.cjs');
+var VerifyRequest = require('../models/VerifyRequest.cjs');
+var VerifyResponse = require('../models/VerifyResponse.cjs');
+var VerifyUnlinkRequest = require('../models/VerifyUnlinkRequest.cjs');
+require('../models/VisitorFilterableFieldsEnum.cjs');
+
+/* tslint:disable */
+/**
+ *
+ */
+class SDKApi extends runtime.BaseAPI {
+    /**
+     * initializes the email verification process
+     */
+    createEmailVerificationRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling createEmailVerification.');
+            }
+            if (requestParameters.emailVerificationCreateRequest === null || requestParameters.emailVerificationCreateRequest === undefined) {
+                throw new runtime.RequiredError('emailVerificationCreateRequest', 'Required parameter requestParameters.emailVerificationCreateRequest was null or undefined when calling createEmailVerification.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/emailVerifications/create`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: EmailVerificationCreateRequest.EmailVerificationCreateRequestToJSON(requestParameters.emailVerificationCreateRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => EmailVerificationCreateResponse.EmailVerificationCreateResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * initializes the email verification process
+     */
+    createEmailVerification(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createEmailVerificationRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    createEmailVerificationOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling createEmailVerificationOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/emailVerifications/create`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    createEmailVerificationOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.createEmailVerificationOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Endpoint to send minimal wallet information for a connect-only or connect-first visitor.
+     */
+    createVisitRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling createVisit.');
+            }
+            if (requestParameters.connectRequest === null || requestParameters.connectRequest === undefined) {
+                throw new runtime.RequiredError('connectRequest', 'Required parameter requestParameters.connectRequest was null or undefined when calling createVisit.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/connect`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: ConnectRequest.ConnectRequestToJSON(requestParameters.connectRequest),
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Endpoint to send minimal wallet information for a connect-only or connect-first visitor.
+     */
+    createVisit(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.createVisitRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     */
+    eventsOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling eventsOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/events`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     */
+    eventsOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.eventsOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Get the environment\'s settings
+     */
+    getEnvironmentSettingsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getEnvironmentSettings.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/settings`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ProjectSettings.ProjectSettingsFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get the environment\'s settings
+     */
+    getEnvironmentSettings(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getEnvironmentSettingsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Find the jwks for the public key for this environment
+     */
+    getJwksByEnvironmentIdRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getJwksByEnvironmentId.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/.well-known/jwks`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => JwksResponse.JwksResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Find the jwks for the public key for this environment
+     */
+    getJwksByEnvironmentId(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getJwksByEnvironmentIdRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Find the configuration for the enabled networks associated to an environment
+     */
+    getNetworksConfigurationByEnvIdRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getNetworksConfigurationByEnvId.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/networks`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(NetworkConfigurationResponse.NetworkConfigurationResponseFromJSON));
+        });
+    }
+    /**
+     * Find the configuration for the enabled networks associated to an environment
+     */
+    getNetworksConfigurationByEnvId(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getNetworksConfigurationByEnvIdRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates a nonce for the authentication flow
+     */
+    getNonceRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getNonce.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/nonce`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => NonceResponse.NonceResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Creates a nonce for the authentication flow
+     */
+    getNonce(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getNonceRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Find the configuration for the enabled onramps associated to an environment
+     */
+    getSupportedOnrampsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getSupportedOnramps.');
+            }
+            if (requestParameters.walletAddress === null || requestParameters.walletAddress === undefined) {
+                throw new runtime.RequiredError('walletAddress', 'Required parameter requestParameters.walletAddress was null or undefined when calling getSupportedOnramps.');
+            }
+            if (requestParameters.chain === null || requestParameters.chain === undefined) {
+                throw new runtime.RequiredError('chain', 'Required parameter requestParameters.chain was null or undefined when calling getSupportedOnramps.');
+            }
+            const queryParameters = {};
+            if (requestParameters.walletAddress !== undefined) {
+                queryParameters['walletAddress'] = requestParameters.walletAddress;
+            }
+            if (requestParameters.chain !== undefined) {
+                queryParameters['chain'] = requestParameters.chain;
+            }
+            if (requestParameters.networkId !== undefined) {
+                queryParameters['networkId'] = requestParameters.networkId;
+            }
+            if (requestParameters.token !== undefined) {
+                queryParameters['token'] = requestParameters.token;
+            }
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/onramps`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => SupportedOnrampsResponse.SupportedOnrampsResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Find the configuration for the enabled onramps associated to an environment
+     */
+    getSupportedOnramps(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getSupportedOnrampsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    jwksOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling jwksOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/.well-known/jwks`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    jwksOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.jwksOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    networksOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling networksOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/networks`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    networksOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.networksOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    nonceOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling nonceOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/nonce`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    nonceOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.nonceOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Get redirect URL for Oauth provider login
+     */
+    oauthLoginRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling oauthLogin.');
+            }
+            if (requestParameters.providerType === null || requestParameters.providerType === undefined) {
+                throw new runtime.RequiredError('providerType', 'Required parameter requestParameters.providerType was null or undefined when calling oauthLogin.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/providers/{providerType}/login`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"providerType"}}`, encodeURIComponent(String(requestParameters.providerType))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Get redirect URL for Oauth provider login
+     */
+    oauthLogin(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.oauthLoginRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    oauthLoginOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling oauthLoginOptions.');
+            }
+            if (requestParameters.providerType === null || requestParameters.providerType === undefined) {
+                throw new runtime.RequiredError('providerType', 'Required parameter requestParameters.providerType was null or undefined when calling oauthLoginOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/providers/{providerType}/login`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"providerType"}}`, encodeURIComponent(String(requestParameters.providerType))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    oauthLoginOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.oauthLoginOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Hacky endpoint to get the code
+     */
+    oauthRedirectCodeRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling oauthRedirectCode.');
+            }
+            if (requestParameters.providerType === null || requestParameters.providerType === undefined) {
+                throw new runtime.RequiredError('providerType', 'Required parameter requestParameters.providerType was null or undefined when calling oauthRedirectCode.');
+            }
+            const queryParameters = {};
+            if (requestParameters.code !== undefined) {
+                queryParameters['code'] = requestParameters.code;
+            }
+            if (requestParameters.scope !== undefined) {
+                queryParameters['scope'] = requestParameters.scope;
+            }
+            if (requestParameters.authuser !== undefined) {
+                queryParameters['authuser'] = requestParameters.authuser;
+            }
+            if (requestParameters.prompt !== undefined) {
+                queryParameters['prompt'] = requestParameters.prompt;
+            }
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/providers/{providerType}/redirect`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"providerType"}}`, encodeURIComponent(String(requestParameters.providerType))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.TextApiResponse(response);
+        });
+    }
+    /**
+     * Hacky endpoint to get the code
+     */
+    oauthRedirectCode(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.oauthRedirectCodeRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    oauthRedirectOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling oauthRedirectOptions.');
+            }
+            if (requestParameters.providerType === null || requestParameters.providerType === undefined) {
+                throw new runtime.RequiredError('providerType', 'Required parameter requestParameters.providerType was null or undefined when calling oauthRedirectOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/providers/{providerType}/redirect`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"providerType"}}`, encodeURIComponent(String(requestParameters.providerType))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    oauthRedirectOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.oauthRedirectOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Standard OAuth verify callback to exchange temproary code for oauth access
+     */
+    oauthVerifyRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling oauthVerify.');
+            }
+            if (requestParameters.providerType === null || requestParameters.providerType === undefined) {
+                throw new runtime.RequiredError('providerType', 'Required parameter requestParameters.providerType was null or undefined when calling oauthVerify.');
+            }
+            if (requestParameters.oauthRequest === null || requestParameters.oauthRequest === undefined) {
+                throw new runtime.RequiredError('oauthRequest', 'Required parameter requestParameters.oauthRequest was null or undefined when calling oauthVerify.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/providers/{providerType}/verify`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"providerType"}}`, encodeURIComponent(String(requestParameters.providerType))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: OauthRequest.OauthRequestToJSON(requestParameters.oauthRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => VerifyResponse.VerifyResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Standard OAuth verify callback to exchange temproary code for oauth access
+     */
+    oauthVerify(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.oauthVerifyRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    oauthVerifyOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling oauthVerifyOptions.');
+            }
+            if (requestParameters.providerType === null || requestParameters.providerType === undefined) {
+                throw new runtime.RequiredError('providerType', 'Required parameter requestParameters.providerType was null or undefined when calling oauthVerifyOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/providers/{providerType}/verify`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"providerType"}}`, encodeURIComponent(String(requestParameters.providerType))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    oauthVerifyOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.oauthVerifyOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    onrampsOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling onrampsOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/onramps`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    onrampsOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.onrampsOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    optionsConnectRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling optionsConnect.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/connect`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    optionsConnect(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.optionsConnectRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Endpoint to send minimal wallet information to the API to prefetch name service information for an address.
+     */
+    prefetchRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling prefetch.');
+            }
+            if (requestParameters.prefetchRequest === null || requestParameters.prefetchRequest === undefined) {
+                throw new runtime.RequiredError('prefetchRequest', 'Required parameter requestParameters.prefetchRequest was null or undefined when calling prefetch.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/prefetch`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PrefetchRequest.PrefetchRequestToJSON(requestParameters.prefetchRequest),
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Endpoint to send minimal wallet information to the API to prefetch name service information for an address.
+     */
+    prefetch(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.prefetchRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Publish events for SDK
+     */
+    publishEventRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling publishEvent.');
+            }
+            if (requestParameters.publishEvents === null || requestParameters.publishEvents === undefined) {
+                throw new runtime.RequiredError('publishEvents', 'Required parameter requestParameters.publishEvents was null or undefined when calling publishEvent.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/events`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PublishEvents.PublishEventsToJSON(requestParameters.publishEvents),
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Publish events for SDK
+     */
+    publishEvent(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.publishEventRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Sends a new code for the email verification flow
+     */
+    retryEmailVerificationRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling retryEmailVerification.');
+            }
+            if (requestParameters.emailVerificationRetryRequest === null || requestParameters.emailVerificationRetryRequest === undefined) {
+                throw new runtime.RequiredError('emailVerificationRetryRequest', 'Required parameter requestParameters.emailVerificationRetryRequest was null or undefined when calling retryEmailVerification.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/emailVerifications/retry`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: EmailVerificationRetryRequest.EmailVerificationRetryRequestToJSON(requestParameters.emailVerificationRetryRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => EmailVerificationCreateResponse.EmailVerificationCreateResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Sends a new code for the email verification flow
+     */
+    retryEmailVerification(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.retryEmailVerificationRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    retryEmailVerificationOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling retryEmailVerificationOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/emailVerifications/retry`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    retryEmailVerificationOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.retryEmailVerificationOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Revoke a session from the SDK environment
+     */
+    revokeSessionRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling revokeSession.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/revoke`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Revoke a session from the SDK environment
+     */
+    revokeSession(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.revokeSessionRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    revokeSessionOptionRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling revokeSessionOption.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/revoke`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    revokeSessionOption(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.revokeSessionOptionRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    settingsOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling settingsOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/settings`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    settingsOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.settingsOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * verify the email and sign in the user
+     */
+    signInWithEmailVerificationRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling signInWithEmailVerification.');
+            }
+            if (requestParameters.emailVerificationVerifyRequest === null || requestParameters.emailVerificationVerifyRequest === undefined) {
+                throw new runtime.RequiredError('emailVerificationVerifyRequest', 'Required parameter requestParameters.emailVerificationVerifyRequest was null or undefined when calling signInWithEmailVerification.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/emailVerifications/signin`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: EmailVerificationVerifyRequest.EmailVerificationVerifyRequestToJSON(requestParameters.emailVerificationVerifyRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => VerifyResponse.VerifyResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * verify the email and sign in the user
+     */
+    signInWithEmailVerification(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.signInWithEmailVerificationRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    signInWithEmailVerificationOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling signInWithEmailVerificationOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/emailVerifications/signin`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    signInWithEmailVerificationOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.signInWithEmailVerificationOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Update the user\'s fields
+     */
+    updateSelfRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling updateSelf.');
+            }
+            if (requestParameters.userFields === null || requestParameters.userFields === undefined) {
+                throw new runtime.RequiredError('userFields', 'Required parameter requestParameters.userFields was null or undefined when calling updateSelf.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: UserFields.UserFieldsToJSON(requestParameters.userFields),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => UpdateSelfResponse.UpdateSelfResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Update the user\'s fields
+     */
+    updateSelf(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.updateSelfRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    usersOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling usersOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    usersOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.usersOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Verifies payload and returns jwt
+     */
+    verifyRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verify.');
+            }
+            if (requestParameters.verifyRequest === null || requestParameters.verifyRequest === undefined) {
+                throw new runtime.RequiredError('verifyRequest', 'Required parameter requestParameters.verifyRequest was null or undefined when calling verify.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/verify`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: VerifyRequest.VerifyRequestToJSON(requestParameters.verifyRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => VerifyResponse.VerifyResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Verifies payload and returns jwt
+     */
+    verify(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.verifyRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * verify the email verification request
+     */
+    verifyEmailVerificationRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyEmailVerification.');
+            }
+            if (requestParameters.emailVerificationVerifyRequest === null || requestParameters.emailVerificationVerifyRequest === undefined) {
+                throw new runtime.RequiredError('emailVerificationVerifyRequest', 'Required parameter requestParameters.emailVerificationVerifyRequest was null or undefined when calling verifyEmailVerification.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/emailVerifications/verify`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: EmailVerificationVerifyRequest.EmailVerificationVerifyRequestToJSON(requestParameters.emailVerificationVerifyRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => UpdateSelfResponse.UpdateSelfResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * verify the email verification request
+     */
+    verifyEmailVerification(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.verifyEmailVerificationRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyEmailVerificationOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyEmailVerificationOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/emailVerifications/verify`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyEmailVerificationOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.verifyEmailVerificationOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Link a wallet to a valid environment user, and return an updated JWT
+     */
+    verifyLinkRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyLink.');
+            }
+            if (requestParameters.verifyRequest === null || requestParameters.verifyRequest === undefined) {
+                throw new runtime.RequiredError('verifyRequest', 'Required parameter requestParameters.verifyRequest was null or undefined when calling verifyLink.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/verify/link`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: VerifyRequest.VerifyRequestToJSON(requestParameters.verifyRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => VerifyResponse.VerifyResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Link a wallet to a valid environment user, and return an updated JWT
+     */
+    verifyLink(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.verifyLinkRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyLinkOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyLinkOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/verify/link`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyLinkOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.verifyLinkOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/verify`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.verifyOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyPrefetchRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyPrefetch.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/prefetch`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyPrefetch(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.verifyPrefetchRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * This is a subsequent call to link a wallet after user has confirmed transfer to the new account
+     */
+    verifyTransferRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyTransfer.');
+            }
+            if (requestParameters.verifyRequest === null || requestParameters.verifyRequest === undefined) {
+                throw new runtime.RequiredError('verifyRequest', 'Required parameter requestParameters.verifyRequest was null or undefined when calling verifyTransfer.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/verify/transfer`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: VerifyRequest.VerifyRequestToJSON(requestParameters.verifyRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => VerifyResponse.VerifyResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * This is a subsequent call to link a wallet after user has confirmed transfer to the new account
+     */
+    verifyTransfer(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.verifyTransferRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyTransferOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyTransferOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/verify/transfer`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyTransferOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.verifyTransferOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Remove a link from to a valid environment user, and return an updated JWT
+     */
+    verifyUnlinkRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyUnlink.');
+            }
+            if (requestParameters.verifyUnlinkRequest === null || requestParameters.verifyUnlinkRequest === undefined) {
+                throw new runtime.RequiredError('verifyUnlinkRequest', 'Required parameter requestParameters.verifyUnlinkRequest was null or undefined when calling verifyUnlink.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/verify/unlink`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: VerifyUnlinkRequest.VerifyUnlinkRequestToJSON(requestParameters.verifyUnlinkRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => VerifyResponse.VerifyResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Remove a link from to a valid environment user, and return an updated JWT
+     */
+    verifyUnlink(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.verifyUnlinkRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyUnlinkOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling verifyUnlinkOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/verify/unlink`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    verifyUnlinkOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.verifyUnlinkOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+}
+
+exports.SDKApi = SDKApi;