@vercel/sdk 1.8.0 → 1.8.2

package/esm/models/approverollingreleasestageop.d.ts

@@ -0,0 +1,661 @@
+import * as z from "zod";
+import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./sdkvalidationerror.js";
+export type ApproveRollingReleaseStageRequestBody = {
+    /**
+     * The index of the stage to transition to
+     */
+    nextStageIndex: number;
+    /**
+     * The id of the canary deployment to approve for the next stage
+     */
+    canaryDeploymentId: string;
+};
+export type ApproveRollingReleaseStageRequest = {
+    /**
+     * Project ID or project name (URL-encoded)
+     */
+    idOrName: string;
+    /**
+     * The Team identifier to perform the request on behalf of.
+     */
+    teamId?: string | undefined;
+    /**
+     * The Team slug to perform the request on behalf of.
+     */
+    slug?: string | undefined;
+    requestBody?: ApproveRollingReleaseStageRequestBody | undefined;
+};
+/**
+ * The current state of the rolling release
+ */
+export declare const ApproveRollingReleaseStageState: {
+    readonly Active: "ACTIVE";
+    readonly Complete: "COMPLETE";
+    readonly Aborted: "ABORTED";
+};
+/**
+ * The current state of the rolling release
+ */
+export type ApproveRollingReleaseStageState = ClosedEnum<typeof ApproveRollingReleaseStageState>;
+export declare const ApproveRollingReleaseStageTarget: {
+    readonly Staging: "staging";
+    readonly Production: "production";
+};
+export type ApproveRollingReleaseStageTarget = ClosedEnum<typeof ApproveRollingReleaseStageTarget>;
+export declare const ApproveRollingReleaseStageSource: {
+    readonly ApiTriggerGitDeploy: "api-trigger-git-deploy";
+    readonly Cli: "cli";
+    readonly CloneRepo: "clone/repo";
+    readonly Git: "git";
+    readonly Import: "import";
+    readonly ImportRepo: "import/repo";
+    readonly Redeploy: "redeploy";
+    readonly V0Web: "v0-web";
+};
+export type ApproveRollingReleaseStageSource = ClosedEnum<typeof ApproveRollingReleaseStageSource>;
+export declare const ApproveRollingReleaseStageReadyState: {
+    readonly Building: "BUILDING";
+    readonly Error: "ERROR";
+    readonly Initializing: "INITIALIZING";
+    readonly Queued: "QUEUED";
+    readonly Ready: "READY";
+    readonly Canceled: "CANCELED";
+};
+export type ApproveRollingReleaseStageReadyState = ClosedEnum<typeof ApproveRollingReleaseStageReadyState>;
+/**
+ * The current deployment receiving production traffic
+ */
+export type ApproveRollingReleaseStageCurrentDeployment = {
+    id: string;
+    name: string;
+    url: string;
+    target?: ApproveRollingReleaseStageTarget | null | undefined;
+    source?: ApproveRollingReleaseStageSource | undefined;
+    createdAt: number;
+    readyState: ApproveRollingReleaseStageReadyState;
+    readyStateAt?: number | undefined;
+};
+export declare const ApproveRollingReleaseStageRollingReleaseTarget: {
+    readonly Staging: "staging";
+    readonly Production: "production";
+};
+export type ApproveRollingReleaseStageRollingReleaseTarget = ClosedEnum<typeof ApproveRollingReleaseStageRollingReleaseTarget>;
+export declare const ApproveRollingReleaseStageRollingReleaseSource: {
+    readonly ApiTriggerGitDeploy: "api-trigger-git-deploy";
+    readonly Cli: "cli";
+    readonly CloneRepo: "clone/repo";
+    readonly Git: "git";
+    readonly Import: "import";
+    readonly ImportRepo: "import/repo";
+    readonly Redeploy: "redeploy";
+    readonly V0Web: "v0-web";
+};
+export type ApproveRollingReleaseStageRollingReleaseSource = ClosedEnum<typeof ApproveRollingReleaseStageRollingReleaseSource>;
+export declare const ApproveRollingReleaseStageRollingReleaseReadyState: {
+    readonly Building: "BUILDING";
+    readonly Error: "ERROR";
+    readonly Initializing: "INITIALIZING";
+    readonly Queued: "QUEUED";
+    readonly Ready: "READY";
+    readonly Canceled: "CANCELED";
+};
+export type ApproveRollingReleaseStageRollingReleaseReadyState = ClosedEnum<typeof ApproveRollingReleaseStageRollingReleaseReadyState>;
+/**
+ * The canary deployment being rolled out
+ */
+export type ApproveRollingReleaseStageCanaryDeployment = {
+    id: string;
+    name: string;
+    url: string;
+    target?: ApproveRollingReleaseStageRollingReleaseTarget | null | undefined;
+    source?: ApproveRollingReleaseStageRollingReleaseSource | undefined;
+    createdAt: number;
+    readyState: ApproveRollingReleaseStageRollingReleaseReadyState;
+    readyStateAt?: number | undefined;
+};
+/**
+ * All stages configured for this rolling release
+ */
+export type ApproveRollingReleaseStageStages = {
+    /**
+     * The zero-based index of the stage
+     */
+    index: number;
+    /**
+     * Whether or not this stage is the final stage (targetPercentage === 100)
+     */
+    isFinalStage: boolean;
+    /**
+     * The percentage of traffic to serve to the canary deployment (0-100)
+     */
+    targetPercentage: number;
+    /**
+     * Whether or not this stage requires manual approval to proceed
+     */
+    requireApproval: boolean;
+    /**
+     * Duration in seconds for automatic advancement, null for manual stages or the final stage
+     */
+    duration: number | null;
+};
+/**
+ * The currently active stage, null if the rollout is aborted
+ */
+export type ApproveRollingReleaseStageActiveStage = {
+    /**
+     * The zero-based index of the stage
+     */
+    index: number;
+    /**
+     * Whether or not this stage is the final stage (targetPercentage === 100)
+     */
+    isFinalStage: boolean;
+    /**
+     * The percentage of traffic to serve to the canary deployment (0-100)
+     */
+    targetPercentage: number;
+    /**
+     * Whether or not this stage requires manual approval to proceed
+     */
+    requireApproval: boolean;
+    /**
+     * Duration in seconds for automatic advancement, null for manual stages or the final stage
+     */
+    duration: number | null;
+};
+/**
+ * The next stage to be activated, null if not in ACTIVE state
+ */
+export type ApproveRollingReleaseStageNextStage = {
+    /**
+     * The zero-based index of the stage
+     */
+    index: number;
+    /**
+     * Whether or not this stage is the final stage (targetPercentage === 100)
+     */
+    isFinalStage: boolean;
+    /**
+     * The percentage of traffic to serve to the canary deployment (0-100)
+     */
+    targetPercentage: number;
+    /**
+     * Whether or not this stage requires manual approval to proceed
+     */
+    requireApproval: boolean;
+    /**
+     * Duration in seconds for automatic advancement, null for manual stages or the final stage
+     */
+    duration: number | null;
+};
+/**
+ * Rolling release information including configuration and document details, or null if no rolling release exists
+ */
+export type ApproveRollingReleaseStageRollingRelease = {
+    /**
+     * The current state of the rolling release
+     */
+    state: ApproveRollingReleaseStageState;
+    /**
+     * The current deployment receiving production traffic
+     */
+    currentDeployment: ApproveRollingReleaseStageCurrentDeployment | null;
+    /**
+     * The canary deployment being rolled out
+     */
+    canaryDeployment: ApproveRollingReleaseStageCanaryDeployment | null;
+    /**
+     * The ID of a deployment queued for the next rolling release
+     */
+    queuedDeploymentId: string | null;
+    /**
+     * All stages configured for this rolling release
+     */
+    stages: Array<ApproveRollingReleaseStageStages>;
+    /**
+     * The currently active stage, null if the rollout is aborted
+     */
+    activeStage: ApproveRollingReleaseStageActiveStage | null;
+    /**
+     * The next stage to be activated, null if not in ACTIVE state
+     */
+    nextStage: ApproveRollingReleaseStageNextStage | null;
+    /**
+     * Unix timestamp in milliseconds when the rolling release started
+     */
+    startedAt: number;
+    /**
+     * Unix timestamp in milliseconds when the rolling release was last updated
+     */
+    updatedAt: number;
+};
+/**
+ * The response format for rolling release endpoints that return rolling release information
+ */
+export type ApproveRollingReleaseStageResponseBody = {
+    /**
+     * Rolling release information including configuration and document details, or null if no rolling release exists
+     */
+    rollingRelease: ApproveRollingReleaseStageRollingRelease | null;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageRequestBody$inboundSchema: z.ZodType<ApproveRollingReleaseStageRequestBody, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ApproveRollingReleaseStageRequestBody$Outbound = {
+    nextStageIndex: number;
+    canaryDeploymentId: string;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageRequestBody$outboundSchema: z.ZodType<ApproveRollingReleaseStageRequestBody$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageRequestBody>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageRequestBody$ {
+    /** @deprecated use `ApproveRollingReleaseStageRequestBody$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ApproveRollingReleaseStageRequestBody, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ApproveRollingReleaseStageRequestBody$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ApproveRollingReleaseStageRequestBody$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageRequestBody>;
+    /** @deprecated use `ApproveRollingReleaseStageRequestBody$Outbound` instead. */
+    type Outbound = ApproveRollingReleaseStageRequestBody$Outbound;
+}
+export declare function approveRollingReleaseStageRequestBodyToJSON(approveRollingReleaseStageRequestBody: ApproveRollingReleaseStageRequestBody): string;
+export declare function approveRollingReleaseStageRequestBodyFromJSON(jsonString: string): SafeParseResult<ApproveRollingReleaseStageRequestBody, SDKValidationError>;
+/** @internal */
+export declare const ApproveRollingReleaseStageRequest$inboundSchema: z.ZodType<ApproveRollingReleaseStageRequest, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ApproveRollingReleaseStageRequest$Outbound = {
+    idOrName: string;
+    teamId?: string | undefined;
+    slug?: string | undefined;
+    RequestBody?: ApproveRollingReleaseStageRequestBody$Outbound | undefined;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageRequest$outboundSchema: z.ZodType<ApproveRollingReleaseStageRequest$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageRequest>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageRequest$ {
+    /** @deprecated use `ApproveRollingReleaseStageRequest$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ApproveRollingReleaseStageRequest, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ApproveRollingReleaseStageRequest$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ApproveRollingReleaseStageRequest$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageRequest>;
+    /** @deprecated use `ApproveRollingReleaseStageRequest$Outbound` instead. */
+    type Outbound = ApproveRollingReleaseStageRequest$Outbound;
+}
+export declare function approveRollingReleaseStageRequestToJSON(approveRollingReleaseStageRequest: ApproveRollingReleaseStageRequest): string;
+export declare function approveRollingReleaseStageRequestFromJSON(jsonString: string): SafeParseResult<ApproveRollingReleaseStageRequest, SDKValidationError>;
+/** @internal */
+export declare const ApproveRollingReleaseStageState$inboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageState>;
+/** @internal */
+export declare const ApproveRollingReleaseStageState$outboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageState>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageState$ {
+    /** @deprecated use `ApproveRollingReleaseStageState$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Active: "ACTIVE";
+        readonly Complete: "COMPLETE";
+        readonly Aborted: "ABORTED";
+    }>;
+    /** @deprecated use `ApproveRollingReleaseStageState$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Active: "ACTIVE";
+        readonly Complete: "COMPLETE";
+        readonly Aborted: "ABORTED";
+    }>;
+}
+/** @internal */
+export declare const ApproveRollingReleaseStageTarget$inboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageTarget>;
+/** @internal */
+export declare const ApproveRollingReleaseStageTarget$outboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageTarget>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageTarget$ {
+    /** @deprecated use `ApproveRollingReleaseStageTarget$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Staging: "staging";
+        readonly Production: "production";
+    }>;
+    /** @deprecated use `ApproveRollingReleaseStageTarget$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Staging: "staging";
+        readonly Production: "production";
+    }>;
+}
+/** @internal */
+export declare const ApproveRollingReleaseStageSource$inboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageSource>;
+/** @internal */
+export declare const ApproveRollingReleaseStageSource$outboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageSource>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageSource$ {
+    /** @deprecated use `ApproveRollingReleaseStageSource$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly ApiTriggerGitDeploy: "api-trigger-git-deploy";
+        readonly Cli: "cli";
+        readonly CloneRepo: "clone/repo";
+        readonly Git: "git";
+        readonly Import: "import";
+        readonly ImportRepo: "import/repo";
+        readonly Redeploy: "redeploy";
+        readonly V0Web: "v0-web";
+    }>;
+    /** @deprecated use `ApproveRollingReleaseStageSource$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly ApiTriggerGitDeploy: "api-trigger-git-deploy";
+        readonly Cli: "cli";
+        readonly CloneRepo: "clone/repo";
+        readonly Git: "git";
+        readonly Import: "import";
+        readonly ImportRepo: "import/repo";
+        readonly Redeploy: "redeploy";
+        readonly V0Web: "v0-web";
+    }>;
+}
+/** @internal */
+export declare const ApproveRollingReleaseStageReadyState$inboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageReadyState>;
+/** @internal */
+export declare const ApproveRollingReleaseStageReadyState$outboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageReadyState>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageReadyState$ {
+    /** @deprecated use `ApproveRollingReleaseStageReadyState$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Building: "BUILDING";
+        readonly Error: "ERROR";
+        readonly Initializing: "INITIALIZING";
+        readonly Queued: "QUEUED";
+        readonly Ready: "READY";
+        readonly Canceled: "CANCELED";
+    }>;
+    /** @deprecated use `ApproveRollingReleaseStageReadyState$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Building: "BUILDING";
+        readonly Error: "ERROR";
+        readonly Initializing: "INITIALIZING";
+        readonly Queued: "QUEUED";
+        readonly Ready: "READY";
+        readonly Canceled: "CANCELED";
+    }>;
+}
+/** @internal */
+export declare const ApproveRollingReleaseStageCurrentDeployment$inboundSchema: z.ZodType<ApproveRollingReleaseStageCurrentDeployment, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ApproveRollingReleaseStageCurrentDeployment$Outbound = {
+    id: string;
+    name: string;
+    url: string;
+    target?: string | null | undefined;
+    source?: string | undefined;
+    createdAt: number;
+    readyState: string;
+    readyStateAt?: number | undefined;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageCurrentDeployment$outboundSchema: z.ZodType<ApproveRollingReleaseStageCurrentDeployment$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageCurrentDeployment>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageCurrentDeployment$ {
+    /** @deprecated use `ApproveRollingReleaseStageCurrentDeployment$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ApproveRollingReleaseStageCurrentDeployment, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ApproveRollingReleaseStageCurrentDeployment$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ApproveRollingReleaseStageCurrentDeployment$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageCurrentDeployment>;
+    /** @deprecated use `ApproveRollingReleaseStageCurrentDeployment$Outbound` instead. */
+    type Outbound = ApproveRollingReleaseStageCurrentDeployment$Outbound;
+}
+export declare function approveRollingReleaseStageCurrentDeploymentToJSON(approveRollingReleaseStageCurrentDeployment: ApproveRollingReleaseStageCurrentDeployment): string;
+export declare function approveRollingReleaseStageCurrentDeploymentFromJSON(jsonString: string): SafeParseResult<ApproveRollingReleaseStageCurrentDeployment, SDKValidationError>;
+/** @internal */
+export declare const ApproveRollingReleaseStageRollingReleaseTarget$inboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageRollingReleaseTarget>;
+/** @internal */
+export declare const ApproveRollingReleaseStageRollingReleaseTarget$outboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageRollingReleaseTarget>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageRollingReleaseTarget$ {
+    /** @deprecated use `ApproveRollingReleaseStageRollingReleaseTarget$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Staging: "staging";
+        readonly Production: "production";
+    }>;
+    /** @deprecated use `ApproveRollingReleaseStageRollingReleaseTarget$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Staging: "staging";
+        readonly Production: "production";
+    }>;
+}
+/** @internal */
+export declare const ApproveRollingReleaseStageRollingReleaseSource$inboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageRollingReleaseSource>;
+/** @internal */
+export declare const ApproveRollingReleaseStageRollingReleaseSource$outboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageRollingReleaseSource>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageRollingReleaseSource$ {
+    /** @deprecated use `ApproveRollingReleaseStageRollingReleaseSource$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly ApiTriggerGitDeploy: "api-trigger-git-deploy";
+        readonly Cli: "cli";
+        readonly CloneRepo: "clone/repo";
+        readonly Git: "git";
+        readonly Import: "import";
+        readonly ImportRepo: "import/repo";
+        readonly Redeploy: "redeploy";
+        readonly V0Web: "v0-web";
+    }>;
+    /** @deprecated use `ApproveRollingReleaseStageRollingReleaseSource$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly ApiTriggerGitDeploy: "api-trigger-git-deploy";
+        readonly Cli: "cli";
+        readonly CloneRepo: "clone/repo";
+        readonly Git: "git";
+        readonly Import: "import";
+        readonly ImportRepo: "import/repo";
+        readonly Redeploy: "redeploy";
+        readonly V0Web: "v0-web";
+    }>;
+}
+/** @internal */
+export declare const ApproveRollingReleaseStageRollingReleaseReadyState$inboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageRollingReleaseReadyState>;
+/** @internal */
+export declare const ApproveRollingReleaseStageRollingReleaseReadyState$outboundSchema: z.ZodNativeEnum<typeof ApproveRollingReleaseStageRollingReleaseReadyState>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageRollingReleaseReadyState$ {
+    /** @deprecated use `ApproveRollingReleaseStageRollingReleaseReadyState$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Building: "BUILDING";
+        readonly Error: "ERROR";
+        readonly Initializing: "INITIALIZING";
+        readonly Queued: "QUEUED";
+        readonly Ready: "READY";
+        readonly Canceled: "CANCELED";
+    }>;
+    /** @deprecated use `ApproveRollingReleaseStageRollingReleaseReadyState$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Building: "BUILDING";
+        readonly Error: "ERROR";
+        readonly Initializing: "INITIALIZING";
+        readonly Queued: "QUEUED";
+        readonly Ready: "READY";
+        readonly Canceled: "CANCELED";
+    }>;
+}
+/** @internal */
+export declare const ApproveRollingReleaseStageCanaryDeployment$inboundSchema: z.ZodType<ApproveRollingReleaseStageCanaryDeployment, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ApproveRollingReleaseStageCanaryDeployment$Outbound = {
+    id: string;
+    name: string;
+    url: string;
+    target?: string | null | undefined;
+    source?: string | undefined;
+    createdAt: number;
+    readyState: string;
+    readyStateAt?: number | undefined;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageCanaryDeployment$outboundSchema: z.ZodType<ApproveRollingReleaseStageCanaryDeployment$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageCanaryDeployment>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageCanaryDeployment$ {
+    /** @deprecated use `ApproveRollingReleaseStageCanaryDeployment$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ApproveRollingReleaseStageCanaryDeployment, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ApproveRollingReleaseStageCanaryDeployment$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ApproveRollingReleaseStageCanaryDeployment$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageCanaryDeployment>;
+    /** @deprecated use `ApproveRollingReleaseStageCanaryDeployment$Outbound` instead. */
+    type Outbound = ApproveRollingReleaseStageCanaryDeployment$Outbound;
+}
+export declare function approveRollingReleaseStageCanaryDeploymentToJSON(approveRollingReleaseStageCanaryDeployment: ApproveRollingReleaseStageCanaryDeployment): string;
+export declare function approveRollingReleaseStageCanaryDeploymentFromJSON(jsonString: string): SafeParseResult<ApproveRollingReleaseStageCanaryDeployment, SDKValidationError>;
+/** @internal */
+export declare const ApproveRollingReleaseStageStages$inboundSchema: z.ZodType<ApproveRollingReleaseStageStages, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ApproveRollingReleaseStageStages$Outbound = {
+    index: number;
+    isFinalStage: boolean;
+    targetPercentage: number;
+    requireApproval: boolean;
+    duration: number | null;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageStages$outboundSchema: z.ZodType<ApproveRollingReleaseStageStages$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageStages>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageStages$ {
+    /** @deprecated use `ApproveRollingReleaseStageStages$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ApproveRollingReleaseStageStages, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ApproveRollingReleaseStageStages$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ApproveRollingReleaseStageStages$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageStages>;
+    /** @deprecated use `ApproveRollingReleaseStageStages$Outbound` instead. */
+    type Outbound = ApproveRollingReleaseStageStages$Outbound;
+}
+export declare function approveRollingReleaseStageStagesToJSON(approveRollingReleaseStageStages: ApproveRollingReleaseStageStages): string;
+export declare function approveRollingReleaseStageStagesFromJSON(jsonString: string): SafeParseResult<ApproveRollingReleaseStageStages, SDKValidationError>;
+/** @internal */
+export declare const ApproveRollingReleaseStageActiveStage$inboundSchema: z.ZodType<ApproveRollingReleaseStageActiveStage, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ApproveRollingReleaseStageActiveStage$Outbound = {
+    index: number;
+    isFinalStage: boolean;
+    targetPercentage: number;
+    requireApproval: boolean;
+    duration: number | null;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageActiveStage$outboundSchema: z.ZodType<ApproveRollingReleaseStageActiveStage$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageActiveStage>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageActiveStage$ {
+    /** @deprecated use `ApproveRollingReleaseStageActiveStage$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ApproveRollingReleaseStageActiveStage, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ApproveRollingReleaseStageActiveStage$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ApproveRollingReleaseStageActiveStage$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageActiveStage>;
+    /** @deprecated use `ApproveRollingReleaseStageActiveStage$Outbound` instead. */
+    type Outbound = ApproveRollingReleaseStageActiveStage$Outbound;
+}
+export declare function approveRollingReleaseStageActiveStageToJSON(approveRollingReleaseStageActiveStage: ApproveRollingReleaseStageActiveStage): string;
+export declare function approveRollingReleaseStageActiveStageFromJSON(jsonString: string): SafeParseResult<ApproveRollingReleaseStageActiveStage, SDKValidationError>;
+/** @internal */
+export declare const ApproveRollingReleaseStageNextStage$inboundSchema: z.ZodType<ApproveRollingReleaseStageNextStage, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ApproveRollingReleaseStageNextStage$Outbound = {
+    index: number;
+    isFinalStage: boolean;
+    targetPercentage: number;
+    requireApproval: boolean;
+    duration: number | null;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageNextStage$outboundSchema: z.ZodType<ApproveRollingReleaseStageNextStage$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageNextStage>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageNextStage$ {
+    /** @deprecated use `ApproveRollingReleaseStageNextStage$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ApproveRollingReleaseStageNextStage, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ApproveRollingReleaseStageNextStage$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ApproveRollingReleaseStageNextStage$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageNextStage>;
+    /** @deprecated use `ApproveRollingReleaseStageNextStage$Outbound` instead. */
+    type Outbound = ApproveRollingReleaseStageNextStage$Outbound;
+}
+export declare function approveRollingReleaseStageNextStageToJSON(approveRollingReleaseStageNextStage: ApproveRollingReleaseStageNextStage): string;
+export declare function approveRollingReleaseStageNextStageFromJSON(jsonString: string): SafeParseResult<ApproveRollingReleaseStageNextStage, SDKValidationError>;
+/** @internal */
+export declare const ApproveRollingReleaseStageRollingRelease$inboundSchema: z.ZodType<ApproveRollingReleaseStageRollingRelease, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ApproveRollingReleaseStageRollingRelease$Outbound = {
+    state: string;
+    currentDeployment: ApproveRollingReleaseStageCurrentDeployment$Outbound | null;
+    canaryDeployment: ApproveRollingReleaseStageCanaryDeployment$Outbound | null;
+    queuedDeploymentId: string | null;
+    stages: Array<ApproveRollingReleaseStageStages$Outbound>;
+    activeStage: ApproveRollingReleaseStageActiveStage$Outbound | null;
+    nextStage: ApproveRollingReleaseStageNextStage$Outbound | null;
+    startedAt: number;
+    updatedAt: number;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageRollingRelease$outboundSchema: z.ZodType<ApproveRollingReleaseStageRollingRelease$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageRollingRelease>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageRollingRelease$ {
+    /** @deprecated use `ApproveRollingReleaseStageRollingRelease$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ApproveRollingReleaseStageRollingRelease, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ApproveRollingReleaseStageRollingRelease$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ApproveRollingReleaseStageRollingRelease$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageRollingRelease>;
+    /** @deprecated use `ApproveRollingReleaseStageRollingRelease$Outbound` instead. */
+    type Outbound = ApproveRollingReleaseStageRollingRelease$Outbound;
+}
+export declare function approveRollingReleaseStageRollingReleaseToJSON(approveRollingReleaseStageRollingRelease: ApproveRollingReleaseStageRollingRelease): string;
+export declare function approveRollingReleaseStageRollingReleaseFromJSON(jsonString: string): SafeParseResult<ApproveRollingReleaseStageRollingRelease, SDKValidationError>;
+/** @internal */
+export declare const ApproveRollingReleaseStageResponseBody$inboundSchema: z.ZodType<ApproveRollingReleaseStageResponseBody, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ApproveRollingReleaseStageResponseBody$Outbound = {
+    rollingRelease: ApproveRollingReleaseStageRollingRelease$Outbound | null;
+};
+/** @internal */
+export declare const ApproveRollingReleaseStageResponseBody$outboundSchema: z.ZodType<ApproveRollingReleaseStageResponseBody$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageResponseBody>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ApproveRollingReleaseStageResponseBody$ {
+    /** @deprecated use `ApproveRollingReleaseStageResponseBody$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ApproveRollingReleaseStageResponseBody, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ApproveRollingReleaseStageResponseBody$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ApproveRollingReleaseStageResponseBody$Outbound, z.ZodTypeDef, ApproveRollingReleaseStageResponseBody>;
+    /** @deprecated use `ApproveRollingReleaseStageResponseBody$Outbound` instead. */
+    type Outbound = ApproveRollingReleaseStageResponseBody$Outbound;
+}
+export declare function approveRollingReleaseStageResponseBodyToJSON(approveRollingReleaseStageResponseBody: ApproveRollingReleaseStageResponseBody): string;
+export declare function approveRollingReleaseStageResponseBodyFromJSON(jsonString: string): SafeParseResult<ApproveRollingReleaseStageResponseBody, SDKValidationError>;
+//# sourceMappingURL=approverollingreleasestageop.d.ts.map