@steamsets/client-ts 0.4.0 → 0.5.0

package/src/funcs/settingsAccountV1SettingsVerfyEmail.ts

@@ -20,6 +20,7 @@ import {
 import * as errors from "../models/errors/index.js";
 import { SDKError } from "../models/errors/sdkerror.js";
 import { SDKValidationError } from "../models/errors/sdkvalidationerror.js";
+import * as operations from "../models/operations/index.js";
 import { Result } from "../types/fp.js";
 
 /**
@@ -31,7 +32,7 @@ export async function settingsAccountV1SettingsVerfyEmail(
     options?: RequestOptions
 ): Promise<
     Result<
-        components.V1VerifyEmailResponseBody,
+        operations.AccountV1SettingsVerfyEmailResponse,
         | errors.ErrorModel
         | SDKError
         | SDKValidationError
@@ -105,7 +106,7 @@ export async function settingsAccountV1SettingsVerfyEmail(
     };
 
     const [result$] = await m$.match<
-        components.V1VerifyEmailResponseBody,
+        operations.AccountV1SettingsVerfyEmailResponse,
         | errors.ErrorModel
         | SDKError
         | SDKValidationError
@@ -115,12 +116,14 @@ export async function settingsAccountV1SettingsVerfyEmail(
         | RequestTimeoutError
         | ConnectionError
     >(
-        m$.json(200, components.V1VerifyEmailResponseBody$inboundSchema),
+        m$.json(200, operations.AccountV1SettingsVerfyEmailResponse$inboundSchema, {
+            key: "V1VerifyEmailResponseBody",
+        }),
         m$.jsonErr([404, 422, 429, 500], errors.ErrorModel$inboundSchema, {
             ctype: "application/problem+json",
         }),
         m$.fail(["4XX", "5XX"])
-    )(response, { extraFields: responseFields$ });
+    )(response, request$, { extraFields: responseFields$ });
     if (!result$.ok) {
         return result$;
     }

package/src/lib/config.ts

@@ -52,7 +52,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "1.0.0",
-    sdkVersion: "0.4.0",
+    sdkVersion: "0.5.0",
     genVersion: "2.404.3",
-    userAgent: "speakeasy-sdk/typescript 0.4.0 2.404.3 1.0.0 @steamsets/client-ts",
+    userAgent: "speakeasy-sdk/typescript 0.5.0 2.404.3 1.0.0 @steamsets/client-ts",
 } as const;

package/src/lib/matchers.ts

@@ -143,6 +143,8 @@ export type MatchedValue<Matchers> = Matchers extends Matcher<infer T, any>[] ?
 export type MatchedError<Matchers> = Matchers extends Matcher<any, infer E>[] ? E : never;
 export type MatchFunc<T, E> = (
     response: Response,
+    request: Request,
+
     options?: { resultKey?: string; extraFields?: Record<string, unknown> }
 ) => Promise<[result: Result<T, E>, raw: unknown]>;
 
@@ -151,6 +153,8 @@ export function match<T, E>(
 ): MatchFunc<T, E | SDKError | SDKValidationError> {
     return async function matchFunc(
         response: Response,
+        request: Request,
+
         options?: { resultKey?: string; extraFields?: Record<string, unknown> }
     ): Promise<[result: Result<T, E | SDKError | SDKValidationError>, raw: unknown]> {
         let raw: unknown;
@@ -168,17 +172,16 @@ export function match<T, E>(
         }
 
         if (!matcher) {
-            const responseBody = await response.text();
+            await discardResponseBody(response);
             return [
                 {
                     ok: false,
-                    error: new SDKError(
-                        "Unexpected API response status or content-type",
+                    error: new SDKError("Unexpected API response status or content-type", {
                         response,
-                        responseBody
-                    ),
+                        request,
+                    }),
                 },
-                responseBody,
+                raw,
             ];
         }
 
@@ -203,7 +206,7 @@ export function match<T, E>(
                 raw = await discardResponseBody(response);
                 break;
             case "fail":
-                raw = await response.text();
+                raw = await discardResponseBody(response);
                 break;
             default:
                 encoding satisfies never;
@@ -212,14 +215,7 @@ export function match<T, E>(
 
         if (matcher.enc === "fail") {
             return [
-                {
-                    ok: false,
-                    error: new SDKError(
-                        "API error occurred",
-                        response,
-                        typeof raw === "string" ? raw : ""
-                    ),
-                },
+                { ok: false, error: new SDKError("API error occurred", { response, request }) },
                 raw,
             ];
         }
@@ -239,14 +235,11 @@ export function match<T, E>(
                 ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
                 [resultKey]: raw,
             };
-        } else if (matcher.hdrs) {
+        } else {
             data = {
                 ...options?.extraFields,
                 ...(matcher.hdrs ? { Headers: unpackHeaders(response.headers) } : null),
-                ...(isPlainObject(raw) ? raw : null),
             };
-        } else {
-            data = raw;
         }
 
         if ("err" in matcher) {

package/src/models/components/accountsearchvanitystruct.ts

@@ -21,11 +21,11 @@ export type AccountSearchVanityStruct = {
     /**
      * Which type of vanity to search for
      */
-    type?: Type | undefined;
+    type: Type;
     /**
      * Vanity to search for
      */
-    value?: string | undefined;
+    value: string;
 };
 
 /** @internal */
@@ -51,14 +51,14 @@ export const AccountSearchVanityStruct$inboundSchema: z.ZodType<
     z.ZodTypeDef,
     unknown
 > = z.object({
-    type: Type$inboundSchema.optional(),
-    value: z.string().optional(),
+    type: Type$inboundSchema,
+    value: z.string(),
 });
 
 /** @internal */
 export type AccountSearchVanityStruct$Outbound = {
-    type?: string | undefined;
-    value?: string | undefined;
+    type: string;
+    value: string;
 };
 
 /** @internal */
@@ -67,8 +67,8 @@ export const AccountSearchVanityStruct$outboundSchema: z.ZodType<
     z.ZodTypeDef,
     AccountSearchVanityStruct
 > = z.object({
-    type: Type$outboundSchema.optional(),
-    value: z.string().optional(),
+    type: Type$outboundSchema,
+    value: z.string(),
 });
 
 /**

package/src/models/components/httpmetadata.ts

@@ -0,0 +1,70 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as z from "zod";
+
+export type HTTPMetadata = {
+    /**
+     * Raw HTTP response; suitable for custom response parsing
+     */
+    response: Response;
+    /**
+     * Raw HTTP request; suitable for debugging
+     */
+    request: Request;
+};
+
+/** @internal */
+export const HTTPMetadata$inboundSchema: z.ZodType<HTTPMetadata, z.ZodTypeDef, unknown> = z
+    .object({
+        Response: z.instanceof(Response),
+        Request: z.instanceof(Request),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            Response: "response",
+            Request: "request",
+        });
+    });
+
+/** @internal */
+export type HTTPMetadata$Outbound = {
+    Response: never;
+    Request: never;
+};
+
+/** @internal */
+export const HTTPMetadata$outboundSchema: z.ZodType<
+    HTTPMetadata$Outbound,
+    z.ZodTypeDef,
+    HTTPMetadata
+> = z
+    .object({
+        response: z.instanceof(Response).transform(() => {
+            throw new Error("Response cannot be serialized");
+        }),
+        request: z.instanceof(Request).transform(() => {
+            throw new Error("Response cannot be serialized");
+        }),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            response: "Response",
+            request: "Request",
+        });
+    });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace HTTPMetadata$ {
+    /** @deprecated use `HTTPMetadata$inboundSchema` instead. */
+    export const inboundSchema = HTTPMetadata$inboundSchema;
+    /** @deprecated use `HTTPMetadata$outboundSchema` instead. */
+    export const outboundSchema = HTTPMetadata$outboundSchema;
+    /** @deprecated use `HTTPMetadata$Outbound` instead. */
+    export type Outbound = HTTPMetadata$Outbound;
+}

package/src/models/components/index.ts

@@ -8,6 +8,7 @@ export * from "./accountsearchvanitystruct.js";
 export * from "./connection.js";
 export * from "./emailnotification.js";
 export * from "./errordetail.js";
+export * from "./httpmetadata.js";
 export * from "./image.js";
 export * from "./item.js";
 export * from "./loginrequestbody.js";
@@ -21,6 +22,7 @@ export * from "./v1badge.js";
 export * from "./v1badgesresponsebody.js";
 export * from "./v1connectrequestbody.js";
 export * from "./v1connectresponsebody.js";
+export * from "./v1createsessionbody.js";
 export * from "./v1deleteconnectionrequestbody.js";
 export * from "./v1deleteconnectionresponsebody.js";
 export * from "./v1deleteimagesrequestbody.js";

package/src/models/components/security.ts

@@ -5,23 +5,23 @@
 import * as z from "zod";
 
 export type Security = {
-    session?: string | undefined;
+    session: string;
 };
 
 /** @internal */
 export const Security$inboundSchema: z.ZodType<Security, z.ZodTypeDef, unknown> = z.object({
-    session: z.string().optional(),
+    session: z.string(),
 });
 
 /** @internal */
 export type Security$Outbound = {
-    session?: string | undefined;
+    session: string;
 };
 
 /** @internal */
 export const Security$outboundSchema: z.ZodType<Security$Outbound, z.ZodTypeDef, Security> =
     z.object({
-        session: z.string().optional(),
+        session: z.string(),
     });
 
 /**

package/src/models/components/v1createsessionbody.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as z from "zod";
+
+export type V1CreateSessionBody = {
+    /**
+     * A URL to the JSON Schema for this object.
+     */
+    dollarSchema?: string | undefined;
+    /**
+     * The session id
+     */
+    sessionId: string;
+};
+
+/** @internal */
+export const V1CreateSessionBody$inboundSchema: z.ZodType<
+    V1CreateSessionBody,
+    z.ZodTypeDef,
+    unknown
+> = z
+    .object({
+        $schema: z.string().optional(),
+        sessionId: z.string(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            $schema: "dollarSchema",
+        });
+    });
+
+/** @internal */
+export type V1CreateSessionBody$Outbound = {
+    $schema?: string | undefined;
+    sessionId: string;
+};
+
+/** @internal */
+export const V1CreateSessionBody$outboundSchema: z.ZodType<
+    V1CreateSessionBody$Outbound,
+    z.ZodTypeDef,
+    V1CreateSessionBody
+> = z
+    .object({
+        dollarSchema: z.string().optional(),
+        sessionId: z.string(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            dollarSchema: "$schema",
+        });
+    });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace V1CreateSessionBody$ {
+    /** @deprecated use `V1CreateSessionBody$inboundSchema` instead. */
+    export const inboundSchema = V1CreateSessionBody$inboundSchema;
+    /** @deprecated use `V1CreateSessionBody$outboundSchema` instead. */
+    export const outboundSchema = V1CreateSessionBody$outboundSchema;
+    /** @deprecated use `V1CreateSessionBody$Outbound` instead. */
+    export type Outbound = V1CreateSessionBody$Outbound;
+}

package/src/models/errors/sdkerror.ts

@@ -3,22 +3,18 @@
  */
 
 export class SDKError extends Error {
-    public readonly statusCode: number;
-    public readonly contentType: string;
-
     constructor(
         message: string,
-        public readonly rawResponse: Response,
-        public readonly body: string = ""
+        public readonly httpMeta: {
+            response: Response;
+            request: Request;
+        }
     ) {
-        const statusCode = rawResponse.status;
-        const contentType = rawResponse.headers.get("content-type") || "";
-        const bodyString = body.length > 0 ? `\n${body}` : "";
-
-        super(`${message}: Status ${statusCode} Content-Type ${contentType} Body ${bodyString}`);
-
-        this.statusCode = statusCode;
-        this.contentType = contentType;
+        super(
+            `${message}: Status ${httpMeta.response.status} Content-Type ${
+                httpMeta.response.headers.get("content-type") || ""
+            }`
+        );
 
         this.name = "SDKError";
     }

package/src/models/operations/accountv1connectionconnect.ts

@@ -0,0 +1,68 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as components from "../components/index.js";
+import * as z from "zod";
+
+export type AccountV1ConnectionConnectResponse = {
+    httpMeta: components.HTTPMetadata;
+    /**
+     * OK
+     */
+    v1ConnectResponseBody?: components.V1ConnectResponseBody | undefined;
+};
+
+/** @internal */
+export const AccountV1ConnectionConnectResponse$inboundSchema: z.ZodType<
+    AccountV1ConnectionConnectResponse,
+    z.ZodTypeDef,
+    unknown
+> = z
+    .object({
+        HttpMeta: components.HTTPMetadata$inboundSchema,
+        V1ConnectResponseBody: components.V1ConnectResponseBody$inboundSchema.optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            HttpMeta: "httpMeta",
+            V1ConnectResponseBody: "v1ConnectResponseBody",
+        });
+    });
+
+/** @internal */
+export type AccountV1ConnectionConnectResponse$Outbound = {
+    HttpMeta: components.HTTPMetadata$Outbound;
+    V1ConnectResponseBody?: components.V1ConnectResponseBody$Outbound | undefined;
+};
+
+/** @internal */
+export const AccountV1ConnectionConnectResponse$outboundSchema: z.ZodType<
+    AccountV1ConnectionConnectResponse$Outbound,
+    z.ZodTypeDef,
+    AccountV1ConnectionConnectResponse
+> = z
+    .object({
+        httpMeta: components.HTTPMetadata$outboundSchema,
+        v1ConnectResponseBody: components.V1ConnectResponseBody$outboundSchema.optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            httpMeta: "HttpMeta",
+            v1ConnectResponseBody: "V1ConnectResponseBody",
+        });
+    });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountV1ConnectionConnectResponse$ {
+    /** @deprecated use `AccountV1ConnectionConnectResponse$inboundSchema` instead. */
+    export const inboundSchema = AccountV1ConnectionConnectResponse$inboundSchema;
+    /** @deprecated use `AccountV1ConnectionConnectResponse$outboundSchema` instead. */
+    export const outboundSchema = AccountV1ConnectionConnectResponse$outboundSchema;
+    /** @deprecated use `AccountV1ConnectionConnectResponse$Outbound` instead. */
+    export type Outbound = AccountV1ConnectionConnectResponse$Outbound;
+}

package/src/models/operations/accountv1connectiondeleteconnection.ts

@@ -0,0 +1,70 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as components from "../components/index.js";
+import * as z from "zod";
+
+export type AccountV1ConnectionDeleteConnectionResponse = {
+    httpMeta: components.HTTPMetadata;
+    /**
+     * OK
+     */
+    v1DeleteConnectionResponseBody?: components.V1DeleteConnectionResponseBody | undefined;
+};
+
+/** @internal */
+export const AccountV1ConnectionDeleteConnectionResponse$inboundSchema: z.ZodType<
+    AccountV1ConnectionDeleteConnectionResponse,
+    z.ZodTypeDef,
+    unknown
+> = z
+    .object({
+        HttpMeta: components.HTTPMetadata$inboundSchema,
+        V1DeleteConnectionResponseBody:
+            components.V1DeleteConnectionResponseBody$inboundSchema.optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            HttpMeta: "httpMeta",
+            V1DeleteConnectionResponseBody: "v1DeleteConnectionResponseBody",
+        });
+    });
+
+/** @internal */
+export type AccountV1ConnectionDeleteConnectionResponse$Outbound = {
+    HttpMeta: components.HTTPMetadata$Outbound;
+    V1DeleteConnectionResponseBody?: components.V1DeleteConnectionResponseBody$Outbound | undefined;
+};
+
+/** @internal */
+export const AccountV1ConnectionDeleteConnectionResponse$outboundSchema: z.ZodType<
+    AccountV1ConnectionDeleteConnectionResponse$Outbound,
+    z.ZodTypeDef,
+    AccountV1ConnectionDeleteConnectionResponse
+> = z
+    .object({
+        httpMeta: components.HTTPMetadata$outboundSchema,
+        v1DeleteConnectionResponseBody:
+            components.V1DeleteConnectionResponseBody$outboundSchema.optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            httpMeta: "HttpMeta",
+            v1DeleteConnectionResponseBody: "V1DeleteConnectionResponseBody",
+        });
+    });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountV1ConnectionDeleteConnectionResponse$ {
+    /** @deprecated use `AccountV1ConnectionDeleteConnectionResponse$inboundSchema` instead. */
+    export const inboundSchema = AccountV1ConnectionDeleteConnectionResponse$inboundSchema;
+    /** @deprecated use `AccountV1ConnectionDeleteConnectionResponse$outboundSchema` instead. */
+    export const outboundSchema = AccountV1ConnectionDeleteConnectionResponse$outboundSchema;
+    /** @deprecated use `AccountV1ConnectionDeleteConnectionResponse$Outbound` instead. */
+    export type Outbound = AccountV1ConnectionDeleteConnectionResponse$Outbound;
+}

package/src/models/operations/accountv1connectionupdateconnection.ts

@@ -0,0 +1,70 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as components from "../components/index.js";
+import * as z from "zod";
+
+export type AccountV1ConnectionUpdateConnectionResponse = {
+    httpMeta: components.HTTPMetadata;
+    /**
+     * OK
+     */
+    v1UpdateConnectionResponseBody?: components.V1UpdateConnectionResponseBody | undefined;
+};
+
+/** @internal */
+export const AccountV1ConnectionUpdateConnectionResponse$inboundSchema: z.ZodType<
+    AccountV1ConnectionUpdateConnectionResponse,
+    z.ZodTypeDef,
+    unknown
+> = z
+    .object({
+        HttpMeta: components.HTTPMetadata$inboundSchema,
+        V1UpdateConnectionResponseBody:
+            components.V1UpdateConnectionResponseBody$inboundSchema.optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            HttpMeta: "httpMeta",
+            V1UpdateConnectionResponseBody: "v1UpdateConnectionResponseBody",
+        });
+    });
+
+/** @internal */
+export type AccountV1ConnectionUpdateConnectionResponse$Outbound = {
+    HttpMeta: components.HTTPMetadata$Outbound;
+    V1UpdateConnectionResponseBody?: components.V1UpdateConnectionResponseBody$Outbound | undefined;
+};
+
+/** @internal */
+export const AccountV1ConnectionUpdateConnectionResponse$outboundSchema: z.ZodType<
+    AccountV1ConnectionUpdateConnectionResponse$Outbound,
+    z.ZodTypeDef,
+    AccountV1ConnectionUpdateConnectionResponse
+> = z
+    .object({
+        httpMeta: components.HTTPMetadata$outboundSchema,
+        v1UpdateConnectionResponseBody:
+            components.V1UpdateConnectionResponseBody$outboundSchema.optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            httpMeta: "HttpMeta",
+            v1UpdateConnectionResponseBody: "V1UpdateConnectionResponseBody",
+        });
+    });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountV1ConnectionUpdateConnectionResponse$ {
+    /** @deprecated use `AccountV1ConnectionUpdateConnectionResponse$inboundSchema` instead. */
+    export const inboundSchema = AccountV1ConnectionUpdateConnectionResponse$inboundSchema;
+    /** @deprecated use `AccountV1ConnectionUpdateConnectionResponse$outboundSchema` instead. */
+    export const outboundSchema = AccountV1ConnectionUpdateConnectionResponse$outboundSchema;
+    /** @deprecated use `AccountV1ConnectionUpdateConnectionResponse$Outbound` instead. */
+    export type Outbound = AccountV1ConnectionUpdateConnectionResponse$Outbound;
+}

package/src/models/operations/accountv1connectionverifyconnection.ts

@@ -0,0 +1,70 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as components from "../components/index.js";
+import * as z from "zod";
+
+export type AccountV1ConnectionVerifyConnectionResponse = {
+    httpMeta: components.HTTPMetadata;
+    /**
+     * OK
+     */
+    v1VerifyConnectionResponseBody?: components.V1VerifyConnectionResponseBody | undefined;
+};
+
+/** @internal */
+export const AccountV1ConnectionVerifyConnectionResponse$inboundSchema: z.ZodType<
+    AccountV1ConnectionVerifyConnectionResponse,
+    z.ZodTypeDef,
+    unknown
+> = z
+    .object({
+        HttpMeta: components.HTTPMetadata$inboundSchema,
+        V1VerifyConnectionResponseBody:
+            components.V1VerifyConnectionResponseBody$inboundSchema.optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            HttpMeta: "httpMeta",
+            V1VerifyConnectionResponseBody: "v1VerifyConnectionResponseBody",
+        });
+    });
+
+/** @internal */
+export type AccountV1ConnectionVerifyConnectionResponse$Outbound = {
+    HttpMeta: components.HTTPMetadata$Outbound;
+    V1VerifyConnectionResponseBody?: components.V1VerifyConnectionResponseBody$Outbound | undefined;
+};
+
+/** @internal */
+export const AccountV1ConnectionVerifyConnectionResponse$outboundSchema: z.ZodType<
+    AccountV1ConnectionVerifyConnectionResponse$Outbound,
+    z.ZodTypeDef,
+    AccountV1ConnectionVerifyConnectionResponse
+> = z
+    .object({
+        httpMeta: components.HTTPMetadata$outboundSchema,
+        v1VerifyConnectionResponseBody:
+            components.V1VerifyConnectionResponseBody$outboundSchema.optional(),
+    })
+    .transform((v) => {
+        return remap$(v, {
+            httpMeta: "HttpMeta",
+            v1VerifyConnectionResponseBody: "V1VerifyConnectionResponseBody",
+        });
+    });
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace AccountV1ConnectionVerifyConnectionResponse$ {
+    /** @deprecated use `AccountV1ConnectionVerifyConnectionResponse$inboundSchema` instead. */
+    export const inboundSchema = AccountV1ConnectionVerifyConnectionResponse$inboundSchema;
+    /** @deprecated use `AccountV1ConnectionVerifyConnectionResponse$outboundSchema` instead. */
+    export const outboundSchema = AccountV1ConnectionVerifyConnectionResponse$outboundSchema;
+    /** @deprecated use `AccountV1ConnectionVerifyConnectionResponse$Outbound` instead. */
+    export type Outbound = AccountV1ConnectionVerifyConnectionResponse$Outbound;
+}