@usestatemachines/sdk 0.1.1

package/esm/lib/security.d.ts

@@ -0,0 +1,83 @@
+import * as models from "../models/index.js";
+type OAuth2PasswordFlow = {
+    username: string;
+    password: string;
+    clientID?: string | undefined;
+    clientSecret?: string | undefined;
+    tokenURL: string;
+};
+export declare const SecurityErrorCode: {
+    readonly Incomplete: "incomplete";
+    readonly UnrecognisedSecurityType: "unrecognized_security_type";
+};
+export type SecurityErrorCode = (typeof SecurityErrorCode)[keyof typeof SecurityErrorCode];
+export declare class SecurityError extends Error {
+    code: SecurityErrorCode;
+    constructor(code: SecurityErrorCode, message: string);
+    static incomplete(): SecurityError;
+    static unrecognizedType(type: string): SecurityError;
+}
+export type SecurityState = {
+    basic: {
+        username?: string | undefined;
+        password?: string | undefined;
+    };
+    headers: Record<string, string>;
+    queryParams: Record<string, string>;
+    cookies: Record<string, string>;
+    oauth2: ({
+        type: "password";
+    } & OAuth2PasswordFlow) | {
+        type: "none";
+    };
+};
+type SecurityInputBasic = {
+    type: "http:basic";
+    value: {
+        username?: string | undefined;
+        password?: string | undefined;
+    } | null | undefined;
+};
+type SecurityInputBearer = {
+    type: "http:bearer";
+    value: string | null | undefined;
+    fieldName: string;
+};
+type SecurityInputAPIKey = {
+    type: "apiKey:header" | "apiKey:query" | "apiKey:cookie";
+    value: string | null | undefined;
+    fieldName: string;
+};
+type SecurityInputOIDC = {
+    type: "openIdConnect";
+    value: string | null | undefined;
+    fieldName: string;
+};
+type SecurityInputOAuth2 = {
+    type: "oauth2";
+    value: string | null | undefined;
+    fieldName: string;
+};
+type SecurityInputOAuth2ClientCredentials = {
+    type: "oauth2:client_credentials";
+    value: {
+        clientID?: string | undefined;
+        clientSecret?: string | undefined;
+    } | null | string | undefined;
+    fieldName?: string;
+};
+type SecurityInputOAuth2PasswordCredentials = {
+    type: "oauth2:password";
+    value: string | null | undefined;
+    fieldName?: string;
+};
+type SecurityInputCustom = {
+    type: "http:custom";
+    value: any | null | undefined;
+    fieldName?: string;
+};
+export type SecurityInput = SecurityInputBasic | SecurityInputBearer | SecurityInputAPIKey | SecurityInputOAuth2 | SecurityInputOAuth2ClientCredentials | SecurityInputOAuth2PasswordCredentials | SecurityInputOIDC | SecurityInputCustom;
+export declare function resolveSecurity(...options: SecurityInput[][]): SecurityState | null;
+export declare function resolveGlobalSecurity(security: Partial<models.Security> | null | undefined, allowedFields?: number[]): SecurityState | null;
+export declare function extractSecurity<T extends string | Record<string, unknown>>(sec: T | (() => Promise<T>) | undefined): Promise<T | undefined>;
+export {};

package/esm/lib/security.js

@@ -0,0 +1,145 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+export const SecurityErrorCode = {
+    Incomplete: "incomplete",
+    UnrecognisedSecurityType: "unrecognized_security_type",
+};
+export class SecurityError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SecurityError";
+    }
+    static incomplete() {
+        return new SecurityError(SecurityErrorCode.Incomplete, "Security requirements not met in order to perform the operation");
+    }
+    static unrecognizedType(type) {
+        return new SecurityError(SecurityErrorCode.UnrecognisedSecurityType, `Unrecognised security type: ${type}`);
+    }
+}
+export function resolveSecurity(...options) {
+    const state = {
+        basic: {},
+        headers: {},
+        queryParams: {},
+        cookies: {},
+        oauth2: { type: "none" },
+    };
+    const option = options.find((opts) => {
+        return opts.every((o) => {
+            if (o.value == null) {
+                return false;
+            }
+            else if (o.type === "http:basic") {
+                return o.value.username != null || o.value.password != null;
+            }
+            else if (o.type === "http:custom") {
+                return null;
+            }
+            else if (o.type === "oauth2:password") {
+                return (typeof o.value === "string" && !!o.value);
+            }
+            else if (o.type === "oauth2:client_credentials") {
+                if (typeof o.value == "string") {
+                    return !!o.value;
+                }
+                return o.value.clientID != null || o.value.clientSecret != null;
+            }
+            else if (typeof o.value === "string") {
+                return !!o.value;
+            }
+            else {
+                throw new Error(`Unrecognized security type: ${o.type} (value type: ${typeof o
+                    .value})`);
+            }
+        });
+    });
+    if (option == null) {
+        return null;
+    }
+    option.forEach((spec) => {
+        if (spec.value == null) {
+            return;
+        }
+        const { type } = spec;
+        switch (type) {
+            case "apiKey:header":
+                state.headers[spec.fieldName] = spec.value;
+                break;
+            case "apiKey:query":
+                state.queryParams[spec.fieldName] = spec.value;
+                break;
+            case "apiKey:cookie":
+                state.cookies[spec.fieldName] = spec.value;
+                break;
+            case "http:basic":
+                applyBasic(state, spec);
+                break;
+            case "http:custom":
+                break;
+            case "http:bearer":
+                applyBearer(state, spec);
+                break;
+            case "oauth2":
+                applyBearer(state, spec);
+                break;
+            case "oauth2:password":
+                applyBearer(state, spec);
+                break;
+            case "oauth2:client_credentials":
+                break;
+            case "openIdConnect":
+                applyBearer(state, spec);
+                break;
+            default:
+                throw SecurityError.unrecognizedType((spec, type));
+        }
+    });
+    return state;
+}
+function applyBasic(state, spec) {
+    if (spec.value == null) {
+        return;
+    }
+    state.basic = spec.value;
+}
+function applyBearer(state, spec) {
+    if (typeof spec.value !== "string" || !spec.value) {
+        return;
+    }
+    let value = spec.value;
+    if (value.slice(0, 7).toLowerCase() !== "bearer ") {
+        value = `Bearer ${value}`;
+    }
+    if (spec.fieldName !== undefined) {
+        state.headers[spec.fieldName] = value;
+    }
+}
+export function resolveGlobalSecurity(security, allowedFields) {
+    let inputs = [
+        [
+            {
+                fieldName: "Authorization",
+                type: "http:bearer",
+                value: security?.apiKey,
+            },
+        ],
+    ];
+    if (allowedFields) {
+        inputs = allowedFields.map((i) => {
+            if (i < 0 || i >= inputs.length) {
+                throw new RangeError(`invalid allowedFields index ${i}`);
+            }
+            return inputs[i];
+        });
+    }
+    return resolveSecurity(...inputs);
+}
+export async function extractSecurity(sec) {
+    if (sec == null) {
+        return;
+    }
+    return typeof sec === "function" ? sec() : sec;
+}

package/esm/lib/url.d.ts

@@ -0,0 +1,4 @@
+export type Params = Partial<Record<string, string | number>>;
+export declare function pathToFunc(pathPattern: string, options?: {
+    charEncoding?: "percent" | "none";
+}): (params?: Params) => string;

package/esm/lib/url.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+const hasOwn = Object.prototype.hasOwnProperty;
+export function pathToFunc(pathPattern, options) {
+    const paramRE = /\{([a-zA-Z0-9_][a-zA-Z0-9_-]*?)\}/g;
+    return function buildURLPath(params = {}) {
+        return pathPattern
+            .replace(paramRE, function (_, placeholder) {
+            if (!hasOwn.call(params, placeholder)) {
+                throw new Error(`Parameter '${placeholder}' is required`);
+            }
+            const value = params[placeholder];
+            if (typeof value !== "string" && typeof value !== "number") {
+                throw new Error(`Parameter '${placeholder}' must be a string or number`);
+            }
+            return options?.charEncoding === "percent"
+                ? encodeURIComponent(`${value}`)
+                : `${value}`;
+        })
+            .replace(/^\/+/, "");
+    };
+}

package/esm/models/actor.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { CredentialKind } from "./credential-kind.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type Actor = {
+    id: string;
+    kind: CredentialKind;
+    name: string | null;
+};
+/** @internal */
+export declare const Actor$inboundSchema: z.ZodMiniType<Actor, unknown>;
+export declare function actorFromJSON(jsonString: string): SafeParseResult<Actor, SDKValidationError>;

package/esm/models/actor.js

@@ -0,0 +1,16 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as types from "../types/primitives.js";
+import { CredentialKind$inboundSchema, } from "./credential-kind.js";
+/** @internal */
+export const Actor$inboundSchema = z.object({
+    id: types.string(),
+    kind: CredentialKind$inboundSchema,
+    name: types.nullable(types.string()),
+});
+export function actorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Actor$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Actor' from JSON`);
+}

package/esm/models/api-profile.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type ApiProfile = {
+    actorHeader: string;
+    actorVariable: string;
+    id: string;
+    interactive: boolean;
+    limitations: Array<string>;
+    name: string;
+    pathTemplate: string;
+    requestContentType: string;
+    versions: Array<string>;
+};
+/** @internal */
+export declare const ApiProfile$inboundSchema: z.ZodMiniType<ApiProfile, unknown>;
+export declare function apiProfileFromJSON(jsonString: string): SafeParseResult<ApiProfile, SDKValidationError>;

package/esm/models/api-profile.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as types from "../types/primitives.js";
+/** @internal */
+export const ApiProfile$inboundSchema = z
+    .object({
+    actorHeader: types.string(),
+    actorVariable: types.string(),
+    id: types.string(),
+    interactive: types.boolean(),
+    limitations: z.array(types.string()),
+    name: types.string(),
+    pathTemplate: types.string(),
+    requestContentType: types.string(),
+    versions: z.array(types.string()),
+});
+export function apiProfileFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ApiProfile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ApiProfile' from JSON`);
+}

package/esm/models/app.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type App = {
+    defaultReleaseId: string | null;
+    description: string;
+    id: string;
+    logoPath: string;
+    name: string;
+    vendor: string;
+};
+/** @internal */
+export declare const App$inboundSchema: z.ZodMiniType<App, unknown>;
+export declare function appFromJSON(jsonString: string): SafeParseResult<App, SDKValidationError>;

package/esm/models/app.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as types from "../types/primitives.js";
+/** @internal */
+export const App$inboundSchema = z.object({
+    defaultReleaseId: types.nullable(types.string()),
+    description: types.string(),
+    id: types.string(),
+    logoPath: types.string(),
+    name: types.string(),
+    vendor: types.string(),
+});
+export function appFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => App$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'App' from JSON`);
+}

package/esm/models/catalog.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { App } from "./app.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+import { Release } from "./release.js";
+export type Catalog = {
+    apps: Array<App>;
+    releases: Array<Release>;
+};
+/** @internal */
+export declare const Catalog$inboundSchema: z.ZodMiniType<Catalog, unknown>;
+export declare function catalogFromJSON(jsonString: string): SafeParseResult<Catalog, SDKValidationError>;

package/esm/models/catalog.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import { App$inboundSchema } from "./app.js";
+import { Release$inboundSchema } from "./release.js";
+/** @internal */
+export const Catalog$inboundSchema = z.object({
+    apps: z.array(App$inboundSchema),
+    releases: z.array(Release$inboundSchema),
+});
+export function catalogFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Catalog$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Catalog' from JSON`);
+}

package/esm/models/connection-secret.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4-mini";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type ConnectionSecret = {
+    actorId: string;
+    actorToken: string;
+    appKey: string;
+    environmentId: string;
+    environmentToken: string;
+    expiresAt: Date;
+};
+/** @internal */
+export declare const ConnectionSecret$inboundSchema: z.ZodMiniType<ConnectionSecret, unknown>;
+export declare function connectionSecretFromJSON(jsonString: string): SafeParseResult<ConnectionSecret, SDKValidationError>;

package/esm/models/connection-secret.js

@@ -0,0 +1,18 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as types from "../types/primitives.js";
+/** @internal */
+export const ConnectionSecret$inboundSchema = z.object({
+    actorId: types.string(),
+    actorToken: types.string(),
+    appKey: types.string(),
+    environmentId: types.string(),
+    environmentToken: types.string(),
+    expiresAt: types.date(),
+});
+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

@@ -0,0 +1,26 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+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 declare const ConnectionStatus: {
+    readonly Starting: "starting";
+    readonly Ready: "ready";
+    readonly Unavailable: "unavailable";
+};
+export type ConnectionStatus = OpenEnum<typeof ConnectionStatus>;
+export type Connection = {
+    actors: Array<ReleaseActor>;
+    apis: Array<ApiProfile>;
+    appKey: string;
+    baseUrl: string | null;
+    environmentId: string;
+    expiresAt: Date | null;
+    status: ConnectionStatus;
+};
+/** @internal */
+export declare const ConnectionStatus$inboundSchema: z.ZodMiniType<ConnectionStatus, unknown>;
+/** @internal */
+export declare const Connection$inboundSchema: z.ZodMiniType<Connection, unknown>;
+export declare function connectionFromJSON(jsonString: string): SafeParseResult<Connection, SDKValidationError>;

package/esm/models/connection.js

@@ -0,0 +1,30 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import * as types from "../types/primitives.js";
+import { ApiProfile$inboundSchema } from "./api-profile.js";
+import { ReleaseActor$inboundSchema } from "./release-actor.js";
+export const ConnectionStatus = {
+    Starting: "starting",
+    Ready: "ready",
+    Unavailable: "unavailable",
+};
+/** @internal */
+export const ConnectionStatus$inboundSchema = openEnums.inboundSchema(ConnectionStatus);
+/** @internal */
+export const Connection$inboundSchema = z
+    .object({
+    actors: z.array(ReleaseActor$inboundSchema),
+    apis: z.array(ApiProfile$inboundSchema),
+    appKey: types.string(),
+    baseUrl: types.nullable(types.string()),
+    environmentId: types.string(),
+    expiresAt: types.nullable(types.date()),
+    status: ConnectionStatus$inboundSchema,
+});
+export function connectionFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Connection$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Connection' from JSON`);
+}

package/esm/models/create-environment-input.d.ts

@@ -0,0 +1,35 @@
+import * as z from "zod/v4-mini";
+export type CreateEnvironmentInputApp = {
+    appId: string;
+    appReleaseId?: string | undefined;
+    key: string;
+};
+export type CreateEnvironmentInput = {
+    apps: Array<CreateEnvironmentInputApp>;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export type CreateEnvironmentInputApp$Outbound = {
+    appId: string;
+    appReleaseId?: string | undefined;
+    key: string;
+};
+/** @internal */
+export declare const CreateEnvironmentInputApp$outboundSchema: z.ZodMiniType<CreateEnvironmentInputApp$Outbound, CreateEnvironmentInputApp>;
+export declare function createEnvironmentInputAppToJSON(createEnvironmentInputApp: CreateEnvironmentInputApp): string;
+/** @internal */
+export type CreateEnvironmentInput$Outbound = {
+    apps: Array<CreateEnvironmentInputApp$Outbound>;
+    labels?: {
+        [k: string]: string;
+    } | undefined;
+    lifetimeMinutes?: number | undefined;
+    name?: string | undefined;
+};
+/** @internal */
+export declare const CreateEnvironmentInput$outboundSchema: z.ZodMiniType<CreateEnvironmentInput$Outbound, CreateEnvironmentInput>;
+export declare function createEnvironmentInputToJSON(createEnvironmentInput: CreateEnvironmentInput): string;

package/esm/models/create-environment-input.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+/** @internal */
+export const CreateEnvironmentInputApp$outboundSchema = z.object({
+    appId: z.string(),
+    appReleaseId: z.optional(z.string()),
+    key: z.string(),
+});
+export function createEnvironmentInputAppToJSON(createEnvironmentInputApp) {
+    return JSON.stringify(CreateEnvironmentInputApp$outboundSchema.parse(createEnvironmentInputApp));
+}
+/** @internal */
+export const CreateEnvironmentInput$outboundSchema = z.object({
+    apps: z.array(z.lazy(() => CreateEnvironmentInputApp$outboundSchema)),
+    labels: z.optional(z.record(z.string(), z.string())),
+    lifetimeMinutes: z.optional(z.int()),
+    name: z.optional(z.string()),
+});
+export function createEnvironmentInputToJSON(createEnvironmentInput) {
+    return JSON.stringify(CreateEnvironmentInput$outboundSchema.parse(createEnvironmentInput));
+}

package/esm/models/credential-kind.d.ts

@@ -0,0 +1,9 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+export declare const CredentialKind: {
+    readonly User: "user";
+    readonly ApiKey: "api_key";
+};
+export type CredentialKind = OpenEnum<typeof CredentialKind>;
+/** @internal */
+export declare const CredentialKind$inboundSchema: z.ZodMiniType<CredentialKind, unknown>;

package/esm/models/credential-kind.js

@@ -0,0 +1,10 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as openEnums from "../types/enums.js";
+export const CredentialKind = {
+    User: "user",
+    ApiKey: "api_key",
+};
+/** @internal */
+export const CredentialKind$inboundSchema = openEnums.inboundSchema(CredentialKind);

package/esm/models/credential.d.ts

@@ -0,0 +1,48 @@
+import * as z from "zod/v4-mini";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { CredentialKind } from "./credential-kind.js";
+import { EnvironmentLifetime } from "./environment-lifetime.js";
+import { SDKValidationError } from "./errors/sdk-validation-error.js";
+export type Limits = {
+    environmentLifetime: EnvironmentLifetime;
+    /**
+     * How many environments the organization may run at once; null when there is no organization or it is not known yet. Never means unlimited.
+     */
+    liveEnvironments: number | null;
+};
+export declare const Permission: {
+    readonly EnvironmentsRead: "environments:read";
+    readonly EnvironmentsCreate: "environments:create";
+    readonly EnvironmentsUpdate: "environments:update";
+    readonly EnvironmentsStop: "environments:stop";
+    readonly ConnectionsReveal: "connections:reveal";
+    readonly SnapshotsRead: "snapshots:read";
+    readonly SnapshotsCreate: "snapshots:create";
+    readonly SnapshotsDelete: "snapshots:delete";
+    readonly WorkspacesManage: "workspaces:manage";
+    readonly ApiKeysManage: "api_keys:manage";
+    readonly MembersManage: "members:manage";
+};
+export type Permission = OpenEnum<typeof Permission>;
+export type Credential = {
+    kind: CredentialKind;
+    limits: Limits;
+    /**
+     * The organization the credential acts in; null for a user without an organization.
+     */
+    organizationId: string | null;
+    permissions: Array<Permission>;
+    /**
+     * The workspace an API key is bound to; null for a user session.
+     */
+    workspaceId: string | null;
+};
+/** @internal */
+export declare const Limits$inboundSchema: z.ZodMiniType<Limits, unknown>;
+export declare function limitsFromJSON(jsonString: string): SafeParseResult<Limits, SDKValidationError>;
+/** @internal */
+export declare const Permission$inboundSchema: z.ZodMiniType<Permission, unknown>;
+/** @internal */
+export declare const Credential$inboundSchema: z.ZodMiniType<Credential, unknown>;
+export declare function credentialFromJSON(jsonString: string): SafeParseResult<Credential, SDKValidationError>;

package/esm/models/credential.js

@@ -0,0 +1,44 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4-mini";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+import * as types from "../types/primitives.js";
+import { CredentialKind$inboundSchema, } from "./credential-kind.js";
+import { EnvironmentLifetime$inboundSchema, } from "./environment-lifetime.js";
+export const Permission = {
+    EnvironmentsRead: "environments:read",
+    EnvironmentsCreate: "environments:create",
+    EnvironmentsUpdate: "environments:update",
+    EnvironmentsStop: "environments:stop",
+    ConnectionsReveal: "connections:reveal",
+    SnapshotsRead: "snapshots:read",
+    SnapshotsCreate: "snapshots:create",
+    SnapshotsDelete: "snapshots:delete",
+    WorkspacesManage: "workspaces:manage",
+    ApiKeysManage: "api_keys:manage",
+    MembersManage: "members:manage",
+};
+/** @internal */
+export const Limits$inboundSchema = z.object({
+    environmentLifetime: EnvironmentLifetime$inboundSchema,
+    liveEnvironments: types.nullable(types.number()),
+});
+export function limitsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Limits$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Limits' from JSON`);
+}
+/** @internal */
+export const Permission$inboundSchema = openEnums.inboundSchema(Permission);
+/** @internal */
+export const Credential$inboundSchema = z
+    .object({
+    kind: CredentialKind$inboundSchema,
+    limits: z.lazy(() => Limits$inboundSchema),
+    organizationId: types.nullable(types.string()),
+    permissions: z.array(Permission$inboundSchema),
+    workspaceId: types.nullable(types.string()),
+});
+export function credentialFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Credential$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Credential' from JSON`);
+}