@usestatemachines/sdk 0.1.1 → 0.2.0

package/esm/models/connection-secret.js

@@ -5,13 +5,26 @@ import * as z from "zod/v4-mini";
 import { safeParse } from "../lib/schemas.js";
 import * as types from "../types/primitives.js";
 /** @internal */
+export const Native$inboundSchema = z.object({
+    authentication: types.string(),
+    baseUrl: types.string(),
+    credentials: z.record(z.string(), types.string()),
+    key: types.string(),
+    parameters: z.record(z.string(), types.string()),
+});
+export function nativeFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Native$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Native' from JSON`);
+}
+/** @internal */
 export const ConnectionSecret$inboundSchema = z.object({
     actorId: types.string(),
     actorToken: types.string(),
     appKey: types.string(),
+    connectionKey: types.nullable(types.string()),
     environmentId: types.string(),
     environmentToken: types.string(),
     expiresAt: types.date(),
+    native: types.optional(z.lazy(() => Native$inboundSchema)),
 });
 export function connectionSecretFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ConnectionSecret$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ConnectionSecret' from JSON`);

package/esm/models/connection.d.ts

@@ -4,6 +4,15 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { ApiProfile } from "./api-profile.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 import { ReleaseActor } from "./release-actor.js";
+export type Connection1 = {
+    actorId: string;
+    authentication: string;
+    key: string;
+    parameters: {
+        [k: string]: string;
+    };
+    secrets: Array<string>;
+};
 export declare const ConnectionStatus: {
     readonly Starting: "starting";
     readonly Ready: "ready";
@@ -15,11 +24,16 @@ export type Connection = {
     apis: Array<ApiProfile>;
     appKey: string;
     baseUrl: string | null;
+    connections: Array<Connection1>;
+    defaultConnection: string | null;
     environmentId: string;
     expiresAt: Date | null;
     status: ConnectionStatus;
 };
 /** @internal */
+export declare const Connection1$inboundSchema: z.ZodMiniType<Connection1, unknown>;
+export declare function connection1FromJSON(jsonString: string): SafeParseResult<Connection1, SDKValidationError>;
+/** @internal */
 export declare const ConnectionStatus$inboundSchema: z.ZodMiniType<ConnectionStatus, unknown>;
 /** @internal */
 export declare const Connection$inboundSchema: z.ZodMiniType<Connection, unknown>;

package/esm/models/connection.js

@@ -13,6 +13,18 @@ export const ConnectionStatus = {
     Unavailable: "unavailable",
 };
 /** @internal */
+export const Connection1$inboundSchema = z
+    .object({
+    actorId: types.string(),
+    authentication: types.string(),
+    key: types.string(),
+    parameters: z.record(z.string(), types.string()),
+    secrets: z.array(types.string()),
+});
+export function connection1FromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Connection1$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Connection1' from JSON`);
+}
+/** @internal */
 export const ConnectionStatus$inboundSchema = openEnums.inboundSchema(ConnectionStatus);
 /** @internal */
 export const Connection$inboundSchema = z
@@ -21,6 +33,8 @@ export const Connection$inboundSchema = z
     apis: z.array(ApiProfile$inboundSchema),
     appKey: types.string(),
     baseUrl: types.nullable(types.string()),
+    connections: z.array(z.lazy(() => Connection1$inboundSchema)),
+    defaultConnection: types.nullable(types.string()),
     environmentId: types.string(),
     expiresAt: types.nullable(types.date()),
     status: ConnectionStatus$inboundSchema,

package/esm/models/error-response.d.ts

@@ -4,15 +4,19 @@ import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdk-validation-error.js";
 export declare const Code: {
     readonly BodyTooLarge: "body-too-large";
+    readonly ConnectionNotAuthorized: "connection-not-authorized";
     readonly ConnectionUnavailable: "connection-unavailable";
     readonly EnvironmentLimit: "environment-limit";
     readonly Forbidden: "forbidden";
     readonly IdempotencyConflict: "idempotency-conflict";
     readonly IdentityRequestRejected: "identity-request-rejected";
+    readonly InitializationBusy: "initialization-busy";
+    readonly InitializationUnavailable: "initialization-unavailable";
     readonly InternalError: "internal-error";
     readonly InvalidCursor: "invalid-cursor";
     readonly InvalidRequest: "invalid-request";
     readonly InvalidResponse: "invalid-response";
+    readonly InvalidSetup: "invalid-setup";
     readonly InvalidWebhook: "invalid-webhook";
     readonly LastOwner: "last-owner";
     readonly LastWorkspace: "last-workspace";

package/esm/models/error-response.js

@@ -7,15 +7,19 @@ import * as openEnums from "../types/enums.js";
 import * as types from "../types/primitives.js";
 export const Code = {
     BodyTooLarge: "body-too-large",
+    ConnectionNotAuthorized: "connection-not-authorized",
     ConnectionUnavailable: "connection-unavailable",
     EnvironmentLimit: "environment-limit",
     Forbidden: "forbidden",
     IdempotencyConflict: "idempotency-conflict",
     IdentityRequestRejected: "identity-request-rejected",
+    InitializationBusy: "initialization-busy",
+    InitializationUnavailable: "initialization-unavailable",
     InternalError: "internal-error",
     InvalidCursor: "invalid-cursor",
     InvalidRequest: "invalid-request",
     InvalidResponse: "invalid-response",
+    InvalidSetup: "invalid-setup",
     InvalidWebhook: "invalid-webhook",
     LastOwner: "last-owner",
     LastWorkspace: "last-workspace",

package/esm/models/operations/create-environment-definition.d.ts

@@ -0,0 +1,143 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+import * as models from "../index.js";
+export type From = {
+    snapshot: string;
+};
+export type CreateEnvironmentDefinitionRequestBody2 = {
+    from: From;
+    version?: number | undefined;
+};
+export type Apps = {
+    app: string;
+    /**
+     * Native values validated by the selected replica release.
+     */
+    configure?: {
+        [k: string]: any;
+    } | undefined;
+    /**
+     * Native values validated by the selected replica release.
+     */
+    connections?: {
+        [k: string]: any;
+    } | undefined;
+    defaultConnection?: string | undefined;
+    preset?: string | undefined;
+    release?: string | undefined;
+    /**
+     * Native values validated by the selected replica release.
+     */
+    resources?: {
+        [k: string]: any;
+    } | undefined;
+    /**
+     * Native values validated by the selected replica release.
+     */
+    settings?: {
+        [k: string]: any;
+    } | undefined;
+};
+export type AppsUnion = Array<string> | {
+    [k: string]: Apps;
+};
+export type CreateEnvironmentDefinitionRequestBody1 = {
+    apps: Array<string> | {
+        [k: string]: Apps;
+    };
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
+    version?: number | undefined;
+};
+export type CreateEnvironmentDefinitionRequestBody = CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2;
+export type CreateEnvironmentDefinitionRequest = {
+    workspaceId: string;
+    idempotencyKey: string;
+    body: CreateEnvironmentDefinitionRequestBody1 | CreateEnvironmentDefinitionRequestBody2;
+};
+/**
+ * Environment accepted from its setup definition
+ */
+export type CreateEnvironmentDefinitionResponse = {
+    data: models.Environment;
+};
+/** @internal */
+export type From$Outbound = {
+    snapshot: string;
+};
+/** @internal */
+export declare const From$outboundSchema: z.ZodMiniType<From$Outbound, From>;
+export declare function fromToJSON(from: From): string;
+/** @internal */
+export type CreateEnvironmentDefinitionRequestBody2$Outbound = {
+    from: From$Outbound;
+    version: number;
+};
+/** @internal */
+export declare const CreateEnvironmentDefinitionRequestBody2$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequestBody2$Outbound, CreateEnvironmentDefinitionRequestBody2>;
+export declare function createEnvironmentDefinitionRequestBody2ToJSON(createEnvironmentDefinitionRequestBody2: CreateEnvironmentDefinitionRequestBody2): string;
+/** @internal */
+export type Apps$Outbound = {
+    app: string;
+    configure?: {
+        [k: string]: any;
+    } | undefined;
+    connections?: {
+        [k: string]: any;
+    } | undefined;
+    defaultConnection?: string | undefined;
+    preset?: string | undefined;
+    release?: string | undefined;
+    resources?: {
+        [k: string]: any;
+    } | undefined;
+    settings?: {
+        [k: string]: any;
+    } | undefined;
+};
+/** @internal */
+export declare const Apps$outboundSchema: z.ZodMiniType<Apps$Outbound, Apps>;
+export declare function appsToJSON(apps: Apps): string;
+/** @internal */
+export type AppsUnion$Outbound = Array<string> | {
+    [k: string]: Apps$Outbound;
+};
+/** @internal */
+export declare const AppsUnion$outboundSchema: z.ZodMiniType<AppsUnion$Outbound, AppsUnion>;
+export declare function appsUnionToJSON(appsUnion: AppsUnion): string;
+/** @internal */
+export type CreateEnvironmentDefinitionRequestBody1$Outbound = {
+    apps: Array<string> | {
+        [k: string]: Apps$Outbound;
+    };
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
+    version: number;
+};
+/** @internal */
+export declare const CreateEnvironmentDefinitionRequestBody1$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequestBody1$Outbound, CreateEnvironmentDefinitionRequestBody1>;
+export declare function createEnvironmentDefinitionRequestBody1ToJSON(createEnvironmentDefinitionRequestBody1: CreateEnvironmentDefinitionRequestBody1): string;
+/** @internal */
+export type CreateEnvironmentDefinitionRequestBody$Outbound = CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound;
+/** @internal */
+export declare const CreateEnvironmentDefinitionRequestBody$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequestBody$Outbound, CreateEnvironmentDefinitionRequestBody>;
+export declare function createEnvironmentDefinitionRequestBodyToJSON(createEnvironmentDefinitionRequestBody: CreateEnvironmentDefinitionRequestBody): string;
+/** @internal */
+export type CreateEnvironmentDefinitionRequest$Outbound = {
+    workspaceId: string;
+    "idempotency-key": string;
+    body: CreateEnvironmentDefinitionRequestBody1$Outbound | CreateEnvironmentDefinitionRequestBody2$Outbound;
+};
+/** @internal */
+export declare const CreateEnvironmentDefinitionRequest$outboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionRequest$Outbound, CreateEnvironmentDefinitionRequest>;
+export declare function createEnvironmentDefinitionRequestToJSON(createEnvironmentDefinitionRequest: CreateEnvironmentDefinitionRequest): string;
+/** @internal */
+export declare const CreateEnvironmentDefinitionResponse$inboundSchema: z.ZodMiniType<CreateEnvironmentDefinitionResponse, unknown>;
+export declare function createEnvironmentDefinitionResponseFromJSON(jsonString: string): SafeParseResult<CreateEnvironmentDefinitionResponse, SDKValidationError>;

package/esm/models/operations/create-environment-definition.js

@@ -0,0 +1,90 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { smartUnion } from "../../types/smart-union.js";
+import * as models from "../index.js";
+/** @internal */
+export const From$outboundSchema = z.object({
+    snapshot: z.string(),
+});
+export function fromToJSON(from) {
+    return JSON.stringify(From$outboundSchema.parse(from));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionRequestBody2$outboundSchema = z.object({
+    from: z.lazy(() => From$outboundSchema),
+    version: z._default(z.number(), 1),
+});
+export function createEnvironmentDefinitionRequestBody2ToJSON(createEnvironmentDefinitionRequestBody2) {
+    return JSON.stringify(CreateEnvironmentDefinitionRequestBody2$outboundSchema.parse(createEnvironmentDefinitionRequestBody2));
+}
+/** @internal */
+export const Apps$outboundSchema = z.object({
+    app: z.string(),
+    configure: z.optional(z.record(z.string(), z.any())),
+    connections: z.optional(z.record(z.string(), z.any())),
+    defaultConnection: z.optional(z.string()),
+    preset: z.optional(z.string()),
+    release: z.optional(z.string()),
+    resources: z.optional(z.record(z.string(), z.any())),
+    settings: z.optional(z.record(z.string(), z.any())),
+});
+export function appsToJSON(apps) {
+    return JSON.stringify(Apps$outboundSchema.parse(apps));
+}
+/** @internal */
+export const AppsUnion$outboundSchema = smartUnion([
+    z.array(z.string()),
+    z.record(z.string(), z.lazy(() => Apps$outboundSchema)),
+]);
+export function appsUnionToJSON(appsUnion) {
+    return JSON.stringify(AppsUnion$outboundSchema.parse(appsUnion));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionRequestBody1$outboundSchema = z.object({
+    apps: smartUnion([
+        z.array(z.string()),
+        z.record(z.string(), z.lazy(() => Apps$outboundSchema)),
+    ]),
+    labels: z.optional(z.record(z.string(), z.string())),
+    lifetimeMinutes: z.optional(z.int()),
+    name: z.optional(z.string()),
+    version: z._default(z.number(), 1),
+});
+export function createEnvironmentDefinitionRequestBody1ToJSON(createEnvironmentDefinitionRequestBody1) {
+    return JSON.stringify(CreateEnvironmentDefinitionRequestBody1$outboundSchema.parse(createEnvironmentDefinitionRequestBody1));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionRequestBody$outboundSchema = smartUnion([
+    z.lazy(() => CreateEnvironmentDefinitionRequestBody1$outboundSchema),
+    z.lazy(() => CreateEnvironmentDefinitionRequestBody2$outboundSchema),
+]);
+export function createEnvironmentDefinitionRequestBodyToJSON(createEnvironmentDefinitionRequestBody) {
+    return JSON.stringify(CreateEnvironmentDefinitionRequestBody$outboundSchema.parse(createEnvironmentDefinitionRequestBody));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionRequest$outboundSchema = z.pipe(z.object({
+    workspaceId: z.string(),
+    idempotencyKey: z.string(),
+    body: smartUnion([
+        z.lazy(() => CreateEnvironmentDefinitionRequestBody1$outboundSchema),
+        z.lazy(() => CreateEnvironmentDefinitionRequestBody2$outboundSchema),
+    ]),
+}), z.transform((v) => {
+    return remap$(v, {
+        idempotencyKey: "idempotency-key",
+    });
+}));
+export function createEnvironmentDefinitionRequestToJSON(createEnvironmentDefinitionRequest) {
+    return JSON.stringify(CreateEnvironmentDefinitionRequest$outboundSchema.parse(createEnvironmentDefinitionRequest));
+}
+/** @internal */
+export const CreateEnvironmentDefinitionResponse$inboundSchema = z.object({
+    data: models.Environment$inboundSchema,
+});
+export function createEnvironmentDefinitionResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => CreateEnvironmentDefinitionResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CreateEnvironmentDefinitionResponse' from JSON`);
+}

package/esm/models/operations/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./create-environment-definition.js";
 export * from "./create-environments.js";
 export * from "./get-catalog.js";
 export * from "./get-connection.js";

package/esm/models/operations/index.js

@@ -1,6 +1,7 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
+export * from "./create-environment-definition.js";
 export * from "./create-environments.js";
 export * from "./get-catalog.js";
 export * from "./get-connection.js";

package/esm/models/operations/reveal-connection.d.ts

@@ -2,13 +2,18 @@ import * as z from "zod/v4-mini";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdk-validation-error.js";
 import * as models from "../index.js";
-export type RevealConnectionRequestBody = {
+export type RevealConnectionRequestBody3 = {};
+export type RevealConnectionRequestBody2 = {
     actorId: string;
 };
+export type RevealConnectionRequestBody1 = {
+    connectionKey: string;
+};
+export type RevealConnectionRequestBody = RevealConnectionRequestBody1 | RevealConnectionRequestBody2 | RevealConnectionRequestBody3;
 export type RevealConnectionRequest = {
     environmentId: string;
     appKey: string;
-    body: RevealConnectionRequestBody;
+    body: RevealConnectionRequestBody1 | RevealConnectionRequestBody2 | RevealConnectionRequestBody3;
 };
 /**
  * Live credentials for one actor; recorded as an event
@@ -17,17 +22,34 @@ export type RevealConnectionResponse = {
     data: models.ConnectionSecret;
 };
 /** @internal */
-export type RevealConnectionRequestBody$Outbound = {
+export type RevealConnectionRequestBody3$Outbound = {};
+/** @internal */
+export declare const RevealConnectionRequestBody3$outboundSchema: z.ZodMiniType<RevealConnectionRequestBody3$Outbound, RevealConnectionRequestBody3>;
+export declare function revealConnectionRequestBody3ToJSON(revealConnectionRequestBody3: RevealConnectionRequestBody3): string;
+/** @internal */
+export type RevealConnectionRequestBody2$Outbound = {
     actorId: string;
 };
 /** @internal */
+export declare const RevealConnectionRequestBody2$outboundSchema: z.ZodMiniType<RevealConnectionRequestBody2$Outbound, RevealConnectionRequestBody2>;
+export declare function revealConnectionRequestBody2ToJSON(revealConnectionRequestBody2: RevealConnectionRequestBody2): string;
+/** @internal */
+export type RevealConnectionRequestBody1$Outbound = {
+    connectionKey: string;
+};
+/** @internal */
+export declare const RevealConnectionRequestBody1$outboundSchema: z.ZodMiniType<RevealConnectionRequestBody1$Outbound, RevealConnectionRequestBody1>;
+export declare function revealConnectionRequestBody1ToJSON(revealConnectionRequestBody1: RevealConnectionRequestBody1): string;
+/** @internal */
+export type RevealConnectionRequestBody$Outbound = RevealConnectionRequestBody1$Outbound | RevealConnectionRequestBody2$Outbound | RevealConnectionRequestBody3$Outbound;
+/** @internal */
 export declare const RevealConnectionRequestBody$outboundSchema: z.ZodMiniType<RevealConnectionRequestBody$Outbound, RevealConnectionRequestBody>;
 export declare function revealConnectionRequestBodyToJSON(revealConnectionRequestBody: RevealConnectionRequestBody): string;
 /** @internal */
 export type RevealConnectionRequest$Outbound = {
     environmentId: string;
     appKey: string;
-    body: RevealConnectionRequestBody$Outbound;
+    body: RevealConnectionRequestBody1$Outbound | RevealConnectionRequestBody2$Outbound | RevealConnectionRequestBody3$Outbound;
 };
 /** @internal */
 export declare const RevealConnectionRequest$outboundSchema: z.ZodMiniType<RevealConnectionRequest$Outbound, RevealConnectionRequest>;

package/esm/models/operations/reveal-connection.js

@@ -3,11 +3,33 @@
  */
 import * as z from "zod/v4-mini";
 import { safeParse } from "../../lib/schemas.js";
+import { smartUnion } from "../../types/smart-union.js";
 import * as models from "../index.js";
 /** @internal */
-export const RevealConnectionRequestBody$outboundSchema = z.object({
+export const RevealConnectionRequestBody3$outboundSchema = z.object({});
+export function revealConnectionRequestBody3ToJSON(revealConnectionRequestBody3) {
+    return JSON.stringify(RevealConnectionRequestBody3$outboundSchema.parse(revealConnectionRequestBody3));
+}
+/** @internal */
+export const RevealConnectionRequestBody2$outboundSchema = z.object({
     actorId: z.string(),
 });
+export function revealConnectionRequestBody2ToJSON(revealConnectionRequestBody2) {
+    return JSON.stringify(RevealConnectionRequestBody2$outboundSchema.parse(revealConnectionRequestBody2));
+}
+/** @internal */
+export const RevealConnectionRequestBody1$outboundSchema = z.object({
+    connectionKey: z.string(),
+});
+export function revealConnectionRequestBody1ToJSON(revealConnectionRequestBody1) {
+    return JSON.stringify(RevealConnectionRequestBody1$outboundSchema.parse(revealConnectionRequestBody1));
+}
+/** @internal */
+export const RevealConnectionRequestBody$outboundSchema = smartUnion([
+    z.lazy(() => RevealConnectionRequestBody1$outboundSchema),
+    z.lazy(() => RevealConnectionRequestBody2$outboundSchema),
+    z.lazy(() => RevealConnectionRequestBody3$outboundSchema),
+]);
 export function revealConnectionRequestBodyToJSON(revealConnectionRequestBody) {
     return JSON.stringify(RevealConnectionRequestBody$outboundSchema.parse(revealConnectionRequestBody));
 }
@@ -15,7 +37,11 @@ export function revealConnectionRequestBodyToJSON(revealConnectionRequestBody) {
 export const RevealConnectionRequest$outboundSchema = z.object({
     environmentId: z.string(),
     appKey: z.string(),
-    body: z.lazy(() => RevealConnectionRequestBody$outboundSchema),
+    body: smartUnion([
+        z.lazy(() => RevealConnectionRequestBody1$outboundSchema),
+        z.lazy(() => RevealConnectionRequestBody2$outboundSchema),
+        z.lazy(() => RevealConnectionRequestBody3$outboundSchema),
+    ]),
 });
 export function revealConnectionRequestToJSON(revealConnectionRequest) {
     return JSON.stringify(RevealConnectionRequest$outboundSchema.parse(revealConnectionRequest));

package/esm/sdk/sdk.d.ts

@@ -1,4 +1,5 @@
-import { ClientSDK } from "../lib/sdks.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
 import { Catalog } from "./catalog.js";
 import { Credential } from "./credential.js";
 import { Environments } from "./environments.js";
@@ -12,4 +13,5 @@ export declare class StateMachines extends ClientSDK {
     get environments(): Environments;
     private _workspaces?;
     get workspaces(): Workspaces;
+    createEnvironmentDefinition(request: operations.CreateEnvironmentDefinitionRequest, options?: RequestOptions): Promise<operations.CreateEnvironmentDefinitionResponse>;
 }

package/esm/sdk/sdk.js

@@ -1,7 +1,9 @@
 /*
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
+import { createEnvironmentDefinition } from "../funcs/create-environment-definition.js";
 import { ClientSDK } from "../lib/sdks.js";
+import { unwrapAsync } from "../types/fp.js";
 import { Catalog } from "./catalog.js";
 import { Credential } from "./credential.js";
 import { Environments } from "./environments.js";
@@ -23,4 +25,7 @@ export class StateMachines extends ClientSDK {
     get workspaces() {
         return (this._workspaces ?? (this._workspaces = new Workspaces(this._options)));
     }
+    async createEnvironmentDefinition(request, options) {
+        return unwrapAsync(createEnvironmentDefinition(this, request, options));
+    }
 }