@alienplatform/platform-api 3.3.11 → 3.3.13

package/src/models/operations/createprojectfromtemplate.ts

@@ -13,7 +13,8 @@ import * as models from "../index.js";
 /**
  * Template root directory inside alienplatform/alien
  */
-export const TemplatePathRequest = {
+export const CreateProjectFromTemplateTemplatePathRequest = {
+  ExamplesCustomerModelsTs: "examples/customer-models-ts",
   ExamplesRemoteWorkerTs: "examples/remote-worker-ts",
   ExamplesGithubAgentPackagesRemoteAgent:
     "examples/github-agent/packages/remote-agent",
@@ -23,7 +24,9 @@ export const TemplatePathRequest = {
 /**
  * Template root directory inside alienplatform/alien
  */
-export type TemplatePathRequest = ClosedEnum<typeof TemplatePathRequest>;
+export type CreateProjectFromTemplateTemplatePathRequest = ClosedEnum<
+  typeof CreateProjectFromTemplateTemplatePathRequest
+>;
 
 /**
  * Target OS and architecture for compiled binaries.
@@ -200,7 +203,7 @@ export type CreateProjectFromTemplateRequestBody = {
   /**
    * Template root directory inside alienplatform/alien
    */
-  templatePath: TemplatePathRequest;
+  templatePath: CreateProjectFromTemplateTemplatePathRequest;
   /**
    * The name of a directory or relative path to the source code of your project. When null is used it will default to the project root
    */
@@ -480,6 +483,90 @@ export type CreateProjectFromTemplateDefaultManagers = {
   local?: string | null | undefined;
 };
 
+export type CreateProjectFromTemplateDeployments = {
+  enabled: boolean;
+};
+
+export type CreateProjectFromTemplateKeys = {
+  enabled: boolean;
+  applicationEncryption: boolean;
+};
+
+export const CreateProjectFromTemplateAllowedProvider = {
+  AwsBedrock: "aws-bedrock",
+  GcpVertex: "gcp-vertex",
+  AzureFoundry: "azure-foundry",
+  Anthropic: "anthropic",
+  Databricks: "databricks",
+  Openai: "openai",
+} as const;
+export type CreateProjectFromTemplateAllowedProvider = ClosedEnum<
+  typeof CreateProjectFromTemplateAllowedProvider
+>;
+
+export const CreateProjectFromTemplateClientApi = {
+  OpenaiChat: "openai-chat",
+  OpenaiResponses: "openai-responses",
+  AnthropicMessages: "anthropic-messages",
+} as const;
+export type CreateProjectFromTemplateClientApi = ClosedEnum<
+  typeof CreateProjectFromTemplateClientApi
+>;
+
+export type CreateProjectFromTemplateRequirement = {
+  publicModelId: string;
+  clientApis: Array<CreateProjectFromTemplateClientApi>;
+  required: boolean;
+};
+
+export type CreateProjectFromTemplateModels = {
+  enabled: boolean;
+  allowedProviders: Array<CreateProjectFromTemplateAllowedProvider>;
+  requirements: Array<CreateProjectFromTemplateRequirement>;
+};
+
+export const CreateProjectFromTemplateAccess = {
+  ReadWrite: "read-write",
+} as const;
+export type CreateProjectFromTemplateAccess = ClosedEnum<
+  typeof CreateProjectFromTemplateAccess
+>;
+
+export type CreateProjectFromTemplateBuckets = {
+  enabled: boolean;
+  access: CreateProjectFromTemplateAccess;
+};
+
+export const CreateProjectFromTemplateCredentialPolicy = {
+  PullOnly: "pull-only",
+  PushAndPull: "push-and-pull",
+} as const;
+export type CreateProjectFromTemplateCredentialPolicy = ClosedEnum<
+  typeof CreateProjectFromTemplateCredentialPolicy
+>;
+
+export type CreateProjectFromTemplateRegistry = {
+  enabled: boolean;
+  repositories: Array<string>;
+  credentialPolicy: CreateProjectFromTemplateCredentialPolicy;
+};
+
+export type CreateProjectFromTemplateCapabilities = {
+  deployments?: CreateProjectFromTemplateDeployments | undefined;
+  keys?: CreateProjectFromTemplateKeys | undefined;
+  models?: CreateProjectFromTemplateModels | undefined;
+  buckets?: CreateProjectFromTemplateBuckets | undefined;
+  registry?: CreateProjectFromTemplateRegistry | undefined;
+};
+
+/**
+ * Capabilities this Project may offer through setup links.
+ */
+export type CreateProjectFromTemplateProjectCapabilities = {
+  schemaVersion: number;
+  capabilities: CreateProjectFromTemplateCapabilities;
+};
+
 export type CreateProjectFromTemplateGithubSetup = {
   /**
    * URL to the pull request with the Alien build workflow
@@ -491,15 +578,18 @@ export type CreateProjectFromTemplateGithubSetup = {
   workflowUrl: string;
 };
 
-export const SourceRepository = {
+export const CreateProjectFromTemplateSourceRepository = {
   AlienplatformAlien: "alienplatform/alien",
 } as const;
-export type SourceRepository = ClosedEnum<typeof SourceRepository>;
+export type CreateProjectFromTemplateSourceRepository = ClosedEnum<
+  typeof CreateProjectFromTemplateSourceRepository
+>;
 
 /**
  * Template root directory inside alienplatform/alien
  */
-export const TemplatePathResponse = {
+export const CreateProjectFromTemplateTemplatePathResponse = {
+  ExamplesCustomerModelsTs: "examples/customer-models-ts",
   ExamplesRemoteWorkerTs: "examples/remote-worker-ts",
   ExamplesGithubAgentPackagesRemoteAgent:
     "examples/github-agent/packages/remote-agent",
@@ -509,10 +599,12 @@ export const TemplatePathResponse = {
 /**
  * Template root directory inside alienplatform/alien
  */
-export type TemplatePathResponse = ClosedEnum<typeof TemplatePathResponse>;
+export type CreateProjectFromTemplateTemplatePathResponse = ClosedEnum<
+  typeof CreateProjectFromTemplateTemplatePathResponse
+>;
 
-export type Template = {
-  sourceRepository: SourceRepository;
+export type CreateProjectFromTemplateTemplate = {
+  sourceRepository: CreateProjectFromTemplateSourceRepository;
   /**
    * Fork repository in <owner>/<repo> format
    */
@@ -520,7 +612,7 @@ export type Template = {
   /**
    * Template root directory inside alienplatform/alien
    */
-  templatePath: TemplatePathResponse;
+  templatePath: CreateProjectFromTemplateTemplatePathResponse;
   resolvedRootDirectory: string;
 };
 
@@ -566,6 +658,13 @@ export type CreateProjectFromTemplateResponse = {
    * Project default private managers for new push deployments.
    */
   defaultManagers?: CreateProjectFromTemplateDefaultManagers | null | undefined;
+  /**
+   * Capabilities this Project may offer through setup links.
+   */
+  projectCapabilities?:
+    | CreateProjectFromTemplateProjectCapabilities
+    | null
+    | undefined;
   createdAt: Date;
   /**
    * Unique identifier for the workspace.
@@ -573,13 +672,14 @@ export type CreateProjectFromTemplateResponse = {
   workspaceId: string;
   githubSetup?: CreateProjectFromTemplateGithubSetup | undefined;
   gitRepositoryWarning?: models.APIError | undefined;
-  template: Template;
+  template: CreateProjectFromTemplateTemplate;
 };
 
 /** @internal */
-export const TemplatePathRequest$outboundSchema: z.ZodEnum<
-  typeof TemplatePathRequest
-> = z.enum(TemplatePathRequest);
+export const CreateProjectFromTemplateTemplatePathRequest$outboundSchema:
+  z.ZodEnum<typeof CreateProjectFromTemplateTemplatePathRequest> = z.enum(
+    CreateProjectFromTemplateTemplatePathRequest,
+  );
 
 /** @internal */
 export const CreateProjectFromTemplateBinaryTargetRequest$outboundSchema:
@@ -809,7 +909,7 @@ export const CreateProjectFromTemplateRequestBody$outboundSchema: z.ZodType<
 > = z.object({
   name: z.string(),
   targetNamespace: z.string(),
-  templatePath: TemplatePathRequest$outboundSchema,
+  templatePath: CreateProjectFromTemplateTemplatePathRequest$outboundSchema,
   rootDirectory: z.nullable(z.string()).optional(),
   packagesConfig: z.nullable(
     z.lazy(() => CreateProjectFromTemplatePackagesConfigRequest$outboundSchema),
@@ -1114,6 +1214,200 @@ export function createProjectFromTemplateDefaultManagersFromJSON(
   );
 }
 
+/** @internal */
+export const CreateProjectFromTemplateDeployments$inboundSchema: z.ZodType<
+  CreateProjectFromTemplateDeployments,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+});
+
+export function createProjectFromTemplateDeploymentsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectFromTemplateDeployments, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectFromTemplateDeployments$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectFromTemplateDeployments' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateProjectFromTemplateKeys$inboundSchema: z.ZodType<
+  CreateProjectFromTemplateKeys,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  applicationEncryption: z.boolean(),
+});
+
+export function createProjectFromTemplateKeysFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectFromTemplateKeys, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectFromTemplateKeys$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectFromTemplateKeys' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateProjectFromTemplateAllowedProvider$inboundSchema: z.ZodEnum<
+  typeof CreateProjectFromTemplateAllowedProvider
+> = z.enum(CreateProjectFromTemplateAllowedProvider);
+
+/** @internal */
+export const CreateProjectFromTemplateClientApi$inboundSchema: z.ZodEnum<
+  typeof CreateProjectFromTemplateClientApi
+> = z.enum(CreateProjectFromTemplateClientApi);
+
+/** @internal */
+export const CreateProjectFromTemplateRequirement$inboundSchema: z.ZodType<
+  CreateProjectFromTemplateRequirement,
+  unknown
+> = z.object({
+  publicModelId: z.string(),
+  clientApis: z.array(CreateProjectFromTemplateClientApi$inboundSchema),
+  required: z.boolean(),
+});
+
+export function createProjectFromTemplateRequirementFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectFromTemplateRequirement, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectFromTemplateRequirement$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectFromTemplateRequirement' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateProjectFromTemplateModels$inboundSchema: z.ZodType<
+  CreateProjectFromTemplateModels,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  allowedProviders: z.array(
+    CreateProjectFromTemplateAllowedProvider$inboundSchema,
+  ),
+  requirements: z.array(
+    z.lazy(() => CreateProjectFromTemplateRequirement$inboundSchema),
+  ),
+});
+
+export function createProjectFromTemplateModelsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectFromTemplateModels, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectFromTemplateModels$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectFromTemplateModels' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateProjectFromTemplateAccess$inboundSchema: z.ZodEnum<
+  typeof CreateProjectFromTemplateAccess
+> = z.enum(CreateProjectFromTemplateAccess);
+
+/** @internal */
+export const CreateProjectFromTemplateBuckets$inboundSchema: z.ZodType<
+  CreateProjectFromTemplateBuckets,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  access: CreateProjectFromTemplateAccess$inboundSchema,
+});
+
+export function createProjectFromTemplateBucketsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectFromTemplateBuckets, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectFromTemplateBuckets$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectFromTemplateBuckets' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateProjectFromTemplateCredentialPolicy$inboundSchema: z.ZodEnum<
+  typeof CreateProjectFromTemplateCredentialPolicy
+> = z.enum(CreateProjectFromTemplateCredentialPolicy);
+
+/** @internal */
+export const CreateProjectFromTemplateRegistry$inboundSchema: z.ZodType<
+  CreateProjectFromTemplateRegistry,
+  unknown
+> = z.object({
+  enabled: z.boolean(),
+  repositories: z.array(z.string()),
+  credentialPolicy: CreateProjectFromTemplateCredentialPolicy$inboundSchema,
+});
+
+export function createProjectFromTemplateRegistryFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectFromTemplateRegistry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateProjectFromTemplateRegistry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectFromTemplateRegistry' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateProjectFromTemplateCapabilities$inboundSchema: z.ZodType<
+  CreateProjectFromTemplateCapabilities,
+  unknown
+> = z.object({
+  deployments: z.lazy(() => CreateProjectFromTemplateDeployments$inboundSchema)
+    .optional(),
+  keys: z.lazy(() => CreateProjectFromTemplateKeys$inboundSchema).optional(),
+  models: z.lazy(() => CreateProjectFromTemplateModels$inboundSchema)
+    .optional(),
+  buckets: z.lazy(() => CreateProjectFromTemplateBuckets$inboundSchema)
+    .optional(),
+  registry: z.lazy(() => CreateProjectFromTemplateRegistry$inboundSchema)
+    .optional(),
+});
+
+export function createProjectFromTemplateCapabilitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateProjectFromTemplateCapabilities, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectFromTemplateCapabilities$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectFromTemplateCapabilities' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateProjectFromTemplateProjectCapabilities$inboundSchema:
+  z.ZodType<CreateProjectFromTemplateProjectCapabilities, unknown> = z.object({
+    schemaVersion: z.number(),
+    capabilities: z.lazy(() =>
+      CreateProjectFromTemplateCapabilities$inboundSchema
+    ),
+  });
+
+export function createProjectFromTemplateProjectCapabilitiesFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  CreateProjectFromTemplateProjectCapabilities,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      CreateProjectFromTemplateProjectCapabilities$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'CreateProjectFromTemplateProjectCapabilities' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateProjectFromTemplateGithubSetup$inboundSchema: z.ZodType<
   CreateProjectFromTemplateGithubSetup,
@@ -1135,30 +1429,34 @@ export function createProjectFromTemplateGithubSetupFromJSON(
 }
 
 /** @internal */
-export const SourceRepository$inboundSchema: z.ZodEnum<
-  typeof SourceRepository
-> = z.enum(SourceRepository);
+export const CreateProjectFromTemplateSourceRepository$inboundSchema: z.ZodEnum<
+  typeof CreateProjectFromTemplateSourceRepository
+> = z.enum(CreateProjectFromTemplateSourceRepository);
 
 /** @internal */
-export const TemplatePathResponse$inboundSchema: z.ZodEnum<
-  typeof TemplatePathResponse
-> = z.enum(TemplatePathResponse);
+export const CreateProjectFromTemplateTemplatePathResponse$inboundSchema:
+  z.ZodEnum<typeof CreateProjectFromTemplateTemplatePathResponse> = z.enum(
+    CreateProjectFromTemplateTemplatePathResponse,
+  );
 
 /** @internal */
-export const Template$inboundSchema: z.ZodType<Template, unknown> = z.object({
-  sourceRepository: SourceRepository$inboundSchema,
+export const CreateProjectFromTemplateTemplate$inboundSchema: z.ZodType<
+  CreateProjectFromTemplateTemplate,
+  unknown
+> = z.object({
+  sourceRepository: CreateProjectFromTemplateSourceRepository$inboundSchema,
   forkRepository: z.string(),
-  templatePath: TemplatePathResponse$inboundSchema,
+  templatePath: CreateProjectFromTemplateTemplatePathResponse$inboundSchema,
   resolvedRootDirectory: z.string(),
 });
 
-export function templateFromJSON(
+export function createProjectFromTemplateTemplateFromJSON(
   jsonString: string,
-): SafeParseResult<Template, SDKValidationError> {
+): SafeParseResult<CreateProjectFromTemplateTemplate, SDKValidationError> {
   return safeParse(
     jsonString,
-    (x) => Template$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Template' from JSON`,
+    (x) => CreateProjectFromTemplateTemplate$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateProjectFromTemplateTemplate' from JSON`,
   );
 }
 
@@ -1185,12 +1483,15 @@ export const CreateProjectFromTemplateResponse$inboundSchema: z.ZodType<
   defaultManagers: z.nullable(
     z.lazy(() => CreateProjectFromTemplateDefaultManagers$inboundSchema),
   ).optional(),
+  projectCapabilities: z.nullable(
+    z.lazy(() => CreateProjectFromTemplateProjectCapabilities$inboundSchema),
+  ).optional(),
   createdAt: z.iso.datetime({ offset: true }).transform(v => new Date(v)),
   workspaceId: z.string(),
   githubSetup: z.lazy(() => CreateProjectFromTemplateGithubSetup$inboundSchema)
     .optional(),
   gitRepositoryWarning: models.APIError$inboundSchema.optional(),
-  template: z.lazy(() => Template$inboundSchema),
+  template: z.lazy(() => CreateProjectFromTemplateTemplate$inboundSchema),
 });
 
 export function createProjectFromTemplateResponseFromJSON(

package/src/models/operations/createreleasechannel.ts

@@ -0,0 +1,83 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type CreateReleaseChannelRequestBody = {
+  name: string;
+  /**
+   * Unique identifier for the release.
+   */
+  releaseId?: string | undefined;
+};
+
+export type CreateReleaseChannelRequest = {
+  /**
+   * Workspace name. Required for user/session/OAuth requests. Optional for API keys because API keys are workspace-scoped; if provided with an API key, it must match the key's workspace.
+   */
+  workspace?: string | undefined;
+  /**
+   * Filter by project ID or name.
+   */
+  project: string;
+  requestBody?: CreateReleaseChannelRequestBody | undefined;
+};
+
+/** @internal */
+export type CreateReleaseChannelRequestBody$Outbound = {
+  name: string;
+  releaseId?: string | undefined;
+};
+
+/** @internal */
+export const CreateReleaseChannelRequestBody$outboundSchema: z.ZodType<
+  CreateReleaseChannelRequestBody$Outbound,
+  CreateReleaseChannelRequestBody
+> = z.object({
+  name: z.string(),
+  releaseId: z.string().optional(),
+});
+
+export function createReleaseChannelRequestBodyToJSON(
+  createReleaseChannelRequestBody: CreateReleaseChannelRequestBody,
+): string {
+  return JSON.stringify(
+    CreateReleaseChannelRequestBody$outboundSchema.parse(
+      createReleaseChannelRequestBody,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateReleaseChannelRequest$Outbound = {
+  workspace?: string | undefined;
+  project: string;
+  RequestBody?: CreateReleaseChannelRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateReleaseChannelRequest$outboundSchema: z.ZodType<
+  CreateReleaseChannelRequest$Outbound,
+  CreateReleaseChannelRequest
+> = z.object({
+  workspace: z.string().optional(),
+  project: z.string(),
+  requestBody: z.lazy(() => CreateReleaseChannelRequestBody$outboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function createReleaseChannelRequestToJSON(
+  createReleaseChannelRequest: CreateReleaseChannelRequest,
+): string {
+  return JSON.stringify(
+    CreateReleaseChannelRequest$outboundSchema.parse(
+      createReleaseChannelRequest,
+    ),
+  );
+}

package/src/models/operations/createremotebindingsexternalaccess.ts

@@ -0,0 +1,56 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
+
+export type CreateRemoteBindingsExternalAccessRequest = {
+  /**
+   * Project ID or name.
+   */
+  idOrName: string;
+  /**
+   * Workspace name. Required for user/session/OAuth requests. Optional for API keys because API keys are workspace-scoped; if provided with an API key, it must match the key's workspace.
+   */
+  workspace?: string | undefined;
+  remoteBindingsExternalAccessRequest:
+    models.RemoteBindingsExternalAccessRequest;
+};
+
+/** @internal */
+export type CreateRemoteBindingsExternalAccessRequest$Outbound = {
+  idOrName: string;
+  workspace?: string | undefined;
+  RemoteBindingsExternalAccessRequest:
+    models.RemoteBindingsExternalAccessRequest$Outbound;
+};
+
+/** @internal */
+export const CreateRemoteBindingsExternalAccessRequest$outboundSchema:
+  z.ZodType<
+    CreateRemoteBindingsExternalAccessRequest$Outbound,
+    CreateRemoteBindingsExternalAccessRequest
+  > = z.object({
+    idOrName: z.string(),
+    workspace: z.string().optional(),
+    remoteBindingsExternalAccessRequest:
+      models.RemoteBindingsExternalAccessRequest$outboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      remoteBindingsExternalAccessRequest:
+        "RemoteBindingsExternalAccessRequest",
+    });
+  });
+
+export function createRemoteBindingsExternalAccessRequestToJSON(
+  createRemoteBindingsExternalAccessRequest:
+    CreateRemoteBindingsExternalAccessRequest,
+): string {
+  return JSON.stringify(
+    CreateRemoteBindingsExternalAccessRequest$outboundSchema.parse(
+      createRemoteBindingsExternalAccessRequest,
+    ),
+  );
+}

package/src/models/operations/createsetuplink.ts

@@ -0,0 +1,42 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as models from "../index.js";
+
+export type CreateSetupLinkRequest = {
+  /**
+   * Workspace name. Required for user/session/OAuth requests. Optional for API keys because API keys are workspace-scoped; if provided with an API key, it must match the key's workspace.
+   */
+  workspace?: string | undefined;
+  createSetupLinkRequest: models.CreateSetupLinkRequest;
+};
+
+/** @internal */
+export type CreateSetupLinkRequest$Outbound = {
+  workspace?: string | undefined;
+  CreateSetupLinkRequest: models.CreateSetupLinkRequest$Outbound;
+};
+
+/** @internal */
+export const CreateSetupLinkRequest$outboundSchema: z.ZodType<
+  CreateSetupLinkRequest$Outbound,
+  CreateSetupLinkRequest
+> = z.object({
+  workspace: z.string().optional(),
+  createSetupLinkRequest: models.CreateSetupLinkRequest$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    createSetupLinkRequest: "CreateSetupLinkRequest",
+  });
+});
+
+export function createSetupLinkRequestToJSON(
+  createSetupLinkRequest: CreateSetupLinkRequest,
+): string {
+  return JSON.stringify(
+    CreateSetupLinkRequest$outboundSchema.parse(createSetupLinkRequest),
+  );
+}