@trinsic/api 3.0.1 → 3.1.0-preview1

package/src/apis/SessionsApi.ts

@@ -20,8 +20,6 @@ import type {
   CreateDirectProviderSessionResponse,
   CreateHostedProviderSessionRequest,
   CreateHostedProviderSessionResponse,
-  CreateWidgetSessionRequest,
-  CreateWidgetSessionResponse,
   GetAttachmentRequest,
   GetAttachmentResponse,
   GetSessionResponse,
@@ -49,10 +47,6 @@ import {
     CreateHostedProviderSessionRequestToJSON,
     CreateHostedProviderSessionResponseFromJSON,
     CreateHostedProviderSessionResponseToJSON,
-    CreateWidgetSessionRequestFromJSON,
-    CreateWidgetSessionRequestToJSON,
-    CreateWidgetSessionResponseFromJSON,
-    CreateWidgetSessionResponseToJSON,
     GetAttachmentRequestFromJSON,
     GetAttachmentRequestToJSON,
     GetAttachmentResponseFromJSON,
@@ -97,10 +91,6 @@ export interface CreateHostedProviderSessionOperationRequest {
     createHostedProviderSessionRequest?: CreateHostedProviderSessionRequest;
 }
 
-export interface CreateWidgetSessionOperationRequest {
-    createWidgetSessionRequest?: CreateWidgetSessionRequest;
-}
-
 export interface GetAttachmentOperationRequest {
     sessionId: string;
     attachmentId: string;
@@ -149,6 +139,14 @@ export interface SubmitNativeChallengeResponseOperationRequest {
  * @interface SessionsApiInterface
  */
 export interface SessionsApiInterface {
+    /**
+     * Creates request options for cancelSession without sending the request
+     * @param {string} sessionId 
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    cancelSessionRequestOpts(requestParameters: CancelSessionRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Cancel a Session by its ID
      * @summary Cancel Session
@@ -165,6 +163,14 @@ export interface SessionsApiInterface {
      */
     cancelSession(sessionId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CancelSessionResponse>;
 
+    /**
+     * Creates request options for createDirectProviderSession without sending the request
+     * @param {CreateDirectProviderSessionRequest} [createDirectProviderSessionRequest] 
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    createDirectProviderSessionRequestOpts(requestParameters: CreateDirectProviderSessionOperationRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Verify a user\'s identity with a specific provider, handling additional user interaction in your own UI.   Signal which kinds of user interactions your UI can handle using the `Capabilities` field.   If `FallbackToHostedUi` is `true`, Trinsic\'s hosted UI will automatically be invoked to handle any capabilities you do not support.
      * @summary Create Direct Provider Session
@@ -181,6 +187,14 @@ export interface SessionsApiInterface {
      */
     createDirectProviderSession(createDirectProviderSessionRequest?: CreateDirectProviderSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateDirectProviderSessionResponse>;
 
+    /**
+     * Creates request options for createHostedProviderSession without sending the request
+     * @param {CreateHostedProviderSessionRequest} [createHostedProviderSessionRequest] 
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    createHostedProviderSessionRequestOpts(requestParameters: CreateHostedProviderSessionOperationRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Verify a user\'s identity with a specific provider, using Trinsic-hosted UI for providers which require additional user interaction.
      * @summary Create Hosted Provider Session
@@ -198,20 +212,14 @@ export interface SessionsApiInterface {
     createHostedProviderSession(createHostedProviderSessionRequest?: CreateHostedProviderSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateHostedProviderSessionResponse>;
 
     /**
-     * Verify a user\'s identity using Trinsic\'s hosted Widget flow.
-     * @summary Create Widget Session
-     * @param {CreateWidgetSessionRequest} [createWidgetSessionRequest] 
-     * @param {*} [options] Override http request option.
+     * Creates request options for getAttachment without sending the request
+     * @param {string} sessionId The ID of the Session to fetch the Attachment from
+     * @param {string} attachmentId The ID of the Attachment to fetch
+     * @param {GetAttachmentRequest} [getAttachmentRequest] 
      * @throws {RequiredError}
      * @memberof SessionsApiInterface
      */
-    createWidgetSessionRaw(requestParameters: CreateWidgetSessionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateWidgetSessionResponse>>;
-
-    /**
-     * Verify a user\'s identity using Trinsic\'s hosted Widget flow.
-     * Create Widget Session
-     */
-    createWidgetSession(createWidgetSessionRequest?: CreateWidgetSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateWidgetSessionResponse>;
+    getAttachmentRequestOpts(requestParameters: GetAttachmentOperationRequest): Promise<runtime.RequestOpts>;
 
     /**
      * Fetch an Attachment\'s contents.
@@ -231,6 +239,14 @@ export interface SessionsApiInterface {
      */
     getAttachment(sessionId: string, attachmentId: string, getAttachmentRequest?: GetAttachmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetAttachmentResponse>;
 
+    /**
+     * Creates request options for getSession without sending the request
+     * @param {string} sessionId 
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    getSessionRequestOpts(requestParameters: GetSessionRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Get a Session by its ID
      * @summary Get Session
@@ -247,6 +263,15 @@ export interface SessionsApiInterface {
      */
     getSession(sessionId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetSessionResponse>;
 
+    /**
+     * Creates request options for getSessionResult without sending the request
+     * @param {string} sessionId 
+     * @param {GetSessionResultRequest} [getSessionResultRequest] 
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    getSessionResultRequestOpts(requestParameters: GetSessionResultOperationRequest): Promise<runtime.RequestOpts>;
+
     /**
      * 
      * @summary Get Session Results
@@ -263,6 +288,18 @@ export interface SessionsApiInterface {
      */
     getSessionResult(sessionId: string, getSessionResultRequest?: GetSessionResultRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetSessionResultResponse>;
 
+    /**
+     * Creates request options for listSessions without sending the request
+     * @param {string} verificationProfileId 
+     * @param {SessionOrdering} [orderBy] The field by which sessions should be ordered
+     * @param {OrderDirection} [orderDirection] 
+     * @param {number} [pageSize] The number of items to return per page -- must be between &#x60;1&#x60; and &#x60;50&#x60;
+     * @param {number} [page] The page number to return -- starts at &#x60;1&#x60;
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    listSessionsRequestOpts(requestParameters: ListSessionsRequest): Promise<runtime.RequestOpts>;
+
     /**
      * List Sessions created for a specific Verification Profile
      * @summary List Sessions
@@ -283,6 +320,14 @@ export interface SessionsApiInterface {
      */
     listSessions(verificationProfileId: string, orderBy?: SessionOrdering, orderDirection?: OrderDirection, pageSize?: number, page?: number, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListSessionsResponse>;
 
+    /**
+     * Creates request options for recommendProviders without sending the request
+     * @param {RecommendProvidersRequest} [recommendProvidersRequest] 
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    recommendProvidersRequestOpts(requestParameters: RecommendProvidersOperationRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Recommend providers for a specific user session. You can filter based on health (default=online) and specify country and subdivision information. Trinsic will use the phone number and IP address, if provided, to deduce the country and subdivision of the user and use that info for filtering the providers.
      * @summary Recommend Providers
@@ -299,6 +344,14 @@ export interface SessionsApiInterface {
      */
     recommendProviders(recommendProvidersRequest?: RecommendProvidersRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecommendProvidersResponse>;
 
+    /**
+     * Creates request options for redactSession without sending the request
+     * @param {string} sessionId 
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    redactSessionRequestOpts(requestParameters: RedactSessionRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Redact a Session, removing all identity data from Trinsic\'s servers. Every verification profile has a redaction period that dictates how long we will hold on to your users\' PII data. Once a session falls outside the redaction cutoff date, all PII will automatically be removed from that session. You can utilize this endpoint to redact a session immediately.
      * @summary Redact Session
@@ -315,6 +368,15 @@ export interface SessionsApiInterface {
      */
     redactSession(sessionId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
 
+    /**
+     * Creates request options for refreshStepContent without sending the request
+     * @param {string} sessionId 
+     * @param {RefreshStepContentRequest} [refreshStepContentRequest] 
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    refreshStepContentRequestOpts(requestParameters: RefreshStepContentOperationRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Refreshes the content of a Step for a Direct Provider Session.
      * @summary Refresh Step Content
@@ -332,6 +394,15 @@ export interface SessionsApiInterface {
      */
     refreshStepContent(sessionId: string, refreshStepContentRequest?: RefreshStepContentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RefreshStepContentResponse>;
 
+    /**
+     * Creates request options for submitNativeChallengeResponse without sending the request
+     * @param {string} sessionId 
+     * @param {SubmitNativeChallengeResponseRequest} [submitNativeChallengeResponseRequest] 
+     * @throws {RequiredError}
+     * @memberof SessionsApiInterface
+     */
+    submitNativeChallengeResponseRequestOpts(requestParameters: SubmitNativeChallengeResponseOperationRequest): Promise<runtime.RequestOpts>;
+
     /**
      * Submits the response from a Native Challenge (e.g., mDL exchange via DC API) and processes the results.
      * @summary Submit Native Challenge Response
@@ -357,10 +428,9 @@ export interface SessionsApiInterface {
 export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface {
 
     /**
-     * Cancel a Session by its ID
-     * Cancel Session
+     * Creates request options for cancelSession without sending the request
      */
-    async cancelSessionRaw(requestParameters: CancelSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CancelSessionResponse>> {
+    async cancelSessionRequestOpts(requestParameters: CancelSessionRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['sessionId'] == null) {
             throw new runtime.RequiredError(
                 'sessionId',
@@ -380,12 +450,25 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/{sessionId}/cancel`.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId']))),
+
+        let urlPath = `/api/v1/sessions/{sessionId}/cancel`;
+        urlPath = urlPath.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId'])));
+
+        return {
+            path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Cancel a Session by its ID
+     * Cancel Session
+     */
+    async cancelSessionRaw(requestParameters: CancelSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CancelSessionResponse>> {
+        const requestOptions = await this.cancelSessionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => CancelSessionResponseFromJSON(jsonValue));
     }
@@ -400,10 +483,9 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
     }
 
     /**
-     * Verify a user\'s identity with a specific provider, handling additional user interaction in your own UI.   Signal which kinds of user interactions your UI can handle using the `Capabilities` field.   If `FallbackToHostedUi` is `true`, Trinsic\'s hosted UI will automatically be invoked to handle any capabilities you do not support.
-     * Create Direct Provider Session
+     * Creates request options for createDirectProviderSession without sending the request
      */
-    async createDirectProviderSessionRaw(requestParameters: CreateDirectProviderSessionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateDirectProviderSessionResponse>> {
+    async createDirectProviderSessionRequestOpts(requestParameters: CreateDirectProviderSessionOperationRequest): Promise<runtime.RequestOpts> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -418,13 +500,25 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/provider/direct`,
+
+        let urlPath = `/api/v1/sessions/provider/direct`;
+
+        return {
+            path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: CreateDirectProviderSessionRequestToJSON(requestParameters['createDirectProviderSessionRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Verify a user\'s identity with a specific provider, handling additional user interaction in your own UI.   Signal which kinds of user interactions your UI can handle using the `Capabilities` field.   If `FallbackToHostedUi` is `true`, Trinsic\'s hosted UI will automatically be invoked to handle any capabilities you do not support.
+     * Create Direct Provider Session
+     */
+    async createDirectProviderSessionRaw(requestParameters: CreateDirectProviderSessionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateDirectProviderSessionResponse>> {
+        const requestOptions = await this.createDirectProviderSessionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => CreateDirectProviderSessionResponseFromJSON(jsonValue));
     }
@@ -439,10 +533,9 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
     }
 
     /**
-     * Verify a user\'s identity with a specific provider, using Trinsic-hosted UI for providers which require additional user interaction.
-     * Create Hosted Provider Session
+     * Creates request options for createHostedProviderSession without sending the request
      */
-    async createHostedProviderSessionRaw(requestParameters: CreateHostedProviderSessionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateHostedProviderSessionResponse>> {
+    async createHostedProviderSessionRequestOpts(requestParameters: CreateHostedProviderSessionOperationRequest): Promise<runtime.RequestOpts> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -457,70 +550,42 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/provider/hosted`,
+
+        let urlPath = `/api/v1/sessions/provider/hosted`;
+
+        return {
+            path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: CreateHostedProviderSessionRequestToJSON(requestParameters['createHostedProviderSessionRequest']),
-        }, initOverrides);
-
-        return new runtime.JSONApiResponse(response, (jsonValue) => CreateHostedProviderSessionResponseFromJSON(jsonValue));
+        };
     }
 
     /**
      * Verify a user\'s identity with a specific provider, using Trinsic-hosted UI for providers which require additional user interaction.
      * Create Hosted Provider Session
      */
-    async createHostedProviderSession(createHostedProviderSessionRequest?: CreateHostedProviderSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateHostedProviderSessionResponse> {
-        const response = await this.createHostedProviderSessionRaw({ createHostedProviderSessionRequest: createHostedProviderSessionRequest }, initOverrides);
-        return await response.value();
-    }
-
-    /**
-     * Verify a user\'s identity using Trinsic\'s hosted Widget flow.
-     * Create Widget Session
-     */
-    async createWidgetSessionRaw(requestParameters: CreateWidgetSessionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateWidgetSessionResponse>> {
-        const queryParameters: any = {};
-
-        const headerParameters: runtime.HTTPHeaders = {};
-
-        headerParameters['Content-Type'] = 'application/json';
-
-        if (this.configuration && this.configuration.accessToken) {
-            const token = this.configuration.accessToken;
-            const tokenString = await token("Bearer", []);
-
-            if (tokenString) {
-                headerParameters["Authorization"] = `Bearer ${tokenString}`;
-            }
-        }
-        const response = await this.request({
-            path: `/api/v1/sessions/widget`,
-            method: 'POST',
-            headers: headerParameters,
-            query: queryParameters,
-            body: CreateWidgetSessionRequestToJSON(requestParameters['createWidgetSessionRequest']),
-        }, initOverrides);
+    async createHostedProviderSessionRaw(requestParameters: CreateHostedProviderSessionOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CreateHostedProviderSessionResponse>> {
+        const requestOptions = await this.createHostedProviderSessionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CreateWidgetSessionResponseFromJSON(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => CreateHostedProviderSessionResponseFromJSON(jsonValue));
     }
 
     /**
-     * Verify a user\'s identity using Trinsic\'s hosted Widget flow.
-     * Create Widget Session
+     * Verify a user\'s identity with a specific provider, using Trinsic-hosted UI for providers which require additional user interaction.
+     * Create Hosted Provider Session
      */
-    async createWidgetSession(createWidgetSessionRequest?: CreateWidgetSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateWidgetSessionResponse> {
-        const response = await this.createWidgetSessionRaw({ createWidgetSessionRequest: createWidgetSessionRequest }, initOverrides);
+    async createHostedProviderSession(createHostedProviderSessionRequest?: CreateHostedProviderSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CreateHostedProviderSessionResponse> {
+        const response = await this.createHostedProviderSessionRaw({ createHostedProviderSessionRequest: createHostedProviderSessionRequest }, initOverrides);
         return await response.value();
     }
 
     /**
-     * Fetch an Attachment\'s contents.
-     * Get Attachment
+     * Creates request options for getAttachment without sending the request
      */
-    async getAttachmentRaw(requestParameters: GetAttachmentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetAttachmentResponse>> {
+    async getAttachmentRequestOpts(requestParameters: GetAttachmentOperationRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['sessionId'] == null) {
             throw new runtime.RequiredError(
                 'sessionId',
@@ -549,13 +614,27 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/{sessionId}/attachments/{attachmentId}/get`.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId']))).replace(`{${"attachmentId"}}`, encodeURIComponent(String(requestParameters['attachmentId']))),
+
+        let urlPath = `/api/v1/sessions/{sessionId}/attachments/{attachmentId}/get`;
+        urlPath = urlPath.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId'])));
+        urlPath = urlPath.replace(`{${"attachmentId"}}`, encodeURIComponent(String(requestParameters['attachmentId'])));
+
+        return {
+            path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: GetAttachmentRequestToJSON(requestParameters['getAttachmentRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Fetch an Attachment\'s contents.
+     * Get Attachment
+     */
+    async getAttachmentRaw(requestParameters: GetAttachmentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetAttachmentResponse>> {
+        const requestOptions = await this.getAttachmentRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => GetAttachmentResponseFromJSON(jsonValue));
     }
@@ -570,10 +649,9 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
     }
 
     /**
-     * Get a Session by its ID
-     * Get Session
+     * Creates request options for getSession without sending the request
      */
-    async getSessionRaw(requestParameters: GetSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSessionResponse>> {
+    async getSessionRequestOpts(requestParameters: GetSessionRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['sessionId'] == null) {
             throw new runtime.RequiredError(
                 'sessionId',
@@ -593,12 +671,25 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/{sessionId}`.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId']))),
+
+        let urlPath = `/api/v1/sessions/{sessionId}`;
+        urlPath = urlPath.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId'])));
+
+        return {
+            path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Get a Session by its ID
+     * Get Session
+     */
+    async getSessionRaw(requestParameters: GetSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSessionResponse>> {
+        const requestOptions = await this.getSessionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => GetSessionResponseFromJSON(jsonValue));
     }
@@ -613,9 +704,9 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
     }
 
     /**
-     * Get Session Results
+     * Creates request options for getSessionResult without sending the request
      */
-    async getSessionResultRaw(requestParameters: GetSessionResultOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSessionResultResponse>> {
+    async getSessionResultRequestOpts(requestParameters: GetSessionResultOperationRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['sessionId'] == null) {
             throw new runtime.RequiredError(
                 'sessionId',
@@ -637,13 +728,25 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/{sessionId}/results`.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId']))),
+
+        let urlPath = `/api/v1/sessions/{sessionId}/results`;
+        urlPath = urlPath.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId'])));
+
+        return {
+            path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: GetSessionResultRequestToJSON(requestParameters['getSessionResultRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Get Session Results
+     */
+    async getSessionResultRaw(requestParameters: GetSessionResultOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetSessionResultResponse>> {
+        const requestOptions = await this.getSessionResultRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => GetSessionResultResponseFromJSON(jsonValue));
     }
@@ -657,10 +760,9 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
     }
 
     /**
-     * List Sessions created for a specific Verification Profile
-     * List Sessions
+     * Creates request options for listSessions without sending the request
      */
-    async listSessionsRaw(requestParameters: ListSessionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListSessionsResponse>> {
+    async listSessionsRequestOpts(requestParameters: ListSessionsRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['verificationProfileId'] == null) {
             throw new runtime.RequiredError(
                 'verificationProfileId',
@@ -696,12 +798,25 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/verification-profiles/{verificationProfileId}/sessions`.replace(`{${"verificationProfileId"}}`, encodeURIComponent(String(requestParameters['verificationProfileId']))),
+
+        let urlPath = `/api/v1/verification-profiles/{verificationProfileId}/sessions`;
+        urlPath = urlPath.replace(`{${"verificationProfileId"}}`, encodeURIComponent(String(requestParameters['verificationProfileId'])));
+
+        return {
+            path: urlPath,
             method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * List Sessions created for a specific Verification Profile
+     * List Sessions
+     */
+    async listSessionsRaw(requestParameters: ListSessionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListSessionsResponse>> {
+        const requestOptions = await this.listSessionsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => ListSessionsResponseFromJSON(jsonValue));
     }
@@ -716,10 +831,9 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
     }
 
     /**
-     * Recommend providers for a specific user session. You can filter based on health (default=online) and specify country and subdivision information. Trinsic will use the phone number and IP address, if provided, to deduce the country and subdivision of the user and use that info for filtering the providers.
-     * Recommend Providers
+     * Creates request options for recommendProviders without sending the request
      */
-    async recommendProvidersRaw(requestParameters: RecommendProvidersOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecommendProvidersResponse>> {
+    async recommendProvidersRequestOpts(requestParameters: RecommendProvidersOperationRequest): Promise<runtime.RequestOpts> {
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
@@ -734,13 +848,25 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/providers/recommend`,
+
+        let urlPath = `/api/v1/sessions/providers/recommend`;
+
+        return {
+            path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: RecommendProvidersRequestToJSON(requestParameters['recommendProvidersRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Recommend providers for a specific user session. You can filter based on health (default=online) and specify country and subdivision information. Trinsic will use the phone number and IP address, if provided, to deduce the country and subdivision of the user and use that info for filtering the providers.
+     * Recommend Providers
+     */
+    async recommendProvidersRaw(requestParameters: RecommendProvidersOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecommendProvidersResponse>> {
+        const requestOptions = await this.recommendProvidersRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => RecommendProvidersResponseFromJSON(jsonValue));
     }
@@ -755,10 +881,9 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
     }
 
     /**
-     * Redact a Session, removing all identity data from Trinsic\'s servers. Every verification profile has a redaction period that dictates how long we will hold on to your users\' PII data. Once a session falls outside the redaction cutoff date, all PII will automatically be removed from that session. You can utilize this endpoint to redact a session immediately.
-     * Redact Session
+     * Creates request options for redactSession without sending the request
      */
-    async redactSessionRaw(requestParameters: RedactSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async redactSessionRequestOpts(requestParameters: RedactSessionRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['sessionId'] == null) {
             throw new runtime.RequiredError(
                 'sessionId',
@@ -778,12 +903,25 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/{sessionId}/redact`.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId']))),
+
+        let urlPath = `/api/v1/sessions/{sessionId}/redact`;
+        urlPath = urlPath.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId'])));
+
+        return {
+            path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Redact a Session, removing all identity data from Trinsic\'s servers. Every verification profile has a redaction period that dictates how long we will hold on to your users\' PII data. Once a session falls outside the redaction cutoff date, all PII will automatically be removed from that session. You can utilize this endpoint to redact a session immediately.
+     * Redact Session
+     */
+    async redactSessionRaw(requestParameters: RedactSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.redactSessionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.VoidApiResponse(response);
     }
@@ -797,10 +935,9 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
     }
 
     /**
-     * Refreshes the content of a Step for a Direct Provider Session.
-     * Refresh Step Content
+     * Creates request options for refreshStepContent without sending the request
      */
-    async refreshStepContentRaw(requestParameters: RefreshStepContentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RefreshStepContentResponse>> {
+    async refreshStepContentRequestOpts(requestParameters: RefreshStepContentOperationRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['sessionId'] == null) {
             throw new runtime.RequiredError(
                 'sessionId',
@@ -822,13 +959,26 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/{sessionId}/step/refresh`.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId']))),
+
+        let urlPath = `/api/v1/sessions/{sessionId}/step/refresh`;
+        urlPath = urlPath.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId'])));
+
+        return {
+            path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: RefreshStepContentRequestToJSON(requestParameters['refreshStepContentRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Refreshes the content of a Step for a Direct Provider Session.
+     * Refresh Step Content
+     */
+    async refreshStepContentRaw(requestParameters: RefreshStepContentOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RefreshStepContentResponse>> {
+        const requestOptions = await this.refreshStepContentRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => RefreshStepContentResponseFromJSON(jsonValue));
     }
@@ -843,10 +993,9 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
     }
 
     /**
-     * Submits the response from a Native Challenge (e.g., mDL exchange via DC API) and processes the results.
-     * Submit Native Challenge Response
+     * Creates request options for submitNativeChallengeResponse without sending the request
      */
-    async submitNativeChallengeResponseRaw(requestParameters: SubmitNativeChallengeResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubmitNativeChallengeResponseResponse>> {
+    async submitNativeChallengeResponseRequestOpts(requestParameters: SubmitNativeChallengeResponseOperationRequest): Promise<runtime.RequestOpts> {
         if (requestParameters['sessionId'] == null) {
             throw new runtime.RequiredError(
                 'sessionId',
@@ -868,13 +1017,26 @@ export class SessionsApi extends runtime.BaseAPI implements SessionsApiInterface
                 headerParameters["Authorization"] = `Bearer ${tokenString}`;
             }
         }
-        const response = await this.request({
-            path: `/api/v1/sessions/{sessionId}/native-challenge/submit`.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId']))),
+
+        let urlPath = `/api/v1/sessions/{sessionId}/native-challenge/submit`;
+        urlPath = urlPath.replace(`{${"sessionId"}}`, encodeURIComponent(String(requestParameters['sessionId'])));
+
+        return {
+            path: urlPath,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
             body: SubmitNativeChallengeResponseRequestToJSON(requestParameters['submitNativeChallengeResponseRequest']),
-        }, initOverrides);
+        };
+    }
+
+    /**
+     * Submits the response from a Native Challenge (e.g., mDL exchange via DC API) and processes the results.
+     * Submit Native Challenge Response
+     */
+    async submitNativeChallengeResponseRaw(requestParameters: SubmitNativeChallengeResponseOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SubmitNativeChallengeResponseResponse>> {
+        const requestOptions = await this.submitNativeChallengeResponseRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
 
         return new runtime.JSONApiResponse(response, (jsonValue) => SubmitNativeChallengeResponseResponseFromJSON(jsonValue));
     }