/*
 * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
 * @generated-id: a58d496f3eeb
 */

import * as z from "zod/v4";
import { ClosedEnum } from "../types/enums.js";
import {
  DeploymentState,
  DeploymentState$Outbound,
  DeploymentState$outboundSchema,
} from "./deploymentstate.js";
import {
  ObservedInventoryBatch,
  ObservedInventoryBatch$Outbound,
  ObservedInventoryBatch$outboundSchema,
} from "./observedinventorybatch.js";
import {
  OperationsReport,
  OperationsReport$Outbound,
  OperationsReport$outboundSchema,
} from "./operationsreport.js";
import {
  OperatorCapabilityReport,
  OperatorCapabilityReport$Outbound,
  OperatorCapabilityReport$outboundSchema,
} from "./operatorcapabilityreport.js";
import {
  RemoteOperatorImageIdentity,
  RemoteOperatorImageIdentity$Outbound,
  RemoteOperatorImageIdentity$outboundSchema,
} from "./remoteoperatorimageidentity.js";

export const SyncReconcileRequestBackendEnum = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Local: "local",
  Managed: "managed",
  External: "external",
  Test: "test",
} as const;
export type SyncReconcileRequestBackendEnum = ClosedEnum<
  typeof SyncReconcileRequestBackendEnum
>;

/**
 * Represents the target cloud platform.
 */
export const SyncReconcileRequestControllerPlatform = {
  Aws: "aws",
  Gcp: "gcp",
  Azure: "azure",
  Kubernetes: "kubernetes",
  Machines: "machines",
  Local: "local",
  Test: "test",
} as const;
/**
 * Represents the target cloud platform.
 */
export type SyncReconcileRequestControllerPlatform = ClosedEnum<
  typeof SyncReconcileRequestControllerPlatform
>;

export const SyncReconcileRequestReason74 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason74 = ClosedEnum<
  typeof SyncReconcileRequestReason74
>;

export const StatusSeverity74 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity74 = ClosedEnum<typeof StatusSeverity74>;

export type SyncReconcileRequestCollectionIssue74 = {
  message: string;
  reason: SyncReconcileRequestReason74;
  severity: StatusSeverity74;
  source: string;
};

export const SyncReconcileRequestHealth77 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth77 = ClosedEnum<
  typeof SyncReconcileRequestHealth77
>;

export const SyncReconcileRequestLifecycle77 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle77 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle77
>;

export type SyncReconcileRequestStatus77 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue74>;
  health: SyncReconcileRequestHealth77;
  lifecycle: SyncReconcileRequestLifecycle77;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/**
 * Local: containers Docker still holds for this sandbox.
 */
export type DataLocal12 = {
  activeSessions: number;
  /**
   * Whether the loopback route is serving in this process. False after a manager restart until
   *
   * @remarks
   * the next tick rebinds it.
   */
  routeServing: boolean;
  status: SyncReconcileRequestStatus77;
  backend: "local";
};

export const SyncReconcileRequestReason73 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason73 = ClosedEnum<
  typeof SyncReconcileRequestReason73
>;

export const StatusSeverity73 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity73 = ClosedEnum<typeof StatusSeverity73>;

export type SyncReconcileRequestCollectionIssue73 = {
  message: string;
  reason: SyncReconcileRequestReason73;
  severity: StatusSeverity73;
  source: string;
};

export const SyncReconcileRequestHealth76 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth76 = ClosedEnum<
  typeof SyncReconcileRequestHealth76
>;

export const SyncReconcileRequestLifecycle76 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle76 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle76
>;

export type SyncReconcileRequestStatus76 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue73>;
  health: SyncReconcileRequestHealth76;
  lifecycle: SyncReconcileRequestLifecycle76;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/**
 * Kubernetes: pods carrying the sandbox label, in the deployment's namespace.
 */
export type DataKubernetesPods = {
  activeSessions: number;
  /**
   * Claimed but unused pods waiting in the pool.
   */
  idlePods: number;
  namespace: string;
  status: SyncReconcileRequestStatus76;
  backend: "kubernetesPods";
};

export const SyncReconcileRequestReason72 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason72 = ClosedEnum<
  typeof SyncReconcileRequestReason72
>;

export const StatusSeverity72 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity72 = ClosedEnum<typeof StatusSeverity72>;

export type SyncReconcileRequestCollectionIssue72 = {
  message: string;
  reason: SyncReconcileRequestReason72;
  severity: StatusSeverity72;
  source: string;
};

export const SyncReconcileRequestHealth75 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth75 = ClosedEnum<
  typeof SyncReconcileRequestHealth75
>;

export const SyncReconcileRequestLifecycle75 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle75 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle75
>;

export type SyncReconcileRequestStatus75 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue72>;
  health: SyncReconcileRequestHealth75;
  lifecycle: SyncReconcileRequestLifecycle75;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/**
 * GCP: the Agent Platform template sandboxes are cut from, and the engine it hangs under.
 *
 * @remarks
 *
 * No sandbox count: that needs `aiplatform.sandboxEnvironments.list`, which only the management
 * permission set holds. No template state either — emission is gated on reading it `ACTIVE`,
 * which is what `status` already says.
 */
export type DataGcpAgentPlatform = {
  /**
   * Reasoning engine the template hangs under, without which the template id names nothing.
   */
  engine: string;
  status: SyncReconcileRequestStatus75;
  /**
   * The template sandboxes are currently cut from.
   */
  templateId: string;
  backend: "gcpAgentPlatform";
};

export const SyncReconcileRequestReason71 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason71 = ClosedEnum<
  typeof SyncReconcileRequestReason71
>;

export const StatusSeverity71 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity71 = ClosedEnum<typeof StatusSeverity71>;

export type SyncReconcileRequestCollectionIssue71 = {
  message: string;
  reason: SyncReconcileRequestReason71;
  severity: StatusSeverity71;
  source: string;
};

export const SyncReconcileRequestHealth74 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth74 = ClosedEnum<
  typeof SyncReconcileRequestHealth74
>;

export const SyncReconcileRequestLifecycle74 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle74 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle74
>;

export type SyncReconcileRequestStatus74 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue71>;
  health: SyncReconcileRequestHealth74;
  lifecycle: SyncReconcileRequestLifecycle74;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/**
 * Azure: the sandbox group's ARM state. The data plane has no list operation, so a sandbox count
 *
 * @remarks
 * is not available here.
 */
export type DataAzureSandboxGroup = {
  provisioningState?: string | null | undefined;
  sandboxGroup: string;
  status: SyncReconcileRequestStatus74;
  backend: "azureSandboxGroup";
};

export const SyncReconcileRequestReason70 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason70 = ClosedEnum<
  typeof SyncReconcileRequestReason70
>;

export const StatusSeverity70 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity70 = ClosedEnum<typeof StatusSeverity70>;

export type SyncReconcileRequestCollectionIssue70 = {
  message: string;
  reason: SyncReconcileRequestReason70;
  severity: StatusSeverity70;
  source: string;
};

export const SyncReconcileRequestHealth73 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth73 = ClosedEnum<
  typeof SyncReconcileRequestHealth73
>;

export const SyncReconcileRequestLifecycle73 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle73 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle73
>;

export type SyncReconcileRequestStatus73 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue70>;
  health: SyncReconcileRequestHealth73;
  lifecycle: SyncReconcileRequestLifecycle73;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/**
 * AWS: the image a sandbox runs from, and the lifecycle state AWS reports for it.
 */
export type DataAwsMicrovm = {
  /**
   * Image the sandboxes belong to.
   */
  imageIdentifier: string;
  /**
   * The image's own lifecycle state, which is where AWS surfaces base-image deprecation.
   *
   * @remarks
   *
   * No sandbox count sits beside it: counting means `lambda:ListMicrovms`, which authorizes
   * against no resource type and so cannot be granted without an account-wide reach the
   * permission sets refuse. A field only an over-broad grant could fill is a field whose
   * implementer ships AccessDenied into a customer's account.
   */
  imageState?: string | null | undefined;
  status: SyncReconcileRequestStatus73;
  backend: "awsMicrovm";
};

/**
 * Content-free telemetry about what a sandbox resource is running.
 *
 * @remarks
 *
 * Never anything from inside a sandbox. A controller reaches only the cloud's management APIs,
 * and the whole point of the resource is that the control plane cannot see what runs in it.
 */
export type SyncReconcileRequestDataUnion18 =
  | DataAwsMicrovm
  | DataAzureSandboxGroup
  | DataGcpAgentPlatform
  | DataKubernetesPods
  | DataLocal12;

export type DataSandbox = {
  /**
   * Content-free telemetry about what a sandbox resource is running.
   *
   * @remarks
   *
   * Never anything from inside a sandbox. A controller reaches only the cloud's management APIs,
   * and the whole point of the resource is that the control plane cannot see what runs in it.
   */
  data:
    | DataAwsMicrovm
    | DataAzureSandboxGroup
    | DataGcpAgentPlatform
    | DataKubernetesPods
    | DataLocal12;
  resourceType: "sandbox";
};

export const SyncReconcileRequestHealth72 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth72 = ClosedEnum<
  typeof SyncReconcileRequestHealth72
>;

export const SyncReconcileRequestLifecycle72 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle72 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle72
>;

export type SyncReconcileRequestStatus72 = {
  health: SyncReconcileRequestHealth72;
  lifecycle: SyncReconcileRequestLifecycle72;
  message?: string | null | undefined;
};

export type SyncReconcileRequestData8 = {
  enabled?: boolean | null | undefined;
  keyId: string;
  keyOperations: Array<string>;
  keyType: string;
  recoveryLevel?: string | null | undefined;
  status: SyncReconcileRequestStatus72;
};

export type DataAzureKeyVault2 = {
  data: SyncReconcileRequestData8;
  provider: "azure-key-vault";
};

export const SyncReconcileRequestHealth71 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth71 = ClosedEnum<
  typeof SyncReconcileRequestHealth71
>;

export const SyncReconcileRequestLifecycle71 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle71 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle71
>;

export type SyncReconcileRequestStatus71 = {
  health: SyncReconcileRequestHealth71;
  lifecycle: SyncReconcileRequestLifecycle71;
  message?: string | null | undefined;
};

export type SyncReconcileRequestData7 = {
  algorithm?: string | null | undefined;
  cryptoKeyName: string;
  primaryState?: string | null | undefined;
  primaryVersion?: string | null | undefined;
  purpose: string;
  status: SyncReconcileRequestStatus71;
};

export type DataGcpCloudKms = {
  data: SyncReconcileRequestData7;
  provider: "gcp-cloud-kms";
};

export const SyncReconcileRequestHealth70 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth70 = ClosedEnum<
  typeof SyncReconcileRequestHealth70
>;

export const SyncReconcileRequestLifecycle70 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle70 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle70
>;

export type SyncReconcileRequestStatus70 = {
  health: SyncReconcileRequestHealth70;
  lifecycle: SyncReconcileRequestLifecycle70;
  message?: string | null | undefined;
};

export type SyncReconcileRequestData6 = {
  enabled: boolean;
  keyArn: string;
  keySpec: string;
  keyState: string;
  keyUsage: string;
  status: SyncReconcileRequestStatus70;
};

export type DataAwsKms = {
  data: SyncReconcileRequestData6;
  provider: "aws-kms";
};

export type SyncReconcileRequestDataUnion17 =
  | DataAwsKms
  | DataGcpCloudKms
  | DataAzureKeyVault2;

export type DataKey = {
  data: DataAwsKms | DataGcpCloudKms | DataAzureKeyVault2;
  resourceType: "key";
};

export const SyncReconcileRequestAccessTest4 = {
  Verified: "verified",
  Failed: "failed",
  NotChecked: "not-checked",
} as const;
export type SyncReconcileRequestAccessTest4 = ClosedEnum<
  typeof SyncReconcileRequestAccessTest4
>;

export const SyncReconcileRequestModelAvailability4 = {
  Available: "available",
  Blocked: "blocked",
  Unknown: "unknown",
} as const;
export type SyncReconcileRequestModelAvailability4 = ClosedEnum<
  typeof SyncReconcileRequestModelAvailability4
>;

export const AvailabilityBlocker4 = {
  AgreementRequired: "agreement-required",
  EntitlementRequired: "entitlement-required",
  ModelActivationRequired: "model-activation-required",
  DeploymentRequired: "deployment-required",
  QuotaConfigurationRequired: "quota-configuration-required",
  RegionUnavailable: "region-unavailable",
  AccessDenied: "access-denied",
  ObservationFailed: "observation-failed",
} as const;
export type AvailabilityBlocker4 = ClosedEnum<typeof AvailabilityBlocker4>;

/**
 * A public API accepted from an application client.
 */
export const SyncReconcileRequestClientApi4 = {
  OpenAiChatCompletions: "open-ai-chat-completions",
  OpenAiResponses: "open-ai-responses",
  AnthropicMessages: "anthropic-messages",
} as const;
/**
 * A public API accepted from an application client.
 */
export type SyncReconcileRequestClientApi4 = ClosedEnum<
  typeof SyncReconcileRequestClientApi4
>;

export type SyncReconcileRequestModel4 = {
  accessTest: SyncReconcileRequestAccessTest4;
  availability: SyncReconcileRequestModelAvailability4;
  blockers: Array<AvailabilityBlocker4>;
  clientApis: Array<SyncReconcileRequestClientApi4>;
  errorCode?: string | null | undefined;
  publicModelId: string;
  testedAt?: Date | null | undefined;
};

/**
 * Provider control plane used to observe model availability without invoking
 *
 * @remarks
 * a model, spending customer quota, or accepting provider terms.
 */
export const AvailabilitySource4 = {
  AwsBedrock: "aws-bedrock",
  GcpVertex: "gcp-vertex",
  AzureFoundry: "azure-foundry",
  Anthropic: "anthropic",
} as const;
/**
 * Provider control plane used to observe model availability without invoking
 *
 * @remarks
 * a model, spending customer quota, or accepting provider terms.
 */
export type AvailabilitySource4 = ClosedEnum<typeof AvailabilitySource4>;

export type SyncReconcileRequestAvailability4 = {
  catalogRevision: string;
  location?: string | null | undefined;
  models: Array<SyncReconcileRequestModel4>;
  /**
   * Provider control plane used to observe model availability without invoking
   *
   * @remarks
   * a model, spending customer quota, or accepting provider terms.
   */
  source: AvailabilitySource4;
};

export type Availability = SyncReconcileRequestAvailability4 | any;

export const SyncReconcileRequestReason69 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason69 = ClosedEnum<
  typeof SyncReconcileRequestReason69
>;

export const StatusSeverity69 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity69 = ClosedEnum<typeof StatusSeverity69>;

export type SyncReconcileRequestCollectionIssue69 = {
  message: string;
  reason: SyncReconcileRequestReason69;
  severity: StatusSeverity69;
  source: string;
};

export const SyncReconcileRequestHealth69 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth69 = ClosedEnum<
  typeof SyncReconcileRequestHealth69
>;

export const SyncReconcileRequestLifecycle69 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle69 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle69
>;

export type SyncReconcileRequestStatus69 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue69>;
  health: SyncReconcileRequestHealth69;
  lifecycle: SyncReconcileRequestLifecycle69;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataExternal = {
  availability?: SyncReconcileRequestAvailability4 | any | null | undefined;
  /**
   * The BYO-key provider serving this binding (e.g. "openai"). Used on the Local
   *
   * @remarks
   * platform, where the app brings its own provider key instead of an ambient cloud.
   */
  provider: string;
  status: SyncReconcileRequestStatus69;
  backend: "external";
};

export const SyncReconcileRequestAccessTest3 = {
  Verified: "verified",
  Failed: "failed",
  NotChecked: "not-checked",
} as const;
export type SyncReconcileRequestAccessTest3 = ClosedEnum<
  typeof SyncReconcileRequestAccessTest3
>;

export const SyncReconcileRequestModelAvailability3 = {
  Available: "available",
  Blocked: "blocked",
  Unknown: "unknown",
} as const;
export type SyncReconcileRequestModelAvailability3 = ClosedEnum<
  typeof SyncReconcileRequestModelAvailability3
>;

export const AvailabilityBlocker3 = {
  AgreementRequired: "agreement-required",
  EntitlementRequired: "entitlement-required",
  ModelActivationRequired: "model-activation-required",
  DeploymentRequired: "deployment-required",
  QuotaConfigurationRequired: "quota-configuration-required",
  RegionUnavailable: "region-unavailable",
  AccessDenied: "access-denied",
  ObservationFailed: "observation-failed",
} as const;
export type AvailabilityBlocker3 = ClosedEnum<typeof AvailabilityBlocker3>;

/**
 * A public API accepted from an application client.
 */
export const SyncReconcileRequestClientApi3 = {
  OpenAiChatCompletions: "open-ai-chat-completions",
  OpenAiResponses: "open-ai-responses",
  AnthropicMessages: "anthropic-messages",
} as const;
/**
 * A public API accepted from an application client.
 */
export type SyncReconcileRequestClientApi3 = ClosedEnum<
  typeof SyncReconcileRequestClientApi3
>;

export type SyncReconcileRequestModel3 = {
  accessTest: SyncReconcileRequestAccessTest3;
  availability: SyncReconcileRequestModelAvailability3;
  blockers: Array<AvailabilityBlocker3>;
  clientApis: Array<SyncReconcileRequestClientApi3>;
  errorCode?: string | null | undefined;
  publicModelId: string;
  testedAt?: Date | null | undefined;
};

/**
 * Provider control plane used to observe model availability without invoking
 *
 * @remarks
 * a model, spending customer quota, or accepting provider terms.
 */
export const AvailabilitySource3 = {
  AwsBedrock: "aws-bedrock",
  GcpVertex: "gcp-vertex",
  AzureFoundry: "azure-foundry",
  Anthropic: "anthropic",
} as const;
/**
 * Provider control plane used to observe model availability without invoking
 *
 * @remarks
 * a model, spending customer quota, or accepting provider terms.
 */
export type AvailabilitySource3 = ClosedEnum<typeof AvailabilitySource3>;

export type SyncReconcileRequestAvailability3 = {
  catalogRevision: string;
  location?: string | null | undefined;
  models: Array<SyncReconcileRequestModel3>;
  /**
   * Provider control plane used to observe model availability without invoking
   *
   * @remarks
   * a model, spending customer quota, or accepting provider terms.
   */
  source: AvailabilitySource3;
};

export const SyncReconcileRequestReason68 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason68 = ClosedEnum<
  typeof SyncReconcileRequestReason68
>;

export const StatusSeverity68 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity68 = ClosedEnum<typeof StatusSeverity68>;

export type SyncReconcileRequestCollectionIssue68 = {
  message: string;
  reason: SyncReconcileRequestReason68;
  severity: StatusSeverity68;
  source: string;
};

export const SyncReconcileRequestHealth68 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth68 = ClosedEnum<
  typeof SyncReconcileRequestHealth68
>;

export const SyncReconcileRequestLifecycle68 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle68 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle68
>;

export type SyncReconcileRequestStatus68 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue68>;
  health: SyncReconcileRequestHealth68;
  lifecycle: SyncReconcileRequestLifecycle68;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureFoundry = {
  accountName: string;
  availability: SyncReconcileRequestAvailability3;
  endpoint?: string | null | undefined;
  location?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  status: SyncReconcileRequestStatus68;
  backend: "azureFoundry";
};

export const SyncReconcileRequestAccessTest2 = {
  Verified: "verified",
  Failed: "failed",
  NotChecked: "not-checked",
} as const;
export type SyncReconcileRequestAccessTest2 = ClosedEnum<
  typeof SyncReconcileRequestAccessTest2
>;

export const SyncReconcileRequestModelAvailability2 = {
  Available: "available",
  Blocked: "blocked",
  Unknown: "unknown",
} as const;
export type SyncReconcileRequestModelAvailability2 = ClosedEnum<
  typeof SyncReconcileRequestModelAvailability2
>;

export const AvailabilityBlocker2 = {
  AgreementRequired: "agreement-required",
  EntitlementRequired: "entitlement-required",
  ModelActivationRequired: "model-activation-required",
  DeploymentRequired: "deployment-required",
  QuotaConfigurationRequired: "quota-configuration-required",
  RegionUnavailable: "region-unavailable",
  AccessDenied: "access-denied",
  ObservationFailed: "observation-failed",
} as const;
export type AvailabilityBlocker2 = ClosedEnum<typeof AvailabilityBlocker2>;

/**
 * A public API accepted from an application client.
 */
export const SyncReconcileRequestClientApi2 = {
  OpenAiChatCompletions: "open-ai-chat-completions",
  OpenAiResponses: "open-ai-responses",
  AnthropicMessages: "anthropic-messages",
} as const;
/**
 * A public API accepted from an application client.
 */
export type SyncReconcileRequestClientApi2 = ClosedEnum<
  typeof SyncReconcileRequestClientApi2
>;

export type SyncReconcileRequestModel2 = {
  accessTest: SyncReconcileRequestAccessTest2;
  availability: SyncReconcileRequestModelAvailability2;
  blockers: Array<AvailabilityBlocker2>;
  clientApis: Array<SyncReconcileRequestClientApi2>;
  errorCode?: string | null | undefined;
  publicModelId: string;
  testedAt?: Date | null | undefined;
};

/**
 * Provider control plane used to observe model availability without invoking
 *
 * @remarks
 * a model, spending customer quota, or accepting provider terms.
 */
export const AvailabilitySource2 = {
  AwsBedrock: "aws-bedrock",
  GcpVertex: "gcp-vertex",
  AzureFoundry: "azure-foundry",
  Anthropic: "anthropic",
} as const;
/**
 * Provider control plane used to observe model availability without invoking
 *
 * @remarks
 * a model, spending customer quota, or accepting provider terms.
 */
export type AvailabilitySource2 = ClosedEnum<typeof AvailabilitySource2>;

export type SyncReconcileRequestAvailability2 = {
  catalogRevision: string;
  location?: string | null | undefined;
  models: Array<SyncReconcileRequestModel2>;
  /**
   * Provider control plane used to observe model availability without invoking
   *
   * @remarks
   * a model, spending customer quota, or accepting provider terms.
   */
  source: AvailabilitySource2;
};

export const SyncReconcileRequestReason67 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason67 = ClosedEnum<
  typeof SyncReconcileRequestReason67
>;

export const StatusSeverity67 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity67 = ClosedEnum<typeof StatusSeverity67>;

export type SyncReconcileRequestCollectionIssue67 = {
  message: string;
  reason: SyncReconcileRequestReason67;
  severity: StatusSeverity67;
  source: string;
};

export const SyncReconcileRequestHealth67 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth67 = ClosedEnum<
  typeof SyncReconcileRequestHealth67
>;

export const SyncReconcileRequestLifecycle67 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle67 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle67
>;

export type SyncReconcileRequestStatus67 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue67>;
  health: SyncReconcileRequestHealth67;
  lifecycle: SyncReconcileRequestLifecycle67;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpVertex = {
  availability: SyncReconcileRequestAvailability2;
  location: string;
  project: string;
  status: SyncReconcileRequestStatus67;
  backend: "gcpVertex";
};

export const SyncReconcileRequestAccessTest1 = {
  Verified: "verified",
  Failed: "failed",
  NotChecked: "not-checked",
} as const;
export type SyncReconcileRequestAccessTest1 = ClosedEnum<
  typeof SyncReconcileRequestAccessTest1
>;

export const SyncReconcileRequestModelAvailability1 = {
  Available: "available",
  Blocked: "blocked",
  Unknown: "unknown",
} as const;
export type SyncReconcileRequestModelAvailability1 = ClosedEnum<
  typeof SyncReconcileRequestModelAvailability1
>;

export const AvailabilityBlocker1 = {
  AgreementRequired: "agreement-required",
  EntitlementRequired: "entitlement-required",
  ModelActivationRequired: "model-activation-required",
  DeploymentRequired: "deployment-required",
  QuotaConfigurationRequired: "quota-configuration-required",
  RegionUnavailable: "region-unavailable",
  AccessDenied: "access-denied",
  ObservationFailed: "observation-failed",
} as const;
export type AvailabilityBlocker1 = ClosedEnum<typeof AvailabilityBlocker1>;

/**
 * A public API accepted from an application client.
 */
export const SyncReconcileRequestClientApi1 = {
  OpenAiChatCompletions: "open-ai-chat-completions",
  OpenAiResponses: "open-ai-responses",
  AnthropicMessages: "anthropic-messages",
} as const;
/**
 * A public API accepted from an application client.
 */
export type SyncReconcileRequestClientApi1 = ClosedEnum<
  typeof SyncReconcileRequestClientApi1
>;

export type SyncReconcileRequestModel1 = {
  accessTest: SyncReconcileRequestAccessTest1;
  availability: SyncReconcileRequestModelAvailability1;
  blockers: Array<AvailabilityBlocker1>;
  clientApis: Array<SyncReconcileRequestClientApi1>;
  errorCode?: string | null | undefined;
  publicModelId: string;
  testedAt?: Date | null | undefined;
};

/**
 * Provider control plane used to observe model availability without invoking
 *
 * @remarks
 * a model, spending customer quota, or accepting provider terms.
 */
export const AvailabilitySource1 = {
  AwsBedrock: "aws-bedrock",
  GcpVertex: "gcp-vertex",
  AzureFoundry: "azure-foundry",
  Anthropic: "anthropic",
} as const;
/**
 * Provider control plane used to observe model availability without invoking
 *
 * @remarks
 * a model, spending customer quota, or accepting provider terms.
 */
export type AvailabilitySource1 = ClosedEnum<typeof AvailabilitySource1>;

export type SyncReconcileRequestAvailability1 = {
  catalogRevision: string;
  location?: string | null | undefined;
  models: Array<SyncReconcileRequestModel1>;
  /**
   * Provider control plane used to observe model availability without invoking
   *
   * @remarks
   * a model, spending customer quota, or accepting provider terms.
   */
  source: AvailabilitySource1;
};

export const SyncReconcileRequestReason66 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason66 = ClosedEnum<
  typeof SyncReconcileRequestReason66
>;

export const StatusSeverity66 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity66 = ClosedEnum<typeof StatusSeverity66>;

export type SyncReconcileRequestCollectionIssue66 = {
  message: string;
  reason: SyncReconcileRequestReason66;
  severity: StatusSeverity66;
  source: string;
};

export const SyncReconcileRequestHealth66 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth66 = ClosedEnum<
  typeof SyncReconcileRequestHealth66
>;

export const SyncReconcileRequestLifecycle66 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle66 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle66
>;

export type SyncReconcileRequestStatus66 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue66>;
  health: SyncReconcileRequestHealth66;
  lifecycle: SyncReconcileRequestLifecycle66;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsBedrock = {
  availability: SyncReconcileRequestAvailability1;
  region: string;
  status: SyncReconcileRequestStatus66;
  backend: "awsBedrock";
};

export type SyncReconcileRequestDataUnion16 =
  | DataAwsBedrock
  | DataGcpVertex
  | DataAzureFoundry
  | DataExternal;

export type DataAi = {
  data: DataAwsBedrock | DataGcpVertex | DataAzureFoundry | DataExternal;
  resourceType: "ai";
};

export const SyncReconcileRequestReason65 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason65 = ClosedEnum<
  typeof SyncReconcileRequestReason65
>;

export const StatusSeverity65 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity65 = ClosedEnum<typeof StatusSeverity65>;

export type SyncReconcileRequestCollectionIssue65 = {
  message: string;
  reason: SyncReconcileRequestReason65;
  severity: StatusSeverity65;
  source: string;
};

export const SyncReconcileRequestHealth65 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth65 = ClosedEnum<
  typeof SyncReconcileRequestHealth65
>;

export const SyncReconcileRequestLifecycle65 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle65 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle65
>;

export type SyncReconcileRequestStatus65 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue65>;
  health: SyncReconcileRequestHealth65;
  lifecycle: SyncReconcileRequestLifecycle65;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type SyncReconcileRequestData5 = {
  createdAt?: string | null | undefined;
  disableLocalAuth?: boolean | null | undefined;
  location?: string | null | undefined;
  metricId?: string | null | undefined;
  minimumTlsVersion?: string | null | undefined;
  name: string;
  namespaceStatus?: string | null | undefined;
  premiumMessagingPartitions?: number | null | undefined;
  privateEndpointConnectionCount: number;
  provisioningState?: string | null | undefined;
  publicNetworkAccess?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  serviceBusEndpoint?: string | null | undefined;
  skuCapacity?: number | null | undefined;
  skuName?: string | null | undefined;
  skuTier?: string | null | undefined;
  status: SyncReconcileRequestStatus65;
  updatedAt?: string | null | undefined;
  zoneRedundant?: boolean | null | undefined;
};

export type DataAzureServiceBusNamespace = {
  data: SyncReconcileRequestData5;
  resourceType: "azure_service_bus_namespace";
};

export const SyncReconcileRequestReason64 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason64 = ClosedEnum<
  typeof SyncReconcileRequestReason64
>;

export const StatusSeverity64 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity64 = ClosedEnum<typeof StatusSeverity64>;

export type SyncReconcileRequestCollectionIssue64 = {
  message: string;
  reason: SyncReconcileRequestReason64;
  severity: StatusSeverity64;
  source: string;
};

export const SyncReconcileRequestHealth64 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth64 = ClosedEnum<
  typeof SyncReconcileRequestHealth64
>;

export const SyncReconcileRequestLifecycle64 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle64 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle64
>;

export type SyncReconcileRequestStatus64 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue64>;
  health: SyncReconcileRequestHealth64;
  lifecycle: SyncReconcileRequestLifecycle64;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type WorkloadProfile = {
  maximumCount?: number | null | undefined;
  minimumCount?: number | null | undefined;
  name: string;
  workloadProfileType: string;
};

export type SyncReconcileRequestData4 = {
  customDomainVerificationId?: string | null | undefined;
  defaultDomain?: string | null | undefined;
  eventStreamEndpoint?: string | null | undefined;
  infrastructureResourceGroup?: string | null | undefined;
  kind?: string | null | undefined;
  location?: string | null | undefined;
  name: string;
  provisioningState?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  staticIp?: string | null | undefined;
  status: SyncReconcileRequestStatus64;
  workloadProfileCount: number;
  workloadProfiles: Array<WorkloadProfile>;
  zoneRedundant?: boolean | null | undefined;
};

export type DataAzureContainerAppsEnvironment = {
  data: SyncReconcileRequestData4;
  resourceType: "azure_container_apps_environment";
};

export type PrimaryEndpoints = {
  blob?: string | null | undefined;
  dfs?: string | null | undefined;
  file?: string | null | undefined;
  queue?: string | null | undefined;
  table?: string | null | undefined;
  web?: string | null | undefined;
};

export type SecondaryEndpoints = {
  blob?: string | null | undefined;
  dfs?: string | null | undefined;
  file?: string | null | undefined;
  queue?: string | null | undefined;
  table?: string | null | undefined;
  web?: string | null | undefined;
};

export const SyncReconcileRequestReason63 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason63 = ClosedEnum<
  typeof SyncReconcileRequestReason63
>;

export const StatusSeverity63 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity63 = ClosedEnum<typeof StatusSeverity63>;

export type SyncReconcileRequestCollectionIssue63 = {
  message: string;
  reason: SyncReconcileRequestReason63;
  severity: StatusSeverity63;
  source: string;
};

export const SyncReconcileRequestHealth63 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth63 = ClosedEnum<
  typeof SyncReconcileRequestHealth63
>;

export const SyncReconcileRequestLifecycle63 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle63 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle63
>;

export type SyncReconcileRequestStatus63 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue63>;
  health: SyncReconcileRequestHealth63;
  lifecycle: SyncReconcileRequestLifecycle63;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type SyncReconcileRequestData3 = {
  allowBlobPublicAccess?: boolean | null | undefined;
  allowSharedKeyAccess?: boolean | null | undefined;
  encryptionKeySource?: string | null | undefined;
  kind?: string | null | undefined;
  location?: string | null | undefined;
  minimumTlsVersion?: string | null | undefined;
  name: string;
  networkBypass?: string | null | undefined;
  networkDefaultAction?: string | null | undefined;
  networkIpRuleCount?: number | null | undefined;
  networkResourceAccessRuleCount?: number | null | undefined;
  networkVirtualNetworkRuleCount?: number | null | undefined;
  primaryEndpoints: PrimaryEndpoints;
  provisioningState?: string | null | undefined;
  publicNetworkAccess?: string | null | undefined;
  requireInfrastructureEncryption?: boolean | null | undefined;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  secondaryEndpoints: SecondaryEndpoints;
  skuName?: string | null | undefined;
  skuTier?: string | null | undefined;
  status: SyncReconcileRequestStatus63;
  supportsHttpsTrafficOnly?: boolean | null | undefined;
};

export type DataAzureStorageAccount = {
  data: SyncReconcileRequestData3;
  resourceType: "azure_storage_account";
};

export const SyncReconcileRequestReason62 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason62 = ClosedEnum<
  typeof SyncReconcileRequestReason62
>;

export const StatusSeverity62 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity62 = ClosedEnum<typeof StatusSeverity62>;

export type SyncReconcileRequestCollectionIssue62 = {
  message: string;
  reason: SyncReconcileRequestReason62;
  severity: StatusSeverity62;
  source: string;
};

export const SyncReconcileRequestHealth62 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth62 = ClosedEnum<
  typeof SyncReconcileRequestHealth62
>;

export const SyncReconcileRequestLifecycle62 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle62 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle62
>;

export type SyncReconcileRequestStatus62 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue62>;
  health: SyncReconcileRequestHealth62;
  lifecycle: SyncReconcileRequestLifecycle62;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type SyncReconcileRequestData2 = {
  location?: string | null | undefined;
  managedTags: { [k: string]: string };
  name: string;
  provisioningState?: string | null | undefined;
  resourceId?: string | null | undefined;
  status: SyncReconcileRequestStatus62;
};

export type DataAzureResourceGroup = {
  data: SyncReconcileRequestData2;
  resourceType: "azure_resource_group";
};

export const SyncReconcileRequestReason61 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason61 = ClosedEnum<
  typeof SyncReconcileRequestReason61
>;

export const StatusSeverity61 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity61 = ClosedEnum<typeof StatusSeverity61>;

export type SyncReconcileRequestCollectionIssue61 = {
  message: string;
  reason: SyncReconcileRequestReason61;
  severity: StatusSeverity61;
  source: string;
};

export const SyncReconcileRequestHealth61 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth61 = ClosedEnum<
  typeof SyncReconcileRequestHealth61
>;

export const SyncReconcileRequestLifecycle61 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle61 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle61
>;

export type SyncReconcileRequestStatus61 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue61>;
  health: SyncReconcileRequestHealth61;
  lifecycle: SyncReconcileRequestLifecycle61;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureResourceProvider = {
  namespace: string;
  providerId?: string | null | undefined;
  registered: boolean;
  registrationPolicy?: string | null | undefined;
  registrationState?: string | null | undefined;
  resourceTypeCount: number;
  status: SyncReconcileRequestStatus61;
  backend: "azureResourceProvider";
};

export const SyncReconcileRequestReason60 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason60 = ClosedEnum<
  typeof SyncReconcileRequestReason60
>;

export const StatusSeverity60 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity60 = ClosedEnum<typeof StatusSeverity60>;

export type SyncReconcileRequestCollectionIssue60 = {
  message: string;
  reason: SyncReconcileRequestReason60;
  severity: StatusSeverity60;
  source: string;
};

export const SyncReconcileRequestHealth60 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth60 = ClosedEnum<
  typeof SyncReconcileRequestHealth60
>;

export const SyncReconcileRequestLifecycle60 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle60 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle60
>;

export type SyncReconcileRequestStatus60 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue60>;
  health: SyncReconcileRequestHealth60;
  lifecycle: SyncReconcileRequestLifecycle60;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpServiceUsage = {
  enabled: boolean;
  lastOperationName?: string | null | undefined;
  projectId: string;
  serviceName: string;
  serviceResourceName?: string | null | undefined;
  state?: string | null | undefined;
  status: SyncReconcileRequestStatus60;
  title?: string | null | undefined;
  backend: "gcpServiceUsage";
};

export type SyncReconcileRequestDataUnion15 =
  | DataGcpServiceUsage
  | DataAzureResourceProvider;

export type DataServiceActivation = {
  data: DataGcpServiceUsage | DataAzureResourceProvider;
  resourceType: "service_activation";
};

export type InvolvedObject10 = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

export type InvolvedObjectUnion10 = InvolvedObject10 | any;

export type SourceEvent10 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion10 = SourceEvent10 | any;

export type SyncReconcileRequestEvent13 = {
  count?: number | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject10 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent10 | any | null | undefined;
  type?: string | null | undefined;
};

export const SyncReconcileRequestReason59 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason59 = ClosedEnum<
  typeof SyncReconcileRequestReason59
>;

export const StatusSeverity59 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity59 = ClosedEnum<typeof StatusSeverity59>;

export type SyncReconcileRequestCollectionIssue59 = {
  message: string;
  reason: SyncReconcileRequestReason59;
  severity: StatusSeverity59;
  source: string;
};

export const SyncReconcileRequestHealth59 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth59 = ClosedEnum<
  typeof SyncReconcileRequestHealth59
>;

export const SyncReconcileRequestLifecycle59 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle59 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle59
>;

export type SyncReconcileRequestStatus59 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue59>;
  health: SyncReconcileRequestHealth59;
  lifecycle: SyncReconcileRequestLifecycle59;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataKubernetesJob = {
  active?: number | null | undefined;
  completionTime?: Date | null | undefined;
  conditionCount: number;
  events: Array<SyncReconcileRequestEvent13>;
  failed?: number | null | undefined;
  imageDigest?: string | null | undefined;
  jobName: string;
  namespace: string;
  startTime?: Date | null | undefined;
  status: SyncReconcileRequestStatus59;
  succeeded?: number | null | undefined;
  backend: "kubernetesJob";
};

export const SyncReconcileRequestReason58 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason58 = ClosedEnum<
  typeof SyncReconcileRequestReason58
>;

export const StatusSeverity58 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity58 = ClosedEnum<typeof StatusSeverity58>;

export type SyncReconcileRequestCollectionIssue58 = {
  message: string;
  reason: SyncReconcileRequestReason58;
  severity: StatusSeverity58;
  source: string;
};

export const SyncReconcileRequestHealth58 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth58 = ClosedEnum<
  typeof SyncReconcileRequestHealth58
>;

export const SyncReconcileRequestLifecycle58 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle58 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle58
>;

export type SyncReconcileRequestStatus58 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue58>;
  health: SyncReconcileRequestHealth58;
  lifecycle: SyncReconcileRequestLifecycle58;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureContainerApps2 = {
  environmentVariableCount: number;
  managedEnvironmentId: string;
  managedIdentityId?: string | null | undefined;
  resourceGroupName: string;
  resourcePrefix?: string | null | undefined;
  status: SyncReconcileRequestStatus58;
  backend: "azureContainerApps";
};

export const SyncReconcileRequestReason57 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason57 = ClosedEnum<
  typeof SyncReconcileRequestReason57
>;

export const StatusSeverity57 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity57 = ClosedEnum<typeof StatusSeverity57>;

export type SyncReconcileRequestCollectionIssue57 = {
  message: string;
  reason: SyncReconcileRequestReason57;
  severity: StatusSeverity57;
  source: string;
};

export const SyncReconcileRequestHealth57 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth57 = ClosedEnum<
  typeof SyncReconcileRequestHealth57
>;

export const SyncReconcileRequestLifecycle57 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle57 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle57
>;

export type SyncReconcileRequestStatus57 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue57>;
  health: SyncReconcileRequestHealth57;
  lifecycle: SyncReconcileRequestLifecycle57;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpCloudBuild = {
  buildConfigId: string;
  environmentVariableCount: number;
  location: string;
  projectId: string;
  serviceAccount?: string | null | undefined;
  status: SyncReconcileRequestStatus57;
  backend: "gcpCloudBuild";
};

export const SyncReconcileRequestReason56 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason56 = ClosedEnum<
  typeof SyncReconcileRequestReason56
>;

export const StatusSeverity56 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity56 = ClosedEnum<typeof StatusSeverity56>;

export type SyncReconcileRequestCollectionIssue56 = {
  message: string;
  reason: SyncReconcileRequestReason56;
  severity: StatusSeverity56;
  source: string;
};

export const SyncReconcileRequestHealth56 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth56 = ClosedEnum<
  typeof SyncReconcileRequestHealth56
>;

export const SyncReconcileRequestLifecycle56 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle56 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle56
>;

export type SyncReconcileRequestStatus56 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue56>;
  health: SyncReconcileRequestHealth56;
  lifecycle: SyncReconcileRequestLifecycle56;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsCodeBuild = {
  artifactsEncryptionDisabled?: boolean | null | undefined;
  artifactsType?: string | null | undefined;
  cloudWatchLogsStatus?: string | null | undefined;
  computeType?: string | null | undefined;
  created?: number | null | undefined;
  description?: string | null | undefined;
  encryptionKeyPresent: boolean;
  environmentImage?: string | null | undefined;
  environmentType?: string | null | undefined;
  environmentVariableCount: number;
  imagePullCredentialsType?: string | null | undefined;
  lastModified?: number | null | undefined;
  privilegedMode?: boolean | null | undefined;
  projectArn?: string | null | undefined;
  projectName: string;
  queuedTimeoutInMinutes?: number | null | undefined;
  s3LogsStatus?: string | null | undefined;
  serviceRolePresent: boolean;
  sourceType?: string | null | undefined;
  status: SyncReconcileRequestStatus56;
  timeoutInMinutes?: number | null | undefined;
  backend: "awsCodeBuild";
};

export type SyncReconcileRequestDataUnion14 =
  | DataAwsCodeBuild
  | DataGcpCloudBuild
  | DataAzureContainerApps2
  | DataKubernetesJob;

export type DataBuild = {
  data:
    | DataAwsCodeBuild
    | DataGcpCloudBuild
    | DataAzureContainerApps2
    | DataKubernetesJob;
  resourceType: "build";
};

export const SyncReconcileRequestReason55 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason55 = ClosedEnum<
  typeof SyncReconcileRequestReason55
>;

export const StatusSeverity55 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity55 = ClosedEnum<typeof StatusSeverity55>;

export type SyncReconcileRequestCollectionIssue55 = {
  message: string;
  reason: SyncReconcileRequestReason55;
  severity: StatusSeverity55;
  source: string;
};

export const SyncReconcileRequestHealth55 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth55 = ClosedEnum<
  typeof SyncReconcileRequestHealth55
>;

export const SyncReconcileRequestLifecycle55 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle55 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle55
>;

export type SyncReconcileRequestStatus55 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue55>;
  health: SyncReconcileRequestHealth55;
  lifecycle: SyncReconcileRequestLifecycle55;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal11 = {
  reachable: boolean;
  registryUrl: string;
  status: SyncReconcileRequestStatus55;
  backend: "local";
};

export const SyncReconcileRequestReason54 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason54 = ClosedEnum<
  typeof SyncReconcileRequestReason54
>;

export const StatusSeverity54 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity54 = ClosedEnum<typeof StatusSeverity54>;

export type SyncReconcileRequestCollectionIssue54 = {
  message: string;
  reason: SyncReconcileRequestReason54;
  severity: StatusSeverity54;
  source: string;
};

export const SyncReconcileRequestHealth54 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth54 = ClosedEnum<
  typeof SyncReconcileRequestHealth54
>;

export const SyncReconcileRequestLifecycle54 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle54 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle54
>;

export type SyncReconcileRequestStatus54 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue54>;
  health: SyncReconcileRequestHealth54;
  lifecycle: SyncReconcileRequestLifecycle54;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureContainerRegistry = {
  adminUserEnabled: boolean;
  anonymousPullEnabled: boolean;
  creationDate?: string | null | undefined;
  dataEndpointEnabled?: boolean | null | undefined;
  dataEndpointHostNames: Array<string>;
  encryptionKeyIdentifierPresent: boolean;
  encryptionKeyVaultUriPresent: boolean;
  encryptionStatus?: string | null | undefined;
  ipRuleCount: number;
  location: string;
  loginServer?: string | null | undefined;
  managedTagCount: number;
  name: string;
  networkRuleBypassOptions: string;
  networkRuleDefaultAction?: string | null | undefined;
  policiesPresent: boolean;
  policyCount: number;
  privateEndpointConnectionCount: number;
  provisioningState?: string | null | undefined;
  publicNetworkAccess: string;
  resourceGroup: string;
  resourceId?: string | null | undefined;
  skuName: string;
  skuTier?: string | null | undefined;
  status: SyncReconcileRequestStatus54;
  type?: string | null | undefined;
  zoneRedundancy: string;
  backend: "azureContainerRegistry";
};

export const SyncReconcileRequestReason53 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason53 = ClosedEnum<
  typeof SyncReconcileRequestReason53
>;

export const StatusSeverity53 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity53 = ClosedEnum<typeof StatusSeverity53>;

export type SyncReconcileRequestCollectionIssue53 = {
  message: string;
  reason: SyncReconcileRequestReason53;
  severity: StatusSeverity53;
  source: string;
};

export const SyncReconcileRequestHealth53 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth53 = ClosedEnum<
  typeof SyncReconcileRequestHealth53
>;

export const SyncReconcileRequestLifecycle53 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle53 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle53
>;

export type SyncReconcileRequestStatus53 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue53>;
  health: SyncReconcileRequestHealth53;
  lifecycle: SyncReconcileRequestLifecycle53;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpArtifactRegistry = {
  cleanupPolicyCount: number;
  cleanupPolicyDryRun?: boolean | null | undefined;
  createTime?: string | null | undefined;
  description?: string | null | undefined;
  format?: string | null | undefined;
  iamBindingCount: number;
  iamPolicyEtagPresent: boolean;
  iamRoles: Array<string>;
  kmsKeyNamePresent: boolean;
  labelCount: number;
  location: string;
  mode?: string | null | undefined;
  name?: string | null | undefined;
  projectId: string;
  pullServiceAccountEmail?: string | null | undefined;
  pushServiceAccountEmail?: string | null | undefined;
  repositoryId: string;
  satisfiesPzs?: boolean | null | undefined;
  sizeBytes?: string | null | undefined;
  status: SyncReconcileRequestStatus53;
  updateTime?: string | null | undefined;
  backend: "gcpArtifactRegistry";
};

export type SyncReconcileRequestRepository = {
  createdAt: number;
  encryptionType?: string | null | undefined;
  imageTagMutability?: string | null | undefined;
  kmsKeyPresent: boolean;
  registryId: string;
  repositoryArn: string;
  repositoryName: string;
  repositoryUri: string;
  scanOnPush?: boolean | null | undefined;
};

export const SyncReconcileRequestReason52 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason52 = ClosedEnum<
  typeof SyncReconcileRequestReason52
>;

export const StatusSeverity52 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity52 = ClosedEnum<typeof StatusSeverity52>;

export type SyncReconcileRequestCollectionIssue52 = {
  message: string;
  reason: SyncReconcileRequestReason52;
  severity: StatusSeverity52;
  source: string;
};

export const SyncReconcileRequestHealth52 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth52 = ClosedEnum<
  typeof SyncReconcileRequestHealth52
>;

export const SyncReconcileRequestLifecycle52 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle52 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle52
>;

export type SyncReconcileRequestStatus52 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue52>;
  health: SyncReconcileRequestHealth52;
  lifecycle: SyncReconcileRequestLifecycle52;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsEcr = {
  pullRoleArn?: string | null | undefined;
  pushRoleArn?: string | null | undefined;
  region: string;
  registryId: string;
  registryUri: string;
  repositories: Array<SyncReconcileRequestRepository>;
  repositoriesTruncated: boolean;
  repositoryCount: number;
  repositoryPrefix: string;
  status: SyncReconcileRequestStatus52;
  backend: "awsEcr";
};

export type SyncReconcileRequestDataUnion13 =
  | DataAwsEcr
  | DataGcpArtifactRegistry
  | DataAzureContainerRegistry
  | DataLocal11;

export type DataArtifactRegistry = {
  data:
    | DataAwsEcr
    | DataGcpArtifactRegistry
    | DataAzureContainerRegistry
    | DataLocal11;
  resourceType: "artifact-registry";
};

export const SyncReconcileRequestReason51 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason51 = ClosedEnum<
  typeof SyncReconcileRequestReason51
>;

export const StatusSeverity51 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity51 = ClosedEnum<typeof StatusSeverity51>;

export type SyncReconcileRequestCollectionIssue51 = {
  message: string;
  reason: SyncReconcileRequestReason51;
  severity: StatusSeverity51;
  source: string;
};

export const SyncReconcileRequestHealth51 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth51 = ClosedEnum<
  typeof SyncReconcileRequestHealth51
>;

export const SyncReconcileRequestLifecycle51 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle51 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle51
>;

export type SyncReconcileRequestStatus51 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue51>;
  health: SyncReconcileRequestHealth51;
  lifecycle: SyncReconcileRequestLifecycle51;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureManagedIdentity2 = {
  ficName?: string | null | undefined;
  roleAssignmentIds: Array<string>;
  roleDefinitionId?: string | null | undefined;
  status: SyncReconcileRequestStatus51;
  tenantId?: string | null | undefined;
  uamiClientId?: string | null | undefined;
  uamiPrincipalId?: string | null | undefined;
  uamiResourceId?: string | null | undefined;
  backend: "azureManagedIdentity";
};

export const SyncReconcileRequestReason50 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason50 = ClosedEnum<
  typeof SyncReconcileRequestReason50
>;

export const StatusSeverity50 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity50 = ClosedEnum<typeof StatusSeverity50>;

export type SyncReconcileRequestCollectionIssue50 = {
  message: string;
  reason: SyncReconcileRequestReason50;
  severity: StatusSeverity50;
  source: string;
};

export const SyncReconcileRequestHealth50 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth50 = ClosedEnum<
  typeof SyncReconcileRequestHealth50
>;

export const SyncReconcileRequestLifecycle50 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle50 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle50
>;

export type SyncReconcileRequestStatus50 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue50>;
  health: SyncReconcileRequestHealth50;
  lifecycle: SyncReconcileRequestLifecycle50;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpServiceAccount2 = {
  impersonationGranted: boolean;
  roleBound: boolean;
  serviceAccountEmail?: string | null | undefined;
  serviceAccountUniqueId?: string | null | undefined;
  status: SyncReconcileRequestStatus50;
  backend: "gcpServiceAccount";
};

export const SyncReconcileRequestReason49 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason49 = ClosedEnum<
  typeof SyncReconcileRequestReason49
>;

export const StatusSeverity49 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity49 = ClosedEnum<typeof StatusSeverity49>;

export type SyncReconcileRequestCollectionIssue49 = {
  message: string;
  reason: SyncReconcileRequestReason49;
  severity: StatusSeverity49;
  source: string;
};

export const SyncReconcileRequestHealth49 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth49 = ClosedEnum<
  typeof SyncReconcileRequestHealth49
>;

export const SyncReconcileRequestLifecycle49 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle49 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle49
>;

export type SyncReconcileRequestStatus49 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue49>;
  health: SyncReconcileRequestHealth49;
  lifecycle: SyncReconcileRequestLifecycle49;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsIamRole2 = {
  managementPermissionsApplied: boolean;
  roleArn?: string | null | undefined;
  roleName?: string | null | undefined;
  status: SyncReconcileRequestStatus49;
  backend: "awsIamRole";
};

export type SyncReconcileRequestDataUnion12 =
  | DataAwsIamRole2
  | DataGcpServiceAccount2
  | DataAzureManagedIdentity2;

export type DataRemoteStackManagement = {
  data: DataAwsIamRole2 | DataGcpServiceAccount2 | DataAzureManagedIdentity2;
  resourceType: "remote-stack-management";
};

export const SyncReconcileRequestReason48 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason48 = ClosedEnum<
  typeof SyncReconcileRequestReason48
>;

export const StatusSeverity48 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity48 = ClosedEnum<typeof StatusSeverity48>;

export type SyncReconcileRequestCollectionIssue48 = {
  message: string;
  reason: SyncReconcileRequestReason48;
  severity: StatusSeverity48;
  source: string;
};

export const SyncReconcileRequestHealth48 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth48 = ClosedEnum<
  typeof SyncReconcileRequestHealth48
>;

export const SyncReconcileRequestLifecycle48 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle48 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle48
>;

export type SyncReconcileRequestStatus48 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue48>;
  health: SyncReconcileRequestHealth48;
  lifecycle: SyncReconcileRequestLifecycle48;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureVnet = {
  applicationGatewaySubnetName?: string | null | undefined;
  cidrBlock?: string | null | undefined;
  isByoVnet: boolean;
  lastByoVnetVerificationErrorCode?: string | null | undefined;
  location?: string | null | undefined;
  natGatewayId?: string | null | undefined;
  nsgId?: string | null | undefined;
  privateEndpointSubnetName?: string | null | undefined;
  privateSubnetName?: string | null | undefined;
  publicIpId?: string | null | undefined;
  publicSubnetName?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  status: SyncReconcileRequestStatus48;
  vnetName?: string | null | undefined;
  vnetResourceId?: string | null | undefined;
  backend: "azureVnet";
};

export const SyncReconcileRequestReason47 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason47 = ClosedEnum<
  typeof SyncReconcileRequestReason47
>;

export const StatusSeverity47 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity47 = ClosedEnum<typeof StatusSeverity47>;

export type SyncReconcileRequestCollectionIssue47 = {
  message: string;
  reason: SyncReconcileRequestReason47;
  severity: StatusSeverity47;
  source: string;
};

export const SyncReconcileRequestHealth47 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth47 = ClosedEnum<
  typeof SyncReconcileRequestHealth47
>;

export const SyncReconcileRequestLifecycle47 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle47 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle47
>;

export type SyncReconcileRequestStatus47 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue47>;
  health: SyncReconcileRequestHealth47;
  lifecycle: SyncReconcileRequestLifecycle47;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpVpc = {
  cidrBlock?: string | null | undefined;
  cloudNatName?: string | null | undefined;
  firewallName?: string | null | undefined;
  isByoVpc: boolean;
  networkName?: string | null | undefined;
  networkSelfLink?: string | null | undefined;
  region?: string | null | undefined;
  routerName?: string | null | undefined;
  status: SyncReconcileRequestStatus47;
  subnetworkName?: string | null | undefined;
  subnetworkSelfLink?: string | null | undefined;
  backend: "gcpVpc";
};

export const SyncReconcileRequestReason46 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason46 = ClosedEnum<
  typeof SyncReconcileRequestReason46
>;

export const StatusSeverity46 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity46 = ClosedEnum<typeof StatusSeverity46>;

export type SyncReconcileRequestCollectionIssue46 = {
  message: string;
  reason: SyncReconcileRequestReason46;
  severity: StatusSeverity46;
  source: string;
};

export const SyncReconcileRequestHealth46 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth46 = ClosedEnum<
  typeof SyncReconcileRequestHealth46
>;

export const SyncReconcileRequestLifecycle46 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle46 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle46
>;

export type SyncReconcileRequestStatus46 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue46>;
  health: SyncReconcileRequestHealth46;
  lifecycle: SyncReconcileRequestLifecycle46;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsVpc = {
  availabilityZones: Array<string>;
  cidrBlock?: string | null | undefined;
  internetGatewayId?: string | null | undefined;
  isByoVpc: boolean;
  natGatewayId?: string | null | undefined;
  privateSubnetIds: Array<string>;
  publicSubnetIds: Array<string>;
  routeTableCount: number;
  securityGroupId?: string | null | undefined;
  status: SyncReconcileRequestStatus46;
  vpcId?: string | null | undefined;
  vpcState?: string | null | undefined;
  backend: "awsVpc";
};

export type SyncReconcileRequestDataUnion11 =
  | DataAwsVpc
  | DataGcpVpc
  | DataAzureVnet;

export type DataNetwork = {
  data: DataAwsVpc | DataGcpVpc | DataAzureVnet;
  resourceType: "network";
};

export const SyncReconcileRequestReason45 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason45 = ClosedEnum<
  typeof SyncReconcileRequestReason45
>;

export const StatusSeverity45 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity45 = ClosedEnum<typeof StatusSeverity45>;

export type SyncReconcileRequestCollectionIssue45 = {
  message: string;
  reason: SyncReconcileRequestReason45;
  severity: StatusSeverity45;
  source: string;
};

export const SyncReconcileRequestHealth45 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth45 = ClosedEnum<
  typeof SyncReconcileRequestHealth45
>;

export const SyncReconcileRequestLifecycle45 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle45 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle45
>;

export type SyncReconcileRequestStatus45 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue45>;
  health: SyncReconcileRequestHealth45;
  lifecycle: SyncReconcileRequestLifecycle45;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal10 = {
  configured: boolean;
  identity: string;
  status: SyncReconcileRequestStatus45;
  backend: "local";
};

export const SyncReconcileRequestReason44 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason44 = ClosedEnum<
  typeof SyncReconcileRequestReason44
>;

export const StatusSeverity44 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity44 = ClosedEnum<typeof StatusSeverity44>;

export type SyncReconcileRequestCollectionIssue44 = {
  message: string;
  reason: SyncReconcileRequestReason44;
  severity: StatusSeverity44;
  source: string;
};

export const SyncReconcileRequestHealth44 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth44 = ClosedEnum<
  typeof SyncReconcileRequestHealth44
>;

export const SyncReconcileRequestLifecycle44 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle44 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle44
>;

export type SyncReconcileRequestStatus44 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue44>;
  health: SyncReconcileRequestHealth44;
  lifecycle: SyncReconcileRequestLifecycle44;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureManagedIdentity1 = {
  clientId?: string | null | undefined;
  customRoleDefinitionCount: number;
  customRoleDefinitionIds: Array<string>;
  isolationScope?: string | null | undefined;
  location: string;
  managedTagCount: number;
  name: string;
  principalId?: string | null | undefined;
  resourceGroup: string;
  resourceId: string;
  roleAssignmentCount: number;
  roleAssignmentIds: Array<string>;
  stackPermissionsApplied: boolean;
  status: SyncReconcileRequestStatus44;
  tenantId?: string | null | undefined;
  type?: string | null | undefined;
  backend: "azureManagedIdentity";
};

export const SyncReconcileRequestReason43 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason43 = ClosedEnum<
  typeof SyncReconcileRequestReason43
>;

export const StatusSeverity43 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity43 = ClosedEnum<typeof StatusSeverity43>;

export type SyncReconcileRequestCollectionIssue43 = {
  message: string;
  reason: SyncReconcileRequestReason43;
  severity: StatusSeverity43;
  source: string;
};

export const SyncReconcileRequestHealth43 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth43 = ClosedEnum<
  typeof SyncReconcileRequestHealth43
>;

export const SyncReconcileRequestLifecycle43 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle43 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle43
>;

export type SyncReconcileRequestStatus43 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue43>;
  health: SyncReconcileRequestHealth43;
  lifecycle: SyncReconcileRequestLifecycle43;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpServiceAccount1 = {
  description?: string | null | undefined;
  disabled?: boolean | null | undefined;
  displayName?: string | null | undefined;
  email: string;
  etag?: string | null | undefined;
  name?: string | null | undefined;
  oauth2ClientId?: string | null | undefined;
  projectBindingCount: number;
  projectId?: string | null | undefined;
  projectRoles: Array<string>;
  serviceAccountBindingCount: number;
  serviceAccountRoles: Array<string>;
  status: SyncReconcileRequestStatus43;
  uniqueId?: string | null | undefined;
  backend: "gcpServiceAccount";
};

export const SyncReconcileRequestReason42 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason42 = ClosedEnum<
  typeof SyncReconcileRequestReason42
>;

export const StatusSeverity42 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity42 = ClosedEnum<typeof StatusSeverity42>;

export type SyncReconcileRequestCollectionIssue42 = {
  message: string;
  reason: SyncReconcileRequestReason42;
  severity: StatusSeverity42;
  source: string;
};

export const SyncReconcileRequestHealth42 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth42 = ClosedEnum<
  typeof SyncReconcileRequestHealth42
>;

export const SyncReconcileRequestLifecycle42 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle42 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle42
>;

export type SyncReconcileRequestStatus42 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue42>;
  health: SyncReconcileRequestHealth42;
  lifecycle: SyncReconcileRequestLifecycle42;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsIamRole1 = {
  assumeRolePolicyPresent: boolean;
  attachedPolicyCount: number;
  attachedPolicyNames: Array<string>;
  createDate: string;
  description?: string | null | undefined;
  inlinePolicyCount: number;
  inlinePolicyNames: Array<string>;
  lastUsedDate?: string | null | undefined;
  lastUsedRegion?: string | null | undefined;
  managedTagCount: number;
  maxSessionDuration?: number | null | undefined;
  path: string;
  permissionsBoundaryArn?: string | null | undefined;
  permissionsBoundaryType?: string | null | undefined;
  roleArn: string;
  roleId: string;
  roleName: string;
  stackPermissionsApplied: boolean;
  status: SyncReconcileRequestStatus42;
  tagCount: number;
  backend: "awsIamRole";
};

export type SyncReconcileRequestDataUnion10 =
  | DataAwsIamRole1
  | DataGcpServiceAccount1
  | DataAzureManagedIdentity1
  | DataLocal10;

export type DataServiceAccount = {
  data:
    | DataAwsIamRole1
    | DataGcpServiceAccount1
    | DataAzureManagedIdentity1
    | DataLocal10;
  resourceType: "service-account";
};

export const SyncReconcileRequestReason41 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason41 = ClosedEnum<
  typeof SyncReconcileRequestReason41
>;

export const StatusSeverity41 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity41 = ClosedEnum<typeof StatusSeverity41>;

export type SyncReconcileRequestCollectionIssue41 = {
  message: string;
  reason: SyncReconcileRequestReason41;
  severity: StatusSeverity41;
  source: string;
};

export const SyncReconcileRequestHealth41 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth41 = ClosedEnum<
  typeof SyncReconcileRequestHealth41
>;

export const SyncReconcileRequestLifecycle41 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle41 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle41
>;

export type SyncReconcileRequestStatus41 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue41>;
  health: SyncReconcileRequestHealth41;
  lifecycle: SyncReconcileRequestLifecycle41;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal9 = {
  isDirectory?: boolean | null | undefined;
  modifiedAt?: Date | null | undefined;
  path: string;
  pathExists: boolean;
  readonly?: boolean | null | undefined;
  secretMetadataListed: boolean;
  status: SyncReconcileRequestStatus41;
  backend: "local";
};

export const SyncReconcileRequestReason40 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason40 = ClosedEnum<
  typeof SyncReconcileRequestReason40
>;

export const StatusSeverity40 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity40 = ClosedEnum<typeof StatusSeverity40>;

export type SyncReconcileRequestCollectionIssue40 = {
  message: string;
  reason: SyncReconcileRequestReason40;
  severity: StatusSeverity40;
  source: string;
};

export const SyncReconcileRequestHealth40 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth40 = ClosedEnum<
  typeof SyncReconcileRequestHealth40
>;

export const SyncReconcileRequestLifecycle40 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle40 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle40
>;

export type SyncReconcileRequestStatus40 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue40>;
  health: SyncReconcileRequestHealth40;
  lifecycle: SyncReconcileRequestLifecycle40;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataKubernetesSecret = {
  namespace: string;
  prefix: string;
  secretMetadataListed: boolean;
  status: SyncReconcileRequestStatus40;
  backend: "kubernetesSecret";
};

export const SyncReconcileRequestReason39 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason39 = ClosedEnum<
  typeof SyncReconcileRequestReason39
>;

export const StatusSeverity39 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity39 = ClosedEnum<typeof StatusSeverity39>;

export type SyncReconcileRequestCollectionIssue39 = {
  message: string;
  reason: SyncReconcileRequestReason39;
  severity: StatusSeverity39;
  source: string;
};

export const SyncReconcileRequestHealth39 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth39 = ClosedEnum<
  typeof SyncReconcileRequestHealth39
>;

export const SyncReconcileRequestLifecycle39 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle39 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle39
>;

export type SyncReconcileRequestStatus39 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue39>;
  health: SyncReconcileRequestHealth39;
  lifecycle: SyncReconcileRequestLifecycle39;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureKeyVault1 = {
  accessPolicyCount: number;
  location?: string | null | undefined;
  name: string;
  privateEndpointConnectionCount: number;
  provisioningState?: string | null | undefined;
  publicNetworkAccess: string;
  purgeProtectionEnabled?: boolean | null | undefined;
  rbacAuthorizationEnabled: boolean;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  secretMetadataListed: boolean;
  skuFamily?: string | null | undefined;
  skuName?: string | null | undefined;
  softDeleteEnabled: boolean;
  softDeleteRetentionDays: number;
  status: SyncReconcileRequestStatus39;
  vaultUri?: string | null | undefined;
  backend: "azureKeyVault";
};

export const SyncReconcileRequestReason38 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason38 = ClosedEnum<
  typeof SyncReconcileRequestReason38
>;

export const StatusSeverity38 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity38 = ClosedEnum<typeof StatusSeverity38>;

export type SyncReconcileRequestCollectionIssue38 = {
  message: string;
  reason: SyncReconcileRequestReason38;
  severity: StatusSeverity38;
  source: string;
};

export const SyncReconcileRequestHealth38 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth38 = ClosedEnum<
  typeof SyncReconcileRequestHealth38
>;

export const SyncReconcileRequestLifecycle38 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle38 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle38
>;

export type SyncReconcileRequestStatus38 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue38>;
  health: SyncReconcileRequestHealth38;
  lifecycle: SyncReconcileRequestLifecycle38;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpSecretManager = {
  location: string;
  prefix: string;
  projectId: string;
  secretMetadataListed: boolean;
  status: SyncReconcileRequestStatus38;
  backend: "gcpSecretManager";
};

export const SyncReconcileRequestReason37 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason37 = ClosedEnum<
  typeof SyncReconcileRequestReason37
>;

export const StatusSeverity37 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity37 = ClosedEnum<typeof StatusSeverity37>;

export type SyncReconcileRequestCollectionIssue37 = {
  message: string;
  reason: SyncReconcileRequestReason37;
  severity: StatusSeverity37;
  source: string;
};

export const SyncReconcileRequestHealth37 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth37 = ClosedEnum<
  typeof SyncReconcileRequestHealth37
>;

export const SyncReconcileRequestLifecycle37 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle37 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle37
>;

export type SyncReconcileRequestStatus37 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue37>;
  health: SyncReconcileRequestHealth37;
  lifecycle: SyncReconcileRequestLifecycle37;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsParameterStore = {
  accountId: string;
  hasMoreParameters?: boolean | null | undefined;
  latestModifiedAt?: Date | null | undefined;
  parameterMetadataSampled: boolean;
  prefix: string;
  region: string;
  sampledAdvancedTierCount?: number | null | undefined;
  sampledKmsKeyMetadataPresentCount?: number | null | undefined;
  sampledParameterCount?: number | null | undefined;
  sampledSecureStringCount?: number | null | undefined;
  sampledStringCount?: number | null | undefined;
  sampledStringListCount?: number | null | undefined;
  status: SyncReconcileRequestStatus37;
  backend: "awsParameterStore";
};

export type SyncReconcileRequestDataUnion9 =
  | DataAwsParameterStore
  | DataGcpSecretManager
  | DataAzureKeyVault1
  | DataKubernetesSecret
  | DataLocal9;

export type DataVault = {
  data:
    | DataAwsParameterStore
    | DataGcpSecretManager
    | DataAzureKeyVault1
    | DataKubernetesSecret
    | DataLocal9;
  resourceType: "vault";
};

export const SyncReconcileRequestReason36 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason36 = ClosedEnum<
  typeof SyncReconcileRequestReason36
>;

export const StatusSeverity36 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity36 = ClosedEnum<typeof StatusSeverity36>;

export type SyncReconcileRequestCollectionIssue36 = {
  message: string;
  reason: SyncReconcileRequestReason36;
  severity: StatusSeverity36;
  source: string;
};

export const SyncReconcileRequestHealth36 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth36 = ClosedEnum<
  typeof SyncReconcileRequestHealth36
>;

export const SyncReconcileRequestLifecycle36 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle36 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle36
>;

export type SyncReconcileRequestStatus36 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue36>;
  health: SyncReconcileRequestHealth36;
  lifecycle: SyncReconcileRequestLifecycle36;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/**
 * Local embedded Postgres backend.
 */
export type DataLocal8 = {
  name: string;
  port?: number | null | undefined;
  processRunning: boolean;
  status: SyncReconcileRequestStatus36;
  version: string;
  backend: "local";
};

export const SyncReconcileRequestReason35 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason35 = ClosedEnum<
  typeof SyncReconcileRequestReason35
>;

export const StatusSeverity35 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity35 = ClosedEnum<typeof StatusSeverity35>;

export type SyncReconcileRequestCollectionIssue35 = {
  message: string;
  reason: SyncReconcileRequestReason35;
  severity: StatusSeverity35;
  source: string;
};

export const SyncReconcileRequestHealth35 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth35 = ClosedEnum<
  typeof SyncReconcileRequestHealth35
>;

export const SyncReconcileRequestLifecycle35 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle35 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle35
>;

export type SyncReconcileRequestStatus35 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue35>;
  health: SyncReconcileRequestHealth35;
  lifecycle: SyncReconcileRequestLifecycle35;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/**
 * Azure Flexible Server backend.
 */
export type DataFlexibleServer = {
  serverName: string;
  state?: string | null | undefined;
  status: SyncReconcileRequestStatus35;
  version?: string | null | undefined;
  backend: "flexibleServer";
};

export const SyncReconcileRequestReason34 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason34 = ClosedEnum<
  typeof SyncReconcileRequestReason34
>;

export const StatusSeverity34 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity34 = ClosedEnum<typeof StatusSeverity34>;

export type SyncReconcileRequestCollectionIssue34 = {
  message: string;
  reason: SyncReconcileRequestReason34;
  severity: StatusSeverity34;
  source: string;
};

export const SyncReconcileRequestHealth34 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth34 = ClosedEnum<
  typeof SyncReconcileRequestHealth34
>;

export const SyncReconcileRequestLifecycle34 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle34 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle34
>;

export type SyncReconcileRequestStatus34 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue34>;
  health: SyncReconcileRequestHealth34;
  lifecycle: SyncReconcileRequestLifecycle34;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/**
 * GCP Cloud SQL backend.
 */
export type DataCloudSQL = {
  databaseVersion?: string | null | undefined;
  instanceName: string;
  state?: string | null | undefined;
  status: SyncReconcileRequestStatus34;
  backend: "cloudSql";
};

export const SyncReconcileRequestReason33 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason33 = ClosedEnum<
  typeof SyncReconcileRequestReason33
>;

export const StatusSeverity33 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity33 = ClosedEnum<typeof StatusSeverity33>;

export type SyncReconcileRequestCollectionIssue33 = {
  message: string;
  reason: SyncReconcileRequestReason33;
  severity: StatusSeverity33;
  source: string;
};

export const SyncReconcileRequestHealth33 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth33 = ClosedEnum<
  typeof SyncReconcileRequestHealth33
>;

export const SyncReconcileRequestLifecycle33 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle33 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle33
>;

export type SyncReconcileRequestStatus33 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue33>;
  health: SyncReconcileRequestHealth33;
  lifecycle: SyncReconcileRequestLifecycle33;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/**
 * AWS Aurora Serverless v2 backend.
 */
export type DataAurora = {
  clusterIdentifier: string;
  endpoint?: string | null | undefined;
  engineVersion?: string | null | undefined;
  /**
   * True when a `minCapacity: 0` instance has not reached 0 ACU over the observation
   *
   * @remarks
   * window — it is silently paying always-on prices (auto-pause verification).
   */
  neverPauses: boolean;
  /**
   * Latest sampled `ServerlessDatabaseCapacity` (ACU).
   */
  serverlessCapacity?: number | null | undefined;
  status: SyncReconcileRequestStatus33;
  backend: "aurora";
};

export type SyncReconcileRequestDataUnion8 =
  | DataAurora
  | DataCloudSQL
  | DataFlexibleServer
  | DataLocal8;

export type DataPostgres = {
  data: DataAurora | DataCloudSQL | DataFlexibleServer | DataLocal8;
  resourceType: "postgres";
};

export const SyncReconcileRequestReason32 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason32 = ClosedEnum<
  typeof SyncReconcileRequestReason32
>;

export const StatusSeverity32 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity32 = ClosedEnum<typeof StatusSeverity32>;

export type SyncReconcileRequestCollectionIssue32 = {
  message: string;
  reason: SyncReconcileRequestReason32;
  severity: StatusSeverity32;
  source: string;
};

export const SyncReconcileRequestHealth32 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth32 = ClosedEnum<
  typeof SyncReconcileRequestHealth32
>;

export const SyncReconcileRequestLifecycle32 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle32 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle32
>;

export type SyncReconcileRequestStatus32 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue32>;
  health: SyncReconcileRequestHealth32;
  lifecycle: SyncReconcileRequestLifecycle32;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal7 = {
  cloudMetadataSupported: boolean;
  isDirectory?: boolean | null | undefined;
  name: string;
  path: string;
  pathExists: boolean;
  status: SyncReconcileRequestStatus32;
  backend: "local";
};

export const SyncReconcileRequestReason31 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason31 = ClosedEnum<
  typeof SyncReconcileRequestReason31
>;

export const StatusSeverity31 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity31 = ClosedEnum<typeof StatusSeverity31>;

export type SyncReconcileRequestCollectionIssue31 = {
  message: string;
  reason: SyncReconcileRequestReason31;
  severity: StatusSeverity31;
  source: string;
};

export const SyncReconcileRequestHealth31 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth31 = ClosedEnum<
  typeof SyncReconcileRequestHealth31
>;

export const SyncReconcileRequestLifecycle31 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle31 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle31
>;

export type SyncReconcileRequestStatus31 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue31>;
  health: SyncReconcileRequestHealth31;
  lifecycle: SyncReconcileRequestLifecycle31;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureTable = {
  endpoint?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  signedIdentifierCount?: number | null | undefined;
  status: SyncReconcileRequestStatus31;
  storageAccountKind?: string | null | undefined;
  storageAccountLocation?: string | null | undefined;
  storageAccountName: string;
  storageAccountPrimaryStatus?: string | null | undefined;
  storageAccountProvisioningState?: string | null | undefined;
  storageAccountResourceId?: string | null | undefined;
  tableExists: boolean;
  tableName: string;
  backend: "azureTable";
};

export const SyncReconcileRequestReason30 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason30 = ClosedEnum<
  typeof SyncReconcileRequestReason30
>;

export const StatusSeverity30 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity30 = ClosedEnum<typeof StatusSeverity30>;

export type SyncReconcileRequestCollectionIssue30 = {
  message: string;
  reason: SyncReconcileRequestReason30;
  severity: StatusSeverity30;
  source: string;
};

export const SyncReconcileRequestHealth30 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth30 = ClosedEnum<
  typeof SyncReconcileRequestHealth30
>;

export const SyncReconcileRequestLifecycle30 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle30 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle30
>;

export type SyncReconcileRequestStatus30 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue30>;
  health: SyncReconcileRequestHealth30;
  lifecycle: SyncReconcileRequestLifecycle30;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpFirestore = {
  appEngineIntegrationMode?: string | null | undefined;
  cmekEnabled: boolean;
  concurrencyMode?: string | null | undefined;
  createTime?: string | null | undefined;
  databaseEdition?: string | null | undefined;
  databaseName: string;
  databaseType?: string | null | undefined;
  deleteProtectionState?: string | null | undefined;
  deleteTime?: string | null | undefined;
  earliestVersionTime?: string | null | undefined;
  endpoint?: string | null | undefined;
  locationId?: string | null | undefined;
  pointInTimeRecoveryEnablement?: string | null | undefined;
  projectId?: string | null | undefined;
  sourceInfoPresent: boolean;
  status: SyncReconcileRequestStatus30;
  updateTime?: string | null | undefined;
  versionRetentionPeriod?: string | null | undefined;
  backend: "gcpFirestore";
};

export type KeySchema = {
  attributeName: string;
  keyType: string;
};

export const SyncReconcileRequestReason29 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason29 = ClosedEnum<
  typeof SyncReconcileRequestReason29
>;

export const StatusSeverity29 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity29 = ClosedEnum<typeof StatusSeverity29>;

export type SyncReconcileRequestCollectionIssue29 = {
  message: string;
  reason: SyncReconcileRequestReason29;
  severity: StatusSeverity29;
  source: string;
};

export const SyncReconcileRequestHealth29 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth29 = ClosedEnum<
  typeof SyncReconcileRequestHealth29
>;

export const SyncReconcileRequestLifecycle29 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle29 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle29
>;

export type SyncReconcileRequestStatus29 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue29>;
  health: SyncReconcileRequestHealth29;
  lifecycle: SyncReconcileRequestLifecycle29;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsDynamoDb = {
  billingMode?: string | null | undefined;
  deletionProtectionEnabled?: boolean | null | undefined;
  globalSecondaryIndexCount?: number | null | undefined;
  itemCount?: number | null | undefined;
  keySchema: Array<KeySchema>;
  localSecondaryIndexCount?: number | null | undefined;
  name: string;
  region?: string | null | undefined;
  replicaCount?: number | null | undefined;
  restoreInProgress?: boolean | null | undefined;
  sseStatus?: string | null | undefined;
  sseType?: string | null | undefined;
  status: SyncReconcileRequestStatus29;
  streamEnabled?: boolean | null | undefined;
  streamViewType?: string | null | undefined;
  tableArn?: string | null | undefined;
  tableClass?: string | null | undefined;
  tableSizeBytes?: number | null | undefined;
  tableStatus?: string | null | undefined;
  ttlAttributeName?: string | null | undefined;
  ttlStatus?: string | null | undefined;
  backend: "awsDynamoDb";
};

export type SyncReconcileRequestDataUnion7 =
  | DataAwsDynamoDb
  | DataGcpFirestore
  | DataAzureTable
  | DataLocal7;

export type DataKv = {
  data: DataAwsDynamoDb | DataGcpFirestore | DataAzureTable | DataLocal7;
  resourceType: "kv";
};

export const SyncReconcileRequestReason28 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason28 = ClosedEnum<
  typeof SyncReconcileRequestReason28
>;

export const StatusSeverity28 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity28 = ClosedEnum<typeof StatusSeverity28>;

export type SyncReconcileRequestCollectionIssue28 = {
  message: string;
  reason: SyncReconcileRequestReason28;
  severity: StatusSeverity28;
  source: string;
};

export const SyncReconcileRequestHealth28 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth28 = ClosedEnum<
  typeof SyncReconcileRequestHealth28
>;

export const SyncReconcileRequestLifecycle28 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle28 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle28
>;

export type SyncReconcileRequestStatus28 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue28>;
  health: SyncReconcileRequestHealth28;
  lifecycle: SyncReconcileRequestLifecycle28;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal6 = {
  name: string;
  path?: string | null | undefined;
  serviceStatus?: string | null | undefined;
  status: SyncReconcileRequestStatus28;
  backend: "local";
};

export const SyncReconcileRequestReason27 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason27 = ClosedEnum<
  typeof SyncReconcileRequestReason27
>;

export const StatusSeverity27 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity27 = ClosedEnum<typeof StatusSeverity27>;

export type SyncReconcileRequestCollectionIssue27 = {
  message: string;
  reason: SyncReconcileRequestReason27;
  severity: StatusSeverity27;
  source: string;
};

export const SyncReconcileRequestHealth27 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth27 = ClosedEnum<
  typeof SyncReconcileRequestHealth27
>;

export const SyncReconcileRequestLifecycle27 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle27 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle27
>;

export type SyncReconcileRequestStatus27 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue27>;
  health: SyncReconcileRequestHealth27;
  lifecycle: SyncReconcileRequestLifecycle27;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureServiceBus = {
  accessedAt?: string | null | undefined;
  activeMessageCount?: number | null | undefined;
  autoDeleteOnIdle?: string | null | undefined;
  createdAt?: string | null | undefined;
  deadLetterMessageCount?: number | null | undefined;
  deadLetteringOnMessageExpiration?: boolean | null | undefined;
  defaultMessageTimeToLive?: string | null | undefined;
  duplicateDetectionHistoryTimeWindow?: string | null | undefined;
  enableBatchedOperations?: boolean | null | undefined;
  enableExpress?: boolean | null | undefined;
  enablePartitioning?: boolean | null | undefined;
  endpoint?: string | null | undefined;
  forwardDeadLetteredMessagesTo?: string | null | undefined;
  forwardTo?: string | null | undefined;
  lockDuration?: string | null | undefined;
  maxDeliveryCount?: number | null | undefined;
  maxMessageSizeInKilobytes?: number | null | undefined;
  maxSizeInMegabytes?: number | null | undefined;
  messageCount?: number | null | undefined;
  name: string;
  namespaceName: string;
  queueStatus?: string | null | undefined;
  requiresDuplicateDetection?: boolean | null | undefined;
  requiresSession?: boolean | null | undefined;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  scheduledMessageCount?: number | null | undefined;
  sizeInBytes?: number | null | undefined;
  status: SyncReconcileRequestStatus27;
  transferDeadLetterMessageCount?: number | null | undefined;
  transferMessageCount?: number | null | undefined;
  updatedAt?: string | null | undefined;
  backend: "azureServiceBus";
};

export const SyncReconcileRequestReason26 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason26 = ClosedEnum<
  typeof SyncReconcileRequestReason26
>;

export const StatusSeverity26 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity26 = ClosedEnum<typeof StatusSeverity26>;

export type SyncReconcileRequestCollectionIssue26 = {
  message: string;
  reason: SyncReconcileRequestReason26;
  severity: StatusSeverity26;
  source: string;
};

export const SyncReconcileRequestHealth26 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth26 = ClosedEnum<
  typeof SyncReconcileRequestHealth26
>;

export const SyncReconcileRequestLifecycle26 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle26 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle26
>;

export type SyncReconcileRequestStatus26 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue26>;
  health: SyncReconcileRequestHealth26;
  lifecycle: SyncReconcileRequestLifecycle26;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpPubSub = {
  endpoint?: string | null | undefined;
  kmsKeyName?: string | null | undefined;
  messageStorageAllowedPersistenceRegions: Array<string>;
  messageStorageEnforceInTransit?: boolean | null | undefined;
  projectId?: string | null | undefined;
  schemaEncoding?: string | null | undefined;
  schemaFirstRevisionId?: string | null | undefined;
  schemaLastRevisionId?: string | null | undefined;
  schemaName?: string | null | undefined;
  status: SyncReconcileRequestStatus26;
  subscriptionAckDeadlineSeconds?: number | null | undefined;
  subscriptionDeadLetterMaxDeliveryAttempts?: number | null | undefined;
  subscriptionDeadLetterTopic?: string | null | undefined;
  subscriptionDetached?: boolean | null | undefined;
  subscriptionEnableMessageOrdering?: boolean | null | undefined;
  subscriptionFilter?: string | null | undefined;
  subscriptionFullName?: string | null | undefined;
  subscriptionLabels: { [k: string]: string };
  subscriptionMessageRetentionDuration?: string | null | undefined;
  subscriptionName?: string | null | undefined;
  subscriptionPushAttributes: { [k: string]: string };
  subscriptionPushConfigPresent?: boolean | null | undefined;
  subscriptionPushEndpoint?: string | null | undefined;
  subscriptionPushNoWrapperWriteMetadata?: boolean | null | undefined;
  subscriptionPushOidcAudience?: string | null | undefined;
  subscriptionPushOidcServiceAccountEmail?: string | null | undefined;
  subscriptionPushPubsubWrapperWriteMetadata?: boolean | null | undefined;
  subscriptionRetainAckedMessages?: boolean | null | undefined;
  subscriptionState?: string | null | undefined;
  topicFullName?: string | null | undefined;
  topicLabels: { [k: string]: string };
  topicMessageRetentionDuration?: string | null | undefined;
  topicName: string;
  topicState?: string | null | undefined;
  backend: "gcpPubSub";
};

export const SyncReconcileRequestReason25 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason25 = ClosedEnum<
  typeof SyncReconcileRequestReason25
>;

export const StatusSeverity25 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity25 = ClosedEnum<typeof StatusSeverity25>;

export type SyncReconcileRequestCollectionIssue25 = {
  message: string;
  reason: SyncReconcileRequestReason25;
  severity: StatusSeverity25;
  source: string;
};

export const SyncReconcileRequestHealth25 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth25 = ClosedEnum<
  typeof SyncReconcileRequestHealth25
>;

export const SyncReconcileRequestLifecycle25 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle25 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle25
>;

export type SyncReconcileRequestStatus25 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue25>;
  health: SyncReconcileRequestHealth25;
  lifecycle: SyncReconcileRequestLifecycle25;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsSqs = {
  approximateCounts: boolean;
  approximateDelayedMessages?: number | null | undefined;
  approximateInFlightMessages?: number | null | undefined;
  approximateVisibleMessages?: number | null | undefined;
  contentBasedDeduplication?: boolean | null | undefined;
  deduplicationScope?: string | null | undefined;
  delaySeconds?: number | null | undefined;
  fifoQueue?: boolean | null | undefined;
  fifoThroughputLimit?: string | null | undefined;
  kmsDataKeyReusePeriodSeconds?: number | null | undefined;
  kmsMasterKeyId?: string | null | undefined;
  maximumMessageSize?: number | null | undefined;
  messageRetentionPeriodSeconds?: number | null | undefined;
  name: string;
  queueArn?: string | null | undefined;
  queueUrl?: string | null | undefined;
  receiveMessageWaitTimeSeconds?: number | null | undefined;
  redriveAllowPolicy?: string | null | undefined;
  redrivePolicy?: string | null | undefined;
  region?: string | null | undefined;
  sqsManagedSseEnabled?: boolean | null | undefined;
  sseEnabled?: boolean | null | undefined;
  status: SyncReconcileRequestStatus25;
  visibilityTimeoutSeconds?: number | null | undefined;
  backend: "awsSqs";
};

export type SyncReconcileRequestDataUnion6 =
  | DataAwsSqs
  | DataGcpPubSub
  | DataAzureServiceBus
  | DataLocal6;

export type DataQueue = {
  data: DataAwsSqs | DataGcpPubSub | DataAzureServiceBus | DataLocal6;
  resourceType: "queue";
};

export const CpuUnit11 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit11 = ClosedEnum<typeof CpuUnit11>;

export type SyncReconcileRequestCpu11 = {
  unit: CpuUnit11;
  value: number;
};

export type CpuUnion11 = SyncReconcileRequestCpu11 | any;

export type InvolvedObject9 = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

export type InvolvedObjectUnion9 = InvolvedObject9 | any;

export type SourceEvent9 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion9 = SourceEvent9 | any;

export type SyncReconcileRequestEvent12 = {
  count?: number | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject9 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent9 | any | null | undefined;
  type?: string | null | undefined;
};

export const MemoryUnit11 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit11 = ClosedEnum<typeof MemoryUnit11>;

export type SyncReconcileRequestMemory11 = {
  unit: MemoryUnit11;
  value: number;
};

export type MemoryUnion11 = SyncReconcileRequestMemory11 | any;

export type NodeCounts = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

export const CpuAllocatableUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuAllocatableUnit = ClosedEnum<typeof CpuAllocatableUnit>;

export type CpuAllocatable = {
  unit: CpuAllocatableUnit;
  value: number;
};

export type AllocatableCpuUnion = CpuAllocatable | any;

export const MemoryAllocatableUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryAllocatableUnit = ClosedEnum<typeof MemoryAllocatableUnit>;

export type MemoryAllocatable = {
  unit: MemoryAllocatableUnit;
  value: number;
};

export type AllocatableMemoryUnion = MemoryAllocatable | any;

export type Allocatable = {
  cpu?: CpuAllocatable | any | null | undefined;
  memory?: MemoryAllocatable | any | null | undefined;
  pods?: number | null | undefined;
};

export const CpuCapacityUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuCapacityUnit = ClosedEnum<typeof CpuCapacityUnit>;

export type CpuCapacity = {
  unit: CpuCapacityUnit;
  value: number;
};

export type CapacityCpuUnion = CpuCapacity | any;

export const MemoryCapacityUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryCapacityUnit = ClosedEnum<typeof MemoryCapacityUnit>;

export type MemoryCapacity = {
  unit: MemoryCapacityUnit;
  value: number;
};

export type CapacityMemoryUnion = MemoryCapacity | any;

export type Capacity = {
  cpu?: CpuCapacity | any | null | undefined;
  memory?: MemoryCapacity | any | null | undefined;
  pods?: number | null | undefined;
};

export type NodeStatusCondition = {
  message?: string | null | undefined;
  reason?: string | null | undefined;
  status: string;
  type: string;
};

export const UsageCpuUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type UsageCpuUnit = ClosedEnum<typeof UsageCpuUnit>;

export type UsageCpu = {
  unit: UsageCpuUnit;
  value: number;
};

export type UsageCpuUnion = UsageCpu | any;

export const UsageMemoryUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type UsageMemoryUnit = ClosedEnum<typeof UsageMemoryUnit>;

export type UsageMemory = {
  unit: UsageMemoryUnit;
  value: number;
};

export type UsageMemoryUnion = UsageMemory | any;

export type SyncReconcileRequestUsage = {
  cpu?: UsageCpu | any | null | undefined;
  memory?: UsageMemory | any | null | undefined;
};

export type Usage = SyncReconcileRequestUsage | any;

export type NodeStatus = {
  allocatable: Allocatable;
  capacity: Capacity;
  conditions?: Array<NodeStatusCondition> | undefined;
  containerRuntimeVersion?: string | null | undefined;
  kubeletVersion?: string | null | undefined;
  labels: { [k: string]: string };
  name: string;
  ready: boolean;
  roles: Array<string>;
  uid?: string | null | undefined;
  usage?: SyncReconcileRequestUsage | any | null | undefined;
};

export type PodCounts = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

export const SyncReconcileRequestReason24 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason24 = ClosedEnum<
  typeof SyncReconcileRequestReason24
>;

export const StatusSeverity24 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity24 = ClosedEnum<typeof StatusSeverity24>;

export type SyncReconcileRequestCollectionIssue24 = {
  message: string;
  reason: SyncReconcileRequestReason24;
  severity: StatusSeverity24;
  source: string;
};

export const SyncReconcileRequestHealth24 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth24 = ClosedEnum<
  typeof SyncReconcileRequestHealth24
>;

export const SyncReconcileRequestLifecycle24 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle24 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle24
>;

export type SyncReconcileRequestStatus24 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue24>;
  health: SyncReconcileRequestHealth24;
  lifecycle: SyncReconcileRequestLifecycle24;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type SyncReconcileRequestData1 = {
  cpu?: SyncReconcileRequestCpu11 | any | null | undefined;
  events: Array<SyncReconcileRequestEvent12>;
  memory?: SyncReconcileRequestMemory11 | any | null | undefined;
  name: string;
  namespace?: string | null | undefined;
  nodeCounts: NodeCounts;
  nodeStatuses?: Array<NodeStatus> | undefined;
  podCounts: PodCounts;
  region?: string | null | undefined;
  status: SyncReconcileRequestStatus24;
  version?: string | null | undefined;
};

export type DataKubernetesCluster = {
  data: SyncReconcileRequestData1;
  resourceType: "kubernetes-cluster";
};

export type Nodes5 = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

export const SyncReconcileRequestReason23 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason23 = ClosedEnum<
  typeof SyncReconcileRequestReason23
>;

export const StatusSeverity23 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity23 = ClosedEnum<typeof StatusSeverity23>;

export type SyncReconcileRequestCollectionIssue23 = {
  message: string;
  reason: SyncReconcileRequestReason23;
  severity: StatusSeverity23;
  source: string;
};

export const SyncReconcileRequestHealth23 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth23 = ClosedEnum<
  typeof SyncReconcileRequestHealth23
>;

export const SyncReconcileRequestLifecycle23 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle23 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle23
>;

export type SyncReconcileRequestStatus23 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue23>;
  health: SyncReconcileRequestHealth23;
  lifecycle: SyncReconcileRequestLifecycle23;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal5 = {
  dockerApiVersion?: string | null | undefined;
  dockerArch?: string | null | undefined;
  dockerAvailable: boolean;
  dockerOs?: string | null | undefined;
  dockerVersion?: string | null | undefined;
  hostIdentifier?: string | null | undefined;
  name: string;
  networkAvailable: boolean;
  networkName?: string | null | undefined;
  nodes: Nodes5;
  runningContainers?: number | null | undefined;
  status: SyncReconcileRequestStatus23;
  trackedContainers?: number | null | undefined;
  backend: "local";
};

export const Category4 = {
  Quota: "quota",
  Capacity: "capacity",
  Allocation: "allocation",
  Other: "other",
} as const;
export type Category4 = ClosedEnum<typeof Category4>;

export type CapacityBlocker4 = {
  category: Category4;
  message: string;
  observedAt: Date;
  providerCode?: string | null | undefined;
  providerReference?: string | null | undefined;
};

export type CapacityBlockerUnion4 = CapacityBlocker4 | any;

export type DrainProgressBlocker4 = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

export const DrainProgressStatus4 = {
  Draining: "draining",
  Drained: "drained",
  Terminating: "terminating",
} as const;
export type DrainProgressStatus4 = ClosedEnum<typeof DrainProgressStatus4>;

export type DrainProgress4 = {
  blockers?: Array<DrainProgressBlocker4> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  force: boolean;
  machineId: string;
  replicaCount: number;
  stalled: boolean;
  status: DrainProgressStatus4;
};

export type DrainProgressUnion4 = DrainProgress4 | any;

export const UtilizationUnit4 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type UtilizationUnit4 = ClosedEnum<typeof UtilizationUnit4>;

export type Utilization4 = {
  unit: UtilizationUnit4;
  value: number;
};

export type UtilizationUnion4 = Utilization4 | any;

export type Recommendation4 = {
  desiredMachines: number;
  reason?: string | null | undefined;
  unschedulableReplicas?: number | null | undefined;
  utilization?: Utilization4 | any | null | undefined;
};

export type RecommendationUnion4 = Recommendation4 | any;

export type CapacityGroup4 = {
  capacityBlocker?: CapacityBlocker4 | any | null | undefined;
  currentMachines: number;
  desiredMachines: number;
  drainProgress?: DrainProgress4 | any | null | undefined;
  groupId: string;
  instanceType?: string | null | undefined;
  maxMachines?: number | null | undefined;
  minMachines?: number | null | undefined;
  recommendation?: Recommendation4 | any | null | undefined;
};

export const CpuUnit10 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit10 = ClosedEnum<typeof CpuUnit10>;

export type SyncReconcileRequestCpu10 = {
  unit: CpuUnit10;
  value: number;
};

export type CpuUnion10 = SyncReconcileRequestCpu10 | any;

export type SyncReconcileRequestDrainBlocker = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

export type SyncReconcileRequestMachine = {
  capacityGroup: string;
  cpuCores?: number | null | undefined;
  drainBlockers?: Array<SyncReconcileRequestDrainBlocker> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainForce: boolean;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  horizondVersion?: string | null | undefined;
  lastHeartbeat: string;
  machineId: string;
  memoryBytes?: number | null | undefined;
  overlayIp?: string | null | undefined;
  publicIp?: string | null | undefined;
  replicaCount: number;
  status: string;
  zone: string;
};

export const MemoryUnit10 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit10 = ClosedEnum<typeof MemoryUnit10>;

export type SyncReconcileRequestMemory10 = {
  unit: MemoryUnit10;
  value: number;
};

export type MemoryUnion10 = SyncReconcileRequestMemory10 | any;

export type Nodes4 = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

export const SyncReconcileRequestReason22 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason22 = ClosedEnum<
  typeof SyncReconcileRequestReason22
>;

export const StatusSeverity22 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity22 = ClosedEnum<typeof StatusSeverity22>;

export type SyncReconcileRequestCollectionIssue22 = {
  message: string;
  reason: SyncReconcileRequestReason22;
  severity: StatusSeverity22;
  source: string;
};

export const SyncReconcileRequestHealth22 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth22 = ClosedEnum<
  typeof SyncReconcileRequestHealth22
>;

export const SyncReconcileRequestLifecycle22 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle22 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle22
>;

export type SyncReconcileRequestStatus22 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue22>;
  health: SyncReconcileRequestHealth22;
  lifecycle: SyncReconcileRequestLifecycle22;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataMachines2 = {
  backendClusterId?: string | null | undefined;
  capacityGroups: Array<CapacityGroup4>;
  cpu?: SyncReconcileRequestCpu10 | any | null | undefined;
  machines: Array<SyncReconcileRequestMachine>;
  memory?: SyncReconcileRequestMemory10 | any | null | undefined;
  name: string;
  nodes: Nodes4;
  status: SyncReconcileRequestStatus22;
  backend: "machines";
};

export const Category3 = {
  Quota: "quota",
  Capacity: "capacity",
  Allocation: "allocation",
  Other: "other",
} as const;
export type Category3 = ClosedEnum<typeof Category3>;

export type CapacityBlocker3 = {
  category: Category3;
  message: string;
  observedAt: Date;
  providerCode?: string | null | undefined;
  providerReference?: string | null | undefined;
};

export type CapacityBlockerUnion3 = CapacityBlocker3 | any;

export type DrainProgressBlocker3 = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

export const DrainProgressStatus3 = {
  Draining: "draining",
  Drained: "drained",
  Terminating: "terminating",
} as const;
export type DrainProgressStatus3 = ClosedEnum<typeof DrainProgressStatus3>;

export type DrainProgress3 = {
  blockers?: Array<DrainProgressBlocker3> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  force: boolean;
  machineId: string;
  replicaCount: number;
  stalled: boolean;
  status: DrainProgressStatus3;
};

export type DrainProgressUnion3 = DrainProgress3 | any;

export const UtilizationUnit3 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type UtilizationUnit3 = ClosedEnum<typeof UtilizationUnit3>;

export type Utilization3 = {
  unit: UtilizationUnit3;
  value: number;
};

export type UtilizationUnion3 = Utilization3 | any;

export type Recommendation3 = {
  desiredMachines: number;
  reason?: string | null | undefined;
  unschedulableReplicas?: number | null | undefined;
  utilization?: Utilization3 | any | null | undefined;
};

export type RecommendationUnion3 = Recommendation3 | any;

export type CapacityGroup3 = {
  capacityBlocker?: CapacityBlocker3 | any | null | undefined;
  currentMachines: number;
  desiredMachines: number;
  drainProgress?: DrainProgress3 | any | null | undefined;
  groupId: string;
  instanceType?: string | null | undefined;
  maxMachines?: number | null | undefined;
  minMachines?: number | null | undefined;
  recommendation?: Recommendation3 | any | null | undefined;
};

export const CpuUnit9 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit9 = ClosedEnum<typeof CpuUnit9>;

export type SyncReconcileRequestCpu9 = {
  unit: CpuUnit9;
  value: number;
};

export type CpuUnion9 = SyncReconcileRequestCpu9 | any;

export const MemoryUnit9 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit9 = ClosedEnum<typeof MemoryUnit9>;

export type SyncReconcileRequestMemory9 = {
  unit: MemoryUnit9;
  value: number;
};

export type MemoryUnion9 = SyncReconcileRequestMemory9 | any;

export type Nodes3 = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

export type ProviderFleet3 = {
  currentMachines: number;
  desiredMachines: number;
  groupId: string;
  location?: string | null | undefined;
  providerId: string;
};

export const SyncReconcileRequestReason21 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason21 = ClosedEnum<
  typeof SyncReconcileRequestReason21
>;

export const StatusSeverity21 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity21 = ClosedEnum<typeof StatusSeverity21>;

export type SyncReconcileRequestCollectionIssue21 = {
  message: string;
  reason: SyncReconcileRequestReason21;
  severity: StatusSeverity21;
  source: string;
};

export const SyncReconcileRequestHealth21 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth21 = ClosedEnum<
  typeof SyncReconcileRequestHealth21
>;

export const SyncReconcileRequestLifecycle21 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle21 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle21
>;

export type SyncReconcileRequestStatus21 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue21>;
  health: SyncReconcileRequestHealth21;
  lifecycle: SyncReconcileRequestLifecycle21;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzure2 = {
  backendClusterId?: string | null | undefined;
  capacityGroups: Array<CapacityGroup3>;
  cpu?: SyncReconcileRequestCpu9 | any | null | undefined;
  memory?: SyncReconcileRequestMemory9 | any | null | undefined;
  name: string;
  nodes: Nodes3;
  providerFleets: Array<ProviderFleet3>;
  region?: string | null | undefined;
  status: SyncReconcileRequestStatus21;
  backend: "azure";
};

export const Category2 = {
  Quota: "quota",
  Capacity: "capacity",
  Allocation: "allocation",
  Other: "other",
} as const;
export type Category2 = ClosedEnum<typeof Category2>;

export type CapacityBlocker2 = {
  category: Category2;
  message: string;
  observedAt: Date;
  providerCode?: string | null | undefined;
  providerReference?: string | null | undefined;
};

export type CapacityBlockerUnion2 = CapacityBlocker2 | any;

export type DrainProgressBlocker2 = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

export const DrainProgressStatus2 = {
  Draining: "draining",
  Drained: "drained",
  Terminating: "terminating",
} as const;
export type DrainProgressStatus2 = ClosedEnum<typeof DrainProgressStatus2>;

export type DrainProgress2 = {
  blockers?: Array<DrainProgressBlocker2> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  force: boolean;
  machineId: string;
  replicaCount: number;
  stalled: boolean;
  status: DrainProgressStatus2;
};

export type DrainProgressUnion2 = DrainProgress2 | any;

export const UtilizationUnit2 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type UtilizationUnit2 = ClosedEnum<typeof UtilizationUnit2>;

export type Utilization2 = {
  unit: UtilizationUnit2;
  value: number;
};

export type UtilizationUnion2 = Utilization2 | any;

export type Recommendation2 = {
  desiredMachines: number;
  reason?: string | null | undefined;
  unschedulableReplicas?: number | null | undefined;
  utilization?: Utilization2 | any | null | undefined;
};

export type RecommendationUnion2 = Recommendation2 | any;

export type CapacityGroup2 = {
  capacityBlocker?: CapacityBlocker2 | any | null | undefined;
  currentMachines: number;
  desiredMachines: number;
  drainProgress?: DrainProgress2 | any | null | undefined;
  groupId: string;
  instanceType?: string | null | undefined;
  maxMachines?: number | null | undefined;
  minMachines?: number | null | undefined;
  recommendation?: Recommendation2 | any | null | undefined;
};

export const CpuUnit8 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit8 = ClosedEnum<typeof CpuUnit8>;

export type SyncReconcileRequestCpu8 = {
  unit: CpuUnit8;
  value: number;
};

export type CpuUnion8 = SyncReconcileRequestCpu8 | any;

export const MemoryUnit8 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit8 = ClosedEnum<typeof MemoryUnit8>;

export type SyncReconcileRequestMemory8 = {
  unit: MemoryUnit8;
  value: number;
};

export type MemoryUnion8 = SyncReconcileRequestMemory8 | any;

export type Nodes2 = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

export type ProviderFleet2 = {
  currentMachines: number;
  desiredMachines: number;
  groupId: string;
  location?: string | null | undefined;
  providerId: string;
};

export const SyncReconcileRequestReason20 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason20 = ClosedEnum<
  typeof SyncReconcileRequestReason20
>;

export const StatusSeverity20 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity20 = ClosedEnum<typeof StatusSeverity20>;

export type SyncReconcileRequestCollectionIssue20 = {
  message: string;
  reason: SyncReconcileRequestReason20;
  severity: StatusSeverity20;
  source: string;
};

export const SyncReconcileRequestHealth20 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth20 = ClosedEnum<
  typeof SyncReconcileRequestHealth20
>;

export const SyncReconcileRequestLifecycle20 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle20 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle20
>;

export type SyncReconcileRequestStatus20 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue20>;
  health: SyncReconcileRequestHealth20;
  lifecycle: SyncReconcileRequestLifecycle20;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcp2 = {
  backendClusterId?: string | null | undefined;
  capacityGroups: Array<CapacityGroup2>;
  cpu?: SyncReconcileRequestCpu8 | any | null | undefined;
  memory?: SyncReconcileRequestMemory8 | any | null | undefined;
  name: string;
  nodes: Nodes2;
  providerFleets: Array<ProviderFleet2>;
  region?: string | null | undefined;
  status: SyncReconcileRequestStatus20;
  backend: "gcp";
};

export const Category1 = {
  Quota: "quota",
  Capacity: "capacity",
  Allocation: "allocation",
  Other: "other",
} as const;
export type Category1 = ClosedEnum<typeof Category1>;

export type CapacityBlocker1 = {
  category: Category1;
  message: string;
  observedAt: Date;
  providerCode?: string | null | undefined;
  providerReference?: string | null | undefined;
};

export type CapacityBlockerUnion1 = CapacityBlocker1 | any;

export type DrainProgressBlocker1 = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

export const DrainProgressStatus1 = {
  Draining: "draining",
  Drained: "drained",
  Terminating: "terminating",
} as const;
export type DrainProgressStatus1 = ClosedEnum<typeof DrainProgressStatus1>;

export type DrainProgress1 = {
  blockers?: Array<DrainProgressBlocker1> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  force: boolean;
  machineId: string;
  replicaCount: number;
  stalled: boolean;
  status: DrainProgressStatus1;
};

export type DrainProgressUnion1 = DrainProgress1 | any;

export const UtilizationUnit1 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type UtilizationUnit1 = ClosedEnum<typeof UtilizationUnit1>;

export type Utilization1 = {
  unit: UtilizationUnit1;
  value: number;
};

export type UtilizationUnion1 = Utilization1 | any;

export type Recommendation1 = {
  desiredMachines: number;
  reason?: string | null | undefined;
  unschedulableReplicas?: number | null | undefined;
  utilization?: Utilization1 | any | null | undefined;
};

export type RecommendationUnion1 = Recommendation1 | any;

export type CapacityGroup1 = {
  capacityBlocker?: CapacityBlocker1 | any | null | undefined;
  currentMachines: number;
  desiredMachines: number;
  drainProgress?: DrainProgress1 | any | null | undefined;
  groupId: string;
  instanceType?: string | null | undefined;
  maxMachines?: number | null | undefined;
  minMachines?: number | null | undefined;
  recommendation?: Recommendation1 | any | null | undefined;
};

export const CpuUnit7 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit7 = ClosedEnum<typeof CpuUnit7>;

export type SyncReconcileRequestCpu7 = {
  unit: CpuUnit7;
  value: number;
};

export type CpuUnion7 = SyncReconcileRequestCpu7 | any;

export const MemoryUnit7 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit7 = ClosedEnum<typeof MemoryUnit7>;

export type SyncReconcileRequestMemory7 = {
  unit: MemoryUnit7;
  value: number;
};

export type MemoryUnion7 = SyncReconcileRequestMemory7 | any;

export type Nodes1 = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

export type ProviderFleet1 = {
  currentMachines: number;
  desiredMachines: number;
  groupId: string;
  location?: string | null | undefined;
  providerId: string;
};

export const SyncReconcileRequestReason19 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason19 = ClosedEnum<
  typeof SyncReconcileRequestReason19
>;

export const StatusSeverity19 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity19 = ClosedEnum<typeof StatusSeverity19>;

export type SyncReconcileRequestCollectionIssue19 = {
  message: string;
  reason: SyncReconcileRequestReason19;
  severity: StatusSeverity19;
  source: string;
};

export const SyncReconcileRequestHealth19 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth19 = ClosedEnum<
  typeof SyncReconcileRequestHealth19
>;

export const SyncReconcileRequestLifecycle19 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle19 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle19
>;

export type SyncReconcileRequestStatus19 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue19>;
  health: SyncReconcileRequestHealth19;
  lifecycle: SyncReconcileRequestLifecycle19;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAws2 = {
  backendClusterId?: string | null | undefined;
  capacityGroups: Array<CapacityGroup1>;
  cpu?: SyncReconcileRequestCpu7 | any | null | undefined;
  memory?: SyncReconcileRequestMemory7 | any | null | undefined;
  name: string;
  nodes: Nodes1;
  providerFleets: Array<ProviderFleet1>;
  region?: string | null | undefined;
  status: SyncReconcileRequestStatus19;
  backend: "aws";
};

export type SyncReconcileRequestDataUnion5 =
  | DataAws2
  | DataGcp2
  | DataAzure2
  | DataMachines2
  | DataLocal5;

export type DataComputeCluster = {
  data: DataAws2 | DataGcp2 | DataAzure2 | DataMachines2 | DataLocal5;
  resourceType: "compute-cluster";
};

export const DaemonInstanceCpuUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type DaemonInstanceCpuUnit = ClosedEnum<typeof DaemonInstanceCpuUnit>;

export type DaemonInstanceCpu = {
  unit: DaemonInstanceCpuUnit;
  value: number;
};

export type DaemonInstanceCpuUnion5 = DaemonInstanceCpu | any;

export const DaemonInstanceKind = {
  Container: "container",
  Process: "process",
  Daemon: "daemon",
} as const;
export type DaemonInstanceKind = ClosedEnum<typeof DaemonInstanceKind>;

export const DaemonInstanceMemoryUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type DaemonInstanceMemoryUnit = ClosedEnum<
  typeof DaemonInstanceMemoryUnit
>;

export type DaemonInstanceMemory = {
  unit: DaemonInstanceMemoryUnit;
  value: number;
};

export type DaemonInstanceMemoryUnion5 = DaemonInstanceMemory | any;

export type DaemonInstance5 = {
  cpu?: DaemonInstanceCpu | any | null | undefined;
  kind: DaemonInstanceKind;
  memory?: DaemonInstanceMemory | any | null | undefined;
  name: string;
  phase?: string | null | undefined;
  pid?: number | null | undefined;
  ready: boolean;
  restartCount?: number | null | undefined;
  unitId: string;
};

export type DaemonInstanceUnion = DaemonInstance5 | any;

export const EventSeverity3 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type EventSeverity3 = ClosedEnum<typeof EventSeverity3>;

export type SyncReconcileRequestSubject3 = {
  id?: string | null | undefined;
  kind: string;
  name?: string | null | undefined;
};

export type SyncReconcileRequestSubjectUnion3 =
  | SyncReconcileRequestSubject3
  | any;

export type SyncReconcileRequestEvent11 = {
  kind: string;
  message: string;
  raw?: any | null | undefined;
  severity: EventSeverity3;
  subject?: SyncReconcileRequestSubject3 | any | null | undefined;
  timestamp: Date;
};

export const SyncReconcileRequestReason18 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason18 = ClosedEnum<
  typeof SyncReconcileRequestReason18
>;

export const StatusSeverity18 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity18 = ClosedEnum<typeof StatusSeverity18>;

export type SyncReconcileRequestCollectionIssue18 = {
  message: string;
  reason: SyncReconcileRequestReason18;
  severity: StatusSeverity18;
  source: string;
};

export const SyncReconcileRequestHealth18 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth18 = ClosedEnum<
  typeof SyncReconcileRequestHealth18
>;

export const SyncReconcileRequestLifecycle18 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle18 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle18
>;

export type SyncReconcileRequestStatus18 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue18>;
  health: SyncReconcileRequestHealth18;
  lifecycle: SyncReconcileRequestLifecycle18;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal4 = {
  commandSupported: boolean;
  daemonInstance?: DaemonInstance5 | any | null | undefined;
  daemonName?: string | undefined;
  events: Array<SyncReconcileRequestEvent11>;
  exitReason?: string | null | undefined;
  imagePathPresent: boolean;
  pid?: number | null | undefined;
  restartCount?: number | null | undefined;
  runtimeId: string;
  status: SyncReconcileRequestStatus18;
  backend: "local";
};

export const CpuUnit6 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit6 = ClosedEnum<typeof CpuUnit6>;

export type SyncReconcileRequestCpu6 = {
  unit: CpuUnit6;
  value: number;
};

export type CpuUnion6 = SyncReconcileRequestCpu6 | any;

export type InvolvedObject8 = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

export type InvolvedObjectUnion8 = InvolvedObject8 | any;

export type SourceEvent8 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion8 = SourceEvent8 | any;

export type SyncReconcileRequestEvent10 = {
  count?: number | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject8 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent8 | any | null | undefined;
  type?: string | null | undefined;
};

export const MemoryUnit6 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit6 = ClosedEnum<typeof MemoryUnit6>;

export type SyncReconcileRequestMemory6 = {
  unit: MemoryUnit6;
  value: number;
};

export type MemoryUnion6 = SyncReconcileRequestMemory6 | any;

export const CpuPodUnit3 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuPodUnit3 = ClosedEnum<typeof CpuPodUnit3>;

export type CpuPod3 = {
  unit: CpuPodUnit3;
  value: number;
};

export type PodCpuUnion3 = CpuPod3 | any;

export const MemoryPodUnit3 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryPodUnit3 = ClosedEnum<typeof MemoryPodUnit3>;

export type MemoryPod3 = {
  unit: MemoryPodUnit3;
  value: number;
};

export type PodMemoryUnion3 = MemoryPod3 | any;

export type OwnerReference3 = {
  controller: boolean;
  kind: string;
  name: string;
  uid: string;
};

export type Pod3 = {
  cpu?: CpuPod3 | any | null | undefined;
  memory?: MemoryPod3 | any | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  ownerReferences: Array<OwnerReference3>;
  phase?: string | null | undefined;
  podIp?: string | null | undefined;
  ready: boolean;
  restartCount: number;
  terminatedReason?: string | null | undefined;
  uid?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

export type Replicas4 = {
  available?: number | null | undefined;
  current?: number | null | undefined;
  desired?: number | null | undefined;
  misscheduled?: number | null | undefined;
  ready?: number | null | undefined;
  updated?: number | null | undefined;
};

export const SyncReconcileRequestReason17 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason17 = ClosedEnum<
  typeof SyncReconcileRequestReason17
>;

export const StatusSeverity17 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity17 = ClosedEnum<typeof StatusSeverity17>;

export type SyncReconcileRequestCollectionIssue17 = {
  message: string;
  reason: SyncReconcileRequestReason17;
  severity: StatusSeverity17;
  source: string;
};

export const SyncReconcileRequestHealth17 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth17 = ClosedEnum<
  typeof SyncReconcileRequestHealth17
>;

export const SyncReconcileRequestLifecycle17 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle17 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle17
>;

export type SyncReconcileRequestStatus17 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue17>;
  health: SyncReconcileRequestHealth17;
  lifecycle: SyncReconcileRequestLifecycle17;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type WorkloadCondition3 = {
  lastTransitionTime?: Date | null | undefined;
  message?: string | null | undefined;
  reason?: string | null | undefined;
  status: string;
  type: string;
};

export type Workload3 = {
  availableReplicas?: number | null | undefined;
  conditions: Array<WorkloadCondition3>;
  desiredGeneration?: number | null | undefined;
  desiredReplicas?: number | null | undefined;
  observedGeneration?: number | null | undefined;
  readyReplicas?: number | null | undefined;
  rolloutReason?: string | null | undefined;
  updatedReplicas?: number | null | undefined;
};

export type WorkloadUnion3 = Workload3 | any;

export type DataKubernetes3 = {
  commandSupported: boolean;
  cpu?: SyncReconcileRequestCpu6 | any | null | undefined;
  events: Array<SyncReconcileRequestEvent10>;
  memory?: SyncReconcileRequestMemory6 | any | null | undefined;
  name: string;
  namespace: string;
  pods: Array<Pod3>;
  replicas: Replicas4;
  restarts?: number | null | undefined;
  status: SyncReconcileRequestStatus17;
  workload?: Workload3 | any | null | undefined;
  backend: "kubernetes";
};

export const CpuDaemonInstanceUnit4 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuDaemonInstanceUnit4 = ClosedEnum<typeof CpuDaemonInstanceUnit4>;

export type CpuDaemonInstance4 = {
  unit: CpuDaemonInstanceUnit4;
  value: number;
};

export type DaemonInstanceCpuUnion4 = CpuDaemonInstance4 | any;

export const MemoryDaemonInstanceUnit4 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryDaemonInstanceUnit4 = ClosedEnum<
  typeof MemoryDaemonInstanceUnit4
>;

export type MemoryDaemonInstance4 = {
  unit: MemoryDaemonInstanceUnit4;
  value: number;
};

export type DaemonInstanceMemoryUnion4 = MemoryDaemonInstance4 | any;

export type DaemonInstance4 = {
  cpu?: CpuDaemonInstance4 | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryDaemonInstance4 | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

export type InvolvedObject7 = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

export type InvolvedObjectUnion7 = InvolvedObject7 | any;

export type SourceEvent7 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion7 = SourceEvent7 | any;

export type SyncReconcileRequestEvent9 = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject7 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent7 | any | null | undefined;
  type?: string | null | undefined;
};

export const SyncReconcileRequestReason16 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason16 = ClosedEnum<
  typeof SyncReconcileRequestReason16
>;

export const StatusSeverity16 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity16 = ClosedEnum<typeof StatusSeverity16>;

export type SyncReconcileRequestCollectionIssue16 = {
  message: string;
  reason: SyncReconcileRequestReason16;
  severity: StatusSeverity16;
  source: string;
};

export const SyncReconcileRequestHealth16 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth16 = ClosedEnum<
  typeof SyncReconcileRequestHealth16
>;

export const SyncReconcileRequestLifecycle16 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle16 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle16
>;

export type SyncReconcileRequestStatus16 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue16>;
  health: SyncReconcileRequestHealth16;
  lifecycle: SyncReconcileRequestLifecycle16;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataMachines1 = {
  assignedMachines: number;
  capacityGroup: string;
  commandSupported: boolean;
  daemonInstances: Array<DaemonInstance4>;
  daemonName?: string | undefined;
  desiredMachines: number;
  events: Array<SyncReconcileRequestEvent9>;
  healthyInstances: number;
  horizonClusterId: string;
  horizonStatus: string;
  horizonStatusMessage?: string | null | undefined;
  horizonStatusReason?: string | null | undefined;
  latestUpdateTimestamp: string;
  observedImage?: string | null | undefined;
  status: SyncReconcileRequestStatus16;
  unavailableInstances: number;
  backend: "machines";
};

export const CpuDaemonInstanceUnit3 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuDaemonInstanceUnit3 = ClosedEnum<typeof CpuDaemonInstanceUnit3>;

export type CpuDaemonInstance3 = {
  unit: CpuDaemonInstanceUnit3;
  value: number;
};

export type DaemonInstanceCpuUnion3 = CpuDaemonInstance3 | any;

export const MemoryDaemonInstanceUnit3 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryDaemonInstanceUnit3 = ClosedEnum<
  typeof MemoryDaemonInstanceUnit3
>;

export type MemoryDaemonInstance3 = {
  unit: MemoryDaemonInstanceUnit3;
  value: number;
};

export type DaemonInstanceMemoryUnion3 = MemoryDaemonInstance3 | any;

export type DaemonInstance3 = {
  cpu?: CpuDaemonInstance3 | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryDaemonInstance3 | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

export type InvolvedObject6 = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

export type InvolvedObjectUnion6 = InvolvedObject6 | any;

export type SourceEvent6 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion6 = SourceEvent6 | any;

export type SyncReconcileRequestEvent8 = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject6 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent6 | any | null | undefined;
  type?: string | null | undefined;
};

export const SyncReconcileRequestReason15 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason15 = ClosedEnum<
  typeof SyncReconcileRequestReason15
>;

export const StatusSeverity15 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity15 = ClosedEnum<typeof StatusSeverity15>;

export type SyncReconcileRequestCollectionIssue15 = {
  message: string;
  reason: SyncReconcileRequestReason15;
  severity: StatusSeverity15;
  source: string;
};

export const SyncReconcileRequestHealth15 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth15 = ClosedEnum<
  typeof SyncReconcileRequestHealth15
>;

export const SyncReconcileRequestLifecycle15 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle15 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle15
>;

export type SyncReconcileRequestStatus15 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue15>;
  health: SyncReconcileRequestHealth15;
  lifecycle: SyncReconcileRequestLifecycle15;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzure1 = {
  assignedMachines: number;
  capacityGroup: string;
  commandSupported: boolean;
  daemonInstances: Array<DaemonInstance3>;
  daemonName?: string | undefined;
  desiredMachines: number;
  events: Array<SyncReconcileRequestEvent8>;
  healthyInstances: number;
  horizonClusterId: string;
  horizonStatus: string;
  horizonStatusMessage?: string | null | undefined;
  horizonStatusReason?: string | null | undefined;
  latestUpdateTimestamp: string;
  observedImage?: string | null | undefined;
  status: SyncReconcileRequestStatus15;
  unavailableInstances: number;
  backend: "azure";
};

export const CpuDaemonInstanceUnit2 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuDaemonInstanceUnit2 = ClosedEnum<typeof CpuDaemonInstanceUnit2>;

export type CpuDaemonInstance2 = {
  unit: CpuDaemonInstanceUnit2;
  value: number;
};

export type DaemonInstanceCpuUnion2 = CpuDaemonInstance2 | any;

export const MemoryDaemonInstanceUnit2 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryDaemonInstanceUnit2 = ClosedEnum<
  typeof MemoryDaemonInstanceUnit2
>;

export type MemoryDaemonInstance2 = {
  unit: MemoryDaemonInstanceUnit2;
  value: number;
};

export type DaemonInstanceMemoryUnion2 = MemoryDaemonInstance2 | any;

export type DaemonInstance2 = {
  cpu?: CpuDaemonInstance2 | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryDaemonInstance2 | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

export type InvolvedObject5 = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

export type InvolvedObjectUnion5 = InvolvedObject5 | any;

export type SourceEvent5 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion5 = SourceEvent5 | any;

export type SyncReconcileRequestEvent7 = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject5 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent5 | any | null | undefined;
  type?: string | null | undefined;
};

export const SyncReconcileRequestReason14 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason14 = ClosedEnum<
  typeof SyncReconcileRequestReason14
>;

export const StatusSeverity14 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity14 = ClosedEnum<typeof StatusSeverity14>;

export type SyncReconcileRequestCollectionIssue14 = {
  message: string;
  reason: SyncReconcileRequestReason14;
  severity: StatusSeverity14;
  source: string;
};

export const SyncReconcileRequestHealth14 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth14 = ClosedEnum<
  typeof SyncReconcileRequestHealth14
>;

export const SyncReconcileRequestLifecycle14 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle14 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle14
>;

export type SyncReconcileRequestStatus14 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue14>;
  health: SyncReconcileRequestHealth14;
  lifecycle: SyncReconcileRequestLifecycle14;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcp1 = {
  assignedMachines: number;
  capacityGroup: string;
  commandSupported: boolean;
  daemonInstances: Array<DaemonInstance2>;
  daemonName?: string | undefined;
  desiredMachines: number;
  events: Array<SyncReconcileRequestEvent7>;
  healthyInstances: number;
  horizonClusterId: string;
  horizonStatus: string;
  horizonStatusMessage?: string | null | undefined;
  horizonStatusReason?: string | null | undefined;
  latestUpdateTimestamp: string;
  observedImage?: string | null | undefined;
  status: SyncReconcileRequestStatus14;
  unavailableInstances: number;
  backend: "gcp";
};

export const CpuDaemonInstanceUnit1 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuDaemonInstanceUnit1 = ClosedEnum<typeof CpuDaemonInstanceUnit1>;

export type CpuDaemonInstance1 = {
  unit: CpuDaemonInstanceUnit1;
  value: number;
};

export type DaemonInstanceCpuUnion1 = CpuDaemonInstance1 | any;

export const MemoryDaemonInstanceUnit1 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryDaemonInstanceUnit1 = ClosedEnum<
  typeof MemoryDaemonInstanceUnit1
>;

export type MemoryDaemonInstance1 = {
  unit: MemoryDaemonInstanceUnit1;
  value: number;
};

export type DaemonInstanceMemoryUnion1 = MemoryDaemonInstance1 | any;

export type DaemonInstance1 = {
  cpu?: CpuDaemonInstance1 | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryDaemonInstance1 | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

export type InvolvedObject4 = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

export type InvolvedObjectUnion4 = InvolvedObject4 | any;

export type SourceEvent4 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion4 = SourceEvent4 | any;

export type SyncReconcileRequestEvent6 = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject4 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent4 | any | null | undefined;
  type?: string | null | undefined;
};

export const SyncReconcileRequestReason13 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason13 = ClosedEnum<
  typeof SyncReconcileRequestReason13
>;

export const StatusSeverity13 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity13 = ClosedEnum<typeof StatusSeverity13>;

export type SyncReconcileRequestCollectionIssue13 = {
  message: string;
  reason: SyncReconcileRequestReason13;
  severity: StatusSeverity13;
  source: string;
};

export const SyncReconcileRequestHealth13 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth13 = ClosedEnum<
  typeof SyncReconcileRequestHealth13
>;

export const SyncReconcileRequestLifecycle13 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle13 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle13
>;

export type SyncReconcileRequestStatus13 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue13>;
  health: SyncReconcileRequestHealth13;
  lifecycle: SyncReconcileRequestLifecycle13;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAws1 = {
  assignedMachines: number;
  capacityGroup: string;
  commandSupported: boolean;
  daemonInstances: Array<DaemonInstance1>;
  daemonName?: string | undefined;
  desiredMachines: number;
  events: Array<SyncReconcileRequestEvent6>;
  healthyInstances: number;
  horizonClusterId: string;
  horizonStatus: string;
  horizonStatusMessage?: string | null | undefined;
  horizonStatusReason?: string | null | undefined;
  latestUpdateTimestamp: string;
  observedImage?: string | null | undefined;
  status: SyncReconcileRequestStatus13;
  unavailableInstances: number;
  backend: "aws";
};

export type SyncReconcileRequestDataUnion4 =
  | DataAws1
  | DataGcp1
  | DataAzure1
  | DataMachines1
  | DataKubernetes3
  | DataLocal4;

export type DataDaemon = {
  data:
    | DataAws1
    | DataGcp1
    | DataAzure1
    | DataMachines1
    | DataKubernetes3
    | DataLocal4;
  resourceType: "daemon";
};

export const ContainerUnitCpuUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type ContainerUnitCpuUnit = ClosedEnum<typeof ContainerUnitCpuUnit>;

export type ContainerUnitCpu = {
  unit: ContainerUnitCpuUnit;
  value: number;
};

export type ContainerUnitCpuUnion = ContainerUnitCpu | any;

export const ContainerUnitKind = {
  Container: "container",
  Process: "process",
  Daemon: "daemon",
} as const;
export type ContainerUnitKind = ClosedEnum<typeof ContainerUnitKind>;

export const ContainerUnitMemoryUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type ContainerUnitMemoryUnit = ClosedEnum<
  typeof ContainerUnitMemoryUnit
>;

export type ContainerUnitMemory = {
  unit: ContainerUnitMemoryUnit;
  value: number;
};

export type ContainerUnitMemoryUnion = ContainerUnitMemory | any;

export type ContainerUnit = {
  cpu?: ContainerUnitCpu | any | null | undefined;
  kind: ContainerUnitKind;
  memory?: ContainerUnitMemory | any | null | undefined;
  name: string;
  phase?: string | null | undefined;
  pid?: number | null | undefined;
  ready: boolean;
  restartCount?: number | null | undefined;
  unitId: string;
};

export type ContainerUnitUnion = ContainerUnit | any;

export const CpuUnit5 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit5 = ClosedEnum<typeof CpuUnit5>;

export type SyncReconcileRequestCpu5 = {
  unit: CpuUnit5;
  value: number;
};

export type CpuUnion5 = SyncReconcileRequestCpu5 | any;

export const EventSeverity2 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type EventSeverity2 = ClosedEnum<typeof EventSeverity2>;

export type SyncReconcileRequestSubject2 = {
  id?: string | null | undefined;
  kind: string;
  name?: string | null | undefined;
};

export type SyncReconcileRequestSubjectUnion2 =
  | SyncReconcileRequestSubject2
  | any;

export type SyncReconcileRequestEvent5 = {
  kind: string;
  message: string;
  raw?: any | null | undefined;
  severity: EventSeverity2;
  subject?: SyncReconcileRequestSubject2 | any | null | undefined;
  timestamp: Date;
};

export const MemoryUnit5 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit5 = ClosedEnum<typeof MemoryUnit5>;

export type SyncReconcileRequestMemory5 = {
  unit: MemoryUnit5;
  value: number;
};

export type MemoryUnion5 = SyncReconcileRequestMemory5 | any;

export const SyncReconcileRequestReason12 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason12 = ClosedEnum<
  typeof SyncReconcileRequestReason12
>;

export const StatusSeverity12 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity12 = ClosedEnum<typeof StatusSeverity12>;

export type SyncReconcileRequestCollectionIssue12 = {
  message: string;
  reason: SyncReconcileRequestReason12;
  severity: StatusSeverity12;
  source: string;
};

export const SyncReconcileRequestHealth12 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth12 = ClosedEnum<
  typeof SyncReconcileRequestHealth12
>;

export const SyncReconcileRequestLifecycle12 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle12 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle12
>;

export type SyncReconcileRequestStatus12 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue12>;
  health: SyncReconcileRequestHealth12;
  lifecycle: SyncReconcileRequestLifecycle12;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal3 = {
  bindMountCount: number;
  containerId?: string | null | undefined;
  containerUnit?: ContainerUnit | any | null | undefined;
  cpu?: SyncReconcileRequestCpu5 | any | null | undefined;
  events: Array<SyncReconcileRequestEvent5>;
  image?: string | null | undefined;
  localUrl?: string | null | undefined;
  memory?: SyncReconcileRequestMemory5 | any | null | undefined;
  name?: string | null | undefined;
  portCount: number;
  restartCount?: number | null | undefined;
  runtimeReachable: boolean;
  runtimeStatus?: string | null | undefined;
  status: SyncReconcileRequestStatus12;
  backend: "local";
};

export const CpuUnit4 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit4 = ClosedEnum<typeof CpuUnit4>;

export type SyncReconcileRequestCpu4 = {
  unit: CpuUnit4;
  value: number;
};

export type CpuUnion4 = SyncReconcileRequestCpu4 | any;

export type InvolvedObject3 = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

export type InvolvedObjectUnion3 = InvolvedObject3 | any;

export type SourceEvent3 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion3 = SourceEvent3 | any;

export type SyncReconcileRequestEvent4 = {
  count?: number | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject3 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent3 | any | null | undefined;
  type?: string | null | undefined;
};

export const MemoryUnit4 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit4 = ClosedEnum<typeof MemoryUnit4>;

export type SyncReconcileRequestMemory4 = {
  unit: MemoryUnit4;
  value: number;
};

export type MemoryUnion4 = SyncReconcileRequestMemory4 | any;

export const CpuPodUnit2 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuPodUnit2 = ClosedEnum<typeof CpuPodUnit2>;

export type CpuPod2 = {
  unit: CpuPodUnit2;
  value: number;
};

export type PodCpuUnion2 = CpuPod2 | any;

export const MemoryPodUnit2 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryPodUnit2 = ClosedEnum<typeof MemoryPodUnit2>;

export type MemoryPod2 = {
  unit: MemoryPodUnit2;
  value: number;
};

export type PodMemoryUnion2 = MemoryPod2 | any;

export type OwnerReference2 = {
  controller: boolean;
  kind: string;
  name: string;
  uid: string;
};

export type Pod2 = {
  cpu?: CpuPod2 | any | null | undefined;
  memory?: MemoryPod2 | any | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  ownerReferences: Array<OwnerReference2>;
  phase?: string | null | undefined;
  podIp?: string | null | undefined;
  ready: boolean;
  restartCount: number;
  terminatedReason?: string | null | undefined;
  uid?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

export type Replicas3 = {
  available?: number | null | undefined;
  current?: number | null | undefined;
  desired?: number | null | undefined;
  misscheduled?: number | null | undefined;
  ready?: number | null | undefined;
  updated?: number | null | undefined;
};

export const SyncReconcileRequestReason11 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason11 = ClosedEnum<
  typeof SyncReconcileRequestReason11
>;

export const StatusSeverity11 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity11 = ClosedEnum<typeof StatusSeverity11>;

export type SyncReconcileRequestCollectionIssue11 = {
  message: string;
  reason: SyncReconcileRequestReason11;
  severity: StatusSeverity11;
  source: string;
};

export const SyncReconcileRequestHealth11 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth11 = ClosedEnum<
  typeof SyncReconcileRequestHealth11
>;

export const SyncReconcileRequestLifecycle11 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle11 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle11
>;

export type SyncReconcileRequestStatus11 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue11>;
  health: SyncReconcileRequestHealth11;
  lifecycle: SyncReconcileRequestLifecycle11;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type WorkloadCondition2 = {
  lastTransitionTime?: Date | null | undefined;
  message?: string | null | undefined;
  reason?: string | null | undefined;
  status: string;
  type: string;
};

export type Workload2 = {
  availableReplicas?: number | null | undefined;
  conditions: Array<WorkloadCondition2>;
  desiredGeneration?: number | null | undefined;
  desiredReplicas?: number | null | undefined;
  observedGeneration?: number | null | undefined;
  readyReplicas?: number | null | undefined;
  rolloutReason?: string | null | undefined;
  updatedReplicas?: number | null | undefined;
};

export type WorkloadUnion2 = Workload2 | any;

export const WorkloadKind2 = {
  Deployment: "deployment",
  StatefulSet: "statefulSet",
  DaemonSet: "daemonSet",
  ReplicaSet: "replicaSet",
  Pod: "pod",
} as const;
export type WorkloadKind2 = ClosedEnum<typeof WorkloadKind2>;

export type DataKubernetes2 = {
  cpu?: SyncReconcileRequestCpu4 | any | null | undefined;
  events: Array<SyncReconcileRequestEvent4>;
  memory?: SyncReconcileRequestMemory4 | any | null | undefined;
  name: string;
  namespace: string;
  pods: Array<Pod2>;
  replicas: Replicas3;
  restarts?: number | null | undefined;
  status: SyncReconcileRequestStatus11;
  workload?: Workload2 | any | null | undefined;
  workloadKind: WorkloadKind2;
  backend: "kubernetes";
};

export const CpuUnit3 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit3 = ClosedEnum<typeof CpuUnit3>;

export type SyncReconcileRequestCpu3 = {
  unit: CpuUnit3;
  value: number;
};

export type CpuUnion3 = SyncReconcileRequestCpu3 | any;

export type InvolvedObject2 = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

export type InvolvedObjectUnion2 = InvolvedObject2 | any;

export type SourceEvent2 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion2 = SourceEvent2 | any;

export type SyncReconcileRequestEvent3 = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject2 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent2 | any | null | undefined;
  type?: string | null | undefined;
};

export const MemoryUnit3 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit3 = ClosedEnum<typeof MemoryUnit3>;

export type SyncReconcileRequestMemory3 = {
  unit: MemoryUnit3;
  value: number;
};

export type MemoryUnion3 = SyncReconcileRequestMemory3 | any;

export const CpuReplicaUnitUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuReplicaUnitUnit = ClosedEnum<typeof CpuReplicaUnitUnit>;

export type CpuReplicaUnit = {
  unit: CpuReplicaUnitUnit;
  value: number;
};

export type ReplicaUnitCpuUnion = CpuReplicaUnit | any;

export const MemoryReplicaUnitUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryReplicaUnitUnit = ClosedEnum<typeof MemoryReplicaUnitUnit>;

export type MemoryReplicaUnit = {
  unit: MemoryReplicaUnitUnit;
  value: number;
};

export type ReplicaUnitMemoryUnion = MemoryReplicaUnit | any;

export type ReplicaUnit = {
  cpu?: CpuReplicaUnit | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryReplicaUnit | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

export type Replicas2 = {
  available?: number | null | undefined;
  current?: number | null | undefined;
  desired?: number | null | undefined;
  misscheduled?: number | null | undefined;
  ready?: number | null | undefined;
  updated?: number | null | undefined;
};

export const SchedulingMode = {
  Replicated: "replicated",
  Stateful: "stateful",
  Daemon: "daemon",
} as const;
export type SchedulingMode = ClosedEnum<typeof SchedulingMode>;

export const SyncReconcileRequestReason10 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason10 = ClosedEnum<
  typeof SyncReconcileRequestReason10
>;

export const StatusSeverity10 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity10 = ClosedEnum<typeof StatusSeverity10>;

export type SyncReconcileRequestCollectionIssue10 = {
  message: string;
  reason: SyncReconcileRequestReason10;
  severity: StatusSeverity10;
  source: string;
};

export const SyncReconcileRequestHealth10 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth10 = ClosedEnum<
  typeof SyncReconcileRequestHealth10
>;

export const SyncReconcileRequestLifecycle10 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle10 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle10
>;

export type SyncReconcileRequestStatus10 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue10>;
  health: SyncReconcileRequestHealth10;
  lifecycle: SyncReconcileRequestLifecycle10;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataHorizonPlatform = {
  attentionCount: number;
  containerId: string;
  cpu?: SyncReconcileRequestCpu3 | any | null | undefined;
  events: Array<SyncReconcileRequestEvent3>;
  image?: string | null | undefined;
  latestUpdateTimestamp?: string | null | undefined;
  memory?: SyncReconcileRequestMemory3 | any | null | undefined;
  observedImage?: string | null | undefined;
  replicaUnits: Array<ReplicaUnit>;
  replicas: Replicas2;
  schedulingMode: SchedulingMode;
  status: SyncReconcileRequestStatus10;
  backend: "horizonPlatform";
};

export type SyncReconcileRequestDataUnion3 =
  | DataHorizonPlatform
  | DataKubernetes2
  | DataLocal3;

export type DataContainer = {
  data: DataHorizonPlatform | DataKubernetes2 | DataLocal3;
  resourceType: "container";
};

export const CpuUnit2 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit2 = ClosedEnum<typeof CpuUnit2>;

export type SyncReconcileRequestCpu2 = {
  unit: CpuUnit2;
  value: number;
};

export type CpuUnion2 = SyncReconcileRequestCpu2 | any;

export const EventSeverity1 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type EventSeverity1 = ClosedEnum<typeof EventSeverity1>;

export type SyncReconcileRequestSubject1 = {
  id?: string | null | undefined;
  kind: string;
  name?: string | null | undefined;
};

export type SyncReconcileRequestSubjectUnion1 =
  | SyncReconcileRequestSubject1
  | any;

export type SyncReconcileRequestEvent2 = {
  kind: string;
  message: string;
  raw?: any | null | undefined;
  severity: EventSeverity1;
  subject?: SyncReconcileRequestSubject1 | any | null | undefined;
  timestamp: Date;
};

export const MemoryUnit2 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit2 = ClosedEnum<typeof MemoryUnit2>;

export type SyncReconcileRequestMemory2 = {
  unit: MemoryUnit2;
  value: number;
};

export type MemoryUnion2 = SyncReconcileRequestMemory2 | any;

export const ProcessCpuUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type ProcessCpuUnit = ClosedEnum<typeof ProcessCpuUnit>;

export type ProcessCpu = {
  unit: ProcessCpuUnit;
  value: number;
};

export type ProcessCpuUnion = ProcessCpu | any;

export const ProcessKind = {
  Container: "container",
  Process: "process",
  Daemon: "daemon",
} as const;
export type ProcessKind = ClosedEnum<typeof ProcessKind>;

export const ProcessMemoryUnit = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type ProcessMemoryUnit = ClosedEnum<typeof ProcessMemoryUnit>;

export type ProcessMemory = {
  unit: ProcessMemoryUnit;
  value: number;
};

export type ProcessMemoryUnion = ProcessMemory | any;

export type Process = {
  cpu?: ProcessCpu | any | null | undefined;
  kind: ProcessKind;
  memory?: ProcessMemory | any | null | undefined;
  name: string;
  phase?: string | null | undefined;
  pid?: number | null | undefined;
  ready: boolean;
  restartCount?: number | null | undefined;
  unitId: string;
};

export type ProcessUnion = Process | any;

export const SyncReconcileRequestReason9 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason9 = ClosedEnum<
  typeof SyncReconcileRequestReason9
>;

export const StatusSeverity9 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity9 = ClosedEnum<typeof StatusSeverity9>;

export type SyncReconcileRequestCollectionIssue9 = {
  message: string;
  reason: SyncReconcileRequestReason9;
  severity: StatusSeverity9;
  source: string;
};

export const SyncReconcileRequestHealth9 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth9 = ClosedEnum<
  typeof SyncReconcileRequestHealth9
>;

export const SyncReconcileRequestLifecycle9 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle9 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle9
>;

export type SyncReconcileRequestStatus9 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue9>;
  health: SyncReconcileRequestHealth9;
  lifecycle: SyncReconcileRequestLifecycle9;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal2 = {
  commandSupported: boolean;
  cpu?: SyncReconcileRequestCpu2 | any | null | undefined;
  events: Array<SyncReconcileRequestEvent2>;
  imagePathPresent: boolean;
  memory?: SyncReconcileRequestMemory2 | any | null | undefined;
  pid?: number | null | undefined;
  process?: Process | any | null | undefined;
  readinessProbeOk?: boolean | null | undefined;
  status: SyncReconcileRequestStatus9;
  triggerCount: number;
  backend: "local";
};

export const CpuUnit1 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuUnit1 = ClosedEnum<typeof CpuUnit1>;

export type SyncReconcileRequestCpu1 = {
  unit: CpuUnit1;
  value: number;
};

export type CpuUnion1 = SyncReconcileRequestCpu1 | any;

export type InvolvedObject1 = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

export type InvolvedObjectUnion1 = InvolvedObject1 | any;

export type SourceEvent1 = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

export type EventSourceUnion1 = SourceEvent1 | any;

export type SyncReconcileRequestEvent1 = {
  count?: number | null | undefined;
  eventTime?: Date | null | undefined;
  firstTimestamp?: Date | null | undefined;
  involvedObject?: InvolvedObject1 | any | null | undefined;
  lastTimestamp?: Date | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent1 | any | null | undefined;
  type?: string | null | undefined;
};

export const MemoryUnit1 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryUnit1 = ClosedEnum<typeof MemoryUnit1>;

export type SyncReconcileRequestMemory1 = {
  unit: MemoryUnit1;
  value: number;
};

export type MemoryUnion1 = SyncReconcileRequestMemory1 | any;

export const CpuPodUnit1 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type CpuPodUnit1 = ClosedEnum<typeof CpuPodUnit1>;

export type CpuPod1 = {
  unit: CpuPodUnit1;
  value: number;
};

export type PodCpuUnion1 = CpuPod1 | any;

export const MemoryPodUnit1 = {
  Count: "count",
  Percent: "percent",
  Bytes: "bytes",
  Cores: "cores",
  Milliseconds: "milliseconds",
  RequestsPerSecond: "requests-per-second",
} as const;
export type MemoryPodUnit1 = ClosedEnum<typeof MemoryPodUnit1>;

export type MemoryPod1 = {
  unit: MemoryPodUnit1;
  value: number;
};

export type PodMemoryUnion1 = MemoryPod1 | any;

export type OwnerReference1 = {
  controller: boolean;
  kind: string;
  name: string;
  uid: string;
};

export type Pod1 = {
  cpu?: CpuPod1 | any | null | undefined;
  memory?: MemoryPod1 | any | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  ownerReferences: Array<OwnerReference1>;
  phase?: string | null | undefined;
  podIp?: string | null | undefined;
  ready: boolean;
  restartCount: number;
  terminatedReason?: string | null | undefined;
  uid?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

export type Replicas1 = {
  available?: number | null | undefined;
  current?: number | null | undefined;
  desired?: number | null | undefined;
  misscheduled?: number | null | undefined;
  ready?: number | null | undefined;
  updated?: number | null | undefined;
};

export const SyncReconcileRequestReason8 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason8 = ClosedEnum<
  typeof SyncReconcileRequestReason8
>;

export const StatusSeverity8 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity8 = ClosedEnum<typeof StatusSeverity8>;

export type SyncReconcileRequestCollectionIssue8 = {
  message: string;
  reason: SyncReconcileRequestReason8;
  severity: StatusSeverity8;
  source: string;
};

export const SyncReconcileRequestHealth8 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth8 = ClosedEnum<
  typeof SyncReconcileRequestHealth8
>;

export const SyncReconcileRequestLifecycle8 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle8 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle8
>;

export type SyncReconcileRequestStatus8 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue8>;
  health: SyncReconcileRequestHealth8;
  lifecycle: SyncReconcileRequestLifecycle8;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type WorkloadCondition1 = {
  lastTransitionTime?: Date | null | undefined;
  message?: string | null | undefined;
  reason?: string | null | undefined;
  status: string;
  type: string;
};

export type Workload1 = {
  availableReplicas?: number | null | undefined;
  conditions: Array<WorkloadCondition1>;
  desiredGeneration?: number | null | undefined;
  desiredReplicas?: number | null | undefined;
  observedGeneration?: number | null | undefined;
  readyReplicas?: number | null | undefined;
  rolloutReason?: string | null | undefined;
  updatedReplicas?: number | null | undefined;
};

export type WorkloadUnion1 = Workload1 | any;

export const WorkloadKind1 = {
  Deployment: "deployment",
  StatefulSet: "statefulSet",
  DaemonSet: "daemonSet",
  ReplicaSet: "replicaSet",
  Pod: "pod",
} as const;
export type WorkloadKind1 = ClosedEnum<typeof WorkloadKind1>;

export type DataKubernetes1 = {
  cpu?: SyncReconcileRequestCpu1 | any | null | undefined;
  events: Array<SyncReconcileRequestEvent1>;
  memory?: SyncReconcileRequestMemory1 | any | null | undefined;
  name: string;
  namespace: string;
  pods: Array<Pod1>;
  replicas: Replicas1;
  restarts?: number | null | undefined;
  status: SyncReconcileRequestStatus8;
  triggerCount: number;
  workload?: Workload1 | any | null | undefined;
  workloadKind: WorkloadKind1;
  backend: "kubernetes";
};

export const SyncReconcileRequestReason7 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason7 = ClosedEnum<
  typeof SyncReconcileRequestReason7
>;

export const StatusSeverity7 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity7 = ClosedEnum<typeof StatusSeverity7>;

export type SyncReconcileRequestCollectionIssue7 = {
  message: string;
  reason: SyncReconcileRequestReason7;
  severity: StatusSeverity7;
  source: string;
};

export const SyncReconcileRequestHealth7 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth7 = ClosedEnum<
  typeof SyncReconcileRequestHealth7
>;

export const SyncReconcileRequestLifecycle7 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle7 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle7
>;

export type SyncReconcileRequestStatus7 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue7>;
  health: SyncReconcileRequestHealth7;
  lifecycle: SyncReconcileRequestLifecycle7;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureContainerApps1 = {
  appName: string;
  cpu?: number | null | undefined;
  environmentName?: string | null | undefined;
  ingressFqdn?: string | null | undefined;
  maxReplicas?: number | null | undefined;
  memory?: string | null | undefined;
  minReplicas?: number | null | undefined;
  provisioningState?: string | null | undefined;
  revision?: string | null | undefined;
  runningStatus?: string | null | undefined;
  status: SyncReconcileRequestStatus7;
  backend: "azureContainerApps";
};

export const SyncReconcileRequestReason6 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason6 = ClosedEnum<
  typeof SyncReconcileRequestReason6
>;

export const StatusSeverity6 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity6 = ClosedEnum<typeof StatusSeverity6>;

export type SyncReconcileRequestCollectionIssue6 = {
  message: string;
  reason: SyncReconcileRequestReason6;
  severity: StatusSeverity6;
  source: string;
};

export const SyncReconcileRequestHealth6 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth6 = ClosedEnum<
  typeof SyncReconcileRequestHealth6
>;

export const SyncReconcileRequestLifecycle6 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle6 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle6
>;

export type SyncReconcileRequestStatus6 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue6>;
  health: SyncReconcileRequestHealth6;
  lifecycle: SyncReconcileRequestLifecycle6;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpCloudRun = {
  containerImage?: string | null | undefined;
  cpuLimit?: string | null | undefined;
  generation?: number | null | undefined;
  latestCreatedRevision?: string | null | undefined;
  latestReadyRevision?: string | null | undefined;
  maxInstanceCount?: number | null | undefined;
  memoryLimit?: string | null | undefined;
  minInstanceCount?: number | null | undefined;
  observedGeneration?: number | null | undefined;
  region?: string | null | undefined;
  service: string;
  status: SyncReconcileRequestStatus6;
  trafficCount: number;
  uri?: string | null | undefined;
  urls: Array<string>;
  backend: "gcpCloudRun";
};

export const SyncReconcileRequestReason5 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason5 = ClosedEnum<
  typeof SyncReconcileRequestReason5
>;

export const StatusSeverity5 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity5 = ClosedEnum<typeof StatusSeverity5>;

export type SyncReconcileRequestCollectionIssue5 = {
  message: string;
  reason: SyncReconcileRequestReason5;
  severity: StatusSeverity5;
  source: string;
};

export const SyncReconcileRequestHealth5 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth5 = ClosedEnum<
  typeof SyncReconcileRequestHealth5
>;

export const SyncReconcileRequestLifecycle5 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle5 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle5
>;

export type SyncReconcileRequestStatus5 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue5>;
  health: SyncReconcileRequestHealth5;
  lifecycle: SyncReconcileRequestLifecycle5;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsLambda = {
  codeSha256?: string | null | undefined;
  functionName: string;
  functionUrlAuthType?: string | null | undefined;
  functionUrlCorsPresent: boolean;
  lastModified?: string | null | undefined;
  lastUpdateStatus?: string | null | undefined;
  lastUpdateStatusReason?: string | null | undefined;
  lastUpdateStatusReasonCode?: string | null | undefined;
  layerCount: number;
  memorySizeMb?: number | null | undefined;
  packageType?: string | null | undefined;
  revisionId?: string | null | undefined;
  runtime?: string | null | undefined;
  state?: string | null | undefined;
  stateReason?: string | null | undefined;
  stateReasonCode?: string | null | undefined;
  status: SyncReconcileRequestStatus5;
  timeoutSeconds?: number | null | undefined;
  triggerCount: number;
  version?: string | null | undefined;
  backend: "awsLambda";
};

export type SyncReconcileRequestDataUnion2 =
  | DataAwsLambda
  | DataGcpCloudRun
  | DataAzureContainerApps1
  | DataKubernetes1
  | DataLocal2;

export type DataWorker = {
  data:
    | DataAwsLambda
    | DataGcpCloudRun
    | DataAzureContainerApps1
    | DataKubernetes1
    | DataLocal2;
  resourceType: "worker";
};

export const SyncReconcileRequestReason4 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason4 = ClosedEnum<
  typeof SyncReconcileRequestReason4
>;

export const StatusSeverity4 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity4 = ClosedEnum<typeof StatusSeverity4>;

export type SyncReconcileRequestCollectionIssue4 = {
  message: string;
  reason: SyncReconcileRequestReason4;
  severity: StatusSeverity4;
  source: string;
};

export const SyncReconcileRequestHealth4 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth4 = ClosedEnum<
  typeof SyncReconcileRequestHealth4
>;

export const SyncReconcileRequestLifecycle4 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle4 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle4
>;

export type SyncReconcileRequestStatus4 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue4>;
  health: SyncReconcileRequestHealth4;
  lifecycle: SyncReconcileRequestLifecycle4;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataLocal1 = {
  isDirectory?: boolean | null | undefined;
  modifiedAt?: Date | null | undefined;
  path: string;
  pathExists: boolean;
  readonly?: boolean | null | undefined;
  status: SyncReconcileRequestStatus4;
  backend: "local";
};

export const SyncReconcileRequestReason3 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason3 = ClosedEnum<
  typeof SyncReconcileRequestReason3
>;

export const StatusSeverity3 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity3 = ClosedEnum<typeof StatusSeverity3>;

export type SyncReconcileRequestCollectionIssue3 = {
  message: string;
  reason: SyncReconcileRequestReason3;
  severity: StatusSeverity3;
  source: string;
};

export const SyncReconcileRequestHealth3 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth3 = ClosedEnum<
  typeof SyncReconcileRequestHealth3
>;

export const SyncReconcileRequestLifecycle3 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle3 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle3
>;

export type SyncReconcileRequestStatus3 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue3>;
  health: SyncReconcileRequestHealth3;
  lifecycle: SyncReconcileRequestLifecycle3;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAzureBlob = {
  accessTier?: string | null | undefined;
  accountKind?: string | null | undefined;
  allowBlobPublicAccess?: boolean | null | undefined;
  blobDeleteRetentionDays?: number | null | undefined;
  blobDeleteRetentionEnabled?: boolean | null | undefined;
  blobEncryptionEnabled?: boolean | null | undefined;
  blobVersioningEnabled?: boolean | null | undefined;
  changeFeedEnabled?: boolean | null | undefined;
  changeFeedRetentionDays?: number | null | undefined;
  containerDeleteRetentionDays?: number | null | undefined;
  containerDeleteRetentionEnabled?: boolean | null | undefined;
  containerPublicAccess?: string | null | undefined;
  encryptionKeySource?: string | null | undefined;
  fileEncryptionEnabled?: boolean | null | undefined;
  location?: string | null | undefined;
  name: string;
  primaryLocation?: string | null | undefined;
  provisioningState?: string | null | undefined;
  publicNetworkAccess?: string | null | undefined;
  queueEncryptionEnabled?: boolean | null | undefined;
  resourceGroup?: string | null | undefined;
  secondaryLocation?: string | null | undefined;
  skuName?: string | null | undefined;
  skuTier?: string | null | undefined;
  status: SyncReconcileRequestStatus3;
  statusOfPrimary?: string | null | undefined;
  statusOfSecondary?: string | null | undefined;
  storageAccountName?: string | null | undefined;
  tableEncryptionEnabled?: boolean | null | undefined;
  backend: "azureBlob";
};

export const SyncReconcileRequestReason2 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason2 = ClosedEnum<
  typeof SyncReconcileRequestReason2
>;

export const StatusSeverity2 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity2 = ClosedEnum<typeof StatusSeverity2>;

export type SyncReconcileRequestCollectionIssue2 = {
  message: string;
  reason: SyncReconcileRequestReason2;
  severity: StatusSeverity2;
  source: string;
};

export const SyncReconcileRequestHealth2 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth2 = ClosedEnum<
  typeof SyncReconcileRequestHealth2
>;

export const SyncReconcileRequestLifecycle2 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle2 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle2
>;

export type SyncReconcileRequestStatus2 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue2>;
  health: SyncReconcileRequestHealth2;
  lifecycle: SyncReconcileRequestLifecycle2;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataGcpCloudStorage = {
  bucketId?: string | null | undefined;
  defaultKmsKeyName?: string | null | undefined;
  encryptionConfigPresent: boolean;
  lifecyclePresent: boolean;
  lifecycleRuleCount?: number | null | undefined;
  location?: string | null | undefined;
  locationType?: string | null | undefined;
  name: string;
  publicAccessPrevention?: string | null | undefined;
  retentionPeriod?: string | null | undefined;
  retentionPolicyEffectiveTime?: string | null | undefined;
  retentionPolicyIsLocked?: boolean | null | undefined;
  softDeleteEffectiveTime?: string | null | undefined;
  softDeleteRetentionDurationSeconds?: string | null | undefined;
  status: SyncReconcileRequestStatus2;
  storageClass?: string | null | undefined;
  uniformBucketLevelAccessEnabled?: boolean | null | undefined;
  uniformBucketLevelAccessLockedTime?: string | null | undefined;
  versioningEnabled?: boolean | null | undefined;
  backend: "gcpCloudStorage";
};

export const SyncReconcileRequestReason1 = {
  Forbidden: "forbidden",
  NotInstalled: "not-installed",
  ApiUnavailable: "api-unavailable",
  CollectionFailed: "collection-failed",
  TimedOut: "timed-out",
} as const;
export type SyncReconcileRequestReason1 = ClosedEnum<
  typeof SyncReconcileRequestReason1
>;

export const StatusSeverity1 = {
  Info: "info",
  Warning: "warning",
  Error: "error",
} as const;
export type StatusSeverity1 = ClosedEnum<typeof StatusSeverity1>;

export type SyncReconcileRequestCollectionIssue1 = {
  message: string;
  reason: SyncReconcileRequestReason1;
  severity: StatusSeverity1;
  source: string;
};

export const SyncReconcileRequestHealth1 = {
  Unknown: "unknown",
  Healthy: "healthy",
  Degraded: "degraded",
  Unhealthy: "unhealthy",
} as const;
export type SyncReconcileRequestHealth1 = ClosedEnum<
  typeof SyncReconcileRequestHealth1
>;

export const SyncReconcileRequestLifecycle1 = {
  Unknown: "unknown",
  Creating: "creating",
  Updating: "updating",
  Running: "running",
  Scaling: "scaling",
  Stopping: "stopping",
  Stopped: "stopped",
  Deleting: "deleting",
  Deleted: "deleted",
  Failed: "failed",
} as const;
export type SyncReconcileRequestLifecycle1 = ClosedEnum<
  typeof SyncReconcileRequestLifecycle1
>;

export type SyncReconcileRequestStatus1 = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue1>;
  health: SyncReconcileRequestHealth1;
  lifecycle: SyncReconcileRequestLifecycle1;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

export type DataAwsS3 = {
  blockPublicAcls?: boolean | null | undefined;
  blockPublicPolicy?: boolean | null | undefined;
  bucketAclPresent?: boolean | null | undefined;
  bucketLocation?: string | null | undefined;
  bucketPolicyPresent?: boolean | null | undefined;
  encryptionConfigPresent: boolean;
  encryptionEnabled?: boolean | null | undefined;
  ignorePublicAcls?: boolean | null | undefined;
  lifecyclePresent: boolean;
  lifecycleRuleCount?: number | null | undefined;
  name: string;
  publicAccessBlockPresent: boolean;
  region?: string | null | undefined;
  restrictPublicBuckets?: boolean | null | undefined;
  status: SyncReconcileRequestStatus1;
  versioningEnabled?: boolean | null | undefined;
  versioningStatus?: string | null | undefined;
  backend: "awsS3";
};

export type SyncReconcileRequestDataUnion1 =
  | DataAwsS3
  | DataGcpCloudStorage
  | DataAzureBlob
  | DataLocal1;

export type DataStorage = {
  data: DataAwsS3 | DataGcpCloudStorage | DataAzureBlob | DataLocal1;
  resourceType: "storage";
};

export type SyncReconcileRequestDataUnion19 =
  | DataStorage
  | DataWorker
  | DataContainer
  | DataDaemon
  | DataComputeCluster
  | DataKubernetesCluster
  | DataQueue
  | DataKv
  | DataPostgres
  | DataVault
  | DataServiceAccount
  | DataNetwork
  | DataRemoteStackManagement
  | DataArtifactRegistry
  | DataBuild
  | DataServiceActivation
  | DataAzureResourceGroup
  | DataAzureStorageAccount
  | DataAzureContainerAppsEnvironment
  | DataAzureServiceBusNamespace
  | DataAi
  | DataKey
  | DataSandbox;

export const SyncReconcileRequestFormat = {
  Json: "json",
  Yaml: "yaml",
  Text: "text",
} as const;
export type SyncReconcileRequestFormat = ClosedEnum<
  typeof SyncReconcileRequestFormat
>;

export type SyncReconcileRequestRaw = {
  body: string;
  collectedAt: Date;
  format: SyncReconcileRequestFormat;
  source: string;
  truncated: boolean;
};

export type ResourceHeartbeat = {
  backend: SyncReconcileRequestBackendEnum;
  /**
   * Represents the target cloud platform.
   */
  controllerPlatform: SyncReconcileRequestControllerPlatform;
  data:
    | DataStorage
    | DataWorker
    | DataContainer
    | DataDaemon
    | DataComputeCluster
    | DataKubernetesCluster
    | DataQueue
    | DataKv
    | DataPostgres
    | DataVault
    | DataServiceAccount
    | DataNetwork
    | DataRemoteStackManagement
    | DataArtifactRegistry
    | DataBuild
    | DataServiceActivation
    | DataAzureResourceGroup
    | DataAzureStorageAccount
    | DataAzureContainerAppsEnvironment
    | DataAzureServiceBusNamespace
    | DataAi
    | DataKey
    | DataSandbox;
  deploymentId?: string | null | undefined;
  observedAt: Date;
  raw: Array<SyncReconcileRequestRaw>;
  /**
   * Alien resource id, such as the `alien.Container` or `alien.Storage`
   *
   * @remarks
   * resource id from the stack.
   */
  resourceId: string;
  /**
   * Resource type identifier that determines the specific kind of resource. This field is used for polymorphic deserialization and resource-specific behavior.
   */
  resourceType: string;
};

/**
 * Request to reconcile deployment state
 */
export type SyncReconcileRequest = {
  /**
   * Deployment ID to reconcile state for
   */
  deploymentId: string;
  /**
   * Lock session (push model only) - verifies lock ownership
   */
  session?: string | undefined;
  /**
   * Immutable operation claimed at acquisition. Required with attemptId for update execution.
   */
  operationId?: string | undefined;
  /**
   * Execution attempt claimed at acquisition. Required with operationId for update execution.
   */
  attemptId?: string | undefined;
  state: DeploymentState;
  /**
   * Update heartbeat timestamp (for successful health checks)
   */
  updateHeartbeat?: boolean | undefined;
  /**
   * Delay before this deployment should be acquired again.
   */
  suggestedDelayMs?: number | undefined;
  /**
   * Latest typed resource heartbeats collected during this step.
   */
  resourceHeartbeats?: Array<ResourceHeartbeat> | undefined;
  /**
   * Observed raw-resource inventory batches read during this step.
   */
  observedInventoryBatches?: Array<ObservedInventoryBatch> | undefined;
  /**
   * Operator-reported runtime capabilities.
   */
  capabilities?: Array<OperatorCapabilityReport> | undefined;
  /**
   * Operator binary version reported by the runtime.
   */
  operatorVersion?: string | undefined;
  /**
   * Exact immutable image identity reported by a running Remote Operator.
   */
  operatorImage?: RemoteOperatorImageIdentity | undefined;
  /**
   * Operations bundle set the Operator currently has loaded, for plugin-sync status tracking.
   */
  operationsReport?: OperationsReport | undefined;
};

/** @internal */
export const SyncReconcileRequestBackendEnum$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestBackendEnum
> = z.enum(SyncReconcileRequestBackendEnum);

/** @internal */
export const SyncReconcileRequestControllerPlatform$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestControllerPlatform
> = z.enum(SyncReconcileRequestControllerPlatform);

/** @internal */
export const SyncReconcileRequestReason74$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason74
> = z.enum(SyncReconcileRequestReason74);

/** @internal */
export const StatusSeverity74$outboundSchema: z.ZodEnum<
  typeof StatusSeverity74
> = z.enum(StatusSeverity74);

/** @internal */
export type SyncReconcileRequestCollectionIssue74$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue74$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue74$Outbound,
  SyncReconcileRequestCollectionIssue74
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason74$outboundSchema,
  severity: StatusSeverity74$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue74ToJSON(
  syncReconcileRequestCollectionIssue74: SyncReconcileRequestCollectionIssue74,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue74$outboundSchema.parse(
      syncReconcileRequestCollectionIssue74,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth77$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth77
> = z.enum(SyncReconcileRequestHealth77);

/** @internal */
export const SyncReconcileRequestLifecycle77$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle77
> = z.enum(SyncReconcileRequestLifecycle77);

/** @internal */
export type SyncReconcileRequestStatus77$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue74$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus77$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus77$Outbound,
  SyncReconcileRequestStatus77
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue74$outboundSchema),
  ),
  health: SyncReconcileRequestHealth77$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle77$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus77ToJSON(
  syncReconcileRequestStatus77: SyncReconcileRequestStatus77,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus77$outboundSchema.parse(
      syncReconcileRequestStatus77,
    ),
  );
}

/** @internal */
export type DataLocal12$Outbound = {
  activeSessions: number;
  routeServing: boolean;
  status: SyncReconcileRequestStatus77$Outbound;
  backend: "local";
};

/** @internal */
export const DataLocal12$outboundSchema: z.ZodType<
  DataLocal12$Outbound,
  DataLocal12
> = z.object({
  activeSessions: z.int(),
  routeServing: z.boolean(),
  status: z.lazy(() => SyncReconcileRequestStatus77$outboundSchema),
  backend: z.literal("local"),
});

export function dataLocal12ToJSON(dataLocal12: DataLocal12): string {
  return JSON.stringify(DataLocal12$outboundSchema.parse(dataLocal12));
}

/** @internal */
export const SyncReconcileRequestReason73$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason73
> = z.enum(SyncReconcileRequestReason73);

/** @internal */
export const StatusSeverity73$outboundSchema: z.ZodEnum<
  typeof StatusSeverity73
> = z.enum(StatusSeverity73);

/** @internal */
export type SyncReconcileRequestCollectionIssue73$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue73$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue73$Outbound,
  SyncReconcileRequestCollectionIssue73
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason73$outboundSchema,
  severity: StatusSeverity73$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue73ToJSON(
  syncReconcileRequestCollectionIssue73: SyncReconcileRequestCollectionIssue73,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue73$outboundSchema.parse(
      syncReconcileRequestCollectionIssue73,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth76$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth76
> = z.enum(SyncReconcileRequestHealth76);

/** @internal */
export const SyncReconcileRequestLifecycle76$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle76
> = z.enum(SyncReconcileRequestLifecycle76);

/** @internal */
export type SyncReconcileRequestStatus76$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue73$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus76$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus76$Outbound,
  SyncReconcileRequestStatus76
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue73$outboundSchema),
  ),
  health: SyncReconcileRequestHealth76$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle76$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus76ToJSON(
  syncReconcileRequestStatus76: SyncReconcileRequestStatus76,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus76$outboundSchema.parse(
      syncReconcileRequestStatus76,
    ),
  );
}

/** @internal */
export type DataKubernetesPods$Outbound = {
  activeSessions: number;
  idlePods: number;
  namespace: string;
  status: SyncReconcileRequestStatus76$Outbound;
  backend: "kubernetesPods";
};

/** @internal */
export const DataKubernetesPods$outboundSchema: z.ZodType<
  DataKubernetesPods$Outbound,
  DataKubernetesPods
> = z.object({
  activeSessions: z.int(),
  idlePods: z.int(),
  namespace: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus76$outboundSchema),
  backend: z.literal("kubernetesPods"),
});

export function dataKubernetesPodsToJSON(
  dataKubernetesPods: DataKubernetesPods,
): string {
  return JSON.stringify(
    DataKubernetesPods$outboundSchema.parse(dataKubernetesPods),
  );
}

/** @internal */
export const SyncReconcileRequestReason72$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason72
> = z.enum(SyncReconcileRequestReason72);

/** @internal */
export const StatusSeverity72$outboundSchema: z.ZodEnum<
  typeof StatusSeverity72
> = z.enum(StatusSeverity72);

/** @internal */
export type SyncReconcileRequestCollectionIssue72$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue72$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue72$Outbound,
  SyncReconcileRequestCollectionIssue72
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason72$outboundSchema,
  severity: StatusSeverity72$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue72ToJSON(
  syncReconcileRequestCollectionIssue72: SyncReconcileRequestCollectionIssue72,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue72$outboundSchema.parse(
      syncReconcileRequestCollectionIssue72,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth75$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth75
> = z.enum(SyncReconcileRequestHealth75);

/** @internal */
export const SyncReconcileRequestLifecycle75$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle75
> = z.enum(SyncReconcileRequestLifecycle75);

/** @internal */
export type SyncReconcileRequestStatus75$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue72$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus75$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus75$Outbound,
  SyncReconcileRequestStatus75
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue72$outboundSchema),
  ),
  health: SyncReconcileRequestHealth75$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle75$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus75ToJSON(
  syncReconcileRequestStatus75: SyncReconcileRequestStatus75,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus75$outboundSchema.parse(
      syncReconcileRequestStatus75,
    ),
  );
}

/** @internal */
export type DataGcpAgentPlatform$Outbound = {
  engine: string;
  status: SyncReconcileRequestStatus75$Outbound;
  templateId: string;
  backend: "gcpAgentPlatform";
};

/** @internal */
export const DataGcpAgentPlatform$outboundSchema: z.ZodType<
  DataGcpAgentPlatform$Outbound,
  DataGcpAgentPlatform
> = z.object({
  engine: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus75$outboundSchema),
  templateId: z.string(),
  backend: z.literal("gcpAgentPlatform"),
});

export function dataGcpAgentPlatformToJSON(
  dataGcpAgentPlatform: DataGcpAgentPlatform,
): string {
  return JSON.stringify(
    DataGcpAgentPlatform$outboundSchema.parse(dataGcpAgentPlatform),
  );
}

/** @internal */
export const SyncReconcileRequestReason71$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason71
> = z.enum(SyncReconcileRequestReason71);

/** @internal */
export const StatusSeverity71$outboundSchema: z.ZodEnum<
  typeof StatusSeverity71
> = z.enum(StatusSeverity71);

/** @internal */
export type SyncReconcileRequestCollectionIssue71$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue71$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue71$Outbound,
  SyncReconcileRequestCollectionIssue71
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason71$outboundSchema,
  severity: StatusSeverity71$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue71ToJSON(
  syncReconcileRequestCollectionIssue71: SyncReconcileRequestCollectionIssue71,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue71$outboundSchema.parse(
      syncReconcileRequestCollectionIssue71,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth74$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth74
> = z.enum(SyncReconcileRequestHealth74);

/** @internal */
export const SyncReconcileRequestLifecycle74$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle74
> = z.enum(SyncReconcileRequestLifecycle74);

/** @internal */
export type SyncReconcileRequestStatus74$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue71$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus74$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus74$Outbound,
  SyncReconcileRequestStatus74
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue71$outboundSchema),
  ),
  health: SyncReconcileRequestHealth74$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle74$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus74ToJSON(
  syncReconcileRequestStatus74: SyncReconcileRequestStatus74,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus74$outboundSchema.parse(
      syncReconcileRequestStatus74,
    ),
  );
}

/** @internal */
export type DataAzureSandboxGroup$Outbound = {
  provisioningState?: string | null | undefined;
  sandboxGroup: string;
  status: SyncReconcileRequestStatus74$Outbound;
  backend: "azureSandboxGroup";
};

/** @internal */
export const DataAzureSandboxGroup$outboundSchema: z.ZodType<
  DataAzureSandboxGroup$Outbound,
  DataAzureSandboxGroup
> = z.object({
  provisioningState: z.nullable(z.string()).optional(),
  sandboxGroup: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus74$outboundSchema),
  backend: z.literal("azureSandboxGroup"),
});

export function dataAzureSandboxGroupToJSON(
  dataAzureSandboxGroup: DataAzureSandboxGroup,
): string {
  return JSON.stringify(
    DataAzureSandboxGroup$outboundSchema.parse(dataAzureSandboxGroup),
  );
}

/** @internal */
export const SyncReconcileRequestReason70$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason70
> = z.enum(SyncReconcileRequestReason70);

/** @internal */
export const StatusSeverity70$outboundSchema: z.ZodEnum<
  typeof StatusSeverity70
> = z.enum(StatusSeverity70);

/** @internal */
export type SyncReconcileRequestCollectionIssue70$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue70$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue70$Outbound,
  SyncReconcileRequestCollectionIssue70
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason70$outboundSchema,
  severity: StatusSeverity70$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue70ToJSON(
  syncReconcileRequestCollectionIssue70: SyncReconcileRequestCollectionIssue70,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue70$outboundSchema.parse(
      syncReconcileRequestCollectionIssue70,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth73$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth73
> = z.enum(SyncReconcileRequestHealth73);

/** @internal */
export const SyncReconcileRequestLifecycle73$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle73
> = z.enum(SyncReconcileRequestLifecycle73);

/** @internal */
export type SyncReconcileRequestStatus73$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue70$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus73$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus73$Outbound,
  SyncReconcileRequestStatus73
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue70$outboundSchema),
  ),
  health: SyncReconcileRequestHealth73$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle73$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus73ToJSON(
  syncReconcileRequestStatus73: SyncReconcileRequestStatus73,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus73$outboundSchema.parse(
      syncReconcileRequestStatus73,
    ),
  );
}

/** @internal */
export type DataAwsMicrovm$Outbound = {
  imageIdentifier: string;
  imageState?: string | null | undefined;
  status: SyncReconcileRequestStatus73$Outbound;
  backend: "awsMicrovm";
};

/** @internal */
export const DataAwsMicrovm$outboundSchema: z.ZodType<
  DataAwsMicrovm$Outbound,
  DataAwsMicrovm
> = z.object({
  imageIdentifier: z.string(),
  imageState: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus73$outboundSchema),
  backend: z.literal("awsMicrovm"),
});

export function dataAwsMicrovmToJSON(dataAwsMicrovm: DataAwsMicrovm): string {
  return JSON.stringify(DataAwsMicrovm$outboundSchema.parse(dataAwsMicrovm));
}

/** @internal */
export type SyncReconcileRequestDataUnion18$Outbound =
  | DataAwsMicrovm$Outbound
  | DataAzureSandboxGroup$Outbound
  | DataGcpAgentPlatform$Outbound
  | DataKubernetesPods$Outbound
  | DataLocal12$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion18$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion18$Outbound,
  SyncReconcileRequestDataUnion18
> = z.union([
  z.lazy(() => DataAwsMicrovm$outboundSchema),
  z.lazy(() => DataAzureSandboxGroup$outboundSchema),
  z.lazy(() => DataGcpAgentPlatform$outboundSchema),
  z.lazy(() => DataKubernetesPods$outboundSchema),
  z.lazy(() => DataLocal12$outboundSchema),
]);

export function syncReconcileRequestDataUnion18ToJSON(
  syncReconcileRequestDataUnion18: SyncReconcileRequestDataUnion18,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion18$outboundSchema.parse(
      syncReconcileRequestDataUnion18,
    ),
  );
}

/** @internal */
export type DataSandbox$Outbound = {
  data:
    | DataAwsMicrovm$Outbound
    | DataAzureSandboxGroup$Outbound
    | DataGcpAgentPlatform$Outbound
    | DataKubernetesPods$Outbound
    | DataLocal12$Outbound;
  resourceType: "sandbox";
};

/** @internal */
export const DataSandbox$outboundSchema: z.ZodType<
  DataSandbox$Outbound,
  DataSandbox
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsMicrovm$outboundSchema),
    z.lazy(() => DataAzureSandboxGroup$outboundSchema),
    z.lazy(() => DataGcpAgentPlatform$outboundSchema),
    z.lazy(() => DataKubernetesPods$outboundSchema),
    z.lazy(() => DataLocal12$outboundSchema),
  ]),
  resourceType: z.literal("sandbox"),
});

export function dataSandboxToJSON(dataSandbox: DataSandbox): string {
  return JSON.stringify(DataSandbox$outboundSchema.parse(dataSandbox));
}

/** @internal */
export const SyncReconcileRequestHealth72$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth72
> = z.enum(SyncReconcileRequestHealth72);

/** @internal */
export const SyncReconcileRequestLifecycle72$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle72
> = z.enum(SyncReconcileRequestLifecycle72);

/** @internal */
export type SyncReconcileRequestStatus72$Outbound = {
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestStatus72$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus72$Outbound,
  SyncReconcileRequestStatus72
> = z.object({
  health: SyncReconcileRequestHealth72$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle72$outboundSchema,
  message: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestStatus72ToJSON(
  syncReconcileRequestStatus72: SyncReconcileRequestStatus72,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus72$outboundSchema.parse(
      syncReconcileRequestStatus72,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestData8$Outbound = {
  enabled?: boolean | null | undefined;
  keyId: string;
  keyOperations: Array<string>;
  keyType: string;
  recoveryLevel?: string | null | undefined;
  status: SyncReconcileRequestStatus72$Outbound;
};

/** @internal */
export const SyncReconcileRequestData8$outboundSchema: z.ZodType<
  SyncReconcileRequestData8$Outbound,
  SyncReconcileRequestData8
> = z.object({
  enabled: z.nullable(z.boolean()).optional(),
  keyId: z.string(),
  keyOperations: z.array(z.string()),
  keyType: z.string(),
  recoveryLevel: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus72$outboundSchema),
});

export function syncReconcileRequestData8ToJSON(
  syncReconcileRequestData8: SyncReconcileRequestData8,
): string {
  return JSON.stringify(
    SyncReconcileRequestData8$outboundSchema.parse(syncReconcileRequestData8),
  );
}

/** @internal */
export type DataAzureKeyVault2$Outbound = {
  data: SyncReconcileRequestData8$Outbound;
  provider: "azure-key-vault";
};

/** @internal */
export const DataAzureKeyVault2$outboundSchema: z.ZodType<
  DataAzureKeyVault2$Outbound,
  DataAzureKeyVault2
> = z.object({
  data: z.lazy(() => SyncReconcileRequestData8$outboundSchema),
  provider: z.literal("azure-key-vault"),
});

export function dataAzureKeyVault2ToJSON(
  dataAzureKeyVault2: DataAzureKeyVault2,
): string {
  return JSON.stringify(
    DataAzureKeyVault2$outboundSchema.parse(dataAzureKeyVault2),
  );
}

/** @internal */
export const SyncReconcileRequestHealth71$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth71
> = z.enum(SyncReconcileRequestHealth71);

/** @internal */
export const SyncReconcileRequestLifecycle71$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle71
> = z.enum(SyncReconcileRequestLifecycle71);

/** @internal */
export type SyncReconcileRequestStatus71$Outbound = {
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestStatus71$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus71$Outbound,
  SyncReconcileRequestStatus71
> = z.object({
  health: SyncReconcileRequestHealth71$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle71$outboundSchema,
  message: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestStatus71ToJSON(
  syncReconcileRequestStatus71: SyncReconcileRequestStatus71,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus71$outboundSchema.parse(
      syncReconcileRequestStatus71,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestData7$Outbound = {
  algorithm?: string | null | undefined;
  cryptoKeyName: string;
  primaryState?: string | null | undefined;
  primaryVersion?: string | null | undefined;
  purpose: string;
  status: SyncReconcileRequestStatus71$Outbound;
};

/** @internal */
export const SyncReconcileRequestData7$outboundSchema: z.ZodType<
  SyncReconcileRequestData7$Outbound,
  SyncReconcileRequestData7
> = z.object({
  algorithm: z.nullable(z.string()).optional(),
  cryptoKeyName: z.string(),
  primaryState: z.nullable(z.string()).optional(),
  primaryVersion: z.nullable(z.string()).optional(),
  purpose: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus71$outboundSchema),
});

export function syncReconcileRequestData7ToJSON(
  syncReconcileRequestData7: SyncReconcileRequestData7,
): string {
  return JSON.stringify(
    SyncReconcileRequestData7$outboundSchema.parse(syncReconcileRequestData7),
  );
}

/** @internal */
export type DataGcpCloudKms$Outbound = {
  data: SyncReconcileRequestData7$Outbound;
  provider: "gcp-cloud-kms";
};

/** @internal */
export const DataGcpCloudKms$outboundSchema: z.ZodType<
  DataGcpCloudKms$Outbound,
  DataGcpCloudKms
> = z.object({
  data: z.lazy(() => SyncReconcileRequestData7$outboundSchema),
  provider: z.literal("gcp-cloud-kms"),
});

export function dataGcpCloudKmsToJSON(
  dataGcpCloudKms: DataGcpCloudKms,
): string {
  return JSON.stringify(DataGcpCloudKms$outboundSchema.parse(dataGcpCloudKms));
}

/** @internal */
export const SyncReconcileRequestHealth70$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth70
> = z.enum(SyncReconcileRequestHealth70);

/** @internal */
export const SyncReconcileRequestLifecycle70$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle70
> = z.enum(SyncReconcileRequestLifecycle70);

/** @internal */
export type SyncReconcileRequestStatus70$Outbound = {
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestStatus70$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus70$Outbound,
  SyncReconcileRequestStatus70
> = z.object({
  health: SyncReconcileRequestHealth70$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle70$outboundSchema,
  message: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestStatus70ToJSON(
  syncReconcileRequestStatus70: SyncReconcileRequestStatus70,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus70$outboundSchema.parse(
      syncReconcileRequestStatus70,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestData6$Outbound = {
  enabled: boolean;
  keyArn: string;
  keySpec: string;
  keyState: string;
  keyUsage: string;
  status: SyncReconcileRequestStatus70$Outbound;
};

/** @internal */
export const SyncReconcileRequestData6$outboundSchema: z.ZodType<
  SyncReconcileRequestData6$Outbound,
  SyncReconcileRequestData6
> = z.object({
  enabled: z.boolean(),
  keyArn: z.string(),
  keySpec: z.string(),
  keyState: z.string(),
  keyUsage: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus70$outboundSchema),
});

export function syncReconcileRequestData6ToJSON(
  syncReconcileRequestData6: SyncReconcileRequestData6,
): string {
  return JSON.stringify(
    SyncReconcileRequestData6$outboundSchema.parse(syncReconcileRequestData6),
  );
}

/** @internal */
export type DataAwsKms$Outbound = {
  data: SyncReconcileRequestData6$Outbound;
  provider: "aws-kms";
};

/** @internal */
export const DataAwsKms$outboundSchema: z.ZodType<
  DataAwsKms$Outbound,
  DataAwsKms
> = z.object({
  data: z.lazy(() => SyncReconcileRequestData6$outboundSchema),
  provider: z.literal("aws-kms"),
});

export function dataAwsKmsToJSON(dataAwsKms: DataAwsKms): string {
  return JSON.stringify(DataAwsKms$outboundSchema.parse(dataAwsKms));
}

/** @internal */
export type SyncReconcileRequestDataUnion17$Outbound =
  | DataAwsKms$Outbound
  | DataGcpCloudKms$Outbound
  | DataAzureKeyVault2$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion17$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion17$Outbound,
  SyncReconcileRequestDataUnion17
> = z.union([
  z.lazy(() => DataAwsKms$outboundSchema),
  z.lazy(() => DataGcpCloudKms$outboundSchema),
  z.lazy(() => DataAzureKeyVault2$outboundSchema),
]);

export function syncReconcileRequestDataUnion17ToJSON(
  syncReconcileRequestDataUnion17: SyncReconcileRequestDataUnion17,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion17$outboundSchema.parse(
      syncReconcileRequestDataUnion17,
    ),
  );
}

/** @internal */
export type DataKey$Outbound = {
  data:
    | DataAwsKms$Outbound
    | DataGcpCloudKms$Outbound
    | DataAzureKeyVault2$Outbound;
  resourceType: "key";
};

/** @internal */
export const DataKey$outboundSchema: z.ZodType<DataKey$Outbound, DataKey> = z
  .object({
    data: z.union([
      z.lazy(() => DataAwsKms$outboundSchema),
      z.lazy(() => DataGcpCloudKms$outboundSchema),
      z.lazy(() => DataAzureKeyVault2$outboundSchema),
    ]),
    resourceType: z.literal("key"),
  });

export function dataKeyToJSON(dataKey: DataKey): string {
  return JSON.stringify(DataKey$outboundSchema.parse(dataKey));
}

/** @internal */
export const SyncReconcileRequestAccessTest4$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestAccessTest4
> = z.enum(SyncReconcileRequestAccessTest4);

/** @internal */
export const SyncReconcileRequestModelAvailability4$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestModelAvailability4
> = z.enum(SyncReconcileRequestModelAvailability4);

/** @internal */
export const AvailabilityBlocker4$outboundSchema: z.ZodEnum<
  typeof AvailabilityBlocker4
> = z.enum(AvailabilityBlocker4);

/** @internal */
export const SyncReconcileRequestClientApi4$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestClientApi4
> = z.enum(SyncReconcileRequestClientApi4);

/** @internal */
export type SyncReconcileRequestModel4$Outbound = {
  accessTest: string;
  availability: string;
  blockers: Array<string>;
  clientApis: Array<string>;
  errorCode?: string | null | undefined;
  publicModelId: string;
  testedAt?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestModel4$outboundSchema: z.ZodType<
  SyncReconcileRequestModel4$Outbound,
  SyncReconcileRequestModel4
> = z.object({
  accessTest: SyncReconcileRequestAccessTest4$outboundSchema,
  availability: SyncReconcileRequestModelAvailability4$outboundSchema,
  blockers: z.array(AvailabilityBlocker4$outboundSchema),
  clientApis: z.array(SyncReconcileRequestClientApi4$outboundSchema),
  errorCode: z.nullable(z.string()).optional(),
  publicModelId: z.string(),
  testedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
});

export function syncReconcileRequestModel4ToJSON(
  syncReconcileRequestModel4: SyncReconcileRequestModel4,
): string {
  return JSON.stringify(
    SyncReconcileRequestModel4$outboundSchema.parse(syncReconcileRequestModel4),
  );
}

/** @internal */
export const AvailabilitySource4$outboundSchema: z.ZodEnum<
  typeof AvailabilitySource4
> = z.enum(AvailabilitySource4);

/** @internal */
export type SyncReconcileRequestAvailability4$Outbound = {
  catalogRevision: string;
  location?: string | null | undefined;
  models: Array<SyncReconcileRequestModel4$Outbound>;
  source: string;
};

/** @internal */
export const SyncReconcileRequestAvailability4$outboundSchema: z.ZodType<
  SyncReconcileRequestAvailability4$Outbound,
  SyncReconcileRequestAvailability4
> = z.object({
  catalogRevision: z.string(),
  location: z.nullable(z.string()).optional(),
  models: z.array(z.lazy(() => SyncReconcileRequestModel4$outboundSchema)),
  source: AvailabilitySource4$outboundSchema,
});

export function syncReconcileRequestAvailability4ToJSON(
  syncReconcileRequestAvailability4: SyncReconcileRequestAvailability4,
): string {
  return JSON.stringify(
    SyncReconcileRequestAvailability4$outboundSchema.parse(
      syncReconcileRequestAvailability4,
    ),
  );
}

/** @internal */
export type Availability$Outbound =
  | SyncReconcileRequestAvailability4$Outbound
  | any;

/** @internal */
export const Availability$outboundSchema: z.ZodType<
  Availability$Outbound,
  Availability
> = z.union([
  z.lazy(() => SyncReconcileRequestAvailability4$outboundSchema),
  z.any(),
]);

export function availabilityToJSON(availability: Availability): string {
  return JSON.stringify(Availability$outboundSchema.parse(availability));
}

/** @internal */
export const SyncReconcileRequestReason69$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason69
> = z.enum(SyncReconcileRequestReason69);

/** @internal */
export const StatusSeverity69$outboundSchema: z.ZodEnum<
  typeof StatusSeverity69
> = z.enum(StatusSeverity69);

/** @internal */
export type SyncReconcileRequestCollectionIssue69$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue69$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue69$Outbound,
  SyncReconcileRequestCollectionIssue69
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason69$outboundSchema,
  severity: StatusSeverity69$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue69ToJSON(
  syncReconcileRequestCollectionIssue69: SyncReconcileRequestCollectionIssue69,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue69$outboundSchema.parse(
      syncReconcileRequestCollectionIssue69,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth69$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth69
> = z.enum(SyncReconcileRequestHealth69);

/** @internal */
export const SyncReconcileRequestLifecycle69$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle69
> = z.enum(SyncReconcileRequestLifecycle69);

/** @internal */
export type SyncReconcileRequestStatus69$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue69$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus69$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus69$Outbound,
  SyncReconcileRequestStatus69
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue69$outboundSchema),
  ),
  health: SyncReconcileRequestHealth69$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle69$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus69ToJSON(
  syncReconcileRequestStatus69: SyncReconcileRequestStatus69,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus69$outboundSchema.parse(
      syncReconcileRequestStatus69,
    ),
  );
}

/** @internal */
export type DataExternal$Outbound = {
  availability?:
    | SyncReconcileRequestAvailability4$Outbound
    | any
    | null
    | undefined;
  provider: string;
  status: SyncReconcileRequestStatus69$Outbound;
  backend: "external";
};

/** @internal */
export const DataExternal$outboundSchema: z.ZodType<
  DataExternal$Outbound,
  DataExternal
> = z.object({
  availability: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestAvailability4$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  provider: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus69$outboundSchema),
  backend: z.literal("external"),
});

export function dataExternalToJSON(dataExternal: DataExternal): string {
  return JSON.stringify(DataExternal$outboundSchema.parse(dataExternal));
}

/** @internal */
export const SyncReconcileRequestAccessTest3$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestAccessTest3
> = z.enum(SyncReconcileRequestAccessTest3);

/** @internal */
export const SyncReconcileRequestModelAvailability3$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestModelAvailability3
> = z.enum(SyncReconcileRequestModelAvailability3);

/** @internal */
export const AvailabilityBlocker3$outboundSchema: z.ZodEnum<
  typeof AvailabilityBlocker3
> = z.enum(AvailabilityBlocker3);

/** @internal */
export const SyncReconcileRequestClientApi3$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestClientApi3
> = z.enum(SyncReconcileRequestClientApi3);

/** @internal */
export type SyncReconcileRequestModel3$Outbound = {
  accessTest: string;
  availability: string;
  blockers: Array<string>;
  clientApis: Array<string>;
  errorCode?: string | null | undefined;
  publicModelId: string;
  testedAt?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestModel3$outboundSchema: z.ZodType<
  SyncReconcileRequestModel3$Outbound,
  SyncReconcileRequestModel3
> = z.object({
  accessTest: SyncReconcileRequestAccessTest3$outboundSchema,
  availability: SyncReconcileRequestModelAvailability3$outboundSchema,
  blockers: z.array(AvailabilityBlocker3$outboundSchema),
  clientApis: z.array(SyncReconcileRequestClientApi3$outboundSchema),
  errorCode: z.nullable(z.string()).optional(),
  publicModelId: z.string(),
  testedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
});

export function syncReconcileRequestModel3ToJSON(
  syncReconcileRequestModel3: SyncReconcileRequestModel3,
): string {
  return JSON.stringify(
    SyncReconcileRequestModel3$outboundSchema.parse(syncReconcileRequestModel3),
  );
}

/** @internal */
export const AvailabilitySource3$outboundSchema: z.ZodEnum<
  typeof AvailabilitySource3
> = z.enum(AvailabilitySource3);

/** @internal */
export type SyncReconcileRequestAvailability3$Outbound = {
  catalogRevision: string;
  location?: string | null | undefined;
  models: Array<SyncReconcileRequestModel3$Outbound>;
  source: string;
};

/** @internal */
export const SyncReconcileRequestAvailability3$outboundSchema: z.ZodType<
  SyncReconcileRequestAvailability3$Outbound,
  SyncReconcileRequestAvailability3
> = z.object({
  catalogRevision: z.string(),
  location: z.nullable(z.string()).optional(),
  models: z.array(z.lazy(() => SyncReconcileRequestModel3$outboundSchema)),
  source: AvailabilitySource3$outboundSchema,
});

export function syncReconcileRequestAvailability3ToJSON(
  syncReconcileRequestAvailability3: SyncReconcileRequestAvailability3,
): string {
  return JSON.stringify(
    SyncReconcileRequestAvailability3$outboundSchema.parse(
      syncReconcileRequestAvailability3,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestReason68$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason68
> = z.enum(SyncReconcileRequestReason68);

/** @internal */
export const StatusSeverity68$outboundSchema: z.ZodEnum<
  typeof StatusSeverity68
> = z.enum(StatusSeverity68);

/** @internal */
export type SyncReconcileRequestCollectionIssue68$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue68$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue68$Outbound,
  SyncReconcileRequestCollectionIssue68
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason68$outboundSchema,
  severity: StatusSeverity68$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue68ToJSON(
  syncReconcileRequestCollectionIssue68: SyncReconcileRequestCollectionIssue68,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue68$outboundSchema.parse(
      syncReconcileRequestCollectionIssue68,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth68$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth68
> = z.enum(SyncReconcileRequestHealth68);

/** @internal */
export const SyncReconcileRequestLifecycle68$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle68
> = z.enum(SyncReconcileRequestLifecycle68);

/** @internal */
export type SyncReconcileRequestStatus68$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue68$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus68$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus68$Outbound,
  SyncReconcileRequestStatus68
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue68$outboundSchema),
  ),
  health: SyncReconcileRequestHealth68$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle68$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus68ToJSON(
  syncReconcileRequestStatus68: SyncReconcileRequestStatus68,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus68$outboundSchema.parse(
      syncReconcileRequestStatus68,
    ),
  );
}

/** @internal */
export type DataAzureFoundry$Outbound = {
  accountName: string;
  availability: SyncReconcileRequestAvailability3$Outbound;
  endpoint?: string | null | undefined;
  location?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  status: SyncReconcileRequestStatus68$Outbound;
  backend: "azureFoundry";
};

/** @internal */
export const DataAzureFoundry$outboundSchema: z.ZodType<
  DataAzureFoundry$Outbound,
  DataAzureFoundry
> = z.object({
  accountName: z.string(),
  availability: z.lazy(() => SyncReconcileRequestAvailability3$outboundSchema),
  endpoint: z.nullable(z.string()).optional(),
  location: z.nullable(z.string()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus68$outboundSchema),
  backend: z.literal("azureFoundry"),
});

export function dataAzureFoundryToJSON(
  dataAzureFoundry: DataAzureFoundry,
): string {
  return JSON.stringify(
    DataAzureFoundry$outboundSchema.parse(dataAzureFoundry),
  );
}

/** @internal */
export const SyncReconcileRequestAccessTest2$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestAccessTest2
> = z.enum(SyncReconcileRequestAccessTest2);

/** @internal */
export const SyncReconcileRequestModelAvailability2$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestModelAvailability2
> = z.enum(SyncReconcileRequestModelAvailability2);

/** @internal */
export const AvailabilityBlocker2$outboundSchema: z.ZodEnum<
  typeof AvailabilityBlocker2
> = z.enum(AvailabilityBlocker2);

/** @internal */
export const SyncReconcileRequestClientApi2$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestClientApi2
> = z.enum(SyncReconcileRequestClientApi2);

/** @internal */
export type SyncReconcileRequestModel2$Outbound = {
  accessTest: string;
  availability: string;
  blockers: Array<string>;
  clientApis: Array<string>;
  errorCode?: string | null | undefined;
  publicModelId: string;
  testedAt?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestModel2$outboundSchema: z.ZodType<
  SyncReconcileRequestModel2$Outbound,
  SyncReconcileRequestModel2
> = z.object({
  accessTest: SyncReconcileRequestAccessTest2$outboundSchema,
  availability: SyncReconcileRequestModelAvailability2$outboundSchema,
  blockers: z.array(AvailabilityBlocker2$outboundSchema),
  clientApis: z.array(SyncReconcileRequestClientApi2$outboundSchema),
  errorCode: z.nullable(z.string()).optional(),
  publicModelId: z.string(),
  testedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
});

export function syncReconcileRequestModel2ToJSON(
  syncReconcileRequestModel2: SyncReconcileRequestModel2,
): string {
  return JSON.stringify(
    SyncReconcileRequestModel2$outboundSchema.parse(syncReconcileRequestModel2),
  );
}

/** @internal */
export const AvailabilitySource2$outboundSchema: z.ZodEnum<
  typeof AvailabilitySource2
> = z.enum(AvailabilitySource2);

/** @internal */
export type SyncReconcileRequestAvailability2$Outbound = {
  catalogRevision: string;
  location?: string | null | undefined;
  models: Array<SyncReconcileRequestModel2$Outbound>;
  source: string;
};

/** @internal */
export const SyncReconcileRequestAvailability2$outboundSchema: z.ZodType<
  SyncReconcileRequestAvailability2$Outbound,
  SyncReconcileRequestAvailability2
> = z.object({
  catalogRevision: z.string(),
  location: z.nullable(z.string()).optional(),
  models: z.array(z.lazy(() => SyncReconcileRequestModel2$outboundSchema)),
  source: AvailabilitySource2$outboundSchema,
});

export function syncReconcileRequestAvailability2ToJSON(
  syncReconcileRequestAvailability2: SyncReconcileRequestAvailability2,
): string {
  return JSON.stringify(
    SyncReconcileRequestAvailability2$outboundSchema.parse(
      syncReconcileRequestAvailability2,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestReason67$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason67
> = z.enum(SyncReconcileRequestReason67);

/** @internal */
export const StatusSeverity67$outboundSchema: z.ZodEnum<
  typeof StatusSeverity67
> = z.enum(StatusSeverity67);

/** @internal */
export type SyncReconcileRequestCollectionIssue67$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue67$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue67$Outbound,
  SyncReconcileRequestCollectionIssue67
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason67$outboundSchema,
  severity: StatusSeverity67$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue67ToJSON(
  syncReconcileRequestCollectionIssue67: SyncReconcileRequestCollectionIssue67,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue67$outboundSchema.parse(
      syncReconcileRequestCollectionIssue67,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth67$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth67
> = z.enum(SyncReconcileRequestHealth67);

/** @internal */
export const SyncReconcileRequestLifecycle67$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle67
> = z.enum(SyncReconcileRequestLifecycle67);

/** @internal */
export type SyncReconcileRequestStatus67$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue67$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus67$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus67$Outbound,
  SyncReconcileRequestStatus67
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue67$outboundSchema),
  ),
  health: SyncReconcileRequestHealth67$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle67$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus67ToJSON(
  syncReconcileRequestStatus67: SyncReconcileRequestStatus67,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus67$outboundSchema.parse(
      syncReconcileRequestStatus67,
    ),
  );
}

/** @internal */
export type DataGcpVertex$Outbound = {
  availability: SyncReconcileRequestAvailability2$Outbound;
  location: string;
  project: string;
  status: SyncReconcileRequestStatus67$Outbound;
  backend: "gcpVertex";
};

/** @internal */
export const DataGcpVertex$outboundSchema: z.ZodType<
  DataGcpVertex$Outbound,
  DataGcpVertex
> = z.object({
  availability: z.lazy(() => SyncReconcileRequestAvailability2$outboundSchema),
  location: z.string(),
  project: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus67$outboundSchema),
  backend: z.literal("gcpVertex"),
});

export function dataGcpVertexToJSON(dataGcpVertex: DataGcpVertex): string {
  return JSON.stringify(DataGcpVertex$outboundSchema.parse(dataGcpVertex));
}

/** @internal */
export const SyncReconcileRequestAccessTest1$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestAccessTest1
> = z.enum(SyncReconcileRequestAccessTest1);

/** @internal */
export const SyncReconcileRequestModelAvailability1$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestModelAvailability1
> = z.enum(SyncReconcileRequestModelAvailability1);

/** @internal */
export const AvailabilityBlocker1$outboundSchema: z.ZodEnum<
  typeof AvailabilityBlocker1
> = z.enum(AvailabilityBlocker1);

/** @internal */
export const SyncReconcileRequestClientApi1$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestClientApi1
> = z.enum(SyncReconcileRequestClientApi1);

/** @internal */
export type SyncReconcileRequestModel1$Outbound = {
  accessTest: string;
  availability: string;
  blockers: Array<string>;
  clientApis: Array<string>;
  errorCode?: string | null | undefined;
  publicModelId: string;
  testedAt?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestModel1$outboundSchema: z.ZodType<
  SyncReconcileRequestModel1$Outbound,
  SyncReconcileRequestModel1
> = z.object({
  accessTest: SyncReconcileRequestAccessTest1$outboundSchema,
  availability: SyncReconcileRequestModelAvailability1$outboundSchema,
  blockers: z.array(AvailabilityBlocker1$outboundSchema),
  clientApis: z.array(SyncReconcileRequestClientApi1$outboundSchema),
  errorCode: z.nullable(z.string()).optional(),
  publicModelId: z.string(),
  testedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
});

export function syncReconcileRequestModel1ToJSON(
  syncReconcileRequestModel1: SyncReconcileRequestModel1,
): string {
  return JSON.stringify(
    SyncReconcileRequestModel1$outboundSchema.parse(syncReconcileRequestModel1),
  );
}

/** @internal */
export const AvailabilitySource1$outboundSchema: z.ZodEnum<
  typeof AvailabilitySource1
> = z.enum(AvailabilitySource1);

/** @internal */
export type SyncReconcileRequestAvailability1$Outbound = {
  catalogRevision: string;
  location?: string | null | undefined;
  models: Array<SyncReconcileRequestModel1$Outbound>;
  source: string;
};

/** @internal */
export const SyncReconcileRequestAvailability1$outboundSchema: z.ZodType<
  SyncReconcileRequestAvailability1$Outbound,
  SyncReconcileRequestAvailability1
> = z.object({
  catalogRevision: z.string(),
  location: z.nullable(z.string()).optional(),
  models: z.array(z.lazy(() => SyncReconcileRequestModel1$outboundSchema)),
  source: AvailabilitySource1$outboundSchema,
});

export function syncReconcileRequestAvailability1ToJSON(
  syncReconcileRequestAvailability1: SyncReconcileRequestAvailability1,
): string {
  return JSON.stringify(
    SyncReconcileRequestAvailability1$outboundSchema.parse(
      syncReconcileRequestAvailability1,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestReason66$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason66
> = z.enum(SyncReconcileRequestReason66);

/** @internal */
export const StatusSeverity66$outboundSchema: z.ZodEnum<
  typeof StatusSeverity66
> = z.enum(StatusSeverity66);

/** @internal */
export type SyncReconcileRequestCollectionIssue66$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue66$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue66$Outbound,
  SyncReconcileRequestCollectionIssue66
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason66$outboundSchema,
  severity: StatusSeverity66$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue66ToJSON(
  syncReconcileRequestCollectionIssue66: SyncReconcileRequestCollectionIssue66,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue66$outboundSchema.parse(
      syncReconcileRequestCollectionIssue66,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth66$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth66
> = z.enum(SyncReconcileRequestHealth66);

/** @internal */
export const SyncReconcileRequestLifecycle66$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle66
> = z.enum(SyncReconcileRequestLifecycle66);

/** @internal */
export type SyncReconcileRequestStatus66$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue66$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus66$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus66$Outbound,
  SyncReconcileRequestStatus66
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue66$outboundSchema),
  ),
  health: SyncReconcileRequestHealth66$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle66$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus66ToJSON(
  syncReconcileRequestStatus66: SyncReconcileRequestStatus66,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus66$outboundSchema.parse(
      syncReconcileRequestStatus66,
    ),
  );
}

/** @internal */
export type DataAwsBedrock$Outbound = {
  availability: SyncReconcileRequestAvailability1$Outbound;
  region: string;
  status: SyncReconcileRequestStatus66$Outbound;
  backend: "awsBedrock";
};

/** @internal */
export const DataAwsBedrock$outboundSchema: z.ZodType<
  DataAwsBedrock$Outbound,
  DataAwsBedrock
> = z.object({
  availability: z.lazy(() => SyncReconcileRequestAvailability1$outboundSchema),
  region: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus66$outboundSchema),
  backend: z.literal("awsBedrock"),
});

export function dataAwsBedrockToJSON(dataAwsBedrock: DataAwsBedrock): string {
  return JSON.stringify(DataAwsBedrock$outboundSchema.parse(dataAwsBedrock));
}

/** @internal */
export type SyncReconcileRequestDataUnion16$Outbound =
  | DataAwsBedrock$Outbound
  | DataGcpVertex$Outbound
  | DataAzureFoundry$Outbound
  | DataExternal$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion16$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion16$Outbound,
  SyncReconcileRequestDataUnion16
> = z.union([
  z.lazy(() => DataAwsBedrock$outboundSchema),
  z.lazy(() => DataGcpVertex$outboundSchema),
  z.lazy(() => DataAzureFoundry$outboundSchema),
  z.lazy(() => DataExternal$outboundSchema),
]);

export function syncReconcileRequestDataUnion16ToJSON(
  syncReconcileRequestDataUnion16: SyncReconcileRequestDataUnion16,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion16$outboundSchema.parse(
      syncReconcileRequestDataUnion16,
    ),
  );
}

/** @internal */
export type DataAi$Outbound = {
  data:
    | DataAwsBedrock$Outbound
    | DataGcpVertex$Outbound
    | DataAzureFoundry$Outbound
    | DataExternal$Outbound;
  resourceType: "ai";
};

/** @internal */
export const DataAi$outboundSchema: z.ZodType<DataAi$Outbound, DataAi> = z
  .object({
    data: z.union([
      z.lazy(() => DataAwsBedrock$outboundSchema),
      z.lazy(() => DataGcpVertex$outboundSchema),
      z.lazy(() => DataAzureFoundry$outboundSchema),
      z.lazy(() => DataExternal$outboundSchema),
    ]),
    resourceType: z.literal("ai"),
  });

export function dataAiToJSON(dataAi: DataAi): string {
  return JSON.stringify(DataAi$outboundSchema.parse(dataAi));
}

/** @internal */
export const SyncReconcileRequestReason65$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason65
> = z.enum(SyncReconcileRequestReason65);

/** @internal */
export const StatusSeverity65$outboundSchema: z.ZodEnum<
  typeof StatusSeverity65
> = z.enum(StatusSeverity65);

/** @internal */
export type SyncReconcileRequestCollectionIssue65$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue65$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue65$Outbound,
  SyncReconcileRequestCollectionIssue65
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason65$outboundSchema,
  severity: StatusSeverity65$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue65ToJSON(
  syncReconcileRequestCollectionIssue65: SyncReconcileRequestCollectionIssue65,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue65$outboundSchema.parse(
      syncReconcileRequestCollectionIssue65,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth65$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth65
> = z.enum(SyncReconcileRequestHealth65);

/** @internal */
export const SyncReconcileRequestLifecycle65$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle65
> = z.enum(SyncReconcileRequestLifecycle65);

/** @internal */
export type SyncReconcileRequestStatus65$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue65$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus65$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus65$Outbound,
  SyncReconcileRequestStatus65
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue65$outboundSchema),
  ),
  health: SyncReconcileRequestHealth65$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle65$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus65ToJSON(
  syncReconcileRequestStatus65: SyncReconcileRequestStatus65,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus65$outboundSchema.parse(
      syncReconcileRequestStatus65,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestData5$Outbound = {
  createdAt?: string | null | undefined;
  disableLocalAuth?: boolean | null | undefined;
  location?: string | null | undefined;
  metricId?: string | null | undefined;
  minimumTlsVersion?: string | null | undefined;
  name: string;
  namespaceStatus?: string | null | undefined;
  premiumMessagingPartitions?: number | null | undefined;
  privateEndpointConnectionCount: number;
  provisioningState?: string | null | undefined;
  publicNetworkAccess?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  serviceBusEndpoint?: string | null | undefined;
  skuCapacity?: number | null | undefined;
  skuName?: string | null | undefined;
  skuTier?: string | null | undefined;
  status: SyncReconcileRequestStatus65$Outbound;
  updatedAt?: string | null | undefined;
  zoneRedundant?: boolean | null | undefined;
};

/** @internal */
export const SyncReconcileRequestData5$outboundSchema: z.ZodType<
  SyncReconcileRequestData5$Outbound,
  SyncReconcileRequestData5
> = z.object({
  createdAt: z.nullable(z.string()).optional(),
  disableLocalAuth: z.nullable(z.boolean()).optional(),
  location: z.nullable(z.string()).optional(),
  metricId: z.nullable(z.string()).optional(),
  minimumTlsVersion: z.nullable(z.string()).optional(),
  name: z.string(),
  namespaceStatus: z.nullable(z.string()).optional(),
  premiumMessagingPartitions: z.nullable(z.int()).optional(),
  privateEndpointConnectionCount: z.int(),
  provisioningState: z.nullable(z.string()).optional(),
  publicNetworkAccess: z.nullable(z.string()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  resourceId: z.nullable(z.string()).optional(),
  serviceBusEndpoint: z.nullable(z.string()).optional(),
  skuCapacity: z.nullable(z.int()).optional(),
  skuName: z.nullable(z.string()).optional(),
  skuTier: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus65$outboundSchema),
  updatedAt: z.nullable(z.string()).optional(),
  zoneRedundant: z.nullable(z.boolean()).optional(),
});

export function syncReconcileRequestData5ToJSON(
  syncReconcileRequestData5: SyncReconcileRequestData5,
): string {
  return JSON.stringify(
    SyncReconcileRequestData5$outboundSchema.parse(syncReconcileRequestData5),
  );
}

/** @internal */
export type DataAzureServiceBusNamespace$Outbound = {
  data: SyncReconcileRequestData5$Outbound;
  resourceType: "azure_service_bus_namespace";
};

/** @internal */
export const DataAzureServiceBusNamespace$outboundSchema: z.ZodType<
  DataAzureServiceBusNamespace$Outbound,
  DataAzureServiceBusNamespace
> = z.object({
  data: z.lazy(() => SyncReconcileRequestData5$outboundSchema),
  resourceType: z.literal("azure_service_bus_namespace"),
});

export function dataAzureServiceBusNamespaceToJSON(
  dataAzureServiceBusNamespace: DataAzureServiceBusNamespace,
): string {
  return JSON.stringify(
    DataAzureServiceBusNamespace$outboundSchema.parse(
      dataAzureServiceBusNamespace,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestReason64$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason64
> = z.enum(SyncReconcileRequestReason64);

/** @internal */
export const StatusSeverity64$outboundSchema: z.ZodEnum<
  typeof StatusSeverity64
> = z.enum(StatusSeverity64);

/** @internal */
export type SyncReconcileRequestCollectionIssue64$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue64$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue64$Outbound,
  SyncReconcileRequestCollectionIssue64
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason64$outboundSchema,
  severity: StatusSeverity64$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue64ToJSON(
  syncReconcileRequestCollectionIssue64: SyncReconcileRequestCollectionIssue64,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue64$outboundSchema.parse(
      syncReconcileRequestCollectionIssue64,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth64$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth64
> = z.enum(SyncReconcileRequestHealth64);

/** @internal */
export const SyncReconcileRequestLifecycle64$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle64
> = z.enum(SyncReconcileRequestLifecycle64);

/** @internal */
export type SyncReconcileRequestStatus64$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue64$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus64$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus64$Outbound,
  SyncReconcileRequestStatus64
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue64$outboundSchema),
  ),
  health: SyncReconcileRequestHealth64$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle64$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus64ToJSON(
  syncReconcileRequestStatus64: SyncReconcileRequestStatus64,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus64$outboundSchema.parse(
      syncReconcileRequestStatus64,
    ),
  );
}

/** @internal */
export type WorkloadProfile$Outbound = {
  maximumCount?: number | null | undefined;
  minimumCount?: number | null | undefined;
  name: string;
  workloadProfileType: string;
};

/** @internal */
export const WorkloadProfile$outboundSchema: z.ZodType<
  WorkloadProfile$Outbound,
  WorkloadProfile
> = z.object({
  maximumCount: z.nullable(z.int()).optional(),
  minimumCount: z.nullable(z.int()).optional(),
  name: z.string(),
  workloadProfileType: z.string(),
});

export function workloadProfileToJSON(
  workloadProfile: WorkloadProfile,
): string {
  return JSON.stringify(WorkloadProfile$outboundSchema.parse(workloadProfile));
}

/** @internal */
export type SyncReconcileRequestData4$Outbound = {
  customDomainVerificationId?: string | null | undefined;
  defaultDomain?: string | null | undefined;
  eventStreamEndpoint?: string | null | undefined;
  infrastructureResourceGroup?: string | null | undefined;
  kind?: string | null | undefined;
  location?: string | null | undefined;
  name: string;
  provisioningState?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  staticIp?: string | null | undefined;
  status: SyncReconcileRequestStatus64$Outbound;
  workloadProfileCount: number;
  workloadProfiles: Array<WorkloadProfile$Outbound>;
  zoneRedundant?: boolean | null | undefined;
};

/** @internal */
export const SyncReconcileRequestData4$outboundSchema: z.ZodType<
  SyncReconcileRequestData4$Outbound,
  SyncReconcileRequestData4
> = z.object({
  customDomainVerificationId: z.nullable(z.string()).optional(),
  defaultDomain: z.nullable(z.string()).optional(),
  eventStreamEndpoint: z.nullable(z.string()).optional(),
  infrastructureResourceGroup: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  location: z.nullable(z.string()).optional(),
  name: z.string(),
  provisioningState: z.nullable(z.string()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  resourceId: z.nullable(z.string()).optional(),
  staticIp: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus64$outboundSchema),
  workloadProfileCount: z.int(),
  workloadProfiles: z.array(z.lazy(() => WorkloadProfile$outboundSchema)),
  zoneRedundant: z.nullable(z.boolean()).optional(),
});

export function syncReconcileRequestData4ToJSON(
  syncReconcileRequestData4: SyncReconcileRequestData4,
): string {
  return JSON.stringify(
    SyncReconcileRequestData4$outboundSchema.parse(syncReconcileRequestData4),
  );
}

/** @internal */
export type DataAzureContainerAppsEnvironment$Outbound = {
  data: SyncReconcileRequestData4$Outbound;
  resourceType: "azure_container_apps_environment";
};

/** @internal */
export const DataAzureContainerAppsEnvironment$outboundSchema: z.ZodType<
  DataAzureContainerAppsEnvironment$Outbound,
  DataAzureContainerAppsEnvironment
> = z.object({
  data: z.lazy(() => SyncReconcileRequestData4$outboundSchema),
  resourceType: z.literal("azure_container_apps_environment"),
});

export function dataAzureContainerAppsEnvironmentToJSON(
  dataAzureContainerAppsEnvironment: DataAzureContainerAppsEnvironment,
): string {
  return JSON.stringify(
    DataAzureContainerAppsEnvironment$outboundSchema.parse(
      dataAzureContainerAppsEnvironment,
    ),
  );
}

/** @internal */
export type PrimaryEndpoints$Outbound = {
  blob?: string | null | undefined;
  dfs?: string | null | undefined;
  file?: string | null | undefined;
  queue?: string | null | undefined;
  table?: string | null | undefined;
  web?: string | null | undefined;
};

/** @internal */
export const PrimaryEndpoints$outboundSchema: z.ZodType<
  PrimaryEndpoints$Outbound,
  PrimaryEndpoints
> = z.object({
  blob: z.nullable(z.string()).optional(),
  dfs: z.nullable(z.string()).optional(),
  file: z.nullable(z.string()).optional(),
  queue: z.nullable(z.string()).optional(),
  table: z.nullable(z.string()).optional(),
  web: z.nullable(z.string()).optional(),
});

export function primaryEndpointsToJSON(
  primaryEndpoints: PrimaryEndpoints,
): string {
  return JSON.stringify(
    PrimaryEndpoints$outboundSchema.parse(primaryEndpoints),
  );
}

/** @internal */
export type SecondaryEndpoints$Outbound = {
  blob?: string | null | undefined;
  dfs?: string | null | undefined;
  file?: string | null | undefined;
  queue?: string | null | undefined;
  table?: string | null | undefined;
  web?: string | null | undefined;
};

/** @internal */
export const SecondaryEndpoints$outboundSchema: z.ZodType<
  SecondaryEndpoints$Outbound,
  SecondaryEndpoints
> = z.object({
  blob: z.nullable(z.string()).optional(),
  dfs: z.nullable(z.string()).optional(),
  file: z.nullable(z.string()).optional(),
  queue: z.nullable(z.string()).optional(),
  table: z.nullable(z.string()).optional(),
  web: z.nullable(z.string()).optional(),
});

export function secondaryEndpointsToJSON(
  secondaryEndpoints: SecondaryEndpoints,
): string {
  return JSON.stringify(
    SecondaryEndpoints$outboundSchema.parse(secondaryEndpoints),
  );
}

/** @internal */
export const SyncReconcileRequestReason63$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason63
> = z.enum(SyncReconcileRequestReason63);

/** @internal */
export const StatusSeverity63$outboundSchema: z.ZodEnum<
  typeof StatusSeverity63
> = z.enum(StatusSeverity63);

/** @internal */
export type SyncReconcileRequestCollectionIssue63$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue63$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue63$Outbound,
  SyncReconcileRequestCollectionIssue63
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason63$outboundSchema,
  severity: StatusSeverity63$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue63ToJSON(
  syncReconcileRequestCollectionIssue63: SyncReconcileRequestCollectionIssue63,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue63$outboundSchema.parse(
      syncReconcileRequestCollectionIssue63,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth63$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth63
> = z.enum(SyncReconcileRequestHealth63);

/** @internal */
export const SyncReconcileRequestLifecycle63$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle63
> = z.enum(SyncReconcileRequestLifecycle63);

/** @internal */
export type SyncReconcileRequestStatus63$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue63$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus63$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus63$Outbound,
  SyncReconcileRequestStatus63
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue63$outboundSchema),
  ),
  health: SyncReconcileRequestHealth63$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle63$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus63ToJSON(
  syncReconcileRequestStatus63: SyncReconcileRequestStatus63,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus63$outboundSchema.parse(
      syncReconcileRequestStatus63,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestData3$Outbound = {
  allowBlobPublicAccess?: boolean | null | undefined;
  allowSharedKeyAccess?: boolean | null | undefined;
  encryptionKeySource?: string | null | undefined;
  kind?: string | null | undefined;
  location?: string | null | undefined;
  minimumTlsVersion?: string | null | undefined;
  name: string;
  networkBypass?: string | null | undefined;
  networkDefaultAction?: string | null | undefined;
  networkIpRuleCount?: number | null | undefined;
  networkResourceAccessRuleCount?: number | null | undefined;
  networkVirtualNetworkRuleCount?: number | null | undefined;
  primaryEndpoints: PrimaryEndpoints$Outbound;
  provisioningState?: string | null | undefined;
  publicNetworkAccess?: string | null | undefined;
  requireInfrastructureEncryption?: boolean | null | undefined;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  secondaryEndpoints: SecondaryEndpoints$Outbound;
  skuName?: string | null | undefined;
  skuTier?: string | null | undefined;
  status: SyncReconcileRequestStatus63$Outbound;
  supportsHttpsTrafficOnly?: boolean | null | undefined;
};

/** @internal */
export const SyncReconcileRequestData3$outboundSchema: z.ZodType<
  SyncReconcileRequestData3$Outbound,
  SyncReconcileRequestData3
> = z.object({
  allowBlobPublicAccess: z.nullable(z.boolean()).optional(),
  allowSharedKeyAccess: z.nullable(z.boolean()).optional(),
  encryptionKeySource: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  location: z.nullable(z.string()).optional(),
  minimumTlsVersion: z.nullable(z.string()).optional(),
  name: z.string(),
  networkBypass: z.nullable(z.string()).optional(),
  networkDefaultAction: z.nullable(z.string()).optional(),
  networkIpRuleCount: z.nullable(z.int()).optional(),
  networkResourceAccessRuleCount: z.nullable(z.int()).optional(),
  networkVirtualNetworkRuleCount: z.nullable(z.int()).optional(),
  primaryEndpoints: z.lazy(() => PrimaryEndpoints$outboundSchema),
  provisioningState: z.nullable(z.string()).optional(),
  publicNetworkAccess: z.nullable(z.string()).optional(),
  requireInfrastructureEncryption: z.nullable(z.boolean()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  resourceId: z.nullable(z.string()).optional(),
  secondaryEndpoints: z.lazy(() => SecondaryEndpoints$outboundSchema),
  skuName: z.nullable(z.string()).optional(),
  skuTier: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus63$outboundSchema),
  supportsHttpsTrafficOnly: z.nullable(z.boolean()).optional(),
});

export function syncReconcileRequestData3ToJSON(
  syncReconcileRequestData3: SyncReconcileRequestData3,
): string {
  return JSON.stringify(
    SyncReconcileRequestData3$outboundSchema.parse(syncReconcileRequestData3),
  );
}

/** @internal */
export type DataAzureStorageAccount$Outbound = {
  data: SyncReconcileRequestData3$Outbound;
  resourceType: "azure_storage_account";
};

/** @internal */
export const DataAzureStorageAccount$outboundSchema: z.ZodType<
  DataAzureStorageAccount$Outbound,
  DataAzureStorageAccount
> = z.object({
  data: z.lazy(() => SyncReconcileRequestData3$outboundSchema),
  resourceType: z.literal("azure_storage_account"),
});

export function dataAzureStorageAccountToJSON(
  dataAzureStorageAccount: DataAzureStorageAccount,
): string {
  return JSON.stringify(
    DataAzureStorageAccount$outboundSchema.parse(dataAzureStorageAccount),
  );
}

/** @internal */
export const SyncReconcileRequestReason62$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason62
> = z.enum(SyncReconcileRequestReason62);

/** @internal */
export const StatusSeverity62$outboundSchema: z.ZodEnum<
  typeof StatusSeverity62
> = z.enum(StatusSeverity62);

/** @internal */
export type SyncReconcileRequestCollectionIssue62$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue62$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue62$Outbound,
  SyncReconcileRequestCollectionIssue62
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason62$outboundSchema,
  severity: StatusSeverity62$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue62ToJSON(
  syncReconcileRequestCollectionIssue62: SyncReconcileRequestCollectionIssue62,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue62$outboundSchema.parse(
      syncReconcileRequestCollectionIssue62,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth62$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth62
> = z.enum(SyncReconcileRequestHealth62);

/** @internal */
export const SyncReconcileRequestLifecycle62$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle62
> = z.enum(SyncReconcileRequestLifecycle62);

/** @internal */
export type SyncReconcileRequestStatus62$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue62$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus62$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus62$Outbound,
  SyncReconcileRequestStatus62
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue62$outboundSchema),
  ),
  health: SyncReconcileRequestHealth62$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle62$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus62ToJSON(
  syncReconcileRequestStatus62: SyncReconcileRequestStatus62,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus62$outboundSchema.parse(
      syncReconcileRequestStatus62,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestData2$Outbound = {
  location?: string | null | undefined;
  managedTags: { [k: string]: string };
  name: string;
  provisioningState?: string | null | undefined;
  resourceId?: string | null | undefined;
  status: SyncReconcileRequestStatus62$Outbound;
};

/** @internal */
export const SyncReconcileRequestData2$outboundSchema: z.ZodType<
  SyncReconcileRequestData2$Outbound,
  SyncReconcileRequestData2
> = z.object({
  location: z.nullable(z.string()).optional(),
  managedTags: z.record(z.string(), z.string()),
  name: z.string(),
  provisioningState: z.nullable(z.string()).optional(),
  resourceId: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus62$outboundSchema),
});

export function syncReconcileRequestData2ToJSON(
  syncReconcileRequestData2: SyncReconcileRequestData2,
): string {
  return JSON.stringify(
    SyncReconcileRequestData2$outboundSchema.parse(syncReconcileRequestData2),
  );
}

/** @internal */
export type DataAzureResourceGroup$Outbound = {
  data: SyncReconcileRequestData2$Outbound;
  resourceType: "azure_resource_group";
};

/** @internal */
export const DataAzureResourceGroup$outboundSchema: z.ZodType<
  DataAzureResourceGroup$Outbound,
  DataAzureResourceGroup
> = z.object({
  data: z.lazy(() => SyncReconcileRequestData2$outboundSchema),
  resourceType: z.literal("azure_resource_group"),
});

export function dataAzureResourceGroupToJSON(
  dataAzureResourceGroup: DataAzureResourceGroup,
): string {
  return JSON.stringify(
    DataAzureResourceGroup$outboundSchema.parse(dataAzureResourceGroup),
  );
}

/** @internal */
export const SyncReconcileRequestReason61$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason61
> = z.enum(SyncReconcileRequestReason61);

/** @internal */
export const StatusSeverity61$outboundSchema: z.ZodEnum<
  typeof StatusSeverity61
> = z.enum(StatusSeverity61);

/** @internal */
export type SyncReconcileRequestCollectionIssue61$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue61$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue61$Outbound,
  SyncReconcileRequestCollectionIssue61
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason61$outboundSchema,
  severity: StatusSeverity61$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue61ToJSON(
  syncReconcileRequestCollectionIssue61: SyncReconcileRequestCollectionIssue61,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue61$outboundSchema.parse(
      syncReconcileRequestCollectionIssue61,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth61$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth61
> = z.enum(SyncReconcileRequestHealth61);

/** @internal */
export const SyncReconcileRequestLifecycle61$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle61
> = z.enum(SyncReconcileRequestLifecycle61);

/** @internal */
export type SyncReconcileRequestStatus61$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue61$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus61$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus61$Outbound,
  SyncReconcileRequestStatus61
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue61$outboundSchema),
  ),
  health: SyncReconcileRequestHealth61$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle61$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus61ToJSON(
  syncReconcileRequestStatus61: SyncReconcileRequestStatus61,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus61$outboundSchema.parse(
      syncReconcileRequestStatus61,
    ),
  );
}

/** @internal */
export type DataAzureResourceProvider$Outbound = {
  namespace: string;
  providerId?: string | null | undefined;
  registered: boolean;
  registrationPolicy?: string | null | undefined;
  registrationState?: string | null | undefined;
  resourceTypeCount: number;
  status: SyncReconcileRequestStatus61$Outbound;
  backend: "azureResourceProvider";
};

/** @internal */
export const DataAzureResourceProvider$outboundSchema: z.ZodType<
  DataAzureResourceProvider$Outbound,
  DataAzureResourceProvider
> = z.object({
  namespace: z.string(),
  providerId: z.nullable(z.string()).optional(),
  registered: z.boolean(),
  registrationPolicy: z.nullable(z.string()).optional(),
  registrationState: z.nullable(z.string()).optional(),
  resourceTypeCount: z.int(),
  status: z.lazy(() => SyncReconcileRequestStatus61$outboundSchema),
  backend: z.literal("azureResourceProvider"),
});

export function dataAzureResourceProviderToJSON(
  dataAzureResourceProvider: DataAzureResourceProvider,
): string {
  return JSON.stringify(
    DataAzureResourceProvider$outboundSchema.parse(dataAzureResourceProvider),
  );
}

/** @internal */
export const SyncReconcileRequestReason60$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason60
> = z.enum(SyncReconcileRequestReason60);

/** @internal */
export const StatusSeverity60$outboundSchema: z.ZodEnum<
  typeof StatusSeverity60
> = z.enum(StatusSeverity60);

/** @internal */
export type SyncReconcileRequestCollectionIssue60$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue60$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue60$Outbound,
  SyncReconcileRequestCollectionIssue60
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason60$outboundSchema,
  severity: StatusSeverity60$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue60ToJSON(
  syncReconcileRequestCollectionIssue60: SyncReconcileRequestCollectionIssue60,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue60$outboundSchema.parse(
      syncReconcileRequestCollectionIssue60,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth60$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth60
> = z.enum(SyncReconcileRequestHealth60);

/** @internal */
export const SyncReconcileRequestLifecycle60$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle60
> = z.enum(SyncReconcileRequestLifecycle60);

/** @internal */
export type SyncReconcileRequestStatus60$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue60$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus60$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus60$Outbound,
  SyncReconcileRequestStatus60
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue60$outboundSchema),
  ),
  health: SyncReconcileRequestHealth60$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle60$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus60ToJSON(
  syncReconcileRequestStatus60: SyncReconcileRequestStatus60,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus60$outboundSchema.parse(
      syncReconcileRequestStatus60,
    ),
  );
}

/** @internal */
export type DataGcpServiceUsage$Outbound = {
  enabled: boolean;
  lastOperationName?: string | null | undefined;
  projectId: string;
  serviceName: string;
  serviceResourceName?: string | null | undefined;
  state?: string | null | undefined;
  status: SyncReconcileRequestStatus60$Outbound;
  title?: string | null | undefined;
  backend: "gcpServiceUsage";
};

/** @internal */
export const DataGcpServiceUsage$outboundSchema: z.ZodType<
  DataGcpServiceUsage$Outbound,
  DataGcpServiceUsage
> = z.object({
  enabled: z.boolean(),
  lastOperationName: z.nullable(z.string()).optional(),
  projectId: z.string(),
  serviceName: z.string(),
  serviceResourceName: z.nullable(z.string()).optional(),
  state: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus60$outboundSchema),
  title: z.nullable(z.string()).optional(),
  backend: z.literal("gcpServiceUsage"),
});

export function dataGcpServiceUsageToJSON(
  dataGcpServiceUsage: DataGcpServiceUsage,
): string {
  return JSON.stringify(
    DataGcpServiceUsage$outboundSchema.parse(dataGcpServiceUsage),
  );
}

/** @internal */
export type SyncReconcileRequestDataUnion15$Outbound =
  | DataGcpServiceUsage$Outbound
  | DataAzureResourceProvider$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion15$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion15$Outbound,
  SyncReconcileRequestDataUnion15
> = z.union([
  z.lazy(() => DataGcpServiceUsage$outboundSchema),
  z.lazy(() => DataAzureResourceProvider$outboundSchema),
]);

export function syncReconcileRequestDataUnion15ToJSON(
  syncReconcileRequestDataUnion15: SyncReconcileRequestDataUnion15,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion15$outboundSchema.parse(
      syncReconcileRequestDataUnion15,
    ),
  );
}

/** @internal */
export type DataServiceActivation$Outbound = {
  data: DataGcpServiceUsage$Outbound | DataAzureResourceProvider$Outbound;
  resourceType: "service_activation";
};

/** @internal */
export const DataServiceActivation$outboundSchema: z.ZodType<
  DataServiceActivation$Outbound,
  DataServiceActivation
> = z.object({
  data: z.union([
    z.lazy(() => DataGcpServiceUsage$outboundSchema),
    z.lazy(() => DataAzureResourceProvider$outboundSchema),
  ]),
  resourceType: z.literal("service_activation"),
});

export function dataServiceActivationToJSON(
  dataServiceActivation: DataServiceActivation,
): string {
  return JSON.stringify(
    DataServiceActivation$outboundSchema.parse(dataServiceActivation),
  );
}

/** @internal */
export type InvolvedObject10$Outbound = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

/** @internal */
export const InvolvedObject10$outboundSchema: z.ZodType<
  InvolvedObject10$Outbound,
  InvolvedObject10
> = z.object({
  apiVersion: z.nullable(z.string()).optional(),
  fieldPath: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  namespace: z.nullable(z.string()).optional(),
  resourceVersion: z.nullable(z.string()).optional(),
  uid: z.nullable(z.string()).optional(),
});

export function involvedObject10ToJSON(
  involvedObject10: InvolvedObject10,
): string {
  return JSON.stringify(
    InvolvedObject10$outboundSchema.parse(involvedObject10),
  );
}

/** @internal */
export type InvolvedObjectUnion10$Outbound = InvolvedObject10$Outbound | any;

/** @internal */
export const InvolvedObjectUnion10$outboundSchema: z.ZodType<
  InvolvedObjectUnion10$Outbound,
  InvolvedObjectUnion10
> = z.union([z.lazy(() => InvolvedObject10$outboundSchema), z.any()]);

export function involvedObjectUnion10ToJSON(
  involvedObjectUnion10: InvolvedObjectUnion10,
): string {
  return JSON.stringify(
    InvolvedObjectUnion10$outboundSchema.parse(involvedObjectUnion10),
  );
}

/** @internal */
export type SourceEvent10$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent10$outboundSchema: z.ZodType<
  SourceEvent10$Outbound,
  SourceEvent10
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent10ToJSON(sourceEvent10: SourceEvent10): string {
  return JSON.stringify(SourceEvent10$outboundSchema.parse(sourceEvent10));
}

/** @internal */
export type EventSourceUnion10$Outbound = SourceEvent10$Outbound | any;

/** @internal */
export const EventSourceUnion10$outboundSchema: z.ZodType<
  EventSourceUnion10$Outbound,
  EventSourceUnion10
> = z.union([z.lazy(() => SourceEvent10$outboundSchema), z.any()]);

export function eventSourceUnion10ToJSON(
  eventSourceUnion10: EventSourceUnion10,
): string {
  return JSON.stringify(
    EventSourceUnion10$outboundSchema.parse(eventSourceUnion10),
  );
}

/** @internal */
export type SyncReconcileRequestEvent13$Outbound = {
  count?: number | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject10$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent10$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent13$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent13$Outbound,
  SyncReconcileRequestEvent13
> = z.object({
  count: z.nullable(z.int()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject10$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent10$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent13ToJSON(
  syncReconcileRequestEvent13: SyncReconcileRequestEvent13,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent13$outboundSchema.parse(
      syncReconcileRequestEvent13,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestReason59$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason59
> = z.enum(SyncReconcileRequestReason59);

/** @internal */
export const StatusSeverity59$outboundSchema: z.ZodEnum<
  typeof StatusSeverity59
> = z.enum(StatusSeverity59);

/** @internal */
export type SyncReconcileRequestCollectionIssue59$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue59$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue59$Outbound,
  SyncReconcileRequestCollectionIssue59
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason59$outboundSchema,
  severity: StatusSeverity59$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue59ToJSON(
  syncReconcileRequestCollectionIssue59: SyncReconcileRequestCollectionIssue59,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue59$outboundSchema.parse(
      syncReconcileRequestCollectionIssue59,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth59$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth59
> = z.enum(SyncReconcileRequestHealth59);

/** @internal */
export const SyncReconcileRequestLifecycle59$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle59
> = z.enum(SyncReconcileRequestLifecycle59);

/** @internal */
export type SyncReconcileRequestStatus59$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue59$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus59$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus59$Outbound,
  SyncReconcileRequestStatus59
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue59$outboundSchema),
  ),
  health: SyncReconcileRequestHealth59$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle59$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus59ToJSON(
  syncReconcileRequestStatus59: SyncReconcileRequestStatus59,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus59$outboundSchema.parse(
      syncReconcileRequestStatus59,
    ),
  );
}

/** @internal */
export type DataKubernetesJob$Outbound = {
  active?: number | null | undefined;
  completionTime?: string | null | undefined;
  conditionCount: number;
  events: Array<SyncReconcileRequestEvent13$Outbound>;
  failed?: number | null | undefined;
  imageDigest?: string | null | undefined;
  jobName: string;
  namespace: string;
  startTime?: string | null | undefined;
  status: SyncReconcileRequestStatus59$Outbound;
  succeeded?: number | null | undefined;
  backend: "kubernetesJob";
};

/** @internal */
export const DataKubernetesJob$outboundSchema: z.ZodType<
  DataKubernetesJob$Outbound,
  DataKubernetesJob
> = z.object({
  active: z.nullable(z.int()).optional(),
  completionTime: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  conditionCount: z.int(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent13$outboundSchema)),
  failed: z.nullable(z.int()).optional(),
  imageDigest: z.nullable(z.string()).optional(),
  jobName: z.string(),
  namespace: z.string(),
  startTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus59$outboundSchema),
  succeeded: z.nullable(z.int()).optional(),
  backend: z.literal("kubernetesJob"),
});

export function dataKubernetesJobToJSON(
  dataKubernetesJob: DataKubernetesJob,
): string {
  return JSON.stringify(
    DataKubernetesJob$outboundSchema.parse(dataKubernetesJob),
  );
}

/** @internal */
export const SyncReconcileRequestReason58$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason58
> = z.enum(SyncReconcileRequestReason58);

/** @internal */
export const StatusSeverity58$outboundSchema: z.ZodEnum<
  typeof StatusSeverity58
> = z.enum(StatusSeverity58);

/** @internal */
export type SyncReconcileRequestCollectionIssue58$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue58$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue58$Outbound,
  SyncReconcileRequestCollectionIssue58
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason58$outboundSchema,
  severity: StatusSeverity58$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue58ToJSON(
  syncReconcileRequestCollectionIssue58: SyncReconcileRequestCollectionIssue58,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue58$outboundSchema.parse(
      syncReconcileRequestCollectionIssue58,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth58$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth58
> = z.enum(SyncReconcileRequestHealth58);

/** @internal */
export const SyncReconcileRequestLifecycle58$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle58
> = z.enum(SyncReconcileRequestLifecycle58);

/** @internal */
export type SyncReconcileRequestStatus58$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue58$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus58$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus58$Outbound,
  SyncReconcileRequestStatus58
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue58$outboundSchema),
  ),
  health: SyncReconcileRequestHealth58$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle58$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus58ToJSON(
  syncReconcileRequestStatus58: SyncReconcileRequestStatus58,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus58$outboundSchema.parse(
      syncReconcileRequestStatus58,
    ),
  );
}

/** @internal */
export type DataAzureContainerApps2$Outbound = {
  environmentVariableCount: number;
  managedEnvironmentId: string;
  managedIdentityId?: string | null | undefined;
  resourceGroupName: string;
  resourcePrefix?: string | null | undefined;
  status: SyncReconcileRequestStatus58$Outbound;
  backend: "azureContainerApps";
};

/** @internal */
export const DataAzureContainerApps2$outboundSchema: z.ZodType<
  DataAzureContainerApps2$Outbound,
  DataAzureContainerApps2
> = z.object({
  environmentVariableCount: z.int(),
  managedEnvironmentId: z.string(),
  managedIdentityId: z.nullable(z.string()).optional(),
  resourceGroupName: z.string(),
  resourcePrefix: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus58$outboundSchema),
  backend: z.literal("azureContainerApps"),
});

export function dataAzureContainerApps2ToJSON(
  dataAzureContainerApps2: DataAzureContainerApps2,
): string {
  return JSON.stringify(
    DataAzureContainerApps2$outboundSchema.parse(dataAzureContainerApps2),
  );
}

/** @internal */
export const SyncReconcileRequestReason57$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason57
> = z.enum(SyncReconcileRequestReason57);

/** @internal */
export const StatusSeverity57$outboundSchema: z.ZodEnum<
  typeof StatusSeverity57
> = z.enum(StatusSeverity57);

/** @internal */
export type SyncReconcileRequestCollectionIssue57$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue57$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue57$Outbound,
  SyncReconcileRequestCollectionIssue57
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason57$outboundSchema,
  severity: StatusSeverity57$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue57ToJSON(
  syncReconcileRequestCollectionIssue57: SyncReconcileRequestCollectionIssue57,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue57$outboundSchema.parse(
      syncReconcileRequestCollectionIssue57,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth57$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth57
> = z.enum(SyncReconcileRequestHealth57);

/** @internal */
export const SyncReconcileRequestLifecycle57$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle57
> = z.enum(SyncReconcileRequestLifecycle57);

/** @internal */
export type SyncReconcileRequestStatus57$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue57$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus57$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus57$Outbound,
  SyncReconcileRequestStatus57
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue57$outboundSchema),
  ),
  health: SyncReconcileRequestHealth57$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle57$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus57ToJSON(
  syncReconcileRequestStatus57: SyncReconcileRequestStatus57,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus57$outboundSchema.parse(
      syncReconcileRequestStatus57,
    ),
  );
}

/** @internal */
export type DataGcpCloudBuild$Outbound = {
  buildConfigId: string;
  environmentVariableCount: number;
  location: string;
  projectId: string;
  serviceAccount?: string | null | undefined;
  status: SyncReconcileRequestStatus57$Outbound;
  backend: "gcpCloudBuild";
};

/** @internal */
export const DataGcpCloudBuild$outboundSchema: z.ZodType<
  DataGcpCloudBuild$Outbound,
  DataGcpCloudBuild
> = z.object({
  buildConfigId: z.string(),
  environmentVariableCount: z.int(),
  location: z.string(),
  projectId: z.string(),
  serviceAccount: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus57$outboundSchema),
  backend: z.literal("gcpCloudBuild"),
});

export function dataGcpCloudBuildToJSON(
  dataGcpCloudBuild: DataGcpCloudBuild,
): string {
  return JSON.stringify(
    DataGcpCloudBuild$outboundSchema.parse(dataGcpCloudBuild),
  );
}

/** @internal */
export const SyncReconcileRequestReason56$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason56
> = z.enum(SyncReconcileRequestReason56);

/** @internal */
export const StatusSeverity56$outboundSchema: z.ZodEnum<
  typeof StatusSeverity56
> = z.enum(StatusSeverity56);

/** @internal */
export type SyncReconcileRequestCollectionIssue56$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue56$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue56$Outbound,
  SyncReconcileRequestCollectionIssue56
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason56$outboundSchema,
  severity: StatusSeverity56$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue56ToJSON(
  syncReconcileRequestCollectionIssue56: SyncReconcileRequestCollectionIssue56,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue56$outboundSchema.parse(
      syncReconcileRequestCollectionIssue56,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth56$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth56
> = z.enum(SyncReconcileRequestHealth56);

/** @internal */
export const SyncReconcileRequestLifecycle56$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle56
> = z.enum(SyncReconcileRequestLifecycle56);

/** @internal */
export type SyncReconcileRequestStatus56$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue56$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus56$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus56$Outbound,
  SyncReconcileRequestStatus56
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue56$outboundSchema),
  ),
  health: SyncReconcileRequestHealth56$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle56$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus56ToJSON(
  syncReconcileRequestStatus56: SyncReconcileRequestStatus56,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus56$outboundSchema.parse(
      syncReconcileRequestStatus56,
    ),
  );
}

/** @internal */
export type DataAwsCodeBuild$Outbound = {
  artifactsEncryptionDisabled?: boolean | null | undefined;
  artifactsType?: string | null | undefined;
  cloudWatchLogsStatus?: string | null | undefined;
  computeType?: string | null | undefined;
  created?: number | null | undefined;
  description?: string | null | undefined;
  encryptionKeyPresent: boolean;
  environmentImage?: string | null | undefined;
  environmentType?: string | null | undefined;
  environmentVariableCount: number;
  imagePullCredentialsType?: string | null | undefined;
  lastModified?: number | null | undefined;
  privilegedMode?: boolean | null | undefined;
  projectArn?: string | null | undefined;
  projectName: string;
  queuedTimeoutInMinutes?: number | null | undefined;
  s3LogsStatus?: string | null | undefined;
  serviceRolePresent: boolean;
  sourceType?: string | null | undefined;
  status: SyncReconcileRequestStatus56$Outbound;
  timeoutInMinutes?: number | null | undefined;
  backend: "awsCodeBuild";
};

/** @internal */
export const DataAwsCodeBuild$outboundSchema: z.ZodType<
  DataAwsCodeBuild$Outbound,
  DataAwsCodeBuild
> = z.object({
  artifactsEncryptionDisabled: z.nullable(z.boolean()).optional(),
  artifactsType: z.nullable(z.string()).optional(),
  cloudWatchLogsStatus: z.nullable(z.string()).optional(),
  computeType: z.nullable(z.string()).optional(),
  created: z.nullable(z.number()).optional(),
  description: z.nullable(z.string()).optional(),
  encryptionKeyPresent: z.boolean(),
  environmentImage: z.nullable(z.string()).optional(),
  environmentType: z.nullable(z.string()).optional(),
  environmentVariableCount: z.int(),
  imagePullCredentialsType: z.nullable(z.string()).optional(),
  lastModified: z.nullable(z.number()).optional(),
  privilegedMode: z.nullable(z.boolean()).optional(),
  projectArn: z.nullable(z.string()).optional(),
  projectName: z.string(),
  queuedTimeoutInMinutes: z.nullable(z.int()).optional(),
  s3LogsStatus: z.nullable(z.string()).optional(),
  serviceRolePresent: z.boolean(),
  sourceType: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus56$outboundSchema),
  timeoutInMinutes: z.nullable(z.int()).optional(),
  backend: z.literal("awsCodeBuild"),
});

export function dataAwsCodeBuildToJSON(
  dataAwsCodeBuild: DataAwsCodeBuild,
): string {
  return JSON.stringify(
    DataAwsCodeBuild$outboundSchema.parse(dataAwsCodeBuild),
  );
}

/** @internal */
export type SyncReconcileRequestDataUnion14$Outbound =
  | DataAwsCodeBuild$Outbound
  | DataGcpCloudBuild$Outbound
  | DataAzureContainerApps2$Outbound
  | DataKubernetesJob$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion14$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion14$Outbound,
  SyncReconcileRequestDataUnion14
> = z.union([
  z.lazy(() => DataAwsCodeBuild$outboundSchema),
  z.lazy(() => DataGcpCloudBuild$outboundSchema),
  z.lazy(() => DataAzureContainerApps2$outboundSchema),
  z.lazy(() => DataKubernetesJob$outboundSchema),
]);

export function syncReconcileRequestDataUnion14ToJSON(
  syncReconcileRequestDataUnion14: SyncReconcileRequestDataUnion14,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion14$outboundSchema.parse(
      syncReconcileRequestDataUnion14,
    ),
  );
}

/** @internal */
export type DataBuild$Outbound = {
  data:
    | DataAwsCodeBuild$Outbound
    | DataGcpCloudBuild$Outbound
    | DataAzureContainerApps2$Outbound
    | DataKubernetesJob$Outbound;
  resourceType: "build";
};

/** @internal */
export const DataBuild$outboundSchema: z.ZodType<
  DataBuild$Outbound,
  DataBuild
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsCodeBuild$outboundSchema),
    z.lazy(() => DataGcpCloudBuild$outboundSchema),
    z.lazy(() => DataAzureContainerApps2$outboundSchema),
    z.lazy(() => DataKubernetesJob$outboundSchema),
  ]),
  resourceType: z.literal("build"),
});

export function dataBuildToJSON(dataBuild: DataBuild): string {
  return JSON.stringify(DataBuild$outboundSchema.parse(dataBuild));
}

/** @internal */
export const SyncReconcileRequestReason55$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason55
> = z.enum(SyncReconcileRequestReason55);

/** @internal */
export const StatusSeverity55$outboundSchema: z.ZodEnum<
  typeof StatusSeverity55
> = z.enum(StatusSeverity55);

/** @internal */
export type SyncReconcileRequestCollectionIssue55$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue55$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue55$Outbound,
  SyncReconcileRequestCollectionIssue55
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason55$outboundSchema,
  severity: StatusSeverity55$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue55ToJSON(
  syncReconcileRequestCollectionIssue55: SyncReconcileRequestCollectionIssue55,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue55$outboundSchema.parse(
      syncReconcileRequestCollectionIssue55,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth55$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth55
> = z.enum(SyncReconcileRequestHealth55);

/** @internal */
export const SyncReconcileRequestLifecycle55$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle55
> = z.enum(SyncReconcileRequestLifecycle55);

/** @internal */
export type SyncReconcileRequestStatus55$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue55$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus55$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus55$Outbound,
  SyncReconcileRequestStatus55
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue55$outboundSchema),
  ),
  health: SyncReconcileRequestHealth55$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle55$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus55ToJSON(
  syncReconcileRequestStatus55: SyncReconcileRequestStatus55,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus55$outboundSchema.parse(
      syncReconcileRequestStatus55,
    ),
  );
}

/** @internal */
export type DataLocal11$Outbound = {
  reachable: boolean;
  registryUrl: string;
  status: SyncReconcileRequestStatus55$Outbound;
  backend: "local";
};

/** @internal */
export const DataLocal11$outboundSchema: z.ZodType<
  DataLocal11$Outbound,
  DataLocal11
> = z.object({
  reachable: z.boolean(),
  registryUrl: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus55$outboundSchema),
  backend: z.literal("local"),
});

export function dataLocal11ToJSON(dataLocal11: DataLocal11): string {
  return JSON.stringify(DataLocal11$outboundSchema.parse(dataLocal11));
}

/** @internal */
export const SyncReconcileRequestReason54$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason54
> = z.enum(SyncReconcileRequestReason54);

/** @internal */
export const StatusSeverity54$outboundSchema: z.ZodEnum<
  typeof StatusSeverity54
> = z.enum(StatusSeverity54);

/** @internal */
export type SyncReconcileRequestCollectionIssue54$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue54$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue54$Outbound,
  SyncReconcileRequestCollectionIssue54
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason54$outboundSchema,
  severity: StatusSeverity54$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue54ToJSON(
  syncReconcileRequestCollectionIssue54: SyncReconcileRequestCollectionIssue54,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue54$outboundSchema.parse(
      syncReconcileRequestCollectionIssue54,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth54$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth54
> = z.enum(SyncReconcileRequestHealth54);

/** @internal */
export const SyncReconcileRequestLifecycle54$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle54
> = z.enum(SyncReconcileRequestLifecycle54);

/** @internal */
export type SyncReconcileRequestStatus54$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue54$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus54$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus54$Outbound,
  SyncReconcileRequestStatus54
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue54$outboundSchema),
  ),
  health: SyncReconcileRequestHealth54$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle54$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus54ToJSON(
  syncReconcileRequestStatus54: SyncReconcileRequestStatus54,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus54$outboundSchema.parse(
      syncReconcileRequestStatus54,
    ),
  );
}

/** @internal */
export type DataAzureContainerRegistry$Outbound = {
  adminUserEnabled: boolean;
  anonymousPullEnabled: boolean;
  creationDate?: string | null | undefined;
  dataEndpointEnabled?: boolean | null | undefined;
  dataEndpointHostNames: Array<string>;
  encryptionKeyIdentifierPresent: boolean;
  encryptionKeyVaultUriPresent: boolean;
  encryptionStatus?: string | null | undefined;
  ipRuleCount: number;
  location: string;
  loginServer?: string | null | undefined;
  managedTagCount: number;
  name: string;
  networkRuleBypassOptions: string;
  networkRuleDefaultAction?: string | null | undefined;
  policiesPresent: boolean;
  policyCount: number;
  privateEndpointConnectionCount: number;
  provisioningState?: string | null | undefined;
  publicNetworkAccess: string;
  resourceGroup: string;
  resourceId?: string | null | undefined;
  skuName: string;
  skuTier?: string | null | undefined;
  status: SyncReconcileRequestStatus54$Outbound;
  type?: string | null | undefined;
  zoneRedundancy: string;
  backend: "azureContainerRegistry";
};

/** @internal */
export const DataAzureContainerRegistry$outboundSchema: z.ZodType<
  DataAzureContainerRegistry$Outbound,
  DataAzureContainerRegistry
> = z.object({
  adminUserEnabled: z.boolean(),
  anonymousPullEnabled: z.boolean(),
  creationDate: z.nullable(z.string()).optional(),
  dataEndpointEnabled: z.nullable(z.boolean()).optional(),
  dataEndpointHostNames: z.array(z.string()),
  encryptionKeyIdentifierPresent: z.boolean(),
  encryptionKeyVaultUriPresent: z.boolean(),
  encryptionStatus: z.nullable(z.string()).optional(),
  ipRuleCount: z.int(),
  location: z.string(),
  loginServer: z.nullable(z.string()).optional(),
  managedTagCount: z.int(),
  name: z.string(),
  networkRuleBypassOptions: z.string(),
  networkRuleDefaultAction: z.nullable(z.string()).optional(),
  policiesPresent: z.boolean(),
  policyCount: z.int(),
  privateEndpointConnectionCount: z.int(),
  provisioningState: z.nullable(z.string()).optional(),
  publicNetworkAccess: z.string(),
  resourceGroup: z.string(),
  resourceId: z.nullable(z.string()).optional(),
  skuName: z.string(),
  skuTier: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus54$outboundSchema),
  type: z.nullable(z.string()).optional(),
  zoneRedundancy: z.string(),
  backend: z.literal("azureContainerRegistry"),
});

export function dataAzureContainerRegistryToJSON(
  dataAzureContainerRegistry: DataAzureContainerRegistry,
): string {
  return JSON.stringify(
    DataAzureContainerRegistry$outboundSchema.parse(dataAzureContainerRegistry),
  );
}

/** @internal */
export const SyncReconcileRequestReason53$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason53
> = z.enum(SyncReconcileRequestReason53);

/** @internal */
export const StatusSeverity53$outboundSchema: z.ZodEnum<
  typeof StatusSeverity53
> = z.enum(StatusSeverity53);

/** @internal */
export type SyncReconcileRequestCollectionIssue53$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue53$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue53$Outbound,
  SyncReconcileRequestCollectionIssue53
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason53$outboundSchema,
  severity: StatusSeverity53$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue53ToJSON(
  syncReconcileRequestCollectionIssue53: SyncReconcileRequestCollectionIssue53,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue53$outboundSchema.parse(
      syncReconcileRequestCollectionIssue53,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth53$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth53
> = z.enum(SyncReconcileRequestHealth53);

/** @internal */
export const SyncReconcileRequestLifecycle53$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle53
> = z.enum(SyncReconcileRequestLifecycle53);

/** @internal */
export type SyncReconcileRequestStatus53$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue53$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus53$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus53$Outbound,
  SyncReconcileRequestStatus53
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue53$outboundSchema),
  ),
  health: SyncReconcileRequestHealth53$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle53$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus53ToJSON(
  syncReconcileRequestStatus53: SyncReconcileRequestStatus53,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus53$outboundSchema.parse(
      syncReconcileRequestStatus53,
    ),
  );
}

/** @internal */
export type DataGcpArtifactRegistry$Outbound = {
  cleanupPolicyCount: number;
  cleanupPolicyDryRun?: boolean | null | undefined;
  createTime?: string | null | undefined;
  description?: string | null | undefined;
  format?: string | null | undefined;
  iamBindingCount: number;
  iamPolicyEtagPresent: boolean;
  iamRoles: Array<string>;
  kmsKeyNamePresent: boolean;
  labelCount: number;
  location: string;
  mode?: string | null | undefined;
  name?: string | null | undefined;
  projectId: string;
  pullServiceAccountEmail?: string | null | undefined;
  pushServiceAccountEmail?: string | null | undefined;
  repositoryId: string;
  satisfiesPzs?: boolean | null | undefined;
  sizeBytes?: string | null | undefined;
  status: SyncReconcileRequestStatus53$Outbound;
  updateTime?: string | null | undefined;
  backend: "gcpArtifactRegistry";
};

/** @internal */
export const DataGcpArtifactRegistry$outboundSchema: z.ZodType<
  DataGcpArtifactRegistry$Outbound,
  DataGcpArtifactRegistry
> = z.object({
  cleanupPolicyCount: z.int(),
  cleanupPolicyDryRun: z.nullable(z.boolean()).optional(),
  createTime: z.nullable(z.string()).optional(),
  description: z.nullable(z.string()).optional(),
  format: z.nullable(z.string()).optional(),
  iamBindingCount: z.int(),
  iamPolicyEtagPresent: z.boolean(),
  iamRoles: z.array(z.string()),
  kmsKeyNamePresent: z.boolean(),
  labelCount: z.int(),
  location: z.string(),
  mode: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  projectId: z.string(),
  pullServiceAccountEmail: z.nullable(z.string()).optional(),
  pushServiceAccountEmail: z.nullable(z.string()).optional(),
  repositoryId: z.string(),
  satisfiesPzs: z.nullable(z.boolean()).optional(),
  sizeBytes: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus53$outboundSchema),
  updateTime: z.nullable(z.string()).optional(),
  backend: z.literal("gcpArtifactRegistry"),
});

export function dataGcpArtifactRegistryToJSON(
  dataGcpArtifactRegistry: DataGcpArtifactRegistry,
): string {
  return JSON.stringify(
    DataGcpArtifactRegistry$outboundSchema.parse(dataGcpArtifactRegistry),
  );
}

/** @internal */
export type SyncReconcileRequestRepository$Outbound = {
  createdAt: number;
  encryptionType?: string | null | undefined;
  imageTagMutability?: string | null | undefined;
  kmsKeyPresent: boolean;
  registryId: string;
  repositoryArn: string;
  repositoryName: string;
  repositoryUri: string;
  scanOnPush?: boolean | null | undefined;
};

/** @internal */
export const SyncReconcileRequestRepository$outboundSchema: z.ZodType<
  SyncReconcileRequestRepository$Outbound,
  SyncReconcileRequestRepository
> = z.object({
  createdAt: z.number(),
  encryptionType: z.nullable(z.string()).optional(),
  imageTagMutability: z.nullable(z.string()).optional(),
  kmsKeyPresent: z.boolean(),
  registryId: z.string(),
  repositoryArn: z.string(),
  repositoryName: z.string(),
  repositoryUri: z.string(),
  scanOnPush: z.nullable(z.boolean()).optional(),
});

export function syncReconcileRequestRepositoryToJSON(
  syncReconcileRequestRepository: SyncReconcileRequestRepository,
): string {
  return JSON.stringify(
    SyncReconcileRequestRepository$outboundSchema.parse(
      syncReconcileRequestRepository,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestReason52$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason52
> = z.enum(SyncReconcileRequestReason52);

/** @internal */
export const StatusSeverity52$outboundSchema: z.ZodEnum<
  typeof StatusSeverity52
> = z.enum(StatusSeverity52);

/** @internal */
export type SyncReconcileRequestCollectionIssue52$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue52$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue52$Outbound,
  SyncReconcileRequestCollectionIssue52
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason52$outboundSchema,
  severity: StatusSeverity52$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue52ToJSON(
  syncReconcileRequestCollectionIssue52: SyncReconcileRequestCollectionIssue52,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue52$outboundSchema.parse(
      syncReconcileRequestCollectionIssue52,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth52$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth52
> = z.enum(SyncReconcileRequestHealth52);

/** @internal */
export const SyncReconcileRequestLifecycle52$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle52
> = z.enum(SyncReconcileRequestLifecycle52);

/** @internal */
export type SyncReconcileRequestStatus52$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue52$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus52$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus52$Outbound,
  SyncReconcileRequestStatus52
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue52$outboundSchema),
  ),
  health: SyncReconcileRequestHealth52$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle52$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus52ToJSON(
  syncReconcileRequestStatus52: SyncReconcileRequestStatus52,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus52$outboundSchema.parse(
      syncReconcileRequestStatus52,
    ),
  );
}

/** @internal */
export type DataAwsEcr$Outbound = {
  pullRoleArn?: string | null | undefined;
  pushRoleArn?: string | null | undefined;
  region: string;
  registryId: string;
  registryUri: string;
  repositories: Array<SyncReconcileRequestRepository$Outbound>;
  repositoriesTruncated: boolean;
  repositoryCount: number;
  repositoryPrefix: string;
  status: SyncReconcileRequestStatus52$Outbound;
  backend: "awsEcr";
};

/** @internal */
export const DataAwsEcr$outboundSchema: z.ZodType<
  DataAwsEcr$Outbound,
  DataAwsEcr
> = z.object({
  pullRoleArn: z.nullable(z.string()).optional(),
  pushRoleArn: z.nullable(z.string()).optional(),
  region: z.string(),
  registryId: z.string(),
  registryUri: z.string(),
  repositories: z.array(
    z.lazy(() => SyncReconcileRequestRepository$outboundSchema),
  ),
  repositoriesTruncated: z.boolean(),
  repositoryCount: z.int(),
  repositoryPrefix: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus52$outboundSchema),
  backend: z.literal("awsEcr"),
});

export function dataAwsEcrToJSON(dataAwsEcr: DataAwsEcr): string {
  return JSON.stringify(DataAwsEcr$outboundSchema.parse(dataAwsEcr));
}

/** @internal */
export type SyncReconcileRequestDataUnion13$Outbound =
  | DataAwsEcr$Outbound
  | DataGcpArtifactRegistry$Outbound
  | DataAzureContainerRegistry$Outbound
  | DataLocal11$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion13$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion13$Outbound,
  SyncReconcileRequestDataUnion13
> = z.union([
  z.lazy(() => DataAwsEcr$outboundSchema),
  z.lazy(() => DataGcpArtifactRegistry$outboundSchema),
  z.lazy(() => DataAzureContainerRegistry$outboundSchema),
  z.lazy(() => DataLocal11$outboundSchema),
]);

export function syncReconcileRequestDataUnion13ToJSON(
  syncReconcileRequestDataUnion13: SyncReconcileRequestDataUnion13,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion13$outboundSchema.parse(
      syncReconcileRequestDataUnion13,
    ),
  );
}

/** @internal */
export type DataArtifactRegistry$Outbound = {
  data:
    | DataAwsEcr$Outbound
    | DataGcpArtifactRegistry$Outbound
    | DataAzureContainerRegistry$Outbound
    | DataLocal11$Outbound;
  resourceType: "artifact-registry";
};

/** @internal */
export const DataArtifactRegistry$outboundSchema: z.ZodType<
  DataArtifactRegistry$Outbound,
  DataArtifactRegistry
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsEcr$outboundSchema),
    z.lazy(() => DataGcpArtifactRegistry$outboundSchema),
    z.lazy(() => DataAzureContainerRegistry$outboundSchema),
    z.lazy(() => DataLocal11$outboundSchema),
  ]),
  resourceType: z.literal("artifact-registry"),
});

export function dataArtifactRegistryToJSON(
  dataArtifactRegistry: DataArtifactRegistry,
): string {
  return JSON.stringify(
    DataArtifactRegistry$outboundSchema.parse(dataArtifactRegistry),
  );
}

/** @internal */
export const SyncReconcileRequestReason51$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason51
> = z.enum(SyncReconcileRequestReason51);

/** @internal */
export const StatusSeverity51$outboundSchema: z.ZodEnum<
  typeof StatusSeverity51
> = z.enum(StatusSeverity51);

/** @internal */
export type SyncReconcileRequestCollectionIssue51$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue51$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue51$Outbound,
  SyncReconcileRequestCollectionIssue51
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason51$outboundSchema,
  severity: StatusSeverity51$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue51ToJSON(
  syncReconcileRequestCollectionIssue51: SyncReconcileRequestCollectionIssue51,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue51$outboundSchema.parse(
      syncReconcileRequestCollectionIssue51,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth51$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth51
> = z.enum(SyncReconcileRequestHealth51);

/** @internal */
export const SyncReconcileRequestLifecycle51$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle51
> = z.enum(SyncReconcileRequestLifecycle51);

/** @internal */
export type SyncReconcileRequestStatus51$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue51$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus51$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus51$Outbound,
  SyncReconcileRequestStatus51
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue51$outboundSchema),
  ),
  health: SyncReconcileRequestHealth51$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle51$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus51ToJSON(
  syncReconcileRequestStatus51: SyncReconcileRequestStatus51,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus51$outboundSchema.parse(
      syncReconcileRequestStatus51,
    ),
  );
}

/** @internal */
export type DataAzureManagedIdentity2$Outbound = {
  ficName?: string | null | undefined;
  roleAssignmentIds: Array<string>;
  roleDefinitionId?: string | null | undefined;
  status: SyncReconcileRequestStatus51$Outbound;
  tenantId?: string | null | undefined;
  uamiClientId?: string | null | undefined;
  uamiPrincipalId?: string | null | undefined;
  uamiResourceId?: string | null | undefined;
  backend: "azureManagedIdentity";
};

/** @internal */
export const DataAzureManagedIdentity2$outboundSchema: z.ZodType<
  DataAzureManagedIdentity2$Outbound,
  DataAzureManagedIdentity2
> = z.object({
  ficName: z.nullable(z.string()).optional(),
  roleAssignmentIds: z.array(z.string()),
  roleDefinitionId: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus51$outboundSchema),
  tenantId: z.nullable(z.string()).optional(),
  uamiClientId: z.nullable(z.string()).optional(),
  uamiPrincipalId: z.nullable(z.string()).optional(),
  uamiResourceId: z.nullable(z.string()).optional(),
  backend: z.literal("azureManagedIdentity"),
});

export function dataAzureManagedIdentity2ToJSON(
  dataAzureManagedIdentity2: DataAzureManagedIdentity2,
): string {
  return JSON.stringify(
    DataAzureManagedIdentity2$outboundSchema.parse(dataAzureManagedIdentity2),
  );
}

/** @internal */
export const SyncReconcileRequestReason50$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason50
> = z.enum(SyncReconcileRequestReason50);

/** @internal */
export const StatusSeverity50$outboundSchema: z.ZodEnum<
  typeof StatusSeverity50
> = z.enum(StatusSeverity50);

/** @internal */
export type SyncReconcileRequestCollectionIssue50$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue50$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue50$Outbound,
  SyncReconcileRequestCollectionIssue50
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason50$outboundSchema,
  severity: StatusSeverity50$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue50ToJSON(
  syncReconcileRequestCollectionIssue50: SyncReconcileRequestCollectionIssue50,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue50$outboundSchema.parse(
      syncReconcileRequestCollectionIssue50,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth50$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth50
> = z.enum(SyncReconcileRequestHealth50);

/** @internal */
export const SyncReconcileRequestLifecycle50$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle50
> = z.enum(SyncReconcileRequestLifecycle50);

/** @internal */
export type SyncReconcileRequestStatus50$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue50$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus50$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus50$Outbound,
  SyncReconcileRequestStatus50
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue50$outboundSchema),
  ),
  health: SyncReconcileRequestHealth50$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle50$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus50ToJSON(
  syncReconcileRequestStatus50: SyncReconcileRequestStatus50,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus50$outboundSchema.parse(
      syncReconcileRequestStatus50,
    ),
  );
}

/** @internal */
export type DataGcpServiceAccount2$Outbound = {
  impersonationGranted: boolean;
  roleBound: boolean;
  serviceAccountEmail?: string | null | undefined;
  serviceAccountUniqueId?: string | null | undefined;
  status: SyncReconcileRequestStatus50$Outbound;
  backend: "gcpServiceAccount";
};

/** @internal */
export const DataGcpServiceAccount2$outboundSchema: z.ZodType<
  DataGcpServiceAccount2$Outbound,
  DataGcpServiceAccount2
> = z.object({
  impersonationGranted: z.boolean(),
  roleBound: z.boolean(),
  serviceAccountEmail: z.nullable(z.string()).optional(),
  serviceAccountUniqueId: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus50$outboundSchema),
  backend: z.literal("gcpServiceAccount"),
});

export function dataGcpServiceAccount2ToJSON(
  dataGcpServiceAccount2: DataGcpServiceAccount2,
): string {
  return JSON.stringify(
    DataGcpServiceAccount2$outboundSchema.parse(dataGcpServiceAccount2),
  );
}

/** @internal */
export const SyncReconcileRequestReason49$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason49
> = z.enum(SyncReconcileRequestReason49);

/** @internal */
export const StatusSeverity49$outboundSchema: z.ZodEnum<
  typeof StatusSeverity49
> = z.enum(StatusSeverity49);

/** @internal */
export type SyncReconcileRequestCollectionIssue49$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue49$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue49$Outbound,
  SyncReconcileRequestCollectionIssue49
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason49$outboundSchema,
  severity: StatusSeverity49$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue49ToJSON(
  syncReconcileRequestCollectionIssue49: SyncReconcileRequestCollectionIssue49,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue49$outboundSchema.parse(
      syncReconcileRequestCollectionIssue49,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth49$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth49
> = z.enum(SyncReconcileRequestHealth49);

/** @internal */
export const SyncReconcileRequestLifecycle49$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle49
> = z.enum(SyncReconcileRequestLifecycle49);

/** @internal */
export type SyncReconcileRequestStatus49$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue49$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus49$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus49$Outbound,
  SyncReconcileRequestStatus49
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue49$outboundSchema),
  ),
  health: SyncReconcileRequestHealth49$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle49$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus49ToJSON(
  syncReconcileRequestStatus49: SyncReconcileRequestStatus49,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus49$outboundSchema.parse(
      syncReconcileRequestStatus49,
    ),
  );
}

/** @internal */
export type DataAwsIamRole2$Outbound = {
  managementPermissionsApplied: boolean;
  roleArn?: string | null | undefined;
  roleName?: string | null | undefined;
  status: SyncReconcileRequestStatus49$Outbound;
  backend: "awsIamRole";
};

/** @internal */
export const DataAwsIamRole2$outboundSchema: z.ZodType<
  DataAwsIamRole2$Outbound,
  DataAwsIamRole2
> = z.object({
  managementPermissionsApplied: z.boolean(),
  roleArn: z.nullable(z.string()).optional(),
  roleName: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus49$outboundSchema),
  backend: z.literal("awsIamRole"),
});

export function dataAwsIamRole2ToJSON(
  dataAwsIamRole2: DataAwsIamRole2,
): string {
  return JSON.stringify(DataAwsIamRole2$outboundSchema.parse(dataAwsIamRole2));
}

/** @internal */
export type SyncReconcileRequestDataUnion12$Outbound =
  | DataAwsIamRole2$Outbound
  | DataGcpServiceAccount2$Outbound
  | DataAzureManagedIdentity2$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion12$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion12$Outbound,
  SyncReconcileRequestDataUnion12
> = z.union([
  z.lazy(() => DataAwsIamRole2$outboundSchema),
  z.lazy(() => DataGcpServiceAccount2$outboundSchema),
  z.lazy(() => DataAzureManagedIdentity2$outboundSchema),
]);

export function syncReconcileRequestDataUnion12ToJSON(
  syncReconcileRequestDataUnion12: SyncReconcileRequestDataUnion12,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion12$outboundSchema.parse(
      syncReconcileRequestDataUnion12,
    ),
  );
}

/** @internal */
export type DataRemoteStackManagement$Outbound = {
  data:
    | DataAwsIamRole2$Outbound
    | DataGcpServiceAccount2$Outbound
    | DataAzureManagedIdentity2$Outbound;
  resourceType: "remote-stack-management";
};

/** @internal */
export const DataRemoteStackManagement$outboundSchema: z.ZodType<
  DataRemoteStackManagement$Outbound,
  DataRemoteStackManagement
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsIamRole2$outboundSchema),
    z.lazy(() => DataGcpServiceAccount2$outboundSchema),
    z.lazy(() => DataAzureManagedIdentity2$outboundSchema),
  ]),
  resourceType: z.literal("remote-stack-management"),
});

export function dataRemoteStackManagementToJSON(
  dataRemoteStackManagement: DataRemoteStackManagement,
): string {
  return JSON.stringify(
    DataRemoteStackManagement$outboundSchema.parse(dataRemoteStackManagement),
  );
}

/** @internal */
export const SyncReconcileRequestReason48$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason48
> = z.enum(SyncReconcileRequestReason48);

/** @internal */
export const StatusSeverity48$outboundSchema: z.ZodEnum<
  typeof StatusSeverity48
> = z.enum(StatusSeverity48);

/** @internal */
export type SyncReconcileRequestCollectionIssue48$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue48$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue48$Outbound,
  SyncReconcileRequestCollectionIssue48
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason48$outboundSchema,
  severity: StatusSeverity48$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue48ToJSON(
  syncReconcileRequestCollectionIssue48: SyncReconcileRequestCollectionIssue48,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue48$outboundSchema.parse(
      syncReconcileRequestCollectionIssue48,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth48$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth48
> = z.enum(SyncReconcileRequestHealth48);

/** @internal */
export const SyncReconcileRequestLifecycle48$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle48
> = z.enum(SyncReconcileRequestLifecycle48);

/** @internal */
export type SyncReconcileRequestStatus48$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue48$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus48$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus48$Outbound,
  SyncReconcileRequestStatus48
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue48$outboundSchema),
  ),
  health: SyncReconcileRequestHealth48$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle48$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus48ToJSON(
  syncReconcileRequestStatus48: SyncReconcileRequestStatus48,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus48$outboundSchema.parse(
      syncReconcileRequestStatus48,
    ),
  );
}

/** @internal */
export type DataAzureVnet$Outbound = {
  applicationGatewaySubnetName?: string | null | undefined;
  cidrBlock?: string | null | undefined;
  isByoVnet: boolean;
  lastByoVnetVerificationErrorCode?: string | null | undefined;
  location?: string | null | undefined;
  natGatewayId?: string | null | undefined;
  nsgId?: string | null | undefined;
  privateEndpointSubnetName?: string | null | undefined;
  privateSubnetName?: string | null | undefined;
  publicIpId?: string | null | undefined;
  publicSubnetName?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  status: SyncReconcileRequestStatus48$Outbound;
  vnetName?: string | null | undefined;
  vnetResourceId?: string | null | undefined;
  backend: "azureVnet";
};

/** @internal */
export const DataAzureVnet$outboundSchema: z.ZodType<
  DataAzureVnet$Outbound,
  DataAzureVnet
> = z.object({
  applicationGatewaySubnetName: z.nullable(z.string()).optional(),
  cidrBlock: z.nullable(z.string()).optional(),
  isByoVnet: z.boolean(),
  lastByoVnetVerificationErrorCode: z.nullable(z.string()).optional(),
  location: z.nullable(z.string()).optional(),
  natGatewayId: z.nullable(z.string()).optional(),
  nsgId: z.nullable(z.string()).optional(),
  privateEndpointSubnetName: z.nullable(z.string()).optional(),
  privateSubnetName: z.nullable(z.string()).optional(),
  publicIpId: z.nullable(z.string()).optional(),
  publicSubnetName: z.nullable(z.string()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus48$outboundSchema),
  vnetName: z.nullable(z.string()).optional(),
  vnetResourceId: z.nullable(z.string()).optional(),
  backend: z.literal("azureVnet"),
});

export function dataAzureVnetToJSON(dataAzureVnet: DataAzureVnet): string {
  return JSON.stringify(DataAzureVnet$outboundSchema.parse(dataAzureVnet));
}

/** @internal */
export const SyncReconcileRequestReason47$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason47
> = z.enum(SyncReconcileRequestReason47);

/** @internal */
export const StatusSeverity47$outboundSchema: z.ZodEnum<
  typeof StatusSeverity47
> = z.enum(StatusSeverity47);

/** @internal */
export type SyncReconcileRequestCollectionIssue47$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue47$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue47$Outbound,
  SyncReconcileRequestCollectionIssue47
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason47$outboundSchema,
  severity: StatusSeverity47$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue47ToJSON(
  syncReconcileRequestCollectionIssue47: SyncReconcileRequestCollectionIssue47,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue47$outboundSchema.parse(
      syncReconcileRequestCollectionIssue47,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth47$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth47
> = z.enum(SyncReconcileRequestHealth47);

/** @internal */
export const SyncReconcileRequestLifecycle47$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle47
> = z.enum(SyncReconcileRequestLifecycle47);

/** @internal */
export type SyncReconcileRequestStatus47$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue47$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus47$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus47$Outbound,
  SyncReconcileRequestStatus47
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue47$outboundSchema),
  ),
  health: SyncReconcileRequestHealth47$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle47$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus47ToJSON(
  syncReconcileRequestStatus47: SyncReconcileRequestStatus47,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus47$outboundSchema.parse(
      syncReconcileRequestStatus47,
    ),
  );
}

/** @internal */
export type DataGcpVpc$Outbound = {
  cidrBlock?: string | null | undefined;
  cloudNatName?: string | null | undefined;
  firewallName?: string | null | undefined;
  isByoVpc: boolean;
  networkName?: string | null | undefined;
  networkSelfLink?: string | null | undefined;
  region?: string | null | undefined;
  routerName?: string | null | undefined;
  status: SyncReconcileRequestStatus47$Outbound;
  subnetworkName?: string | null | undefined;
  subnetworkSelfLink?: string | null | undefined;
  backend: "gcpVpc";
};

/** @internal */
export const DataGcpVpc$outboundSchema: z.ZodType<
  DataGcpVpc$Outbound,
  DataGcpVpc
> = z.object({
  cidrBlock: z.nullable(z.string()).optional(),
  cloudNatName: z.nullable(z.string()).optional(),
  firewallName: z.nullable(z.string()).optional(),
  isByoVpc: z.boolean(),
  networkName: z.nullable(z.string()).optional(),
  networkSelfLink: z.nullable(z.string()).optional(),
  region: z.nullable(z.string()).optional(),
  routerName: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus47$outboundSchema),
  subnetworkName: z.nullable(z.string()).optional(),
  subnetworkSelfLink: z.nullable(z.string()).optional(),
  backend: z.literal("gcpVpc"),
});

export function dataGcpVpcToJSON(dataGcpVpc: DataGcpVpc): string {
  return JSON.stringify(DataGcpVpc$outboundSchema.parse(dataGcpVpc));
}

/** @internal */
export const SyncReconcileRequestReason46$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason46
> = z.enum(SyncReconcileRequestReason46);

/** @internal */
export const StatusSeverity46$outboundSchema: z.ZodEnum<
  typeof StatusSeverity46
> = z.enum(StatusSeverity46);

/** @internal */
export type SyncReconcileRequestCollectionIssue46$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue46$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue46$Outbound,
  SyncReconcileRequestCollectionIssue46
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason46$outboundSchema,
  severity: StatusSeverity46$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue46ToJSON(
  syncReconcileRequestCollectionIssue46: SyncReconcileRequestCollectionIssue46,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue46$outboundSchema.parse(
      syncReconcileRequestCollectionIssue46,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth46$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth46
> = z.enum(SyncReconcileRequestHealth46);

/** @internal */
export const SyncReconcileRequestLifecycle46$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle46
> = z.enum(SyncReconcileRequestLifecycle46);

/** @internal */
export type SyncReconcileRequestStatus46$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue46$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus46$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus46$Outbound,
  SyncReconcileRequestStatus46
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue46$outboundSchema),
  ),
  health: SyncReconcileRequestHealth46$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle46$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus46ToJSON(
  syncReconcileRequestStatus46: SyncReconcileRequestStatus46,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus46$outboundSchema.parse(
      syncReconcileRequestStatus46,
    ),
  );
}

/** @internal */
export type DataAwsVpc$Outbound = {
  availabilityZones: Array<string>;
  cidrBlock?: string | null | undefined;
  internetGatewayId?: string | null | undefined;
  isByoVpc: boolean;
  natGatewayId?: string | null | undefined;
  privateSubnetIds: Array<string>;
  publicSubnetIds: Array<string>;
  routeTableCount: number;
  securityGroupId?: string | null | undefined;
  status: SyncReconcileRequestStatus46$Outbound;
  vpcId?: string | null | undefined;
  vpcState?: string | null | undefined;
  backend: "awsVpc";
};

/** @internal */
export const DataAwsVpc$outboundSchema: z.ZodType<
  DataAwsVpc$Outbound,
  DataAwsVpc
> = z.object({
  availabilityZones: z.array(z.string()),
  cidrBlock: z.nullable(z.string()).optional(),
  internetGatewayId: z.nullable(z.string()).optional(),
  isByoVpc: z.boolean(),
  natGatewayId: z.nullable(z.string()).optional(),
  privateSubnetIds: z.array(z.string()),
  publicSubnetIds: z.array(z.string()),
  routeTableCount: z.int(),
  securityGroupId: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus46$outboundSchema),
  vpcId: z.nullable(z.string()).optional(),
  vpcState: z.nullable(z.string()).optional(),
  backend: z.literal("awsVpc"),
});

export function dataAwsVpcToJSON(dataAwsVpc: DataAwsVpc): string {
  return JSON.stringify(DataAwsVpc$outboundSchema.parse(dataAwsVpc));
}

/** @internal */
export type SyncReconcileRequestDataUnion11$Outbound =
  | DataAwsVpc$Outbound
  | DataGcpVpc$Outbound
  | DataAzureVnet$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion11$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion11$Outbound,
  SyncReconcileRequestDataUnion11
> = z.union([
  z.lazy(() => DataAwsVpc$outboundSchema),
  z.lazy(() => DataGcpVpc$outboundSchema),
  z.lazy(() => DataAzureVnet$outboundSchema),
]);

export function syncReconcileRequestDataUnion11ToJSON(
  syncReconcileRequestDataUnion11: SyncReconcileRequestDataUnion11,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion11$outboundSchema.parse(
      syncReconcileRequestDataUnion11,
    ),
  );
}

/** @internal */
export type DataNetwork$Outbound = {
  data: DataAwsVpc$Outbound | DataGcpVpc$Outbound | DataAzureVnet$Outbound;
  resourceType: "network";
};

/** @internal */
export const DataNetwork$outboundSchema: z.ZodType<
  DataNetwork$Outbound,
  DataNetwork
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsVpc$outboundSchema),
    z.lazy(() => DataGcpVpc$outboundSchema),
    z.lazy(() => DataAzureVnet$outboundSchema),
  ]),
  resourceType: z.literal("network"),
});

export function dataNetworkToJSON(dataNetwork: DataNetwork): string {
  return JSON.stringify(DataNetwork$outboundSchema.parse(dataNetwork));
}

/** @internal */
export const SyncReconcileRequestReason45$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason45
> = z.enum(SyncReconcileRequestReason45);

/** @internal */
export const StatusSeverity45$outboundSchema: z.ZodEnum<
  typeof StatusSeverity45
> = z.enum(StatusSeverity45);

/** @internal */
export type SyncReconcileRequestCollectionIssue45$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue45$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue45$Outbound,
  SyncReconcileRequestCollectionIssue45
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason45$outboundSchema,
  severity: StatusSeverity45$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue45ToJSON(
  syncReconcileRequestCollectionIssue45: SyncReconcileRequestCollectionIssue45,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue45$outboundSchema.parse(
      syncReconcileRequestCollectionIssue45,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth45$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth45
> = z.enum(SyncReconcileRequestHealth45);

/** @internal */
export const SyncReconcileRequestLifecycle45$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle45
> = z.enum(SyncReconcileRequestLifecycle45);

/** @internal */
export type SyncReconcileRequestStatus45$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue45$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus45$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus45$Outbound,
  SyncReconcileRequestStatus45
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue45$outboundSchema),
  ),
  health: SyncReconcileRequestHealth45$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle45$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus45ToJSON(
  syncReconcileRequestStatus45: SyncReconcileRequestStatus45,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus45$outboundSchema.parse(
      syncReconcileRequestStatus45,
    ),
  );
}

/** @internal */
export type DataLocal10$Outbound = {
  configured: boolean;
  identity: string;
  status: SyncReconcileRequestStatus45$Outbound;
  backend: "local";
};

/** @internal */
export const DataLocal10$outboundSchema: z.ZodType<
  DataLocal10$Outbound,
  DataLocal10
> = z.object({
  configured: z.boolean(),
  identity: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus45$outboundSchema),
  backend: z.literal("local"),
});

export function dataLocal10ToJSON(dataLocal10: DataLocal10): string {
  return JSON.stringify(DataLocal10$outboundSchema.parse(dataLocal10));
}

/** @internal */
export const SyncReconcileRequestReason44$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason44
> = z.enum(SyncReconcileRequestReason44);

/** @internal */
export const StatusSeverity44$outboundSchema: z.ZodEnum<
  typeof StatusSeverity44
> = z.enum(StatusSeverity44);

/** @internal */
export type SyncReconcileRequestCollectionIssue44$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue44$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue44$Outbound,
  SyncReconcileRequestCollectionIssue44
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason44$outboundSchema,
  severity: StatusSeverity44$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue44ToJSON(
  syncReconcileRequestCollectionIssue44: SyncReconcileRequestCollectionIssue44,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue44$outboundSchema.parse(
      syncReconcileRequestCollectionIssue44,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth44$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth44
> = z.enum(SyncReconcileRequestHealth44);

/** @internal */
export const SyncReconcileRequestLifecycle44$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle44
> = z.enum(SyncReconcileRequestLifecycle44);

/** @internal */
export type SyncReconcileRequestStatus44$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue44$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus44$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus44$Outbound,
  SyncReconcileRequestStatus44
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue44$outboundSchema),
  ),
  health: SyncReconcileRequestHealth44$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle44$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus44ToJSON(
  syncReconcileRequestStatus44: SyncReconcileRequestStatus44,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus44$outboundSchema.parse(
      syncReconcileRequestStatus44,
    ),
  );
}

/** @internal */
export type DataAzureManagedIdentity1$Outbound = {
  clientId?: string | null | undefined;
  customRoleDefinitionCount: number;
  customRoleDefinitionIds: Array<string>;
  isolationScope?: string | null | undefined;
  location: string;
  managedTagCount: number;
  name: string;
  principalId?: string | null | undefined;
  resourceGroup: string;
  resourceId: string;
  roleAssignmentCount: number;
  roleAssignmentIds: Array<string>;
  stackPermissionsApplied: boolean;
  status: SyncReconcileRequestStatus44$Outbound;
  tenantId?: string | null | undefined;
  type?: string | null | undefined;
  backend: "azureManagedIdentity";
};

/** @internal */
export const DataAzureManagedIdentity1$outboundSchema: z.ZodType<
  DataAzureManagedIdentity1$Outbound,
  DataAzureManagedIdentity1
> = z.object({
  clientId: z.nullable(z.string()).optional(),
  customRoleDefinitionCount: z.int(),
  customRoleDefinitionIds: z.array(z.string()),
  isolationScope: z.nullable(z.string()).optional(),
  location: z.string(),
  managedTagCount: z.int(),
  name: z.string(),
  principalId: z.nullable(z.string()).optional(),
  resourceGroup: z.string(),
  resourceId: z.string(),
  roleAssignmentCount: z.int(),
  roleAssignmentIds: z.array(z.string()),
  stackPermissionsApplied: z.boolean(),
  status: z.lazy(() => SyncReconcileRequestStatus44$outboundSchema),
  tenantId: z.nullable(z.string()).optional(),
  type: z.nullable(z.string()).optional(),
  backend: z.literal("azureManagedIdentity"),
});

export function dataAzureManagedIdentity1ToJSON(
  dataAzureManagedIdentity1: DataAzureManagedIdentity1,
): string {
  return JSON.stringify(
    DataAzureManagedIdentity1$outboundSchema.parse(dataAzureManagedIdentity1),
  );
}

/** @internal */
export const SyncReconcileRequestReason43$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason43
> = z.enum(SyncReconcileRequestReason43);

/** @internal */
export const StatusSeverity43$outboundSchema: z.ZodEnum<
  typeof StatusSeverity43
> = z.enum(StatusSeverity43);

/** @internal */
export type SyncReconcileRequestCollectionIssue43$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue43$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue43$Outbound,
  SyncReconcileRequestCollectionIssue43
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason43$outboundSchema,
  severity: StatusSeverity43$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue43ToJSON(
  syncReconcileRequestCollectionIssue43: SyncReconcileRequestCollectionIssue43,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue43$outboundSchema.parse(
      syncReconcileRequestCollectionIssue43,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth43$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth43
> = z.enum(SyncReconcileRequestHealth43);

/** @internal */
export const SyncReconcileRequestLifecycle43$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle43
> = z.enum(SyncReconcileRequestLifecycle43);

/** @internal */
export type SyncReconcileRequestStatus43$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue43$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus43$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus43$Outbound,
  SyncReconcileRequestStatus43
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue43$outboundSchema),
  ),
  health: SyncReconcileRequestHealth43$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle43$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus43ToJSON(
  syncReconcileRequestStatus43: SyncReconcileRequestStatus43,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus43$outboundSchema.parse(
      syncReconcileRequestStatus43,
    ),
  );
}

/** @internal */
export type DataGcpServiceAccount1$Outbound = {
  description?: string | null | undefined;
  disabled?: boolean | null | undefined;
  displayName?: string | null | undefined;
  email: string;
  etag?: string | null | undefined;
  name?: string | null | undefined;
  oauth2ClientId?: string | null | undefined;
  projectBindingCount: number;
  projectId?: string | null | undefined;
  projectRoles: Array<string>;
  serviceAccountBindingCount: number;
  serviceAccountRoles: Array<string>;
  status: SyncReconcileRequestStatus43$Outbound;
  uniqueId?: string | null | undefined;
  backend: "gcpServiceAccount";
};

/** @internal */
export const DataGcpServiceAccount1$outboundSchema: z.ZodType<
  DataGcpServiceAccount1$Outbound,
  DataGcpServiceAccount1
> = z.object({
  description: z.nullable(z.string()).optional(),
  disabled: z.nullable(z.boolean()).optional(),
  displayName: z.nullable(z.string()).optional(),
  email: z.string(),
  etag: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  oauth2ClientId: z.nullable(z.string()).optional(),
  projectBindingCount: z.int(),
  projectId: z.nullable(z.string()).optional(),
  projectRoles: z.array(z.string()),
  serviceAccountBindingCount: z.int(),
  serviceAccountRoles: z.array(z.string()),
  status: z.lazy(() => SyncReconcileRequestStatus43$outboundSchema),
  uniqueId: z.nullable(z.string()).optional(),
  backend: z.literal("gcpServiceAccount"),
});

export function dataGcpServiceAccount1ToJSON(
  dataGcpServiceAccount1: DataGcpServiceAccount1,
): string {
  return JSON.stringify(
    DataGcpServiceAccount1$outboundSchema.parse(dataGcpServiceAccount1),
  );
}

/** @internal */
export const SyncReconcileRequestReason42$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason42
> = z.enum(SyncReconcileRequestReason42);

/** @internal */
export const StatusSeverity42$outboundSchema: z.ZodEnum<
  typeof StatusSeverity42
> = z.enum(StatusSeverity42);

/** @internal */
export type SyncReconcileRequestCollectionIssue42$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue42$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue42$Outbound,
  SyncReconcileRequestCollectionIssue42
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason42$outboundSchema,
  severity: StatusSeverity42$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue42ToJSON(
  syncReconcileRequestCollectionIssue42: SyncReconcileRequestCollectionIssue42,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue42$outboundSchema.parse(
      syncReconcileRequestCollectionIssue42,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth42$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth42
> = z.enum(SyncReconcileRequestHealth42);

/** @internal */
export const SyncReconcileRequestLifecycle42$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle42
> = z.enum(SyncReconcileRequestLifecycle42);

/** @internal */
export type SyncReconcileRequestStatus42$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue42$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus42$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus42$Outbound,
  SyncReconcileRequestStatus42
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue42$outboundSchema),
  ),
  health: SyncReconcileRequestHealth42$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle42$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus42ToJSON(
  syncReconcileRequestStatus42: SyncReconcileRequestStatus42,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus42$outboundSchema.parse(
      syncReconcileRequestStatus42,
    ),
  );
}

/** @internal */
export type DataAwsIamRole1$Outbound = {
  assumeRolePolicyPresent: boolean;
  attachedPolicyCount: number;
  attachedPolicyNames: Array<string>;
  createDate: string;
  description?: string | null | undefined;
  inlinePolicyCount: number;
  inlinePolicyNames: Array<string>;
  lastUsedDate?: string | null | undefined;
  lastUsedRegion?: string | null | undefined;
  managedTagCount: number;
  maxSessionDuration?: number | null | undefined;
  path: string;
  permissionsBoundaryArn?: string | null | undefined;
  permissionsBoundaryType?: string | null | undefined;
  roleArn: string;
  roleId: string;
  roleName: string;
  stackPermissionsApplied: boolean;
  status: SyncReconcileRequestStatus42$Outbound;
  tagCount: number;
  backend: "awsIamRole";
};

/** @internal */
export const DataAwsIamRole1$outboundSchema: z.ZodType<
  DataAwsIamRole1$Outbound,
  DataAwsIamRole1
> = z.object({
  assumeRolePolicyPresent: z.boolean(),
  attachedPolicyCount: z.int(),
  attachedPolicyNames: z.array(z.string()),
  createDate: z.string(),
  description: z.nullable(z.string()).optional(),
  inlinePolicyCount: z.int(),
  inlinePolicyNames: z.array(z.string()),
  lastUsedDate: z.nullable(z.string()).optional(),
  lastUsedRegion: z.nullable(z.string()).optional(),
  managedTagCount: z.int(),
  maxSessionDuration: z.nullable(z.int()).optional(),
  path: z.string(),
  permissionsBoundaryArn: z.nullable(z.string()).optional(),
  permissionsBoundaryType: z.nullable(z.string()).optional(),
  roleArn: z.string(),
  roleId: z.string(),
  roleName: z.string(),
  stackPermissionsApplied: z.boolean(),
  status: z.lazy(() => SyncReconcileRequestStatus42$outboundSchema),
  tagCount: z.int(),
  backend: z.literal("awsIamRole"),
});

export function dataAwsIamRole1ToJSON(
  dataAwsIamRole1: DataAwsIamRole1,
): string {
  return JSON.stringify(DataAwsIamRole1$outboundSchema.parse(dataAwsIamRole1));
}

/** @internal */
export type SyncReconcileRequestDataUnion10$Outbound =
  | DataAwsIamRole1$Outbound
  | DataGcpServiceAccount1$Outbound
  | DataAzureManagedIdentity1$Outbound
  | DataLocal10$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion10$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion10$Outbound,
  SyncReconcileRequestDataUnion10
> = z.union([
  z.lazy(() => DataAwsIamRole1$outboundSchema),
  z.lazy(() => DataGcpServiceAccount1$outboundSchema),
  z.lazy(() => DataAzureManagedIdentity1$outboundSchema),
  z.lazy(() => DataLocal10$outboundSchema),
]);

export function syncReconcileRequestDataUnion10ToJSON(
  syncReconcileRequestDataUnion10: SyncReconcileRequestDataUnion10,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion10$outboundSchema.parse(
      syncReconcileRequestDataUnion10,
    ),
  );
}

/** @internal */
export type DataServiceAccount$Outbound = {
  data:
    | DataAwsIamRole1$Outbound
    | DataGcpServiceAccount1$Outbound
    | DataAzureManagedIdentity1$Outbound
    | DataLocal10$Outbound;
  resourceType: "service-account";
};

/** @internal */
export const DataServiceAccount$outboundSchema: z.ZodType<
  DataServiceAccount$Outbound,
  DataServiceAccount
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsIamRole1$outboundSchema),
    z.lazy(() => DataGcpServiceAccount1$outboundSchema),
    z.lazy(() => DataAzureManagedIdentity1$outboundSchema),
    z.lazy(() => DataLocal10$outboundSchema),
  ]),
  resourceType: z.literal("service-account"),
});

export function dataServiceAccountToJSON(
  dataServiceAccount: DataServiceAccount,
): string {
  return JSON.stringify(
    DataServiceAccount$outboundSchema.parse(dataServiceAccount),
  );
}

/** @internal */
export const SyncReconcileRequestReason41$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason41
> = z.enum(SyncReconcileRequestReason41);

/** @internal */
export const StatusSeverity41$outboundSchema: z.ZodEnum<
  typeof StatusSeverity41
> = z.enum(StatusSeverity41);

/** @internal */
export type SyncReconcileRequestCollectionIssue41$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue41$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue41$Outbound,
  SyncReconcileRequestCollectionIssue41
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason41$outboundSchema,
  severity: StatusSeverity41$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue41ToJSON(
  syncReconcileRequestCollectionIssue41: SyncReconcileRequestCollectionIssue41,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue41$outboundSchema.parse(
      syncReconcileRequestCollectionIssue41,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth41$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth41
> = z.enum(SyncReconcileRequestHealth41);

/** @internal */
export const SyncReconcileRequestLifecycle41$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle41
> = z.enum(SyncReconcileRequestLifecycle41);

/** @internal */
export type SyncReconcileRequestStatus41$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue41$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus41$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus41$Outbound,
  SyncReconcileRequestStatus41
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue41$outboundSchema),
  ),
  health: SyncReconcileRequestHealth41$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle41$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus41ToJSON(
  syncReconcileRequestStatus41: SyncReconcileRequestStatus41,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus41$outboundSchema.parse(
      syncReconcileRequestStatus41,
    ),
  );
}

/** @internal */
export type DataLocal9$Outbound = {
  isDirectory?: boolean | null | undefined;
  modifiedAt?: string | null | undefined;
  path: string;
  pathExists: boolean;
  readonly?: boolean | null | undefined;
  secretMetadataListed: boolean;
  status: SyncReconcileRequestStatus41$Outbound;
  backend: "local";
};

/** @internal */
export const DataLocal9$outboundSchema: z.ZodType<
  DataLocal9$Outbound,
  DataLocal9
> = z.object({
  isDirectory: z.nullable(z.boolean()).optional(),
  modifiedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  path: z.string(),
  pathExists: z.boolean(),
  readonly: z.nullable(z.boolean()).optional(),
  secretMetadataListed: z.boolean(),
  status: z.lazy(() => SyncReconcileRequestStatus41$outboundSchema),
  backend: z.literal("local"),
});

export function dataLocal9ToJSON(dataLocal9: DataLocal9): string {
  return JSON.stringify(DataLocal9$outboundSchema.parse(dataLocal9));
}

/** @internal */
export const SyncReconcileRequestReason40$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason40
> = z.enum(SyncReconcileRequestReason40);

/** @internal */
export const StatusSeverity40$outboundSchema: z.ZodEnum<
  typeof StatusSeverity40
> = z.enum(StatusSeverity40);

/** @internal */
export type SyncReconcileRequestCollectionIssue40$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue40$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue40$Outbound,
  SyncReconcileRequestCollectionIssue40
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason40$outboundSchema,
  severity: StatusSeverity40$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue40ToJSON(
  syncReconcileRequestCollectionIssue40: SyncReconcileRequestCollectionIssue40,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue40$outboundSchema.parse(
      syncReconcileRequestCollectionIssue40,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth40$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth40
> = z.enum(SyncReconcileRequestHealth40);

/** @internal */
export const SyncReconcileRequestLifecycle40$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle40
> = z.enum(SyncReconcileRequestLifecycle40);

/** @internal */
export type SyncReconcileRequestStatus40$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue40$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus40$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus40$Outbound,
  SyncReconcileRequestStatus40
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue40$outboundSchema),
  ),
  health: SyncReconcileRequestHealth40$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle40$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus40ToJSON(
  syncReconcileRequestStatus40: SyncReconcileRequestStatus40,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus40$outboundSchema.parse(
      syncReconcileRequestStatus40,
    ),
  );
}

/** @internal */
export type DataKubernetesSecret$Outbound = {
  namespace: string;
  prefix: string;
  secretMetadataListed: boolean;
  status: SyncReconcileRequestStatus40$Outbound;
  backend: "kubernetesSecret";
};

/** @internal */
export const DataKubernetesSecret$outboundSchema: z.ZodType<
  DataKubernetesSecret$Outbound,
  DataKubernetesSecret
> = z.object({
  namespace: z.string(),
  prefix: z.string(),
  secretMetadataListed: z.boolean(),
  status: z.lazy(() => SyncReconcileRequestStatus40$outboundSchema),
  backend: z.literal("kubernetesSecret"),
});

export function dataKubernetesSecretToJSON(
  dataKubernetesSecret: DataKubernetesSecret,
): string {
  return JSON.stringify(
    DataKubernetesSecret$outboundSchema.parse(dataKubernetesSecret),
  );
}

/** @internal */
export const SyncReconcileRequestReason39$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason39
> = z.enum(SyncReconcileRequestReason39);

/** @internal */
export const StatusSeverity39$outboundSchema: z.ZodEnum<
  typeof StatusSeverity39
> = z.enum(StatusSeverity39);

/** @internal */
export type SyncReconcileRequestCollectionIssue39$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue39$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue39$Outbound,
  SyncReconcileRequestCollectionIssue39
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason39$outboundSchema,
  severity: StatusSeverity39$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue39ToJSON(
  syncReconcileRequestCollectionIssue39: SyncReconcileRequestCollectionIssue39,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue39$outboundSchema.parse(
      syncReconcileRequestCollectionIssue39,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth39$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth39
> = z.enum(SyncReconcileRequestHealth39);

/** @internal */
export const SyncReconcileRequestLifecycle39$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle39
> = z.enum(SyncReconcileRequestLifecycle39);

/** @internal */
export type SyncReconcileRequestStatus39$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue39$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus39$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus39$Outbound,
  SyncReconcileRequestStatus39
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue39$outboundSchema),
  ),
  health: SyncReconcileRequestHealth39$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle39$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus39ToJSON(
  syncReconcileRequestStatus39: SyncReconcileRequestStatus39,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus39$outboundSchema.parse(
      syncReconcileRequestStatus39,
    ),
  );
}

/** @internal */
export type DataAzureKeyVault1$Outbound = {
  accessPolicyCount: number;
  location?: string | null | undefined;
  name: string;
  privateEndpointConnectionCount: number;
  provisioningState?: string | null | undefined;
  publicNetworkAccess: string;
  purgeProtectionEnabled?: boolean | null | undefined;
  rbacAuthorizationEnabled: boolean;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  secretMetadataListed: boolean;
  skuFamily?: string | null | undefined;
  skuName?: string | null | undefined;
  softDeleteEnabled: boolean;
  softDeleteRetentionDays: number;
  status: SyncReconcileRequestStatus39$Outbound;
  vaultUri?: string | null | undefined;
  backend: "azureKeyVault";
};

/** @internal */
export const DataAzureKeyVault1$outboundSchema: z.ZodType<
  DataAzureKeyVault1$Outbound,
  DataAzureKeyVault1
> = z.object({
  accessPolicyCount: z.int(),
  location: z.nullable(z.string()).optional(),
  name: z.string(),
  privateEndpointConnectionCount: z.int(),
  provisioningState: z.nullable(z.string()).optional(),
  publicNetworkAccess: z.string(),
  purgeProtectionEnabled: z.nullable(z.boolean()).optional(),
  rbacAuthorizationEnabled: z.boolean(),
  resourceGroup: z.nullable(z.string()).optional(),
  resourceId: z.nullable(z.string()).optional(),
  secretMetadataListed: z.boolean(),
  skuFamily: z.nullable(z.string()).optional(),
  skuName: z.nullable(z.string()).optional(),
  softDeleteEnabled: z.boolean(),
  softDeleteRetentionDays: z.int(),
  status: z.lazy(() => SyncReconcileRequestStatus39$outboundSchema),
  vaultUri: z.nullable(z.string()).optional(),
  backend: z.literal("azureKeyVault"),
});

export function dataAzureKeyVault1ToJSON(
  dataAzureKeyVault1: DataAzureKeyVault1,
): string {
  return JSON.stringify(
    DataAzureKeyVault1$outboundSchema.parse(dataAzureKeyVault1),
  );
}

/** @internal */
export const SyncReconcileRequestReason38$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason38
> = z.enum(SyncReconcileRequestReason38);

/** @internal */
export const StatusSeverity38$outboundSchema: z.ZodEnum<
  typeof StatusSeverity38
> = z.enum(StatusSeverity38);

/** @internal */
export type SyncReconcileRequestCollectionIssue38$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue38$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue38$Outbound,
  SyncReconcileRequestCollectionIssue38
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason38$outboundSchema,
  severity: StatusSeverity38$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue38ToJSON(
  syncReconcileRequestCollectionIssue38: SyncReconcileRequestCollectionIssue38,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue38$outboundSchema.parse(
      syncReconcileRequestCollectionIssue38,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth38$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth38
> = z.enum(SyncReconcileRequestHealth38);

/** @internal */
export const SyncReconcileRequestLifecycle38$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle38
> = z.enum(SyncReconcileRequestLifecycle38);

/** @internal */
export type SyncReconcileRequestStatus38$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue38$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus38$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus38$Outbound,
  SyncReconcileRequestStatus38
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue38$outboundSchema),
  ),
  health: SyncReconcileRequestHealth38$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle38$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus38ToJSON(
  syncReconcileRequestStatus38: SyncReconcileRequestStatus38,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus38$outboundSchema.parse(
      syncReconcileRequestStatus38,
    ),
  );
}

/** @internal */
export type DataGcpSecretManager$Outbound = {
  location: string;
  prefix: string;
  projectId: string;
  secretMetadataListed: boolean;
  status: SyncReconcileRequestStatus38$Outbound;
  backend: "gcpSecretManager";
};

/** @internal */
export const DataGcpSecretManager$outboundSchema: z.ZodType<
  DataGcpSecretManager$Outbound,
  DataGcpSecretManager
> = z.object({
  location: z.string(),
  prefix: z.string(),
  projectId: z.string(),
  secretMetadataListed: z.boolean(),
  status: z.lazy(() => SyncReconcileRequestStatus38$outboundSchema),
  backend: z.literal("gcpSecretManager"),
});

export function dataGcpSecretManagerToJSON(
  dataGcpSecretManager: DataGcpSecretManager,
): string {
  return JSON.stringify(
    DataGcpSecretManager$outboundSchema.parse(dataGcpSecretManager),
  );
}

/** @internal */
export const SyncReconcileRequestReason37$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason37
> = z.enum(SyncReconcileRequestReason37);

/** @internal */
export const StatusSeverity37$outboundSchema: z.ZodEnum<
  typeof StatusSeverity37
> = z.enum(StatusSeverity37);

/** @internal */
export type SyncReconcileRequestCollectionIssue37$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue37$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue37$Outbound,
  SyncReconcileRequestCollectionIssue37
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason37$outboundSchema,
  severity: StatusSeverity37$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue37ToJSON(
  syncReconcileRequestCollectionIssue37: SyncReconcileRequestCollectionIssue37,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue37$outboundSchema.parse(
      syncReconcileRequestCollectionIssue37,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth37$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth37
> = z.enum(SyncReconcileRequestHealth37);

/** @internal */
export const SyncReconcileRequestLifecycle37$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle37
> = z.enum(SyncReconcileRequestLifecycle37);

/** @internal */
export type SyncReconcileRequestStatus37$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue37$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus37$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus37$Outbound,
  SyncReconcileRequestStatus37
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue37$outboundSchema),
  ),
  health: SyncReconcileRequestHealth37$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle37$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus37ToJSON(
  syncReconcileRequestStatus37: SyncReconcileRequestStatus37,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus37$outboundSchema.parse(
      syncReconcileRequestStatus37,
    ),
  );
}

/** @internal */
export type DataAwsParameterStore$Outbound = {
  accountId: string;
  hasMoreParameters?: boolean | null | undefined;
  latestModifiedAt?: string | null | undefined;
  parameterMetadataSampled: boolean;
  prefix: string;
  region: string;
  sampledAdvancedTierCount?: number | null | undefined;
  sampledKmsKeyMetadataPresentCount?: number | null | undefined;
  sampledParameterCount?: number | null | undefined;
  sampledSecureStringCount?: number | null | undefined;
  sampledStringCount?: number | null | undefined;
  sampledStringListCount?: number | null | undefined;
  status: SyncReconcileRequestStatus37$Outbound;
  backend: "awsParameterStore";
};

/** @internal */
export const DataAwsParameterStore$outboundSchema: z.ZodType<
  DataAwsParameterStore$Outbound,
  DataAwsParameterStore
> = z.object({
  accountId: z.string(),
  hasMoreParameters: z.nullable(z.boolean()).optional(),
  latestModifiedAt: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  parameterMetadataSampled: z.boolean(),
  prefix: z.string(),
  region: z.string(),
  sampledAdvancedTierCount: z.nullable(z.int()).optional(),
  sampledKmsKeyMetadataPresentCount: z.nullable(z.int()).optional(),
  sampledParameterCount: z.nullable(z.int()).optional(),
  sampledSecureStringCount: z.nullable(z.int()).optional(),
  sampledStringCount: z.nullable(z.int()).optional(),
  sampledStringListCount: z.nullable(z.int()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus37$outboundSchema),
  backend: z.literal("awsParameterStore"),
});

export function dataAwsParameterStoreToJSON(
  dataAwsParameterStore: DataAwsParameterStore,
): string {
  return JSON.stringify(
    DataAwsParameterStore$outboundSchema.parse(dataAwsParameterStore),
  );
}

/** @internal */
export type SyncReconcileRequestDataUnion9$Outbound =
  | DataAwsParameterStore$Outbound
  | DataGcpSecretManager$Outbound
  | DataAzureKeyVault1$Outbound
  | DataKubernetesSecret$Outbound
  | DataLocal9$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion9$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion9$Outbound,
  SyncReconcileRequestDataUnion9
> = z.union([
  z.lazy(() => DataAwsParameterStore$outboundSchema),
  z.lazy(() => DataGcpSecretManager$outboundSchema),
  z.lazy(() => DataAzureKeyVault1$outboundSchema),
  z.lazy(() => DataKubernetesSecret$outboundSchema),
  z.lazy(() => DataLocal9$outboundSchema),
]);

export function syncReconcileRequestDataUnion9ToJSON(
  syncReconcileRequestDataUnion9: SyncReconcileRequestDataUnion9,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion9$outboundSchema.parse(
      syncReconcileRequestDataUnion9,
    ),
  );
}

/** @internal */
export type DataVault$Outbound = {
  data:
    | DataAwsParameterStore$Outbound
    | DataGcpSecretManager$Outbound
    | DataAzureKeyVault1$Outbound
    | DataKubernetesSecret$Outbound
    | DataLocal9$Outbound;
  resourceType: "vault";
};

/** @internal */
export const DataVault$outboundSchema: z.ZodType<
  DataVault$Outbound,
  DataVault
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsParameterStore$outboundSchema),
    z.lazy(() => DataGcpSecretManager$outboundSchema),
    z.lazy(() => DataAzureKeyVault1$outboundSchema),
    z.lazy(() => DataKubernetesSecret$outboundSchema),
    z.lazy(() => DataLocal9$outboundSchema),
  ]),
  resourceType: z.literal("vault"),
});

export function dataVaultToJSON(dataVault: DataVault): string {
  return JSON.stringify(DataVault$outboundSchema.parse(dataVault));
}

/** @internal */
export const SyncReconcileRequestReason36$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason36
> = z.enum(SyncReconcileRequestReason36);

/** @internal */
export const StatusSeverity36$outboundSchema: z.ZodEnum<
  typeof StatusSeverity36
> = z.enum(StatusSeverity36);

/** @internal */
export type SyncReconcileRequestCollectionIssue36$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue36$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue36$Outbound,
  SyncReconcileRequestCollectionIssue36
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason36$outboundSchema,
  severity: StatusSeverity36$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue36ToJSON(
  syncReconcileRequestCollectionIssue36: SyncReconcileRequestCollectionIssue36,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue36$outboundSchema.parse(
      syncReconcileRequestCollectionIssue36,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth36$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth36
> = z.enum(SyncReconcileRequestHealth36);

/** @internal */
export const SyncReconcileRequestLifecycle36$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle36
> = z.enum(SyncReconcileRequestLifecycle36);

/** @internal */
export type SyncReconcileRequestStatus36$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue36$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus36$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus36$Outbound,
  SyncReconcileRequestStatus36
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue36$outboundSchema),
  ),
  health: SyncReconcileRequestHealth36$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle36$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus36ToJSON(
  syncReconcileRequestStatus36: SyncReconcileRequestStatus36,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus36$outboundSchema.parse(
      syncReconcileRequestStatus36,
    ),
  );
}

/** @internal */
export type DataLocal8$Outbound = {
  name: string;
  port?: number | null | undefined;
  processRunning: boolean;
  status: SyncReconcileRequestStatus36$Outbound;
  version: string;
  backend: "local";
};

/** @internal */
export const DataLocal8$outboundSchema: z.ZodType<
  DataLocal8$Outbound,
  DataLocal8
> = z.object({
  name: z.string(),
  port: z.nullable(z.int()).optional(),
  processRunning: z.boolean(),
  status: z.lazy(() => SyncReconcileRequestStatus36$outboundSchema),
  version: z.string(),
  backend: z.literal("local"),
});

export function dataLocal8ToJSON(dataLocal8: DataLocal8): string {
  return JSON.stringify(DataLocal8$outboundSchema.parse(dataLocal8));
}

/** @internal */
export const SyncReconcileRequestReason35$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason35
> = z.enum(SyncReconcileRequestReason35);

/** @internal */
export const StatusSeverity35$outboundSchema: z.ZodEnum<
  typeof StatusSeverity35
> = z.enum(StatusSeverity35);

/** @internal */
export type SyncReconcileRequestCollectionIssue35$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue35$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue35$Outbound,
  SyncReconcileRequestCollectionIssue35
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason35$outboundSchema,
  severity: StatusSeverity35$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue35ToJSON(
  syncReconcileRequestCollectionIssue35: SyncReconcileRequestCollectionIssue35,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue35$outboundSchema.parse(
      syncReconcileRequestCollectionIssue35,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth35$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth35
> = z.enum(SyncReconcileRequestHealth35);

/** @internal */
export const SyncReconcileRequestLifecycle35$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle35
> = z.enum(SyncReconcileRequestLifecycle35);

/** @internal */
export type SyncReconcileRequestStatus35$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue35$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus35$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus35$Outbound,
  SyncReconcileRequestStatus35
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue35$outboundSchema),
  ),
  health: SyncReconcileRequestHealth35$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle35$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus35ToJSON(
  syncReconcileRequestStatus35: SyncReconcileRequestStatus35,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus35$outboundSchema.parse(
      syncReconcileRequestStatus35,
    ),
  );
}

/** @internal */
export type DataFlexibleServer$Outbound = {
  serverName: string;
  state?: string | null | undefined;
  status: SyncReconcileRequestStatus35$Outbound;
  version?: string | null | undefined;
  backend: "flexibleServer";
};

/** @internal */
export const DataFlexibleServer$outboundSchema: z.ZodType<
  DataFlexibleServer$Outbound,
  DataFlexibleServer
> = z.object({
  serverName: z.string(),
  state: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus35$outboundSchema),
  version: z.nullable(z.string()).optional(),
  backend: z.literal("flexibleServer"),
});

export function dataFlexibleServerToJSON(
  dataFlexibleServer: DataFlexibleServer,
): string {
  return JSON.stringify(
    DataFlexibleServer$outboundSchema.parse(dataFlexibleServer),
  );
}

/** @internal */
export const SyncReconcileRequestReason34$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason34
> = z.enum(SyncReconcileRequestReason34);

/** @internal */
export const StatusSeverity34$outboundSchema: z.ZodEnum<
  typeof StatusSeverity34
> = z.enum(StatusSeverity34);

/** @internal */
export type SyncReconcileRequestCollectionIssue34$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue34$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue34$Outbound,
  SyncReconcileRequestCollectionIssue34
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason34$outboundSchema,
  severity: StatusSeverity34$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue34ToJSON(
  syncReconcileRequestCollectionIssue34: SyncReconcileRequestCollectionIssue34,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue34$outboundSchema.parse(
      syncReconcileRequestCollectionIssue34,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth34$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth34
> = z.enum(SyncReconcileRequestHealth34);

/** @internal */
export const SyncReconcileRequestLifecycle34$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle34
> = z.enum(SyncReconcileRequestLifecycle34);

/** @internal */
export type SyncReconcileRequestStatus34$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue34$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus34$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus34$Outbound,
  SyncReconcileRequestStatus34
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue34$outboundSchema),
  ),
  health: SyncReconcileRequestHealth34$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle34$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus34ToJSON(
  syncReconcileRequestStatus34: SyncReconcileRequestStatus34,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus34$outboundSchema.parse(
      syncReconcileRequestStatus34,
    ),
  );
}

/** @internal */
export type DataCloudSQL$Outbound = {
  databaseVersion?: string | null | undefined;
  instanceName: string;
  state?: string | null | undefined;
  status: SyncReconcileRequestStatus34$Outbound;
  backend: "cloudSql";
};

/** @internal */
export const DataCloudSQL$outboundSchema: z.ZodType<
  DataCloudSQL$Outbound,
  DataCloudSQL
> = z.object({
  databaseVersion: z.nullable(z.string()).optional(),
  instanceName: z.string(),
  state: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus34$outboundSchema),
  backend: z.literal("cloudSql"),
});

export function dataCloudSQLToJSON(dataCloudSQL: DataCloudSQL): string {
  return JSON.stringify(DataCloudSQL$outboundSchema.parse(dataCloudSQL));
}

/** @internal */
export const SyncReconcileRequestReason33$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason33
> = z.enum(SyncReconcileRequestReason33);

/** @internal */
export const StatusSeverity33$outboundSchema: z.ZodEnum<
  typeof StatusSeverity33
> = z.enum(StatusSeverity33);

/** @internal */
export type SyncReconcileRequestCollectionIssue33$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue33$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue33$Outbound,
  SyncReconcileRequestCollectionIssue33
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason33$outboundSchema,
  severity: StatusSeverity33$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue33ToJSON(
  syncReconcileRequestCollectionIssue33: SyncReconcileRequestCollectionIssue33,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue33$outboundSchema.parse(
      syncReconcileRequestCollectionIssue33,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth33$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth33
> = z.enum(SyncReconcileRequestHealth33);

/** @internal */
export const SyncReconcileRequestLifecycle33$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle33
> = z.enum(SyncReconcileRequestLifecycle33);

/** @internal */
export type SyncReconcileRequestStatus33$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue33$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus33$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus33$Outbound,
  SyncReconcileRequestStatus33
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue33$outboundSchema),
  ),
  health: SyncReconcileRequestHealth33$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle33$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus33ToJSON(
  syncReconcileRequestStatus33: SyncReconcileRequestStatus33,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus33$outboundSchema.parse(
      syncReconcileRequestStatus33,
    ),
  );
}

/** @internal */
export type DataAurora$Outbound = {
  clusterIdentifier: string;
  endpoint?: string | null | undefined;
  engineVersion?: string | null | undefined;
  neverPauses: boolean;
  serverlessCapacity?: number | null | undefined;
  status: SyncReconcileRequestStatus33$Outbound;
  backend: "aurora";
};

/** @internal */
export const DataAurora$outboundSchema: z.ZodType<
  DataAurora$Outbound,
  DataAurora
> = z.object({
  clusterIdentifier: z.string(),
  endpoint: z.nullable(z.string()).optional(),
  engineVersion: z.nullable(z.string()).optional(),
  neverPauses: z.boolean(),
  serverlessCapacity: z.nullable(z.number()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus33$outboundSchema),
  backend: z.literal("aurora"),
});

export function dataAuroraToJSON(dataAurora: DataAurora): string {
  return JSON.stringify(DataAurora$outboundSchema.parse(dataAurora));
}

/** @internal */
export type SyncReconcileRequestDataUnion8$Outbound =
  | DataAurora$Outbound
  | DataCloudSQL$Outbound
  | DataFlexibleServer$Outbound
  | DataLocal8$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion8$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion8$Outbound,
  SyncReconcileRequestDataUnion8
> = z.union([
  z.lazy(() => DataAurora$outboundSchema),
  z.lazy(() => DataCloudSQL$outboundSchema),
  z.lazy(() => DataFlexibleServer$outboundSchema),
  z.lazy(() => DataLocal8$outboundSchema),
]);

export function syncReconcileRequestDataUnion8ToJSON(
  syncReconcileRequestDataUnion8: SyncReconcileRequestDataUnion8,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion8$outboundSchema.parse(
      syncReconcileRequestDataUnion8,
    ),
  );
}

/** @internal */
export type DataPostgres$Outbound = {
  data:
    | DataAurora$Outbound
    | DataCloudSQL$Outbound
    | DataFlexibleServer$Outbound
    | DataLocal8$Outbound;
  resourceType: "postgres";
};

/** @internal */
export const DataPostgres$outboundSchema: z.ZodType<
  DataPostgres$Outbound,
  DataPostgres
> = z.object({
  data: z.union([
    z.lazy(() => DataAurora$outboundSchema),
    z.lazy(() => DataCloudSQL$outboundSchema),
    z.lazy(() => DataFlexibleServer$outboundSchema),
    z.lazy(() => DataLocal8$outboundSchema),
  ]),
  resourceType: z.literal("postgres"),
});

export function dataPostgresToJSON(dataPostgres: DataPostgres): string {
  return JSON.stringify(DataPostgres$outboundSchema.parse(dataPostgres));
}

/** @internal */
export const SyncReconcileRequestReason32$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason32
> = z.enum(SyncReconcileRequestReason32);

/** @internal */
export const StatusSeverity32$outboundSchema: z.ZodEnum<
  typeof StatusSeverity32
> = z.enum(StatusSeverity32);

/** @internal */
export type SyncReconcileRequestCollectionIssue32$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue32$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue32$Outbound,
  SyncReconcileRequestCollectionIssue32
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason32$outboundSchema,
  severity: StatusSeverity32$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue32ToJSON(
  syncReconcileRequestCollectionIssue32: SyncReconcileRequestCollectionIssue32,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue32$outboundSchema.parse(
      syncReconcileRequestCollectionIssue32,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth32$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth32
> = z.enum(SyncReconcileRequestHealth32);

/** @internal */
export const SyncReconcileRequestLifecycle32$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle32
> = z.enum(SyncReconcileRequestLifecycle32);

/** @internal */
export type SyncReconcileRequestStatus32$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue32$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus32$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus32$Outbound,
  SyncReconcileRequestStatus32
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue32$outboundSchema),
  ),
  health: SyncReconcileRequestHealth32$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle32$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus32ToJSON(
  syncReconcileRequestStatus32: SyncReconcileRequestStatus32,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus32$outboundSchema.parse(
      syncReconcileRequestStatus32,
    ),
  );
}

/** @internal */
export type DataLocal7$Outbound = {
  cloudMetadataSupported: boolean;
  isDirectory?: boolean | null | undefined;
  name: string;
  path: string;
  pathExists: boolean;
  status: SyncReconcileRequestStatus32$Outbound;
  backend: "local";
};

/** @internal */
export const DataLocal7$outboundSchema: z.ZodType<
  DataLocal7$Outbound,
  DataLocal7
> = z.object({
  cloudMetadataSupported: z.boolean(),
  isDirectory: z.nullable(z.boolean()).optional(),
  name: z.string(),
  path: z.string(),
  pathExists: z.boolean(),
  status: z.lazy(() => SyncReconcileRequestStatus32$outboundSchema),
  backend: z.literal("local"),
});

export function dataLocal7ToJSON(dataLocal7: DataLocal7): string {
  return JSON.stringify(DataLocal7$outboundSchema.parse(dataLocal7));
}

/** @internal */
export const SyncReconcileRequestReason31$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason31
> = z.enum(SyncReconcileRequestReason31);

/** @internal */
export const StatusSeverity31$outboundSchema: z.ZodEnum<
  typeof StatusSeverity31
> = z.enum(StatusSeverity31);

/** @internal */
export type SyncReconcileRequestCollectionIssue31$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue31$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue31$Outbound,
  SyncReconcileRequestCollectionIssue31
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason31$outboundSchema,
  severity: StatusSeverity31$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue31ToJSON(
  syncReconcileRequestCollectionIssue31: SyncReconcileRequestCollectionIssue31,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue31$outboundSchema.parse(
      syncReconcileRequestCollectionIssue31,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth31$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth31
> = z.enum(SyncReconcileRequestHealth31);

/** @internal */
export const SyncReconcileRequestLifecycle31$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle31
> = z.enum(SyncReconcileRequestLifecycle31);

/** @internal */
export type SyncReconcileRequestStatus31$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue31$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus31$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus31$Outbound,
  SyncReconcileRequestStatus31
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue31$outboundSchema),
  ),
  health: SyncReconcileRequestHealth31$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle31$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus31ToJSON(
  syncReconcileRequestStatus31: SyncReconcileRequestStatus31,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus31$outboundSchema.parse(
      syncReconcileRequestStatus31,
    ),
  );
}

/** @internal */
export type DataAzureTable$Outbound = {
  endpoint?: string | null | undefined;
  resourceGroup?: string | null | undefined;
  signedIdentifierCount?: number | null | undefined;
  status: SyncReconcileRequestStatus31$Outbound;
  storageAccountKind?: string | null | undefined;
  storageAccountLocation?: string | null | undefined;
  storageAccountName: string;
  storageAccountPrimaryStatus?: string | null | undefined;
  storageAccountProvisioningState?: string | null | undefined;
  storageAccountResourceId?: string | null | undefined;
  tableExists: boolean;
  tableName: string;
  backend: "azureTable";
};

/** @internal */
export const DataAzureTable$outboundSchema: z.ZodType<
  DataAzureTable$Outbound,
  DataAzureTable
> = z.object({
  endpoint: z.nullable(z.string()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  signedIdentifierCount: z.nullable(z.int()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus31$outboundSchema),
  storageAccountKind: z.nullable(z.string()).optional(),
  storageAccountLocation: z.nullable(z.string()).optional(),
  storageAccountName: z.string(),
  storageAccountPrimaryStatus: z.nullable(z.string()).optional(),
  storageAccountProvisioningState: z.nullable(z.string()).optional(),
  storageAccountResourceId: z.nullable(z.string()).optional(),
  tableExists: z.boolean(),
  tableName: z.string(),
  backend: z.literal("azureTable"),
});

export function dataAzureTableToJSON(dataAzureTable: DataAzureTable): string {
  return JSON.stringify(DataAzureTable$outboundSchema.parse(dataAzureTable));
}

/** @internal */
export const SyncReconcileRequestReason30$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason30
> = z.enum(SyncReconcileRequestReason30);

/** @internal */
export const StatusSeverity30$outboundSchema: z.ZodEnum<
  typeof StatusSeverity30
> = z.enum(StatusSeverity30);

/** @internal */
export type SyncReconcileRequestCollectionIssue30$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue30$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue30$Outbound,
  SyncReconcileRequestCollectionIssue30
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason30$outboundSchema,
  severity: StatusSeverity30$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue30ToJSON(
  syncReconcileRequestCollectionIssue30: SyncReconcileRequestCollectionIssue30,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue30$outboundSchema.parse(
      syncReconcileRequestCollectionIssue30,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth30$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth30
> = z.enum(SyncReconcileRequestHealth30);

/** @internal */
export const SyncReconcileRequestLifecycle30$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle30
> = z.enum(SyncReconcileRequestLifecycle30);

/** @internal */
export type SyncReconcileRequestStatus30$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue30$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus30$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus30$Outbound,
  SyncReconcileRequestStatus30
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue30$outboundSchema),
  ),
  health: SyncReconcileRequestHealth30$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle30$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus30ToJSON(
  syncReconcileRequestStatus30: SyncReconcileRequestStatus30,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus30$outboundSchema.parse(
      syncReconcileRequestStatus30,
    ),
  );
}

/** @internal */
export type DataGcpFirestore$Outbound = {
  appEngineIntegrationMode?: string | null | undefined;
  cmekEnabled: boolean;
  concurrencyMode?: string | null | undefined;
  createTime?: string | null | undefined;
  databaseEdition?: string | null | undefined;
  databaseName: string;
  databaseType?: string | null | undefined;
  deleteProtectionState?: string | null | undefined;
  deleteTime?: string | null | undefined;
  earliestVersionTime?: string | null | undefined;
  endpoint?: string | null | undefined;
  locationId?: string | null | undefined;
  pointInTimeRecoveryEnablement?: string | null | undefined;
  projectId?: string | null | undefined;
  sourceInfoPresent: boolean;
  status: SyncReconcileRequestStatus30$Outbound;
  updateTime?: string | null | undefined;
  versionRetentionPeriod?: string | null | undefined;
  backend: "gcpFirestore";
};

/** @internal */
export const DataGcpFirestore$outboundSchema: z.ZodType<
  DataGcpFirestore$Outbound,
  DataGcpFirestore
> = z.object({
  appEngineIntegrationMode: z.nullable(z.string()).optional(),
  cmekEnabled: z.boolean(),
  concurrencyMode: z.nullable(z.string()).optional(),
  createTime: z.nullable(z.string()).optional(),
  databaseEdition: z.nullable(z.string()).optional(),
  databaseName: z.string(),
  databaseType: z.nullable(z.string()).optional(),
  deleteProtectionState: z.nullable(z.string()).optional(),
  deleteTime: z.nullable(z.string()).optional(),
  earliestVersionTime: z.nullable(z.string()).optional(),
  endpoint: z.nullable(z.string()).optional(),
  locationId: z.nullable(z.string()).optional(),
  pointInTimeRecoveryEnablement: z.nullable(z.string()).optional(),
  projectId: z.nullable(z.string()).optional(),
  sourceInfoPresent: z.boolean(),
  status: z.lazy(() => SyncReconcileRequestStatus30$outboundSchema),
  updateTime: z.nullable(z.string()).optional(),
  versionRetentionPeriod: z.nullable(z.string()).optional(),
  backend: z.literal("gcpFirestore"),
});

export function dataGcpFirestoreToJSON(
  dataGcpFirestore: DataGcpFirestore,
): string {
  return JSON.stringify(
    DataGcpFirestore$outboundSchema.parse(dataGcpFirestore),
  );
}

/** @internal */
export type KeySchema$Outbound = {
  attributeName: string;
  keyType: string;
};

/** @internal */
export const KeySchema$outboundSchema: z.ZodType<
  KeySchema$Outbound,
  KeySchema
> = z.object({
  attributeName: z.string(),
  keyType: z.string(),
});

export function keySchemaToJSON(keySchema: KeySchema): string {
  return JSON.stringify(KeySchema$outboundSchema.parse(keySchema));
}

/** @internal */
export const SyncReconcileRequestReason29$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason29
> = z.enum(SyncReconcileRequestReason29);

/** @internal */
export const StatusSeverity29$outboundSchema: z.ZodEnum<
  typeof StatusSeverity29
> = z.enum(StatusSeverity29);

/** @internal */
export type SyncReconcileRequestCollectionIssue29$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue29$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue29$Outbound,
  SyncReconcileRequestCollectionIssue29
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason29$outboundSchema,
  severity: StatusSeverity29$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue29ToJSON(
  syncReconcileRequestCollectionIssue29: SyncReconcileRequestCollectionIssue29,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue29$outboundSchema.parse(
      syncReconcileRequestCollectionIssue29,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth29$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth29
> = z.enum(SyncReconcileRequestHealth29);

/** @internal */
export const SyncReconcileRequestLifecycle29$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle29
> = z.enum(SyncReconcileRequestLifecycle29);

/** @internal */
export type SyncReconcileRequestStatus29$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue29$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus29$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus29$Outbound,
  SyncReconcileRequestStatus29
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue29$outboundSchema),
  ),
  health: SyncReconcileRequestHealth29$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle29$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus29ToJSON(
  syncReconcileRequestStatus29: SyncReconcileRequestStatus29,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus29$outboundSchema.parse(
      syncReconcileRequestStatus29,
    ),
  );
}

/** @internal */
export type DataAwsDynamoDb$Outbound = {
  billingMode?: string | null | undefined;
  deletionProtectionEnabled?: boolean | null | undefined;
  globalSecondaryIndexCount?: number | null | undefined;
  itemCount?: number | null | undefined;
  keySchema: Array<KeySchema$Outbound>;
  localSecondaryIndexCount?: number | null | undefined;
  name: string;
  region?: string | null | undefined;
  replicaCount?: number | null | undefined;
  restoreInProgress?: boolean | null | undefined;
  sseStatus?: string | null | undefined;
  sseType?: string | null | undefined;
  status: SyncReconcileRequestStatus29$Outbound;
  streamEnabled?: boolean | null | undefined;
  streamViewType?: string | null | undefined;
  tableArn?: string | null | undefined;
  tableClass?: string | null | undefined;
  tableSizeBytes?: number | null | undefined;
  tableStatus?: string | null | undefined;
  ttlAttributeName?: string | null | undefined;
  ttlStatus?: string | null | undefined;
  backend: "awsDynamoDb";
};

/** @internal */
export const DataAwsDynamoDb$outboundSchema: z.ZodType<
  DataAwsDynamoDb$Outbound,
  DataAwsDynamoDb
> = z.object({
  billingMode: z.nullable(z.string()).optional(),
  deletionProtectionEnabled: z.nullable(z.boolean()).optional(),
  globalSecondaryIndexCount: z.nullable(z.int()).optional(),
  itemCount: z.nullable(z.int()).optional(),
  keySchema: z.array(z.lazy(() => KeySchema$outboundSchema)),
  localSecondaryIndexCount: z.nullable(z.int()).optional(),
  name: z.string(),
  region: z.nullable(z.string()).optional(),
  replicaCount: z.nullable(z.int()).optional(),
  restoreInProgress: z.nullable(z.boolean()).optional(),
  sseStatus: z.nullable(z.string()).optional(),
  sseType: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus29$outboundSchema),
  streamEnabled: z.nullable(z.boolean()).optional(),
  streamViewType: z.nullable(z.string()).optional(),
  tableArn: z.nullable(z.string()).optional(),
  tableClass: z.nullable(z.string()).optional(),
  tableSizeBytes: z.nullable(z.int()).optional(),
  tableStatus: z.nullable(z.string()).optional(),
  ttlAttributeName: z.nullable(z.string()).optional(),
  ttlStatus: z.nullable(z.string()).optional(),
  backend: z.literal("awsDynamoDb"),
});

export function dataAwsDynamoDbToJSON(
  dataAwsDynamoDb: DataAwsDynamoDb,
): string {
  return JSON.stringify(DataAwsDynamoDb$outboundSchema.parse(dataAwsDynamoDb));
}

/** @internal */
export type SyncReconcileRequestDataUnion7$Outbound =
  | DataAwsDynamoDb$Outbound
  | DataGcpFirestore$Outbound
  | DataAzureTable$Outbound
  | DataLocal7$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion7$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion7$Outbound,
  SyncReconcileRequestDataUnion7
> = z.union([
  z.lazy(() => DataAwsDynamoDb$outboundSchema),
  z.lazy(() => DataGcpFirestore$outboundSchema),
  z.lazy(() => DataAzureTable$outboundSchema),
  z.lazy(() => DataLocal7$outboundSchema),
]);

export function syncReconcileRequestDataUnion7ToJSON(
  syncReconcileRequestDataUnion7: SyncReconcileRequestDataUnion7,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion7$outboundSchema.parse(
      syncReconcileRequestDataUnion7,
    ),
  );
}

/** @internal */
export type DataKv$Outbound = {
  data:
    | DataAwsDynamoDb$Outbound
    | DataGcpFirestore$Outbound
    | DataAzureTable$Outbound
    | DataLocal7$Outbound;
  resourceType: "kv";
};

/** @internal */
export const DataKv$outboundSchema: z.ZodType<DataKv$Outbound, DataKv> = z
  .object({
    data: z.union([
      z.lazy(() => DataAwsDynamoDb$outboundSchema),
      z.lazy(() => DataGcpFirestore$outboundSchema),
      z.lazy(() => DataAzureTable$outboundSchema),
      z.lazy(() => DataLocal7$outboundSchema),
    ]),
    resourceType: z.literal("kv"),
  });

export function dataKvToJSON(dataKv: DataKv): string {
  return JSON.stringify(DataKv$outboundSchema.parse(dataKv));
}

/** @internal */
export const SyncReconcileRequestReason28$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason28
> = z.enum(SyncReconcileRequestReason28);

/** @internal */
export const StatusSeverity28$outboundSchema: z.ZodEnum<
  typeof StatusSeverity28
> = z.enum(StatusSeverity28);

/** @internal */
export type SyncReconcileRequestCollectionIssue28$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue28$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue28$Outbound,
  SyncReconcileRequestCollectionIssue28
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason28$outboundSchema,
  severity: StatusSeverity28$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue28ToJSON(
  syncReconcileRequestCollectionIssue28: SyncReconcileRequestCollectionIssue28,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue28$outboundSchema.parse(
      syncReconcileRequestCollectionIssue28,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth28$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth28
> = z.enum(SyncReconcileRequestHealth28);

/** @internal */
export const SyncReconcileRequestLifecycle28$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle28
> = z.enum(SyncReconcileRequestLifecycle28);

/** @internal */
export type SyncReconcileRequestStatus28$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue28$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus28$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus28$Outbound,
  SyncReconcileRequestStatus28
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue28$outboundSchema),
  ),
  health: SyncReconcileRequestHealth28$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle28$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus28ToJSON(
  syncReconcileRequestStatus28: SyncReconcileRequestStatus28,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus28$outboundSchema.parse(
      syncReconcileRequestStatus28,
    ),
  );
}

/** @internal */
export type DataLocal6$Outbound = {
  name: string;
  path?: string | null | undefined;
  serviceStatus?: string | null | undefined;
  status: SyncReconcileRequestStatus28$Outbound;
  backend: "local";
};

/** @internal */
export const DataLocal6$outboundSchema: z.ZodType<
  DataLocal6$Outbound,
  DataLocal6
> = z.object({
  name: z.string(),
  path: z.nullable(z.string()).optional(),
  serviceStatus: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus28$outboundSchema),
  backend: z.literal("local"),
});

export function dataLocal6ToJSON(dataLocal6: DataLocal6): string {
  return JSON.stringify(DataLocal6$outboundSchema.parse(dataLocal6));
}

/** @internal */
export const SyncReconcileRequestReason27$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason27
> = z.enum(SyncReconcileRequestReason27);

/** @internal */
export const StatusSeverity27$outboundSchema: z.ZodEnum<
  typeof StatusSeverity27
> = z.enum(StatusSeverity27);

/** @internal */
export type SyncReconcileRequestCollectionIssue27$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue27$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue27$Outbound,
  SyncReconcileRequestCollectionIssue27
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason27$outboundSchema,
  severity: StatusSeverity27$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue27ToJSON(
  syncReconcileRequestCollectionIssue27: SyncReconcileRequestCollectionIssue27,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue27$outboundSchema.parse(
      syncReconcileRequestCollectionIssue27,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth27$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth27
> = z.enum(SyncReconcileRequestHealth27);

/** @internal */
export const SyncReconcileRequestLifecycle27$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle27
> = z.enum(SyncReconcileRequestLifecycle27);

/** @internal */
export type SyncReconcileRequestStatus27$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue27$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus27$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus27$Outbound,
  SyncReconcileRequestStatus27
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue27$outboundSchema),
  ),
  health: SyncReconcileRequestHealth27$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle27$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus27ToJSON(
  syncReconcileRequestStatus27: SyncReconcileRequestStatus27,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus27$outboundSchema.parse(
      syncReconcileRequestStatus27,
    ),
  );
}

/** @internal */
export type DataAzureServiceBus$Outbound = {
  accessedAt?: string | null | undefined;
  activeMessageCount?: number | null | undefined;
  autoDeleteOnIdle?: string | null | undefined;
  createdAt?: string | null | undefined;
  deadLetterMessageCount?: number | null | undefined;
  deadLetteringOnMessageExpiration?: boolean | null | undefined;
  defaultMessageTimeToLive?: string | null | undefined;
  duplicateDetectionHistoryTimeWindow?: string | null | undefined;
  enableBatchedOperations?: boolean | null | undefined;
  enableExpress?: boolean | null | undefined;
  enablePartitioning?: boolean | null | undefined;
  endpoint?: string | null | undefined;
  forwardDeadLetteredMessagesTo?: string | null | undefined;
  forwardTo?: string | null | undefined;
  lockDuration?: string | null | undefined;
  maxDeliveryCount?: number | null | undefined;
  maxMessageSizeInKilobytes?: number | null | undefined;
  maxSizeInMegabytes?: number | null | undefined;
  messageCount?: number | null | undefined;
  name: string;
  namespaceName: string;
  queueStatus?: string | null | undefined;
  requiresDuplicateDetection?: boolean | null | undefined;
  requiresSession?: boolean | null | undefined;
  resourceGroup?: string | null | undefined;
  resourceId?: string | null | undefined;
  scheduledMessageCount?: number | null | undefined;
  sizeInBytes?: number | null | undefined;
  status: SyncReconcileRequestStatus27$Outbound;
  transferDeadLetterMessageCount?: number | null | undefined;
  transferMessageCount?: number | null | undefined;
  updatedAt?: string | null | undefined;
  backend: "azureServiceBus";
};

/** @internal */
export const DataAzureServiceBus$outboundSchema: z.ZodType<
  DataAzureServiceBus$Outbound,
  DataAzureServiceBus
> = z.object({
  accessedAt: z.nullable(z.string()).optional(),
  activeMessageCount: z.nullable(z.int()).optional(),
  autoDeleteOnIdle: z.nullable(z.string()).optional(),
  createdAt: z.nullable(z.string()).optional(),
  deadLetterMessageCount: z.nullable(z.int()).optional(),
  deadLetteringOnMessageExpiration: z.nullable(z.boolean()).optional(),
  defaultMessageTimeToLive: z.nullable(z.string()).optional(),
  duplicateDetectionHistoryTimeWindow: z.nullable(z.string()).optional(),
  enableBatchedOperations: z.nullable(z.boolean()).optional(),
  enableExpress: z.nullable(z.boolean()).optional(),
  enablePartitioning: z.nullable(z.boolean()).optional(),
  endpoint: z.nullable(z.string()).optional(),
  forwardDeadLetteredMessagesTo: z.nullable(z.string()).optional(),
  forwardTo: z.nullable(z.string()).optional(),
  lockDuration: z.nullable(z.string()).optional(),
  maxDeliveryCount: z.nullable(z.int()).optional(),
  maxMessageSizeInKilobytes: z.nullable(z.int()).optional(),
  maxSizeInMegabytes: z.nullable(z.int()).optional(),
  messageCount: z.nullable(z.int()).optional(),
  name: z.string(),
  namespaceName: z.string(),
  queueStatus: z.nullable(z.string()).optional(),
  requiresDuplicateDetection: z.nullable(z.boolean()).optional(),
  requiresSession: z.nullable(z.boolean()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  resourceId: z.nullable(z.string()).optional(),
  scheduledMessageCount: z.nullable(z.int()).optional(),
  sizeInBytes: z.nullable(z.int()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus27$outboundSchema),
  transferDeadLetterMessageCount: z.nullable(z.int()).optional(),
  transferMessageCount: z.nullable(z.int()).optional(),
  updatedAt: z.nullable(z.string()).optional(),
  backend: z.literal("azureServiceBus"),
});

export function dataAzureServiceBusToJSON(
  dataAzureServiceBus: DataAzureServiceBus,
): string {
  return JSON.stringify(
    DataAzureServiceBus$outboundSchema.parse(dataAzureServiceBus),
  );
}

/** @internal */
export const SyncReconcileRequestReason26$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason26
> = z.enum(SyncReconcileRequestReason26);

/** @internal */
export const StatusSeverity26$outboundSchema: z.ZodEnum<
  typeof StatusSeverity26
> = z.enum(StatusSeverity26);

/** @internal */
export type SyncReconcileRequestCollectionIssue26$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue26$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue26$Outbound,
  SyncReconcileRequestCollectionIssue26
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason26$outboundSchema,
  severity: StatusSeverity26$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue26ToJSON(
  syncReconcileRequestCollectionIssue26: SyncReconcileRequestCollectionIssue26,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue26$outboundSchema.parse(
      syncReconcileRequestCollectionIssue26,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth26$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth26
> = z.enum(SyncReconcileRequestHealth26);

/** @internal */
export const SyncReconcileRequestLifecycle26$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle26
> = z.enum(SyncReconcileRequestLifecycle26);

/** @internal */
export type SyncReconcileRequestStatus26$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue26$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus26$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus26$Outbound,
  SyncReconcileRequestStatus26
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue26$outboundSchema),
  ),
  health: SyncReconcileRequestHealth26$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle26$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus26ToJSON(
  syncReconcileRequestStatus26: SyncReconcileRequestStatus26,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus26$outboundSchema.parse(
      syncReconcileRequestStatus26,
    ),
  );
}

/** @internal */
export type DataGcpPubSub$Outbound = {
  endpoint?: string | null | undefined;
  kmsKeyName?: string | null | undefined;
  messageStorageAllowedPersistenceRegions: Array<string>;
  messageStorageEnforceInTransit?: boolean | null | undefined;
  projectId?: string | null | undefined;
  schemaEncoding?: string | null | undefined;
  schemaFirstRevisionId?: string | null | undefined;
  schemaLastRevisionId?: string | null | undefined;
  schemaName?: string | null | undefined;
  status: SyncReconcileRequestStatus26$Outbound;
  subscriptionAckDeadlineSeconds?: number | null | undefined;
  subscriptionDeadLetterMaxDeliveryAttempts?: number | null | undefined;
  subscriptionDeadLetterTopic?: string | null | undefined;
  subscriptionDetached?: boolean | null | undefined;
  subscriptionEnableMessageOrdering?: boolean | null | undefined;
  subscriptionFilter?: string | null | undefined;
  subscriptionFullName?: string | null | undefined;
  subscriptionLabels: { [k: string]: string };
  subscriptionMessageRetentionDuration?: string | null | undefined;
  subscriptionName?: string | null | undefined;
  subscriptionPushAttributes: { [k: string]: string };
  subscriptionPushConfigPresent?: boolean | null | undefined;
  subscriptionPushEndpoint?: string | null | undefined;
  subscriptionPushNoWrapperWriteMetadata?: boolean | null | undefined;
  subscriptionPushOidcAudience?: string | null | undefined;
  subscriptionPushOidcServiceAccountEmail?: string | null | undefined;
  subscriptionPushPubsubWrapperWriteMetadata?: boolean | null | undefined;
  subscriptionRetainAckedMessages?: boolean | null | undefined;
  subscriptionState?: string | null | undefined;
  topicFullName?: string | null | undefined;
  topicLabels: { [k: string]: string };
  topicMessageRetentionDuration?: string | null | undefined;
  topicName: string;
  topicState?: string | null | undefined;
  backend: "gcpPubSub";
};

/** @internal */
export const DataGcpPubSub$outboundSchema: z.ZodType<
  DataGcpPubSub$Outbound,
  DataGcpPubSub
> = z.object({
  endpoint: z.nullable(z.string()).optional(),
  kmsKeyName: z.nullable(z.string()).optional(),
  messageStorageAllowedPersistenceRegions: z.array(z.string()),
  messageStorageEnforceInTransit: z.nullable(z.boolean()).optional(),
  projectId: z.nullable(z.string()).optional(),
  schemaEncoding: z.nullable(z.string()).optional(),
  schemaFirstRevisionId: z.nullable(z.string()).optional(),
  schemaLastRevisionId: z.nullable(z.string()).optional(),
  schemaName: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus26$outboundSchema),
  subscriptionAckDeadlineSeconds: z.nullable(z.int()).optional(),
  subscriptionDeadLetterMaxDeliveryAttempts: z.nullable(z.int()).optional(),
  subscriptionDeadLetterTopic: z.nullable(z.string()).optional(),
  subscriptionDetached: z.nullable(z.boolean()).optional(),
  subscriptionEnableMessageOrdering: z.nullable(z.boolean()).optional(),
  subscriptionFilter: z.nullable(z.string()).optional(),
  subscriptionFullName: z.nullable(z.string()).optional(),
  subscriptionLabels: z.record(z.string(), z.string()),
  subscriptionMessageRetentionDuration: z.nullable(z.string()).optional(),
  subscriptionName: z.nullable(z.string()).optional(),
  subscriptionPushAttributes: z.record(z.string(), z.string()),
  subscriptionPushConfigPresent: z.nullable(z.boolean()).optional(),
  subscriptionPushEndpoint: z.nullable(z.string()).optional(),
  subscriptionPushNoWrapperWriteMetadata: z.nullable(z.boolean()).optional(),
  subscriptionPushOidcAudience: z.nullable(z.string()).optional(),
  subscriptionPushOidcServiceAccountEmail: z.nullable(z.string()).optional(),
  subscriptionPushPubsubWrapperWriteMetadata: z.nullable(z.boolean())
    .optional(),
  subscriptionRetainAckedMessages: z.nullable(z.boolean()).optional(),
  subscriptionState: z.nullable(z.string()).optional(),
  topicFullName: z.nullable(z.string()).optional(),
  topicLabels: z.record(z.string(), z.string()),
  topicMessageRetentionDuration: z.nullable(z.string()).optional(),
  topicName: z.string(),
  topicState: z.nullable(z.string()).optional(),
  backend: z.literal("gcpPubSub"),
});

export function dataGcpPubSubToJSON(dataGcpPubSub: DataGcpPubSub): string {
  return JSON.stringify(DataGcpPubSub$outboundSchema.parse(dataGcpPubSub));
}

/** @internal */
export const SyncReconcileRequestReason25$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason25
> = z.enum(SyncReconcileRequestReason25);

/** @internal */
export const StatusSeverity25$outboundSchema: z.ZodEnum<
  typeof StatusSeverity25
> = z.enum(StatusSeverity25);

/** @internal */
export type SyncReconcileRequestCollectionIssue25$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue25$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue25$Outbound,
  SyncReconcileRequestCollectionIssue25
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason25$outboundSchema,
  severity: StatusSeverity25$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue25ToJSON(
  syncReconcileRequestCollectionIssue25: SyncReconcileRequestCollectionIssue25,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue25$outboundSchema.parse(
      syncReconcileRequestCollectionIssue25,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth25$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth25
> = z.enum(SyncReconcileRequestHealth25);

/** @internal */
export const SyncReconcileRequestLifecycle25$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle25
> = z.enum(SyncReconcileRequestLifecycle25);

/** @internal */
export type SyncReconcileRequestStatus25$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue25$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus25$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus25$Outbound,
  SyncReconcileRequestStatus25
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue25$outboundSchema),
  ),
  health: SyncReconcileRequestHealth25$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle25$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus25ToJSON(
  syncReconcileRequestStatus25: SyncReconcileRequestStatus25,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus25$outboundSchema.parse(
      syncReconcileRequestStatus25,
    ),
  );
}

/** @internal */
export type DataAwsSqs$Outbound = {
  approximateCounts: boolean;
  approximateDelayedMessages?: number | null | undefined;
  approximateInFlightMessages?: number | null | undefined;
  approximateVisibleMessages?: number | null | undefined;
  contentBasedDeduplication?: boolean | null | undefined;
  deduplicationScope?: string | null | undefined;
  delaySeconds?: number | null | undefined;
  fifoQueue?: boolean | null | undefined;
  fifoThroughputLimit?: string | null | undefined;
  kmsDataKeyReusePeriodSeconds?: number | null | undefined;
  kmsMasterKeyId?: string | null | undefined;
  maximumMessageSize?: number | null | undefined;
  messageRetentionPeriodSeconds?: number | null | undefined;
  name: string;
  queueArn?: string | null | undefined;
  queueUrl?: string | null | undefined;
  receiveMessageWaitTimeSeconds?: number | null | undefined;
  redriveAllowPolicy?: string | null | undefined;
  redrivePolicy?: string | null | undefined;
  region?: string | null | undefined;
  sqsManagedSseEnabled?: boolean | null | undefined;
  sseEnabled?: boolean | null | undefined;
  status: SyncReconcileRequestStatus25$Outbound;
  visibilityTimeoutSeconds?: number | null | undefined;
  backend: "awsSqs";
};

/** @internal */
export const DataAwsSqs$outboundSchema: z.ZodType<
  DataAwsSqs$Outbound,
  DataAwsSqs
> = z.object({
  approximateCounts: z.boolean(),
  approximateDelayedMessages: z.nullable(z.int()).optional(),
  approximateInFlightMessages: z.nullable(z.int()).optional(),
  approximateVisibleMessages: z.nullable(z.int()).optional(),
  contentBasedDeduplication: z.nullable(z.boolean()).optional(),
  deduplicationScope: z.nullable(z.string()).optional(),
  delaySeconds: z.nullable(z.int()).optional(),
  fifoQueue: z.nullable(z.boolean()).optional(),
  fifoThroughputLimit: z.nullable(z.string()).optional(),
  kmsDataKeyReusePeriodSeconds: z.nullable(z.int()).optional(),
  kmsMasterKeyId: z.nullable(z.string()).optional(),
  maximumMessageSize: z.nullable(z.int()).optional(),
  messageRetentionPeriodSeconds: z.nullable(z.int()).optional(),
  name: z.string(),
  queueArn: z.nullable(z.string()).optional(),
  queueUrl: z.nullable(z.string()).optional(),
  receiveMessageWaitTimeSeconds: z.nullable(z.int()).optional(),
  redriveAllowPolicy: z.nullable(z.string()).optional(),
  redrivePolicy: z.nullable(z.string()).optional(),
  region: z.nullable(z.string()).optional(),
  sqsManagedSseEnabled: z.nullable(z.boolean()).optional(),
  sseEnabled: z.nullable(z.boolean()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus25$outboundSchema),
  visibilityTimeoutSeconds: z.nullable(z.int()).optional(),
  backend: z.literal("awsSqs"),
});

export function dataAwsSqsToJSON(dataAwsSqs: DataAwsSqs): string {
  return JSON.stringify(DataAwsSqs$outboundSchema.parse(dataAwsSqs));
}

/** @internal */
export type SyncReconcileRequestDataUnion6$Outbound =
  | DataAwsSqs$Outbound
  | DataGcpPubSub$Outbound
  | DataAzureServiceBus$Outbound
  | DataLocal6$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion6$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion6$Outbound,
  SyncReconcileRequestDataUnion6
> = z.union([
  z.lazy(() => DataAwsSqs$outboundSchema),
  z.lazy(() => DataGcpPubSub$outboundSchema),
  z.lazy(() => DataAzureServiceBus$outboundSchema),
  z.lazy(() => DataLocal6$outboundSchema),
]);

export function syncReconcileRequestDataUnion6ToJSON(
  syncReconcileRequestDataUnion6: SyncReconcileRequestDataUnion6,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion6$outboundSchema.parse(
      syncReconcileRequestDataUnion6,
    ),
  );
}

/** @internal */
export type DataQueue$Outbound = {
  data:
    | DataAwsSqs$Outbound
    | DataGcpPubSub$Outbound
    | DataAzureServiceBus$Outbound
    | DataLocal6$Outbound;
  resourceType: "queue";
};

/** @internal */
export const DataQueue$outboundSchema: z.ZodType<
  DataQueue$Outbound,
  DataQueue
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsSqs$outboundSchema),
    z.lazy(() => DataGcpPubSub$outboundSchema),
    z.lazy(() => DataAzureServiceBus$outboundSchema),
    z.lazy(() => DataLocal6$outboundSchema),
  ]),
  resourceType: z.literal("queue"),
});

export function dataQueueToJSON(dataQueue: DataQueue): string {
  return JSON.stringify(DataQueue$outboundSchema.parse(dataQueue));
}

/** @internal */
export const CpuUnit11$outboundSchema: z.ZodEnum<typeof CpuUnit11> = z.enum(
  CpuUnit11,
);

/** @internal */
export type SyncReconcileRequestCpu11$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu11$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu11$Outbound,
  SyncReconcileRequestCpu11
> = z.object({
  unit: CpuUnit11$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu11ToJSON(
  syncReconcileRequestCpu11: SyncReconcileRequestCpu11,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu11$outboundSchema.parse(syncReconcileRequestCpu11),
  );
}

/** @internal */
export type CpuUnion11$Outbound = SyncReconcileRequestCpu11$Outbound | any;

/** @internal */
export const CpuUnion11$outboundSchema: z.ZodType<
  CpuUnion11$Outbound,
  CpuUnion11
> = z.union([z.lazy(() => SyncReconcileRequestCpu11$outboundSchema), z.any()]);

export function cpuUnion11ToJSON(cpuUnion11: CpuUnion11): string {
  return JSON.stringify(CpuUnion11$outboundSchema.parse(cpuUnion11));
}

/** @internal */
export type InvolvedObject9$Outbound = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

/** @internal */
export const InvolvedObject9$outboundSchema: z.ZodType<
  InvolvedObject9$Outbound,
  InvolvedObject9
> = z.object({
  apiVersion: z.nullable(z.string()).optional(),
  fieldPath: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  namespace: z.nullable(z.string()).optional(),
  resourceVersion: z.nullable(z.string()).optional(),
  uid: z.nullable(z.string()).optional(),
});

export function involvedObject9ToJSON(
  involvedObject9: InvolvedObject9,
): string {
  return JSON.stringify(InvolvedObject9$outboundSchema.parse(involvedObject9));
}

/** @internal */
export type InvolvedObjectUnion9$Outbound = InvolvedObject9$Outbound | any;

/** @internal */
export const InvolvedObjectUnion9$outboundSchema: z.ZodType<
  InvolvedObjectUnion9$Outbound,
  InvolvedObjectUnion9
> = z.union([z.lazy(() => InvolvedObject9$outboundSchema), z.any()]);

export function involvedObjectUnion9ToJSON(
  involvedObjectUnion9: InvolvedObjectUnion9,
): string {
  return JSON.stringify(
    InvolvedObjectUnion9$outboundSchema.parse(involvedObjectUnion9),
  );
}

/** @internal */
export type SourceEvent9$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent9$outboundSchema: z.ZodType<
  SourceEvent9$Outbound,
  SourceEvent9
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent9ToJSON(sourceEvent9: SourceEvent9): string {
  return JSON.stringify(SourceEvent9$outboundSchema.parse(sourceEvent9));
}

/** @internal */
export type EventSourceUnion9$Outbound = SourceEvent9$Outbound | any;

/** @internal */
export const EventSourceUnion9$outboundSchema: z.ZodType<
  EventSourceUnion9$Outbound,
  EventSourceUnion9
> = z.union([z.lazy(() => SourceEvent9$outboundSchema), z.any()]);

export function eventSourceUnion9ToJSON(
  eventSourceUnion9: EventSourceUnion9,
): string {
  return JSON.stringify(
    EventSourceUnion9$outboundSchema.parse(eventSourceUnion9),
  );
}

/** @internal */
export type SyncReconcileRequestEvent12$Outbound = {
  count?: number | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject9$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent9$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent12$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent12$Outbound,
  SyncReconcileRequestEvent12
> = z.object({
  count: z.nullable(z.int()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject9$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent9$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent12ToJSON(
  syncReconcileRequestEvent12: SyncReconcileRequestEvent12,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent12$outboundSchema.parse(
      syncReconcileRequestEvent12,
    ),
  );
}

/** @internal */
export const MemoryUnit11$outboundSchema: z.ZodEnum<typeof MemoryUnit11> = z
  .enum(MemoryUnit11);

/** @internal */
export type SyncReconcileRequestMemory11$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory11$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory11$Outbound,
  SyncReconcileRequestMemory11
> = z.object({
  unit: MemoryUnit11$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory11ToJSON(
  syncReconcileRequestMemory11: SyncReconcileRequestMemory11,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory11$outboundSchema.parse(
      syncReconcileRequestMemory11,
    ),
  );
}

/** @internal */
export type MemoryUnion11$Outbound =
  | SyncReconcileRequestMemory11$Outbound
  | any;

/** @internal */
export const MemoryUnion11$outboundSchema: z.ZodType<
  MemoryUnion11$Outbound,
  MemoryUnion11
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory11$outboundSchema),
  z.any(),
]);

export function memoryUnion11ToJSON(memoryUnion11: MemoryUnion11): string {
  return JSON.stringify(MemoryUnion11$outboundSchema.parse(memoryUnion11));
}

/** @internal */
export type NodeCounts$Outbound = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

/** @internal */
export const NodeCounts$outboundSchema: z.ZodType<
  NodeCounts$Outbound,
  NodeCounts
> = z.object({
  current: z.nullable(z.int()).optional(),
  desired: z.nullable(z.int()).optional(),
  ready: z.nullable(z.int()).optional(),
});

export function nodeCountsToJSON(nodeCounts: NodeCounts): string {
  return JSON.stringify(NodeCounts$outboundSchema.parse(nodeCounts));
}

/** @internal */
export const CpuAllocatableUnit$outboundSchema: z.ZodEnum<
  typeof CpuAllocatableUnit
> = z.enum(CpuAllocatableUnit);

/** @internal */
export type CpuAllocatable$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuAllocatable$outboundSchema: z.ZodType<
  CpuAllocatable$Outbound,
  CpuAllocatable
> = z.object({
  unit: CpuAllocatableUnit$outboundSchema,
  value: z.number(),
});

export function cpuAllocatableToJSON(cpuAllocatable: CpuAllocatable): string {
  return JSON.stringify(CpuAllocatable$outboundSchema.parse(cpuAllocatable));
}

/** @internal */
export type AllocatableCpuUnion$Outbound = CpuAllocatable$Outbound | any;

/** @internal */
export const AllocatableCpuUnion$outboundSchema: z.ZodType<
  AllocatableCpuUnion$Outbound,
  AllocatableCpuUnion
> = z.union([z.lazy(() => CpuAllocatable$outboundSchema), z.any()]);

export function allocatableCpuUnionToJSON(
  allocatableCpuUnion: AllocatableCpuUnion,
): string {
  return JSON.stringify(
    AllocatableCpuUnion$outboundSchema.parse(allocatableCpuUnion),
  );
}

/** @internal */
export const MemoryAllocatableUnit$outboundSchema: z.ZodEnum<
  typeof MemoryAllocatableUnit
> = z.enum(MemoryAllocatableUnit);

/** @internal */
export type MemoryAllocatable$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryAllocatable$outboundSchema: z.ZodType<
  MemoryAllocatable$Outbound,
  MemoryAllocatable
> = z.object({
  unit: MemoryAllocatableUnit$outboundSchema,
  value: z.number(),
});

export function memoryAllocatableToJSON(
  memoryAllocatable: MemoryAllocatable,
): string {
  return JSON.stringify(
    MemoryAllocatable$outboundSchema.parse(memoryAllocatable),
  );
}

/** @internal */
export type AllocatableMemoryUnion$Outbound = MemoryAllocatable$Outbound | any;

/** @internal */
export const AllocatableMemoryUnion$outboundSchema: z.ZodType<
  AllocatableMemoryUnion$Outbound,
  AllocatableMemoryUnion
> = z.union([z.lazy(() => MemoryAllocatable$outboundSchema), z.any()]);

export function allocatableMemoryUnionToJSON(
  allocatableMemoryUnion: AllocatableMemoryUnion,
): string {
  return JSON.stringify(
    AllocatableMemoryUnion$outboundSchema.parse(allocatableMemoryUnion),
  );
}

/** @internal */
export type Allocatable$Outbound = {
  cpu?: CpuAllocatable$Outbound | any | null | undefined;
  memory?: MemoryAllocatable$Outbound | any | null | undefined;
  pods?: number | null | undefined;
};

/** @internal */
export const Allocatable$outboundSchema: z.ZodType<
  Allocatable$Outbound,
  Allocatable
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => CpuAllocatable$outboundSchema), z.any()]),
  ).optional(),
  memory: z.nullable(
    z.union([z.lazy(() => MemoryAllocatable$outboundSchema), z.any()]),
  ).optional(),
  pods: z.nullable(z.int()).optional(),
});

export function allocatableToJSON(allocatable: Allocatable): string {
  return JSON.stringify(Allocatable$outboundSchema.parse(allocatable));
}

/** @internal */
export const CpuCapacityUnit$outboundSchema: z.ZodEnum<typeof CpuCapacityUnit> =
  z.enum(CpuCapacityUnit);

/** @internal */
export type CpuCapacity$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuCapacity$outboundSchema: z.ZodType<
  CpuCapacity$Outbound,
  CpuCapacity
> = z.object({
  unit: CpuCapacityUnit$outboundSchema,
  value: z.number(),
});

export function cpuCapacityToJSON(cpuCapacity: CpuCapacity): string {
  return JSON.stringify(CpuCapacity$outboundSchema.parse(cpuCapacity));
}

/** @internal */
export type CapacityCpuUnion$Outbound = CpuCapacity$Outbound | any;

/** @internal */
export const CapacityCpuUnion$outboundSchema: z.ZodType<
  CapacityCpuUnion$Outbound,
  CapacityCpuUnion
> = z.union([z.lazy(() => CpuCapacity$outboundSchema), z.any()]);

export function capacityCpuUnionToJSON(
  capacityCpuUnion: CapacityCpuUnion,
): string {
  return JSON.stringify(
    CapacityCpuUnion$outboundSchema.parse(capacityCpuUnion),
  );
}

/** @internal */
export const MemoryCapacityUnit$outboundSchema: z.ZodEnum<
  typeof MemoryCapacityUnit
> = z.enum(MemoryCapacityUnit);

/** @internal */
export type MemoryCapacity$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryCapacity$outboundSchema: z.ZodType<
  MemoryCapacity$Outbound,
  MemoryCapacity
> = z.object({
  unit: MemoryCapacityUnit$outboundSchema,
  value: z.number(),
});

export function memoryCapacityToJSON(memoryCapacity: MemoryCapacity): string {
  return JSON.stringify(MemoryCapacity$outboundSchema.parse(memoryCapacity));
}

/** @internal */
export type CapacityMemoryUnion$Outbound = MemoryCapacity$Outbound | any;

/** @internal */
export const CapacityMemoryUnion$outboundSchema: z.ZodType<
  CapacityMemoryUnion$Outbound,
  CapacityMemoryUnion
> = z.union([z.lazy(() => MemoryCapacity$outboundSchema), z.any()]);

export function capacityMemoryUnionToJSON(
  capacityMemoryUnion: CapacityMemoryUnion,
): string {
  return JSON.stringify(
    CapacityMemoryUnion$outboundSchema.parse(capacityMemoryUnion),
  );
}

/** @internal */
export type Capacity$Outbound = {
  cpu?: CpuCapacity$Outbound | any | null | undefined;
  memory?: MemoryCapacity$Outbound | any | null | undefined;
  pods?: number | null | undefined;
};

/** @internal */
export const Capacity$outboundSchema: z.ZodType<Capacity$Outbound, Capacity> = z
  .object({
    cpu: z.nullable(
      z.union([z.lazy(() => CpuCapacity$outboundSchema), z.any()]),
    ).optional(),
    memory: z.nullable(
      z.union([z.lazy(() => MemoryCapacity$outboundSchema), z.any()]),
    ).optional(),
    pods: z.nullable(z.int()).optional(),
  });

export function capacityToJSON(capacity: Capacity): string {
  return JSON.stringify(Capacity$outboundSchema.parse(capacity));
}

/** @internal */
export type NodeStatusCondition$Outbound = {
  message?: string | null | undefined;
  reason?: string | null | undefined;
  status: string;
  type: string;
};

/** @internal */
export const NodeStatusCondition$outboundSchema: z.ZodType<
  NodeStatusCondition$Outbound,
  NodeStatusCondition
> = z.object({
  message: z.nullable(z.string()).optional(),
  reason: z.nullable(z.string()).optional(),
  status: z.string(),
  type: z.string(),
});

export function nodeStatusConditionToJSON(
  nodeStatusCondition: NodeStatusCondition,
): string {
  return JSON.stringify(
    NodeStatusCondition$outboundSchema.parse(nodeStatusCondition),
  );
}

/** @internal */
export const UsageCpuUnit$outboundSchema: z.ZodEnum<typeof UsageCpuUnit> = z
  .enum(UsageCpuUnit);

/** @internal */
export type UsageCpu$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const UsageCpu$outboundSchema: z.ZodType<UsageCpu$Outbound, UsageCpu> = z
  .object({
    unit: UsageCpuUnit$outboundSchema,
    value: z.number(),
  });

export function usageCpuToJSON(usageCpu: UsageCpu): string {
  return JSON.stringify(UsageCpu$outboundSchema.parse(usageCpu));
}

/** @internal */
export type UsageCpuUnion$Outbound = UsageCpu$Outbound | any;

/** @internal */
export const UsageCpuUnion$outboundSchema: z.ZodType<
  UsageCpuUnion$Outbound,
  UsageCpuUnion
> = z.union([z.lazy(() => UsageCpu$outboundSchema), z.any()]);

export function usageCpuUnionToJSON(usageCpuUnion: UsageCpuUnion): string {
  return JSON.stringify(UsageCpuUnion$outboundSchema.parse(usageCpuUnion));
}

/** @internal */
export const UsageMemoryUnit$outboundSchema: z.ZodEnum<typeof UsageMemoryUnit> =
  z.enum(UsageMemoryUnit);

/** @internal */
export type UsageMemory$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const UsageMemory$outboundSchema: z.ZodType<
  UsageMemory$Outbound,
  UsageMemory
> = z.object({
  unit: UsageMemoryUnit$outboundSchema,
  value: z.number(),
});

export function usageMemoryToJSON(usageMemory: UsageMemory): string {
  return JSON.stringify(UsageMemory$outboundSchema.parse(usageMemory));
}

/** @internal */
export type UsageMemoryUnion$Outbound = UsageMemory$Outbound | any;

/** @internal */
export const UsageMemoryUnion$outboundSchema: z.ZodType<
  UsageMemoryUnion$Outbound,
  UsageMemoryUnion
> = z.union([z.lazy(() => UsageMemory$outboundSchema), z.any()]);

export function usageMemoryUnionToJSON(
  usageMemoryUnion: UsageMemoryUnion,
): string {
  return JSON.stringify(
    UsageMemoryUnion$outboundSchema.parse(usageMemoryUnion),
  );
}

/** @internal */
export type SyncReconcileRequestUsage$Outbound = {
  cpu?: UsageCpu$Outbound | any | null | undefined;
  memory?: UsageMemory$Outbound | any | null | undefined;
};

/** @internal */
export const SyncReconcileRequestUsage$outboundSchema: z.ZodType<
  SyncReconcileRequestUsage$Outbound,
  SyncReconcileRequestUsage
> = z.object({
  cpu: z.nullable(z.union([z.lazy(() => UsageCpu$outboundSchema), z.any()]))
    .optional(),
  memory: z.nullable(
    z.union([z.lazy(() => UsageMemory$outboundSchema), z.any()]),
  ).optional(),
});

export function syncReconcileRequestUsageToJSON(
  syncReconcileRequestUsage: SyncReconcileRequestUsage,
): string {
  return JSON.stringify(
    SyncReconcileRequestUsage$outboundSchema.parse(syncReconcileRequestUsage),
  );
}

/** @internal */
export type Usage$Outbound = SyncReconcileRequestUsage$Outbound | any;

/** @internal */
export const Usage$outboundSchema: z.ZodType<Usage$Outbound, Usage> = z.union([
  z.lazy(() => SyncReconcileRequestUsage$outboundSchema),
  z.any(),
]);

export function usageToJSON(usage: Usage): string {
  return JSON.stringify(Usage$outboundSchema.parse(usage));
}

/** @internal */
export type NodeStatus$Outbound = {
  allocatable: Allocatable$Outbound;
  capacity: Capacity$Outbound;
  conditions?: Array<NodeStatusCondition$Outbound> | undefined;
  containerRuntimeVersion?: string | null | undefined;
  kubeletVersion?: string | null | undefined;
  labels: { [k: string]: string };
  name: string;
  ready: boolean;
  roles: Array<string>;
  uid?: string | null | undefined;
  usage?: SyncReconcileRequestUsage$Outbound | any | null | undefined;
};

/** @internal */
export const NodeStatus$outboundSchema: z.ZodType<
  NodeStatus$Outbound,
  NodeStatus
> = z.object({
  allocatable: z.lazy(() => Allocatable$outboundSchema),
  capacity: z.lazy(() => Capacity$outboundSchema),
  conditions: z.array(z.lazy(() => NodeStatusCondition$outboundSchema))
    .optional(),
  containerRuntimeVersion: z.nullable(z.string()).optional(),
  kubeletVersion: z.nullable(z.string()).optional(),
  labels: z.record(z.string(), z.string()),
  name: z.string(),
  ready: z.boolean(),
  roles: z.array(z.string()),
  uid: z.nullable(z.string()).optional(),
  usage: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestUsage$outboundSchema), z.any()]),
  ).optional(),
});

export function nodeStatusToJSON(nodeStatus: NodeStatus): string {
  return JSON.stringify(NodeStatus$outboundSchema.parse(nodeStatus));
}

/** @internal */
export type PodCounts$Outbound = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

/** @internal */
export const PodCounts$outboundSchema: z.ZodType<
  PodCounts$Outbound,
  PodCounts
> = z.object({
  current: z.nullable(z.int()).optional(),
  desired: z.nullable(z.int()).optional(),
  ready: z.nullable(z.int()).optional(),
});

export function podCountsToJSON(podCounts: PodCounts): string {
  return JSON.stringify(PodCounts$outboundSchema.parse(podCounts));
}

/** @internal */
export const SyncReconcileRequestReason24$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason24
> = z.enum(SyncReconcileRequestReason24);

/** @internal */
export const StatusSeverity24$outboundSchema: z.ZodEnum<
  typeof StatusSeverity24
> = z.enum(StatusSeverity24);

/** @internal */
export type SyncReconcileRequestCollectionIssue24$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue24$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue24$Outbound,
  SyncReconcileRequestCollectionIssue24
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason24$outboundSchema,
  severity: StatusSeverity24$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue24ToJSON(
  syncReconcileRequestCollectionIssue24: SyncReconcileRequestCollectionIssue24,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue24$outboundSchema.parse(
      syncReconcileRequestCollectionIssue24,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth24$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth24
> = z.enum(SyncReconcileRequestHealth24);

/** @internal */
export const SyncReconcileRequestLifecycle24$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle24
> = z.enum(SyncReconcileRequestLifecycle24);

/** @internal */
export type SyncReconcileRequestStatus24$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue24$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus24$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus24$Outbound,
  SyncReconcileRequestStatus24
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue24$outboundSchema),
  ),
  health: SyncReconcileRequestHealth24$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle24$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus24ToJSON(
  syncReconcileRequestStatus24: SyncReconcileRequestStatus24,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus24$outboundSchema.parse(
      syncReconcileRequestStatus24,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestData1$Outbound = {
  cpu?: SyncReconcileRequestCpu11$Outbound | any | null | undefined;
  events: Array<SyncReconcileRequestEvent12$Outbound>;
  memory?: SyncReconcileRequestMemory11$Outbound | any | null | undefined;
  name: string;
  namespace?: string | null | undefined;
  nodeCounts: NodeCounts$Outbound;
  nodeStatuses?: Array<NodeStatus$Outbound> | undefined;
  podCounts: PodCounts$Outbound;
  region?: string | null | undefined;
  status: SyncReconcileRequestStatus24$Outbound;
  version?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestData1$outboundSchema: z.ZodType<
  SyncReconcileRequestData1$Outbound,
  SyncReconcileRequestData1
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestCpu11$outboundSchema), z.any()]),
  ).optional(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent12$outboundSchema)),
  memory: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestMemory11$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  name: z.string(),
  namespace: z.nullable(z.string()).optional(),
  nodeCounts: z.lazy(() => NodeCounts$outboundSchema),
  nodeStatuses: z.array(z.lazy(() => NodeStatus$outboundSchema)).optional(),
  podCounts: z.lazy(() => PodCounts$outboundSchema),
  region: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus24$outboundSchema),
  version: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestData1ToJSON(
  syncReconcileRequestData1: SyncReconcileRequestData1,
): string {
  return JSON.stringify(
    SyncReconcileRequestData1$outboundSchema.parse(syncReconcileRequestData1),
  );
}

/** @internal */
export type DataKubernetesCluster$Outbound = {
  data: SyncReconcileRequestData1$Outbound;
  resourceType: "kubernetes-cluster";
};

/** @internal */
export const DataKubernetesCluster$outboundSchema: z.ZodType<
  DataKubernetesCluster$Outbound,
  DataKubernetesCluster
> = z.object({
  data: z.lazy(() => SyncReconcileRequestData1$outboundSchema),
  resourceType: z.literal("kubernetes-cluster"),
});

export function dataKubernetesClusterToJSON(
  dataKubernetesCluster: DataKubernetesCluster,
): string {
  return JSON.stringify(
    DataKubernetesCluster$outboundSchema.parse(dataKubernetesCluster),
  );
}

/** @internal */
export type Nodes5$Outbound = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

/** @internal */
export const Nodes5$outboundSchema: z.ZodType<Nodes5$Outbound, Nodes5> = z
  .object({
    current: z.nullable(z.int()).optional(),
    desired: z.nullable(z.int()).optional(),
    ready: z.nullable(z.int()).optional(),
  });

export function nodes5ToJSON(nodes5: Nodes5): string {
  return JSON.stringify(Nodes5$outboundSchema.parse(nodes5));
}

/** @internal */
export const SyncReconcileRequestReason23$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason23
> = z.enum(SyncReconcileRequestReason23);

/** @internal */
export const StatusSeverity23$outboundSchema: z.ZodEnum<
  typeof StatusSeverity23
> = z.enum(StatusSeverity23);

/** @internal */
export type SyncReconcileRequestCollectionIssue23$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue23$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue23$Outbound,
  SyncReconcileRequestCollectionIssue23
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason23$outboundSchema,
  severity: StatusSeverity23$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue23ToJSON(
  syncReconcileRequestCollectionIssue23: SyncReconcileRequestCollectionIssue23,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue23$outboundSchema.parse(
      syncReconcileRequestCollectionIssue23,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth23$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth23
> = z.enum(SyncReconcileRequestHealth23);

/** @internal */
export const SyncReconcileRequestLifecycle23$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle23
> = z.enum(SyncReconcileRequestLifecycle23);

/** @internal */
export type SyncReconcileRequestStatus23$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue23$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus23$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus23$Outbound,
  SyncReconcileRequestStatus23
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue23$outboundSchema),
  ),
  health: SyncReconcileRequestHealth23$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle23$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus23ToJSON(
  syncReconcileRequestStatus23: SyncReconcileRequestStatus23,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus23$outboundSchema.parse(
      syncReconcileRequestStatus23,
    ),
  );
}

/** @internal */
export type DataLocal5$Outbound = {
  dockerApiVersion?: string | null | undefined;
  dockerArch?: string | null | undefined;
  dockerAvailable: boolean;
  dockerOs?: string | null | undefined;
  dockerVersion?: string | null | undefined;
  hostIdentifier?: string | null | undefined;
  name: string;
  networkAvailable: boolean;
  networkName?: string | null | undefined;
  nodes: Nodes5$Outbound;
  runningContainers?: number | null | undefined;
  status: SyncReconcileRequestStatus23$Outbound;
  trackedContainers?: number | null | undefined;
  backend: "local";
};

/** @internal */
export const DataLocal5$outboundSchema: z.ZodType<
  DataLocal5$Outbound,
  DataLocal5
> = z.object({
  dockerApiVersion: z.nullable(z.string()).optional(),
  dockerArch: z.nullable(z.string()).optional(),
  dockerAvailable: z.boolean(),
  dockerOs: z.nullable(z.string()).optional(),
  dockerVersion: z.nullable(z.string()).optional(),
  hostIdentifier: z.nullable(z.string()).optional(),
  name: z.string(),
  networkAvailable: z.boolean(),
  networkName: z.nullable(z.string()).optional(),
  nodes: z.lazy(() => Nodes5$outboundSchema),
  runningContainers: z.nullable(z.int()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus23$outboundSchema),
  trackedContainers: z.nullable(z.int()).optional(),
  backend: z.literal("local"),
});

export function dataLocal5ToJSON(dataLocal5: DataLocal5): string {
  return JSON.stringify(DataLocal5$outboundSchema.parse(dataLocal5));
}

/** @internal */
export const Category4$outboundSchema: z.ZodEnum<typeof Category4> = z.enum(
  Category4,
);

/** @internal */
export type CapacityBlocker4$Outbound = {
  category: string;
  message: string;
  observedAt: string;
  providerCode?: string | null | undefined;
  providerReference?: string | null | undefined;
};

/** @internal */
export const CapacityBlocker4$outboundSchema: z.ZodType<
  CapacityBlocker4$Outbound,
  CapacityBlocker4
> = z.object({
  category: Category4$outboundSchema,
  message: z.string(),
  observedAt: z.date().transform(v => v.toISOString()),
  providerCode: z.nullable(z.string()).optional(),
  providerReference: z.nullable(z.string()).optional(),
});

export function capacityBlocker4ToJSON(
  capacityBlocker4: CapacityBlocker4,
): string {
  return JSON.stringify(
    CapacityBlocker4$outboundSchema.parse(capacityBlocker4),
  );
}

/** @internal */
export type CapacityBlockerUnion4$Outbound = CapacityBlocker4$Outbound | any;

/** @internal */
export const CapacityBlockerUnion4$outboundSchema: z.ZodType<
  CapacityBlockerUnion4$Outbound,
  CapacityBlockerUnion4
> = z.union([z.lazy(() => CapacityBlocker4$outboundSchema), z.any()]);

export function capacityBlockerUnion4ToJSON(
  capacityBlockerUnion4: CapacityBlockerUnion4,
): string {
  return JSON.stringify(
    CapacityBlockerUnion4$outboundSchema.parse(capacityBlockerUnion4),
  );
}

/** @internal */
export type DrainProgressBlocker4$Outbound = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

/** @internal */
export const DrainProgressBlocker4$outboundSchema: z.ZodType<
  DrainProgressBlocker4$Outbound,
  DrainProgressBlocker4
> = z.object({
  reason: z.string(),
  replicaId: z.string(),
  schedulingMode: z.string(),
  state: z.string(),
  workloadName: z.string(),
});

export function drainProgressBlocker4ToJSON(
  drainProgressBlocker4: DrainProgressBlocker4,
): string {
  return JSON.stringify(
    DrainProgressBlocker4$outboundSchema.parse(drainProgressBlocker4),
  );
}

/** @internal */
export const DrainProgressStatus4$outboundSchema: z.ZodEnum<
  typeof DrainProgressStatus4
> = z.enum(DrainProgressStatus4);

/** @internal */
export type DrainProgress4$Outbound = {
  blockers?: Array<DrainProgressBlocker4$Outbound> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  force: boolean;
  machineId: string;
  replicaCount: number;
  stalled: boolean;
  status: string;
};

/** @internal */
export const DrainProgress4$outboundSchema: z.ZodType<
  DrainProgress4$Outbound,
  DrainProgress4
> = z.object({
  blockers: z.array(z.lazy(() => DrainProgressBlocker4$outboundSchema))
    .optional(),
  drainDeadlineAt: z.nullable(z.string()).optional(),
  drainRequestedAt: z.nullable(z.string()).optional(),
  drainedAt: z.nullable(z.string()).optional(),
  force: z.boolean(),
  machineId: z.string(),
  replicaCount: z.int(),
  stalled: z.boolean(),
  status: DrainProgressStatus4$outboundSchema,
});

export function drainProgress4ToJSON(drainProgress4: DrainProgress4): string {
  return JSON.stringify(DrainProgress4$outboundSchema.parse(drainProgress4));
}

/** @internal */
export type DrainProgressUnion4$Outbound = DrainProgress4$Outbound | any;

/** @internal */
export const DrainProgressUnion4$outboundSchema: z.ZodType<
  DrainProgressUnion4$Outbound,
  DrainProgressUnion4
> = z.union([z.lazy(() => DrainProgress4$outboundSchema), z.any()]);

export function drainProgressUnion4ToJSON(
  drainProgressUnion4: DrainProgressUnion4,
): string {
  return JSON.stringify(
    DrainProgressUnion4$outboundSchema.parse(drainProgressUnion4),
  );
}

/** @internal */
export const UtilizationUnit4$outboundSchema: z.ZodEnum<
  typeof UtilizationUnit4
> = z.enum(UtilizationUnit4);

/** @internal */
export type Utilization4$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const Utilization4$outboundSchema: z.ZodType<
  Utilization4$Outbound,
  Utilization4
> = z.object({
  unit: UtilizationUnit4$outboundSchema,
  value: z.number(),
});

export function utilization4ToJSON(utilization4: Utilization4): string {
  return JSON.stringify(Utilization4$outboundSchema.parse(utilization4));
}

/** @internal */
export type UtilizationUnion4$Outbound = Utilization4$Outbound | any;

/** @internal */
export const UtilizationUnion4$outboundSchema: z.ZodType<
  UtilizationUnion4$Outbound,
  UtilizationUnion4
> = z.union([z.lazy(() => Utilization4$outboundSchema), z.any()]);

export function utilizationUnion4ToJSON(
  utilizationUnion4: UtilizationUnion4,
): string {
  return JSON.stringify(
    UtilizationUnion4$outboundSchema.parse(utilizationUnion4),
  );
}

/** @internal */
export type Recommendation4$Outbound = {
  desiredMachines: number;
  reason?: string | null | undefined;
  unschedulableReplicas?: number | null | undefined;
  utilization?: Utilization4$Outbound | any | null | undefined;
};

/** @internal */
export const Recommendation4$outboundSchema: z.ZodType<
  Recommendation4$Outbound,
  Recommendation4
> = z.object({
  desiredMachines: z.int(),
  reason: z.nullable(z.string()).optional(),
  unschedulableReplicas: z.nullable(z.int()).optional(),
  utilization: z.nullable(
    z.union([z.lazy(() => Utilization4$outboundSchema), z.any()]),
  ).optional(),
});

export function recommendation4ToJSON(
  recommendation4: Recommendation4,
): string {
  return JSON.stringify(Recommendation4$outboundSchema.parse(recommendation4));
}

/** @internal */
export type RecommendationUnion4$Outbound = Recommendation4$Outbound | any;

/** @internal */
export const RecommendationUnion4$outboundSchema: z.ZodType<
  RecommendationUnion4$Outbound,
  RecommendationUnion4
> = z.union([z.lazy(() => Recommendation4$outboundSchema), z.any()]);

export function recommendationUnion4ToJSON(
  recommendationUnion4: RecommendationUnion4,
): string {
  return JSON.stringify(
    RecommendationUnion4$outboundSchema.parse(recommendationUnion4),
  );
}

/** @internal */
export type CapacityGroup4$Outbound = {
  capacityBlocker?: CapacityBlocker4$Outbound | any | null | undefined;
  currentMachines: number;
  desiredMachines: number;
  drainProgress?: DrainProgress4$Outbound | any | null | undefined;
  groupId: string;
  instanceType?: string | null | undefined;
  maxMachines?: number | null | undefined;
  minMachines?: number | null | undefined;
  recommendation?: Recommendation4$Outbound | any | null | undefined;
};

/** @internal */
export const CapacityGroup4$outboundSchema: z.ZodType<
  CapacityGroup4$Outbound,
  CapacityGroup4
> = z.object({
  capacityBlocker: z.nullable(
    z.union([z.lazy(() => CapacityBlocker4$outboundSchema), z.any()]),
  ).optional(),
  currentMachines: z.int(),
  desiredMachines: z.int(),
  drainProgress: z.nullable(
    z.union([z.lazy(() => DrainProgress4$outboundSchema), z.any()]),
  ).optional(),
  groupId: z.string(),
  instanceType: z.nullable(z.string()).optional(),
  maxMachines: z.nullable(z.int()).optional(),
  minMachines: z.nullable(z.int()).optional(),
  recommendation: z.nullable(
    z.union([z.lazy(() => Recommendation4$outboundSchema), z.any()]),
  ).optional(),
});

export function capacityGroup4ToJSON(capacityGroup4: CapacityGroup4): string {
  return JSON.stringify(CapacityGroup4$outboundSchema.parse(capacityGroup4));
}

/** @internal */
export const CpuUnit10$outboundSchema: z.ZodEnum<typeof CpuUnit10> = z.enum(
  CpuUnit10,
);

/** @internal */
export type SyncReconcileRequestCpu10$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu10$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu10$Outbound,
  SyncReconcileRequestCpu10
> = z.object({
  unit: CpuUnit10$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu10ToJSON(
  syncReconcileRequestCpu10: SyncReconcileRequestCpu10,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu10$outboundSchema.parse(syncReconcileRequestCpu10),
  );
}

/** @internal */
export type CpuUnion10$Outbound = SyncReconcileRequestCpu10$Outbound | any;

/** @internal */
export const CpuUnion10$outboundSchema: z.ZodType<
  CpuUnion10$Outbound,
  CpuUnion10
> = z.union([z.lazy(() => SyncReconcileRequestCpu10$outboundSchema), z.any()]);

export function cpuUnion10ToJSON(cpuUnion10: CpuUnion10): string {
  return JSON.stringify(CpuUnion10$outboundSchema.parse(cpuUnion10));
}

/** @internal */
export type SyncReconcileRequestDrainBlocker$Outbound = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

/** @internal */
export const SyncReconcileRequestDrainBlocker$outboundSchema: z.ZodType<
  SyncReconcileRequestDrainBlocker$Outbound,
  SyncReconcileRequestDrainBlocker
> = z.object({
  reason: z.string(),
  replicaId: z.string(),
  schedulingMode: z.string(),
  state: z.string(),
  workloadName: z.string(),
});

export function syncReconcileRequestDrainBlockerToJSON(
  syncReconcileRequestDrainBlocker: SyncReconcileRequestDrainBlocker,
): string {
  return JSON.stringify(
    SyncReconcileRequestDrainBlocker$outboundSchema.parse(
      syncReconcileRequestDrainBlocker,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestMachine$Outbound = {
  capacityGroup: string;
  cpuCores?: number | null | undefined;
  drainBlockers?: Array<SyncReconcileRequestDrainBlocker$Outbound> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainForce: boolean;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  horizondVersion?: string | null | undefined;
  lastHeartbeat: string;
  machineId: string;
  memoryBytes?: number | null | undefined;
  overlayIp?: string | null | undefined;
  publicIp?: string | null | undefined;
  replicaCount: number;
  status: string;
  zone: string;
};

/** @internal */
export const SyncReconcileRequestMachine$outboundSchema: z.ZodType<
  SyncReconcileRequestMachine$Outbound,
  SyncReconcileRequestMachine
> = z.object({
  capacityGroup: z.string(),
  cpuCores: z.nullable(z.number()).optional(),
  drainBlockers: z.array(
    z.lazy(() => SyncReconcileRequestDrainBlocker$outboundSchema),
  ).optional(),
  drainDeadlineAt: z.nullable(z.string()).optional(),
  drainForce: z.boolean(),
  drainRequestedAt: z.nullable(z.string()).optional(),
  drainedAt: z.nullable(z.string()).optional(),
  horizondVersion: z.nullable(z.string()).optional(),
  lastHeartbeat: z.string(),
  machineId: z.string(),
  memoryBytes: z.nullable(z.int()).optional(),
  overlayIp: z.nullable(z.string()).optional(),
  publicIp: z.nullable(z.string()).optional(),
  replicaCount: z.int(),
  status: z.string(),
  zone: z.string(),
});

export function syncReconcileRequestMachineToJSON(
  syncReconcileRequestMachine: SyncReconcileRequestMachine,
): string {
  return JSON.stringify(
    SyncReconcileRequestMachine$outboundSchema.parse(
      syncReconcileRequestMachine,
    ),
  );
}

/** @internal */
export const MemoryUnit10$outboundSchema: z.ZodEnum<typeof MemoryUnit10> = z
  .enum(MemoryUnit10);

/** @internal */
export type SyncReconcileRequestMemory10$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory10$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory10$Outbound,
  SyncReconcileRequestMemory10
> = z.object({
  unit: MemoryUnit10$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory10ToJSON(
  syncReconcileRequestMemory10: SyncReconcileRequestMemory10,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory10$outboundSchema.parse(
      syncReconcileRequestMemory10,
    ),
  );
}

/** @internal */
export type MemoryUnion10$Outbound =
  | SyncReconcileRequestMemory10$Outbound
  | any;

/** @internal */
export const MemoryUnion10$outboundSchema: z.ZodType<
  MemoryUnion10$Outbound,
  MemoryUnion10
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory10$outboundSchema),
  z.any(),
]);

export function memoryUnion10ToJSON(memoryUnion10: MemoryUnion10): string {
  return JSON.stringify(MemoryUnion10$outboundSchema.parse(memoryUnion10));
}

/** @internal */
export type Nodes4$Outbound = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

/** @internal */
export const Nodes4$outboundSchema: z.ZodType<Nodes4$Outbound, Nodes4> = z
  .object({
    current: z.nullable(z.int()).optional(),
    desired: z.nullable(z.int()).optional(),
    ready: z.nullable(z.int()).optional(),
  });

export function nodes4ToJSON(nodes4: Nodes4): string {
  return JSON.stringify(Nodes4$outboundSchema.parse(nodes4));
}

/** @internal */
export const SyncReconcileRequestReason22$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason22
> = z.enum(SyncReconcileRequestReason22);

/** @internal */
export const StatusSeverity22$outboundSchema: z.ZodEnum<
  typeof StatusSeverity22
> = z.enum(StatusSeverity22);

/** @internal */
export type SyncReconcileRequestCollectionIssue22$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue22$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue22$Outbound,
  SyncReconcileRequestCollectionIssue22
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason22$outboundSchema,
  severity: StatusSeverity22$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue22ToJSON(
  syncReconcileRequestCollectionIssue22: SyncReconcileRequestCollectionIssue22,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue22$outboundSchema.parse(
      syncReconcileRequestCollectionIssue22,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth22$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth22
> = z.enum(SyncReconcileRequestHealth22);

/** @internal */
export const SyncReconcileRequestLifecycle22$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle22
> = z.enum(SyncReconcileRequestLifecycle22);

/** @internal */
export type SyncReconcileRequestStatus22$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue22$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus22$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus22$Outbound,
  SyncReconcileRequestStatus22
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue22$outboundSchema),
  ),
  health: SyncReconcileRequestHealth22$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle22$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus22ToJSON(
  syncReconcileRequestStatus22: SyncReconcileRequestStatus22,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus22$outboundSchema.parse(
      syncReconcileRequestStatus22,
    ),
  );
}

/** @internal */
export type DataMachines2$Outbound = {
  backendClusterId?: string | null | undefined;
  capacityGroups: Array<CapacityGroup4$Outbound>;
  cpu?: SyncReconcileRequestCpu10$Outbound | any | null | undefined;
  machines: Array<SyncReconcileRequestMachine$Outbound>;
  memory?: SyncReconcileRequestMemory10$Outbound | any | null | undefined;
  name: string;
  nodes: Nodes4$Outbound;
  status: SyncReconcileRequestStatus22$Outbound;
  backend: "machines";
};

/** @internal */
export const DataMachines2$outboundSchema: z.ZodType<
  DataMachines2$Outbound,
  DataMachines2
> = z.object({
  backendClusterId: z.nullable(z.string()).optional(),
  capacityGroups: z.array(z.lazy(() => CapacityGroup4$outboundSchema)),
  cpu: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestCpu10$outboundSchema), z.any()]),
  ).optional(),
  machines: z.array(z.lazy(() => SyncReconcileRequestMachine$outboundSchema)),
  memory: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestMemory10$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  name: z.string(),
  nodes: z.lazy(() => Nodes4$outboundSchema),
  status: z.lazy(() => SyncReconcileRequestStatus22$outboundSchema),
  backend: z.literal("machines"),
});

export function dataMachines2ToJSON(dataMachines2: DataMachines2): string {
  return JSON.stringify(DataMachines2$outboundSchema.parse(dataMachines2));
}

/** @internal */
export const Category3$outboundSchema: z.ZodEnum<typeof Category3> = z.enum(
  Category3,
);

/** @internal */
export type CapacityBlocker3$Outbound = {
  category: string;
  message: string;
  observedAt: string;
  providerCode?: string | null | undefined;
  providerReference?: string | null | undefined;
};

/** @internal */
export const CapacityBlocker3$outboundSchema: z.ZodType<
  CapacityBlocker3$Outbound,
  CapacityBlocker3
> = z.object({
  category: Category3$outboundSchema,
  message: z.string(),
  observedAt: z.date().transform(v => v.toISOString()),
  providerCode: z.nullable(z.string()).optional(),
  providerReference: z.nullable(z.string()).optional(),
});

export function capacityBlocker3ToJSON(
  capacityBlocker3: CapacityBlocker3,
): string {
  return JSON.stringify(
    CapacityBlocker3$outboundSchema.parse(capacityBlocker3),
  );
}

/** @internal */
export type CapacityBlockerUnion3$Outbound = CapacityBlocker3$Outbound | any;

/** @internal */
export const CapacityBlockerUnion3$outboundSchema: z.ZodType<
  CapacityBlockerUnion3$Outbound,
  CapacityBlockerUnion3
> = z.union([z.lazy(() => CapacityBlocker3$outboundSchema), z.any()]);

export function capacityBlockerUnion3ToJSON(
  capacityBlockerUnion3: CapacityBlockerUnion3,
): string {
  return JSON.stringify(
    CapacityBlockerUnion3$outboundSchema.parse(capacityBlockerUnion3),
  );
}

/** @internal */
export type DrainProgressBlocker3$Outbound = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

/** @internal */
export const DrainProgressBlocker3$outboundSchema: z.ZodType<
  DrainProgressBlocker3$Outbound,
  DrainProgressBlocker3
> = z.object({
  reason: z.string(),
  replicaId: z.string(),
  schedulingMode: z.string(),
  state: z.string(),
  workloadName: z.string(),
});

export function drainProgressBlocker3ToJSON(
  drainProgressBlocker3: DrainProgressBlocker3,
): string {
  return JSON.stringify(
    DrainProgressBlocker3$outboundSchema.parse(drainProgressBlocker3),
  );
}

/** @internal */
export const DrainProgressStatus3$outboundSchema: z.ZodEnum<
  typeof DrainProgressStatus3
> = z.enum(DrainProgressStatus3);

/** @internal */
export type DrainProgress3$Outbound = {
  blockers?: Array<DrainProgressBlocker3$Outbound> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  force: boolean;
  machineId: string;
  replicaCount: number;
  stalled: boolean;
  status: string;
};

/** @internal */
export const DrainProgress3$outboundSchema: z.ZodType<
  DrainProgress3$Outbound,
  DrainProgress3
> = z.object({
  blockers: z.array(z.lazy(() => DrainProgressBlocker3$outboundSchema))
    .optional(),
  drainDeadlineAt: z.nullable(z.string()).optional(),
  drainRequestedAt: z.nullable(z.string()).optional(),
  drainedAt: z.nullable(z.string()).optional(),
  force: z.boolean(),
  machineId: z.string(),
  replicaCount: z.int(),
  stalled: z.boolean(),
  status: DrainProgressStatus3$outboundSchema,
});

export function drainProgress3ToJSON(drainProgress3: DrainProgress3): string {
  return JSON.stringify(DrainProgress3$outboundSchema.parse(drainProgress3));
}

/** @internal */
export type DrainProgressUnion3$Outbound = DrainProgress3$Outbound | any;

/** @internal */
export const DrainProgressUnion3$outboundSchema: z.ZodType<
  DrainProgressUnion3$Outbound,
  DrainProgressUnion3
> = z.union([z.lazy(() => DrainProgress3$outboundSchema), z.any()]);

export function drainProgressUnion3ToJSON(
  drainProgressUnion3: DrainProgressUnion3,
): string {
  return JSON.stringify(
    DrainProgressUnion3$outboundSchema.parse(drainProgressUnion3),
  );
}

/** @internal */
export const UtilizationUnit3$outboundSchema: z.ZodEnum<
  typeof UtilizationUnit3
> = z.enum(UtilizationUnit3);

/** @internal */
export type Utilization3$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const Utilization3$outboundSchema: z.ZodType<
  Utilization3$Outbound,
  Utilization3
> = z.object({
  unit: UtilizationUnit3$outboundSchema,
  value: z.number(),
});

export function utilization3ToJSON(utilization3: Utilization3): string {
  return JSON.stringify(Utilization3$outboundSchema.parse(utilization3));
}

/** @internal */
export type UtilizationUnion3$Outbound = Utilization3$Outbound | any;

/** @internal */
export const UtilizationUnion3$outboundSchema: z.ZodType<
  UtilizationUnion3$Outbound,
  UtilizationUnion3
> = z.union([z.lazy(() => Utilization3$outboundSchema), z.any()]);

export function utilizationUnion3ToJSON(
  utilizationUnion3: UtilizationUnion3,
): string {
  return JSON.stringify(
    UtilizationUnion3$outboundSchema.parse(utilizationUnion3),
  );
}

/** @internal */
export type Recommendation3$Outbound = {
  desiredMachines: number;
  reason?: string | null | undefined;
  unschedulableReplicas?: number | null | undefined;
  utilization?: Utilization3$Outbound | any | null | undefined;
};

/** @internal */
export const Recommendation3$outboundSchema: z.ZodType<
  Recommendation3$Outbound,
  Recommendation3
> = z.object({
  desiredMachines: z.int(),
  reason: z.nullable(z.string()).optional(),
  unschedulableReplicas: z.nullable(z.int()).optional(),
  utilization: z.nullable(
    z.union([z.lazy(() => Utilization3$outboundSchema), z.any()]),
  ).optional(),
});

export function recommendation3ToJSON(
  recommendation3: Recommendation3,
): string {
  return JSON.stringify(Recommendation3$outboundSchema.parse(recommendation3));
}

/** @internal */
export type RecommendationUnion3$Outbound = Recommendation3$Outbound | any;

/** @internal */
export const RecommendationUnion3$outboundSchema: z.ZodType<
  RecommendationUnion3$Outbound,
  RecommendationUnion3
> = z.union([z.lazy(() => Recommendation3$outboundSchema), z.any()]);

export function recommendationUnion3ToJSON(
  recommendationUnion3: RecommendationUnion3,
): string {
  return JSON.stringify(
    RecommendationUnion3$outboundSchema.parse(recommendationUnion3),
  );
}

/** @internal */
export type CapacityGroup3$Outbound = {
  capacityBlocker?: CapacityBlocker3$Outbound | any | null | undefined;
  currentMachines: number;
  desiredMachines: number;
  drainProgress?: DrainProgress3$Outbound | any | null | undefined;
  groupId: string;
  instanceType?: string | null | undefined;
  maxMachines?: number | null | undefined;
  minMachines?: number | null | undefined;
  recommendation?: Recommendation3$Outbound | any | null | undefined;
};

/** @internal */
export const CapacityGroup3$outboundSchema: z.ZodType<
  CapacityGroup3$Outbound,
  CapacityGroup3
> = z.object({
  capacityBlocker: z.nullable(
    z.union([z.lazy(() => CapacityBlocker3$outboundSchema), z.any()]),
  ).optional(),
  currentMachines: z.int(),
  desiredMachines: z.int(),
  drainProgress: z.nullable(
    z.union([z.lazy(() => DrainProgress3$outboundSchema), z.any()]),
  ).optional(),
  groupId: z.string(),
  instanceType: z.nullable(z.string()).optional(),
  maxMachines: z.nullable(z.int()).optional(),
  minMachines: z.nullable(z.int()).optional(),
  recommendation: z.nullable(
    z.union([z.lazy(() => Recommendation3$outboundSchema), z.any()]),
  ).optional(),
});

export function capacityGroup3ToJSON(capacityGroup3: CapacityGroup3): string {
  return JSON.stringify(CapacityGroup3$outboundSchema.parse(capacityGroup3));
}

/** @internal */
export const CpuUnit9$outboundSchema: z.ZodEnum<typeof CpuUnit9> = z.enum(
  CpuUnit9,
);

/** @internal */
export type SyncReconcileRequestCpu9$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu9$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu9$Outbound,
  SyncReconcileRequestCpu9
> = z.object({
  unit: CpuUnit9$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu9ToJSON(
  syncReconcileRequestCpu9: SyncReconcileRequestCpu9,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu9$outboundSchema.parse(syncReconcileRequestCpu9),
  );
}

/** @internal */
export type CpuUnion9$Outbound = SyncReconcileRequestCpu9$Outbound | any;

/** @internal */
export const CpuUnion9$outboundSchema: z.ZodType<
  CpuUnion9$Outbound,
  CpuUnion9
> = z.union([z.lazy(() => SyncReconcileRequestCpu9$outboundSchema), z.any()]);

export function cpuUnion9ToJSON(cpuUnion9: CpuUnion9): string {
  return JSON.stringify(CpuUnion9$outboundSchema.parse(cpuUnion9));
}

/** @internal */
export const MemoryUnit9$outboundSchema: z.ZodEnum<typeof MemoryUnit9> = z.enum(
  MemoryUnit9,
);

/** @internal */
export type SyncReconcileRequestMemory9$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory9$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory9$Outbound,
  SyncReconcileRequestMemory9
> = z.object({
  unit: MemoryUnit9$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory9ToJSON(
  syncReconcileRequestMemory9: SyncReconcileRequestMemory9,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory9$outboundSchema.parse(
      syncReconcileRequestMemory9,
    ),
  );
}

/** @internal */
export type MemoryUnion9$Outbound = SyncReconcileRequestMemory9$Outbound | any;

/** @internal */
export const MemoryUnion9$outboundSchema: z.ZodType<
  MemoryUnion9$Outbound,
  MemoryUnion9
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory9$outboundSchema),
  z.any(),
]);

export function memoryUnion9ToJSON(memoryUnion9: MemoryUnion9): string {
  return JSON.stringify(MemoryUnion9$outboundSchema.parse(memoryUnion9));
}

/** @internal */
export type Nodes3$Outbound = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

/** @internal */
export const Nodes3$outboundSchema: z.ZodType<Nodes3$Outbound, Nodes3> = z
  .object({
    current: z.nullable(z.int()).optional(),
    desired: z.nullable(z.int()).optional(),
    ready: z.nullable(z.int()).optional(),
  });

export function nodes3ToJSON(nodes3: Nodes3): string {
  return JSON.stringify(Nodes3$outboundSchema.parse(nodes3));
}

/** @internal */
export type ProviderFleet3$Outbound = {
  currentMachines: number;
  desiredMachines: number;
  groupId: string;
  location?: string | null | undefined;
  providerId: string;
};

/** @internal */
export const ProviderFleet3$outboundSchema: z.ZodType<
  ProviderFleet3$Outbound,
  ProviderFleet3
> = z.object({
  currentMachines: z.int(),
  desiredMachines: z.int(),
  groupId: z.string(),
  location: z.nullable(z.string()).optional(),
  providerId: z.string(),
});

export function providerFleet3ToJSON(providerFleet3: ProviderFleet3): string {
  return JSON.stringify(ProviderFleet3$outboundSchema.parse(providerFleet3));
}

/** @internal */
export const SyncReconcileRequestReason21$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason21
> = z.enum(SyncReconcileRequestReason21);

/** @internal */
export const StatusSeverity21$outboundSchema: z.ZodEnum<
  typeof StatusSeverity21
> = z.enum(StatusSeverity21);

/** @internal */
export type SyncReconcileRequestCollectionIssue21$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue21$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue21$Outbound,
  SyncReconcileRequestCollectionIssue21
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason21$outboundSchema,
  severity: StatusSeverity21$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue21ToJSON(
  syncReconcileRequestCollectionIssue21: SyncReconcileRequestCollectionIssue21,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue21$outboundSchema.parse(
      syncReconcileRequestCollectionIssue21,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth21$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth21
> = z.enum(SyncReconcileRequestHealth21);

/** @internal */
export const SyncReconcileRequestLifecycle21$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle21
> = z.enum(SyncReconcileRequestLifecycle21);

/** @internal */
export type SyncReconcileRequestStatus21$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue21$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus21$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus21$Outbound,
  SyncReconcileRequestStatus21
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue21$outboundSchema),
  ),
  health: SyncReconcileRequestHealth21$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle21$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus21ToJSON(
  syncReconcileRequestStatus21: SyncReconcileRequestStatus21,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus21$outboundSchema.parse(
      syncReconcileRequestStatus21,
    ),
  );
}

/** @internal */
export type DataAzure2$Outbound = {
  backendClusterId?: string | null | undefined;
  capacityGroups: Array<CapacityGroup3$Outbound>;
  cpu?: SyncReconcileRequestCpu9$Outbound | any | null | undefined;
  memory?: SyncReconcileRequestMemory9$Outbound | any | null | undefined;
  name: string;
  nodes: Nodes3$Outbound;
  providerFleets: Array<ProviderFleet3$Outbound>;
  region?: string | null | undefined;
  status: SyncReconcileRequestStatus21$Outbound;
  backend: "azure";
};

/** @internal */
export const DataAzure2$outboundSchema: z.ZodType<
  DataAzure2$Outbound,
  DataAzure2
> = z.object({
  backendClusterId: z.nullable(z.string()).optional(),
  capacityGroups: z.array(z.lazy(() => CapacityGroup3$outboundSchema)),
  cpu: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestCpu9$outboundSchema), z.any()]),
  ).optional(),
  memory: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestMemory9$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  name: z.string(),
  nodes: z.lazy(() => Nodes3$outboundSchema),
  providerFleets: z.array(z.lazy(() => ProviderFleet3$outboundSchema)),
  region: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus21$outboundSchema),
  backend: z.literal("azure"),
});

export function dataAzure2ToJSON(dataAzure2: DataAzure2): string {
  return JSON.stringify(DataAzure2$outboundSchema.parse(dataAzure2));
}

/** @internal */
export const Category2$outboundSchema: z.ZodEnum<typeof Category2> = z.enum(
  Category2,
);

/** @internal */
export type CapacityBlocker2$Outbound = {
  category: string;
  message: string;
  observedAt: string;
  providerCode?: string | null | undefined;
  providerReference?: string | null | undefined;
};

/** @internal */
export const CapacityBlocker2$outboundSchema: z.ZodType<
  CapacityBlocker2$Outbound,
  CapacityBlocker2
> = z.object({
  category: Category2$outboundSchema,
  message: z.string(),
  observedAt: z.date().transform(v => v.toISOString()),
  providerCode: z.nullable(z.string()).optional(),
  providerReference: z.nullable(z.string()).optional(),
});

export function capacityBlocker2ToJSON(
  capacityBlocker2: CapacityBlocker2,
): string {
  return JSON.stringify(
    CapacityBlocker2$outboundSchema.parse(capacityBlocker2),
  );
}

/** @internal */
export type CapacityBlockerUnion2$Outbound = CapacityBlocker2$Outbound | any;

/** @internal */
export const CapacityBlockerUnion2$outboundSchema: z.ZodType<
  CapacityBlockerUnion2$Outbound,
  CapacityBlockerUnion2
> = z.union([z.lazy(() => CapacityBlocker2$outboundSchema), z.any()]);

export function capacityBlockerUnion2ToJSON(
  capacityBlockerUnion2: CapacityBlockerUnion2,
): string {
  return JSON.stringify(
    CapacityBlockerUnion2$outboundSchema.parse(capacityBlockerUnion2),
  );
}

/** @internal */
export type DrainProgressBlocker2$Outbound = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

/** @internal */
export const DrainProgressBlocker2$outboundSchema: z.ZodType<
  DrainProgressBlocker2$Outbound,
  DrainProgressBlocker2
> = z.object({
  reason: z.string(),
  replicaId: z.string(),
  schedulingMode: z.string(),
  state: z.string(),
  workloadName: z.string(),
});

export function drainProgressBlocker2ToJSON(
  drainProgressBlocker2: DrainProgressBlocker2,
): string {
  return JSON.stringify(
    DrainProgressBlocker2$outboundSchema.parse(drainProgressBlocker2),
  );
}

/** @internal */
export const DrainProgressStatus2$outboundSchema: z.ZodEnum<
  typeof DrainProgressStatus2
> = z.enum(DrainProgressStatus2);

/** @internal */
export type DrainProgress2$Outbound = {
  blockers?: Array<DrainProgressBlocker2$Outbound> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  force: boolean;
  machineId: string;
  replicaCount: number;
  stalled: boolean;
  status: string;
};

/** @internal */
export const DrainProgress2$outboundSchema: z.ZodType<
  DrainProgress2$Outbound,
  DrainProgress2
> = z.object({
  blockers: z.array(z.lazy(() => DrainProgressBlocker2$outboundSchema))
    .optional(),
  drainDeadlineAt: z.nullable(z.string()).optional(),
  drainRequestedAt: z.nullable(z.string()).optional(),
  drainedAt: z.nullable(z.string()).optional(),
  force: z.boolean(),
  machineId: z.string(),
  replicaCount: z.int(),
  stalled: z.boolean(),
  status: DrainProgressStatus2$outboundSchema,
});

export function drainProgress2ToJSON(drainProgress2: DrainProgress2): string {
  return JSON.stringify(DrainProgress2$outboundSchema.parse(drainProgress2));
}

/** @internal */
export type DrainProgressUnion2$Outbound = DrainProgress2$Outbound | any;

/** @internal */
export const DrainProgressUnion2$outboundSchema: z.ZodType<
  DrainProgressUnion2$Outbound,
  DrainProgressUnion2
> = z.union([z.lazy(() => DrainProgress2$outboundSchema), z.any()]);

export function drainProgressUnion2ToJSON(
  drainProgressUnion2: DrainProgressUnion2,
): string {
  return JSON.stringify(
    DrainProgressUnion2$outboundSchema.parse(drainProgressUnion2),
  );
}

/** @internal */
export const UtilizationUnit2$outboundSchema: z.ZodEnum<
  typeof UtilizationUnit2
> = z.enum(UtilizationUnit2);

/** @internal */
export type Utilization2$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const Utilization2$outboundSchema: z.ZodType<
  Utilization2$Outbound,
  Utilization2
> = z.object({
  unit: UtilizationUnit2$outboundSchema,
  value: z.number(),
});

export function utilization2ToJSON(utilization2: Utilization2): string {
  return JSON.stringify(Utilization2$outboundSchema.parse(utilization2));
}

/** @internal */
export type UtilizationUnion2$Outbound = Utilization2$Outbound | any;

/** @internal */
export const UtilizationUnion2$outboundSchema: z.ZodType<
  UtilizationUnion2$Outbound,
  UtilizationUnion2
> = z.union([z.lazy(() => Utilization2$outboundSchema), z.any()]);

export function utilizationUnion2ToJSON(
  utilizationUnion2: UtilizationUnion2,
): string {
  return JSON.stringify(
    UtilizationUnion2$outboundSchema.parse(utilizationUnion2),
  );
}

/** @internal */
export type Recommendation2$Outbound = {
  desiredMachines: number;
  reason?: string | null | undefined;
  unschedulableReplicas?: number | null | undefined;
  utilization?: Utilization2$Outbound | any | null | undefined;
};

/** @internal */
export const Recommendation2$outboundSchema: z.ZodType<
  Recommendation2$Outbound,
  Recommendation2
> = z.object({
  desiredMachines: z.int(),
  reason: z.nullable(z.string()).optional(),
  unschedulableReplicas: z.nullable(z.int()).optional(),
  utilization: z.nullable(
    z.union([z.lazy(() => Utilization2$outboundSchema), z.any()]),
  ).optional(),
});

export function recommendation2ToJSON(
  recommendation2: Recommendation2,
): string {
  return JSON.stringify(Recommendation2$outboundSchema.parse(recommendation2));
}

/** @internal */
export type RecommendationUnion2$Outbound = Recommendation2$Outbound | any;

/** @internal */
export const RecommendationUnion2$outboundSchema: z.ZodType<
  RecommendationUnion2$Outbound,
  RecommendationUnion2
> = z.union([z.lazy(() => Recommendation2$outboundSchema), z.any()]);

export function recommendationUnion2ToJSON(
  recommendationUnion2: RecommendationUnion2,
): string {
  return JSON.stringify(
    RecommendationUnion2$outboundSchema.parse(recommendationUnion2),
  );
}

/** @internal */
export type CapacityGroup2$Outbound = {
  capacityBlocker?: CapacityBlocker2$Outbound | any | null | undefined;
  currentMachines: number;
  desiredMachines: number;
  drainProgress?: DrainProgress2$Outbound | any | null | undefined;
  groupId: string;
  instanceType?: string | null | undefined;
  maxMachines?: number | null | undefined;
  minMachines?: number | null | undefined;
  recommendation?: Recommendation2$Outbound | any | null | undefined;
};

/** @internal */
export const CapacityGroup2$outboundSchema: z.ZodType<
  CapacityGroup2$Outbound,
  CapacityGroup2
> = z.object({
  capacityBlocker: z.nullable(
    z.union([z.lazy(() => CapacityBlocker2$outboundSchema), z.any()]),
  ).optional(),
  currentMachines: z.int(),
  desiredMachines: z.int(),
  drainProgress: z.nullable(
    z.union([z.lazy(() => DrainProgress2$outboundSchema), z.any()]),
  ).optional(),
  groupId: z.string(),
  instanceType: z.nullable(z.string()).optional(),
  maxMachines: z.nullable(z.int()).optional(),
  minMachines: z.nullable(z.int()).optional(),
  recommendation: z.nullable(
    z.union([z.lazy(() => Recommendation2$outboundSchema), z.any()]),
  ).optional(),
});

export function capacityGroup2ToJSON(capacityGroup2: CapacityGroup2): string {
  return JSON.stringify(CapacityGroup2$outboundSchema.parse(capacityGroup2));
}

/** @internal */
export const CpuUnit8$outboundSchema: z.ZodEnum<typeof CpuUnit8> = z.enum(
  CpuUnit8,
);

/** @internal */
export type SyncReconcileRequestCpu8$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu8$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu8$Outbound,
  SyncReconcileRequestCpu8
> = z.object({
  unit: CpuUnit8$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu8ToJSON(
  syncReconcileRequestCpu8: SyncReconcileRequestCpu8,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu8$outboundSchema.parse(syncReconcileRequestCpu8),
  );
}

/** @internal */
export type CpuUnion8$Outbound = SyncReconcileRequestCpu8$Outbound | any;

/** @internal */
export const CpuUnion8$outboundSchema: z.ZodType<
  CpuUnion8$Outbound,
  CpuUnion8
> = z.union([z.lazy(() => SyncReconcileRequestCpu8$outboundSchema), z.any()]);

export function cpuUnion8ToJSON(cpuUnion8: CpuUnion8): string {
  return JSON.stringify(CpuUnion8$outboundSchema.parse(cpuUnion8));
}

/** @internal */
export const MemoryUnit8$outboundSchema: z.ZodEnum<typeof MemoryUnit8> = z.enum(
  MemoryUnit8,
);

/** @internal */
export type SyncReconcileRequestMemory8$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory8$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory8$Outbound,
  SyncReconcileRequestMemory8
> = z.object({
  unit: MemoryUnit8$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory8ToJSON(
  syncReconcileRequestMemory8: SyncReconcileRequestMemory8,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory8$outboundSchema.parse(
      syncReconcileRequestMemory8,
    ),
  );
}

/** @internal */
export type MemoryUnion8$Outbound = SyncReconcileRequestMemory8$Outbound | any;

/** @internal */
export const MemoryUnion8$outboundSchema: z.ZodType<
  MemoryUnion8$Outbound,
  MemoryUnion8
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory8$outboundSchema),
  z.any(),
]);

export function memoryUnion8ToJSON(memoryUnion8: MemoryUnion8): string {
  return JSON.stringify(MemoryUnion8$outboundSchema.parse(memoryUnion8));
}

/** @internal */
export type Nodes2$Outbound = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

/** @internal */
export const Nodes2$outboundSchema: z.ZodType<Nodes2$Outbound, Nodes2> = z
  .object({
    current: z.nullable(z.int()).optional(),
    desired: z.nullable(z.int()).optional(),
    ready: z.nullable(z.int()).optional(),
  });

export function nodes2ToJSON(nodes2: Nodes2): string {
  return JSON.stringify(Nodes2$outboundSchema.parse(nodes2));
}

/** @internal */
export type ProviderFleet2$Outbound = {
  currentMachines: number;
  desiredMachines: number;
  groupId: string;
  location?: string | null | undefined;
  providerId: string;
};

/** @internal */
export const ProviderFleet2$outboundSchema: z.ZodType<
  ProviderFleet2$Outbound,
  ProviderFleet2
> = z.object({
  currentMachines: z.int(),
  desiredMachines: z.int(),
  groupId: z.string(),
  location: z.nullable(z.string()).optional(),
  providerId: z.string(),
});

export function providerFleet2ToJSON(providerFleet2: ProviderFleet2): string {
  return JSON.stringify(ProviderFleet2$outboundSchema.parse(providerFleet2));
}

/** @internal */
export const SyncReconcileRequestReason20$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason20
> = z.enum(SyncReconcileRequestReason20);

/** @internal */
export const StatusSeverity20$outboundSchema: z.ZodEnum<
  typeof StatusSeverity20
> = z.enum(StatusSeverity20);

/** @internal */
export type SyncReconcileRequestCollectionIssue20$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue20$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue20$Outbound,
  SyncReconcileRequestCollectionIssue20
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason20$outboundSchema,
  severity: StatusSeverity20$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue20ToJSON(
  syncReconcileRequestCollectionIssue20: SyncReconcileRequestCollectionIssue20,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue20$outboundSchema.parse(
      syncReconcileRequestCollectionIssue20,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth20$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth20
> = z.enum(SyncReconcileRequestHealth20);

/** @internal */
export const SyncReconcileRequestLifecycle20$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle20
> = z.enum(SyncReconcileRequestLifecycle20);

/** @internal */
export type SyncReconcileRequestStatus20$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue20$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus20$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus20$Outbound,
  SyncReconcileRequestStatus20
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue20$outboundSchema),
  ),
  health: SyncReconcileRequestHealth20$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle20$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus20ToJSON(
  syncReconcileRequestStatus20: SyncReconcileRequestStatus20,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus20$outboundSchema.parse(
      syncReconcileRequestStatus20,
    ),
  );
}

/** @internal */
export type DataGcp2$Outbound = {
  backendClusterId?: string | null | undefined;
  capacityGroups: Array<CapacityGroup2$Outbound>;
  cpu?: SyncReconcileRequestCpu8$Outbound | any | null | undefined;
  memory?: SyncReconcileRequestMemory8$Outbound | any | null | undefined;
  name: string;
  nodes: Nodes2$Outbound;
  providerFleets: Array<ProviderFleet2$Outbound>;
  region?: string | null | undefined;
  status: SyncReconcileRequestStatus20$Outbound;
  backend: "gcp";
};

/** @internal */
export const DataGcp2$outboundSchema: z.ZodType<DataGcp2$Outbound, DataGcp2> = z
  .object({
    backendClusterId: z.nullable(z.string()).optional(),
    capacityGroups: z.array(z.lazy(() => CapacityGroup2$outboundSchema)),
    cpu: z.nullable(
      z.union([z.lazy(() => SyncReconcileRequestCpu8$outboundSchema), z.any()]),
    ).optional(),
    memory: z.nullable(
      z.union([
        z.lazy(() => SyncReconcileRequestMemory8$outboundSchema),
        z.any(),
      ]),
    ).optional(),
    name: z.string(),
    nodes: z.lazy(() => Nodes2$outboundSchema),
    providerFleets: z.array(z.lazy(() => ProviderFleet2$outboundSchema)),
    region: z.nullable(z.string()).optional(),
    status: z.lazy(() => SyncReconcileRequestStatus20$outboundSchema),
    backend: z.literal("gcp"),
  });

export function dataGcp2ToJSON(dataGcp2: DataGcp2): string {
  return JSON.stringify(DataGcp2$outboundSchema.parse(dataGcp2));
}

/** @internal */
export const Category1$outboundSchema: z.ZodEnum<typeof Category1> = z.enum(
  Category1,
);

/** @internal */
export type CapacityBlocker1$Outbound = {
  category: string;
  message: string;
  observedAt: string;
  providerCode?: string | null | undefined;
  providerReference?: string | null | undefined;
};

/** @internal */
export const CapacityBlocker1$outboundSchema: z.ZodType<
  CapacityBlocker1$Outbound,
  CapacityBlocker1
> = z.object({
  category: Category1$outboundSchema,
  message: z.string(),
  observedAt: z.date().transform(v => v.toISOString()),
  providerCode: z.nullable(z.string()).optional(),
  providerReference: z.nullable(z.string()).optional(),
});

export function capacityBlocker1ToJSON(
  capacityBlocker1: CapacityBlocker1,
): string {
  return JSON.stringify(
    CapacityBlocker1$outboundSchema.parse(capacityBlocker1),
  );
}

/** @internal */
export type CapacityBlockerUnion1$Outbound = CapacityBlocker1$Outbound | any;

/** @internal */
export const CapacityBlockerUnion1$outboundSchema: z.ZodType<
  CapacityBlockerUnion1$Outbound,
  CapacityBlockerUnion1
> = z.union([z.lazy(() => CapacityBlocker1$outboundSchema), z.any()]);

export function capacityBlockerUnion1ToJSON(
  capacityBlockerUnion1: CapacityBlockerUnion1,
): string {
  return JSON.stringify(
    CapacityBlockerUnion1$outboundSchema.parse(capacityBlockerUnion1),
  );
}

/** @internal */
export type DrainProgressBlocker1$Outbound = {
  reason: string;
  replicaId: string;
  schedulingMode: string;
  state: string;
  workloadName: string;
};

/** @internal */
export const DrainProgressBlocker1$outboundSchema: z.ZodType<
  DrainProgressBlocker1$Outbound,
  DrainProgressBlocker1
> = z.object({
  reason: z.string(),
  replicaId: z.string(),
  schedulingMode: z.string(),
  state: z.string(),
  workloadName: z.string(),
});

export function drainProgressBlocker1ToJSON(
  drainProgressBlocker1: DrainProgressBlocker1,
): string {
  return JSON.stringify(
    DrainProgressBlocker1$outboundSchema.parse(drainProgressBlocker1),
  );
}

/** @internal */
export const DrainProgressStatus1$outboundSchema: z.ZodEnum<
  typeof DrainProgressStatus1
> = z.enum(DrainProgressStatus1);

/** @internal */
export type DrainProgress1$Outbound = {
  blockers?: Array<DrainProgressBlocker1$Outbound> | undefined;
  drainDeadlineAt?: string | null | undefined;
  drainRequestedAt?: string | null | undefined;
  drainedAt?: string | null | undefined;
  force: boolean;
  machineId: string;
  replicaCount: number;
  stalled: boolean;
  status: string;
};

/** @internal */
export const DrainProgress1$outboundSchema: z.ZodType<
  DrainProgress1$Outbound,
  DrainProgress1
> = z.object({
  blockers: z.array(z.lazy(() => DrainProgressBlocker1$outboundSchema))
    .optional(),
  drainDeadlineAt: z.nullable(z.string()).optional(),
  drainRequestedAt: z.nullable(z.string()).optional(),
  drainedAt: z.nullable(z.string()).optional(),
  force: z.boolean(),
  machineId: z.string(),
  replicaCount: z.int(),
  stalled: z.boolean(),
  status: DrainProgressStatus1$outboundSchema,
});

export function drainProgress1ToJSON(drainProgress1: DrainProgress1): string {
  return JSON.stringify(DrainProgress1$outboundSchema.parse(drainProgress1));
}

/** @internal */
export type DrainProgressUnion1$Outbound = DrainProgress1$Outbound | any;

/** @internal */
export const DrainProgressUnion1$outboundSchema: z.ZodType<
  DrainProgressUnion1$Outbound,
  DrainProgressUnion1
> = z.union([z.lazy(() => DrainProgress1$outboundSchema), z.any()]);

export function drainProgressUnion1ToJSON(
  drainProgressUnion1: DrainProgressUnion1,
): string {
  return JSON.stringify(
    DrainProgressUnion1$outboundSchema.parse(drainProgressUnion1),
  );
}

/** @internal */
export const UtilizationUnit1$outboundSchema: z.ZodEnum<
  typeof UtilizationUnit1
> = z.enum(UtilizationUnit1);

/** @internal */
export type Utilization1$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const Utilization1$outboundSchema: z.ZodType<
  Utilization1$Outbound,
  Utilization1
> = z.object({
  unit: UtilizationUnit1$outboundSchema,
  value: z.number(),
});

export function utilization1ToJSON(utilization1: Utilization1): string {
  return JSON.stringify(Utilization1$outboundSchema.parse(utilization1));
}

/** @internal */
export type UtilizationUnion1$Outbound = Utilization1$Outbound | any;

/** @internal */
export const UtilizationUnion1$outboundSchema: z.ZodType<
  UtilizationUnion1$Outbound,
  UtilizationUnion1
> = z.union([z.lazy(() => Utilization1$outboundSchema), z.any()]);

export function utilizationUnion1ToJSON(
  utilizationUnion1: UtilizationUnion1,
): string {
  return JSON.stringify(
    UtilizationUnion1$outboundSchema.parse(utilizationUnion1),
  );
}

/** @internal */
export type Recommendation1$Outbound = {
  desiredMachines: number;
  reason?: string | null | undefined;
  unschedulableReplicas?: number | null | undefined;
  utilization?: Utilization1$Outbound | any | null | undefined;
};

/** @internal */
export const Recommendation1$outboundSchema: z.ZodType<
  Recommendation1$Outbound,
  Recommendation1
> = z.object({
  desiredMachines: z.int(),
  reason: z.nullable(z.string()).optional(),
  unschedulableReplicas: z.nullable(z.int()).optional(),
  utilization: z.nullable(
    z.union([z.lazy(() => Utilization1$outboundSchema), z.any()]),
  ).optional(),
});

export function recommendation1ToJSON(
  recommendation1: Recommendation1,
): string {
  return JSON.stringify(Recommendation1$outboundSchema.parse(recommendation1));
}

/** @internal */
export type RecommendationUnion1$Outbound = Recommendation1$Outbound | any;

/** @internal */
export const RecommendationUnion1$outboundSchema: z.ZodType<
  RecommendationUnion1$Outbound,
  RecommendationUnion1
> = z.union([z.lazy(() => Recommendation1$outboundSchema), z.any()]);

export function recommendationUnion1ToJSON(
  recommendationUnion1: RecommendationUnion1,
): string {
  return JSON.stringify(
    RecommendationUnion1$outboundSchema.parse(recommendationUnion1),
  );
}

/** @internal */
export type CapacityGroup1$Outbound = {
  capacityBlocker?: CapacityBlocker1$Outbound | any | null | undefined;
  currentMachines: number;
  desiredMachines: number;
  drainProgress?: DrainProgress1$Outbound | any | null | undefined;
  groupId: string;
  instanceType?: string | null | undefined;
  maxMachines?: number | null | undefined;
  minMachines?: number | null | undefined;
  recommendation?: Recommendation1$Outbound | any | null | undefined;
};

/** @internal */
export const CapacityGroup1$outboundSchema: z.ZodType<
  CapacityGroup1$Outbound,
  CapacityGroup1
> = z.object({
  capacityBlocker: z.nullable(
    z.union([z.lazy(() => CapacityBlocker1$outboundSchema), z.any()]),
  ).optional(),
  currentMachines: z.int(),
  desiredMachines: z.int(),
  drainProgress: z.nullable(
    z.union([z.lazy(() => DrainProgress1$outboundSchema), z.any()]),
  ).optional(),
  groupId: z.string(),
  instanceType: z.nullable(z.string()).optional(),
  maxMachines: z.nullable(z.int()).optional(),
  minMachines: z.nullable(z.int()).optional(),
  recommendation: z.nullable(
    z.union([z.lazy(() => Recommendation1$outboundSchema), z.any()]),
  ).optional(),
});

export function capacityGroup1ToJSON(capacityGroup1: CapacityGroup1): string {
  return JSON.stringify(CapacityGroup1$outboundSchema.parse(capacityGroup1));
}

/** @internal */
export const CpuUnit7$outboundSchema: z.ZodEnum<typeof CpuUnit7> = z.enum(
  CpuUnit7,
);

/** @internal */
export type SyncReconcileRequestCpu7$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu7$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu7$Outbound,
  SyncReconcileRequestCpu7
> = z.object({
  unit: CpuUnit7$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu7ToJSON(
  syncReconcileRequestCpu7: SyncReconcileRequestCpu7,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu7$outboundSchema.parse(syncReconcileRequestCpu7),
  );
}

/** @internal */
export type CpuUnion7$Outbound = SyncReconcileRequestCpu7$Outbound | any;

/** @internal */
export const CpuUnion7$outboundSchema: z.ZodType<
  CpuUnion7$Outbound,
  CpuUnion7
> = z.union([z.lazy(() => SyncReconcileRequestCpu7$outboundSchema), z.any()]);

export function cpuUnion7ToJSON(cpuUnion7: CpuUnion7): string {
  return JSON.stringify(CpuUnion7$outboundSchema.parse(cpuUnion7));
}

/** @internal */
export const MemoryUnit7$outboundSchema: z.ZodEnum<typeof MemoryUnit7> = z.enum(
  MemoryUnit7,
);

/** @internal */
export type SyncReconcileRequestMemory7$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory7$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory7$Outbound,
  SyncReconcileRequestMemory7
> = z.object({
  unit: MemoryUnit7$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory7ToJSON(
  syncReconcileRequestMemory7: SyncReconcileRequestMemory7,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory7$outboundSchema.parse(
      syncReconcileRequestMemory7,
    ),
  );
}

/** @internal */
export type MemoryUnion7$Outbound = SyncReconcileRequestMemory7$Outbound | any;

/** @internal */
export const MemoryUnion7$outboundSchema: z.ZodType<
  MemoryUnion7$Outbound,
  MemoryUnion7
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory7$outboundSchema),
  z.any(),
]);

export function memoryUnion7ToJSON(memoryUnion7: MemoryUnion7): string {
  return JSON.stringify(MemoryUnion7$outboundSchema.parse(memoryUnion7));
}

/** @internal */
export type Nodes1$Outbound = {
  current?: number | null | undefined;
  desired?: number | null | undefined;
  ready?: number | null | undefined;
};

/** @internal */
export const Nodes1$outboundSchema: z.ZodType<Nodes1$Outbound, Nodes1> = z
  .object({
    current: z.nullable(z.int()).optional(),
    desired: z.nullable(z.int()).optional(),
    ready: z.nullable(z.int()).optional(),
  });

export function nodes1ToJSON(nodes1: Nodes1): string {
  return JSON.stringify(Nodes1$outboundSchema.parse(nodes1));
}

/** @internal */
export type ProviderFleet1$Outbound = {
  currentMachines: number;
  desiredMachines: number;
  groupId: string;
  location?: string | null | undefined;
  providerId: string;
};

/** @internal */
export const ProviderFleet1$outboundSchema: z.ZodType<
  ProviderFleet1$Outbound,
  ProviderFleet1
> = z.object({
  currentMachines: z.int(),
  desiredMachines: z.int(),
  groupId: z.string(),
  location: z.nullable(z.string()).optional(),
  providerId: z.string(),
});

export function providerFleet1ToJSON(providerFleet1: ProviderFleet1): string {
  return JSON.stringify(ProviderFleet1$outboundSchema.parse(providerFleet1));
}

/** @internal */
export const SyncReconcileRequestReason19$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason19
> = z.enum(SyncReconcileRequestReason19);

/** @internal */
export const StatusSeverity19$outboundSchema: z.ZodEnum<
  typeof StatusSeverity19
> = z.enum(StatusSeverity19);

/** @internal */
export type SyncReconcileRequestCollectionIssue19$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue19$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue19$Outbound,
  SyncReconcileRequestCollectionIssue19
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason19$outboundSchema,
  severity: StatusSeverity19$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue19ToJSON(
  syncReconcileRequestCollectionIssue19: SyncReconcileRequestCollectionIssue19,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue19$outboundSchema.parse(
      syncReconcileRequestCollectionIssue19,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth19$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth19
> = z.enum(SyncReconcileRequestHealth19);

/** @internal */
export const SyncReconcileRequestLifecycle19$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle19
> = z.enum(SyncReconcileRequestLifecycle19);

/** @internal */
export type SyncReconcileRequestStatus19$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue19$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus19$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus19$Outbound,
  SyncReconcileRequestStatus19
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue19$outboundSchema),
  ),
  health: SyncReconcileRequestHealth19$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle19$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus19ToJSON(
  syncReconcileRequestStatus19: SyncReconcileRequestStatus19,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus19$outboundSchema.parse(
      syncReconcileRequestStatus19,
    ),
  );
}

/** @internal */
export type DataAws2$Outbound = {
  backendClusterId?: string | null | undefined;
  capacityGroups: Array<CapacityGroup1$Outbound>;
  cpu?: SyncReconcileRequestCpu7$Outbound | any | null | undefined;
  memory?: SyncReconcileRequestMemory7$Outbound | any | null | undefined;
  name: string;
  nodes: Nodes1$Outbound;
  providerFleets: Array<ProviderFleet1$Outbound>;
  region?: string | null | undefined;
  status: SyncReconcileRequestStatus19$Outbound;
  backend: "aws";
};

/** @internal */
export const DataAws2$outboundSchema: z.ZodType<DataAws2$Outbound, DataAws2> = z
  .object({
    backendClusterId: z.nullable(z.string()).optional(),
    capacityGroups: z.array(z.lazy(() => CapacityGroup1$outboundSchema)),
    cpu: z.nullable(
      z.union([z.lazy(() => SyncReconcileRequestCpu7$outboundSchema), z.any()]),
    ).optional(),
    memory: z.nullable(
      z.union([
        z.lazy(() => SyncReconcileRequestMemory7$outboundSchema),
        z.any(),
      ]),
    ).optional(),
    name: z.string(),
    nodes: z.lazy(() => Nodes1$outboundSchema),
    providerFleets: z.array(z.lazy(() => ProviderFleet1$outboundSchema)),
    region: z.nullable(z.string()).optional(),
    status: z.lazy(() => SyncReconcileRequestStatus19$outboundSchema),
    backend: z.literal("aws"),
  });

export function dataAws2ToJSON(dataAws2: DataAws2): string {
  return JSON.stringify(DataAws2$outboundSchema.parse(dataAws2));
}

/** @internal */
export type SyncReconcileRequestDataUnion5$Outbound =
  | DataAws2$Outbound
  | DataGcp2$Outbound
  | DataAzure2$Outbound
  | DataMachines2$Outbound
  | DataLocal5$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion5$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion5$Outbound,
  SyncReconcileRequestDataUnion5
> = z.union([
  z.lazy(() => DataAws2$outboundSchema),
  z.lazy(() => DataGcp2$outboundSchema),
  z.lazy(() => DataAzure2$outboundSchema),
  z.lazy(() => DataMachines2$outboundSchema),
  z.lazy(() => DataLocal5$outboundSchema),
]);

export function syncReconcileRequestDataUnion5ToJSON(
  syncReconcileRequestDataUnion5: SyncReconcileRequestDataUnion5,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion5$outboundSchema.parse(
      syncReconcileRequestDataUnion5,
    ),
  );
}

/** @internal */
export type DataComputeCluster$Outbound = {
  data:
    | DataAws2$Outbound
    | DataGcp2$Outbound
    | DataAzure2$Outbound
    | DataMachines2$Outbound
    | DataLocal5$Outbound;
  resourceType: "compute-cluster";
};

/** @internal */
export const DataComputeCluster$outboundSchema: z.ZodType<
  DataComputeCluster$Outbound,
  DataComputeCluster
> = z.object({
  data: z.union([
    z.lazy(() => DataAws2$outboundSchema),
    z.lazy(() => DataGcp2$outboundSchema),
    z.lazy(() => DataAzure2$outboundSchema),
    z.lazy(() => DataMachines2$outboundSchema),
    z.lazy(() => DataLocal5$outboundSchema),
  ]),
  resourceType: z.literal("compute-cluster"),
});

export function dataComputeClusterToJSON(
  dataComputeCluster: DataComputeCluster,
): string {
  return JSON.stringify(
    DataComputeCluster$outboundSchema.parse(dataComputeCluster),
  );
}

/** @internal */
export const DaemonInstanceCpuUnit$outboundSchema: z.ZodEnum<
  typeof DaemonInstanceCpuUnit
> = z.enum(DaemonInstanceCpuUnit);

/** @internal */
export type DaemonInstanceCpu$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const DaemonInstanceCpu$outboundSchema: z.ZodType<
  DaemonInstanceCpu$Outbound,
  DaemonInstanceCpu
> = z.object({
  unit: DaemonInstanceCpuUnit$outboundSchema,
  value: z.number(),
});

export function daemonInstanceCpuToJSON(
  daemonInstanceCpu: DaemonInstanceCpu,
): string {
  return JSON.stringify(
    DaemonInstanceCpu$outboundSchema.parse(daemonInstanceCpu),
  );
}

/** @internal */
export type DaemonInstanceCpuUnion5$Outbound = DaemonInstanceCpu$Outbound | any;

/** @internal */
export const DaemonInstanceCpuUnion5$outboundSchema: z.ZodType<
  DaemonInstanceCpuUnion5$Outbound,
  DaemonInstanceCpuUnion5
> = z.union([z.lazy(() => DaemonInstanceCpu$outboundSchema), z.any()]);

export function daemonInstanceCpuUnion5ToJSON(
  daemonInstanceCpuUnion5: DaemonInstanceCpuUnion5,
): string {
  return JSON.stringify(
    DaemonInstanceCpuUnion5$outboundSchema.parse(daemonInstanceCpuUnion5),
  );
}

/** @internal */
export const DaemonInstanceKind$outboundSchema: z.ZodEnum<
  typeof DaemonInstanceKind
> = z.enum(DaemonInstanceKind);

/** @internal */
export const DaemonInstanceMemoryUnit$outboundSchema: z.ZodEnum<
  typeof DaemonInstanceMemoryUnit
> = z.enum(DaemonInstanceMemoryUnit);

/** @internal */
export type DaemonInstanceMemory$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const DaemonInstanceMemory$outboundSchema: z.ZodType<
  DaemonInstanceMemory$Outbound,
  DaemonInstanceMemory
> = z.object({
  unit: DaemonInstanceMemoryUnit$outboundSchema,
  value: z.number(),
});

export function daemonInstanceMemoryToJSON(
  daemonInstanceMemory: DaemonInstanceMemory,
): string {
  return JSON.stringify(
    DaemonInstanceMemory$outboundSchema.parse(daemonInstanceMemory),
  );
}

/** @internal */
export type DaemonInstanceMemoryUnion5$Outbound =
  | DaemonInstanceMemory$Outbound
  | any;

/** @internal */
export const DaemonInstanceMemoryUnion5$outboundSchema: z.ZodType<
  DaemonInstanceMemoryUnion5$Outbound,
  DaemonInstanceMemoryUnion5
> = z.union([z.lazy(() => DaemonInstanceMemory$outboundSchema), z.any()]);

export function daemonInstanceMemoryUnion5ToJSON(
  daemonInstanceMemoryUnion5: DaemonInstanceMemoryUnion5,
): string {
  return JSON.stringify(
    DaemonInstanceMemoryUnion5$outboundSchema.parse(daemonInstanceMemoryUnion5),
  );
}

/** @internal */
export type DaemonInstance5$Outbound = {
  cpu?: DaemonInstanceCpu$Outbound | any | null | undefined;
  kind: string;
  memory?: DaemonInstanceMemory$Outbound | any | null | undefined;
  name: string;
  phase?: string | null | undefined;
  pid?: number | null | undefined;
  ready: boolean;
  restartCount?: number | null | undefined;
  unitId: string;
};

/** @internal */
export const DaemonInstance5$outboundSchema: z.ZodType<
  DaemonInstance5$Outbound,
  DaemonInstance5
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => DaemonInstanceCpu$outboundSchema), z.any()]),
  ).optional(),
  kind: DaemonInstanceKind$outboundSchema,
  memory: z.nullable(
    z.union([z.lazy(() => DaemonInstanceMemory$outboundSchema), z.any()]),
  ).optional(),
  name: z.string(),
  phase: z.nullable(z.string()).optional(),
  pid: z.nullable(z.int()).optional(),
  ready: z.boolean(),
  restartCount: z.nullable(z.int()).optional(),
  unitId: z.string(),
});

export function daemonInstance5ToJSON(
  daemonInstance5: DaemonInstance5,
): string {
  return JSON.stringify(DaemonInstance5$outboundSchema.parse(daemonInstance5));
}

/** @internal */
export type DaemonInstanceUnion$Outbound = DaemonInstance5$Outbound | any;

/** @internal */
export const DaemonInstanceUnion$outboundSchema: z.ZodType<
  DaemonInstanceUnion$Outbound,
  DaemonInstanceUnion
> = z.union([z.lazy(() => DaemonInstance5$outboundSchema), z.any()]);

export function daemonInstanceUnionToJSON(
  daemonInstanceUnion: DaemonInstanceUnion,
): string {
  return JSON.stringify(
    DaemonInstanceUnion$outboundSchema.parse(daemonInstanceUnion),
  );
}

/** @internal */
export const EventSeverity3$outboundSchema: z.ZodEnum<typeof EventSeverity3> = z
  .enum(EventSeverity3);

/** @internal */
export type SyncReconcileRequestSubject3$Outbound = {
  id?: string | null | undefined;
  kind: string;
  name?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestSubject3$outboundSchema: z.ZodType<
  SyncReconcileRequestSubject3$Outbound,
  SyncReconcileRequestSubject3
> = z.object({
  id: z.nullable(z.string()).optional(),
  kind: z.string(),
  name: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestSubject3ToJSON(
  syncReconcileRequestSubject3: SyncReconcileRequestSubject3,
): string {
  return JSON.stringify(
    SyncReconcileRequestSubject3$outboundSchema.parse(
      syncReconcileRequestSubject3,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestSubjectUnion3$Outbound =
  | SyncReconcileRequestSubject3$Outbound
  | any;

/** @internal */
export const SyncReconcileRequestSubjectUnion3$outboundSchema: z.ZodType<
  SyncReconcileRequestSubjectUnion3$Outbound,
  SyncReconcileRequestSubjectUnion3
> = z.union([
  z.lazy(() => SyncReconcileRequestSubject3$outboundSchema),
  z.any(),
]);

export function syncReconcileRequestSubjectUnion3ToJSON(
  syncReconcileRequestSubjectUnion3: SyncReconcileRequestSubjectUnion3,
): string {
  return JSON.stringify(
    SyncReconcileRequestSubjectUnion3$outboundSchema.parse(
      syncReconcileRequestSubjectUnion3,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestEvent11$Outbound = {
  kind: string;
  message: string;
  raw?: any | null | undefined;
  severity: string;
  subject?: SyncReconcileRequestSubject3$Outbound | any | null | undefined;
  timestamp: string;
};

/** @internal */
export const SyncReconcileRequestEvent11$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent11$Outbound,
  SyncReconcileRequestEvent11
> = z.object({
  kind: z.string(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  severity: EventSeverity3$outboundSchema,
  subject: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestSubject3$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  timestamp: z.date().transform(v => v.toISOString()),
});

export function syncReconcileRequestEvent11ToJSON(
  syncReconcileRequestEvent11: SyncReconcileRequestEvent11,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent11$outboundSchema.parse(
      syncReconcileRequestEvent11,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestReason18$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason18
> = z.enum(SyncReconcileRequestReason18);

/** @internal */
export const StatusSeverity18$outboundSchema: z.ZodEnum<
  typeof StatusSeverity18
> = z.enum(StatusSeverity18);

/** @internal */
export type SyncReconcileRequestCollectionIssue18$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue18$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue18$Outbound,
  SyncReconcileRequestCollectionIssue18
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason18$outboundSchema,
  severity: StatusSeverity18$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue18ToJSON(
  syncReconcileRequestCollectionIssue18: SyncReconcileRequestCollectionIssue18,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue18$outboundSchema.parse(
      syncReconcileRequestCollectionIssue18,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth18$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth18
> = z.enum(SyncReconcileRequestHealth18);

/** @internal */
export const SyncReconcileRequestLifecycle18$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle18
> = z.enum(SyncReconcileRequestLifecycle18);

/** @internal */
export type SyncReconcileRequestStatus18$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue18$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus18$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus18$Outbound,
  SyncReconcileRequestStatus18
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue18$outboundSchema),
  ),
  health: SyncReconcileRequestHealth18$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle18$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus18ToJSON(
  syncReconcileRequestStatus18: SyncReconcileRequestStatus18,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus18$outboundSchema.parse(
      syncReconcileRequestStatus18,
    ),
  );
}

/** @internal */
export type DataLocal4$Outbound = {
  commandSupported: boolean;
  daemonInstance?: DaemonInstance5$Outbound | any | null | undefined;
  daemonName?: string | undefined;
  events: Array<SyncReconcileRequestEvent11$Outbound>;
  exitReason?: string | null | undefined;
  imagePathPresent: boolean;
  pid?: number | null | undefined;
  restartCount?: number | null | undefined;
  runtimeId: string;
  status: SyncReconcileRequestStatus18$Outbound;
  backend: "local";
};

/** @internal */
export const DataLocal4$outboundSchema: z.ZodType<
  DataLocal4$Outbound,
  DataLocal4
> = z.object({
  commandSupported: z.boolean(),
  daemonInstance: z.nullable(
    z.union([z.lazy(() => DaemonInstance5$outboundSchema), z.any()]),
  ).optional(),
  daemonName: z.string().optional(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent11$outboundSchema)),
  exitReason: z.nullable(z.string()).optional(),
  imagePathPresent: z.boolean(),
  pid: z.nullable(z.int()).optional(),
  restartCount: z.nullable(z.int()).optional(),
  runtimeId: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus18$outboundSchema),
  backend: z.literal("local"),
});

export function dataLocal4ToJSON(dataLocal4: DataLocal4): string {
  return JSON.stringify(DataLocal4$outboundSchema.parse(dataLocal4));
}

/** @internal */
export const CpuUnit6$outboundSchema: z.ZodEnum<typeof CpuUnit6> = z.enum(
  CpuUnit6,
);

/** @internal */
export type SyncReconcileRequestCpu6$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu6$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu6$Outbound,
  SyncReconcileRequestCpu6
> = z.object({
  unit: CpuUnit6$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu6ToJSON(
  syncReconcileRequestCpu6: SyncReconcileRequestCpu6,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu6$outboundSchema.parse(syncReconcileRequestCpu6),
  );
}

/** @internal */
export type CpuUnion6$Outbound = SyncReconcileRequestCpu6$Outbound | any;

/** @internal */
export const CpuUnion6$outboundSchema: z.ZodType<
  CpuUnion6$Outbound,
  CpuUnion6
> = z.union([z.lazy(() => SyncReconcileRequestCpu6$outboundSchema), z.any()]);

export function cpuUnion6ToJSON(cpuUnion6: CpuUnion6): string {
  return JSON.stringify(CpuUnion6$outboundSchema.parse(cpuUnion6));
}

/** @internal */
export type InvolvedObject8$Outbound = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

/** @internal */
export const InvolvedObject8$outboundSchema: z.ZodType<
  InvolvedObject8$Outbound,
  InvolvedObject8
> = z.object({
  apiVersion: z.nullable(z.string()).optional(),
  fieldPath: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  namespace: z.nullable(z.string()).optional(),
  resourceVersion: z.nullable(z.string()).optional(),
  uid: z.nullable(z.string()).optional(),
});

export function involvedObject8ToJSON(
  involvedObject8: InvolvedObject8,
): string {
  return JSON.stringify(InvolvedObject8$outboundSchema.parse(involvedObject8));
}

/** @internal */
export type InvolvedObjectUnion8$Outbound = InvolvedObject8$Outbound | any;

/** @internal */
export const InvolvedObjectUnion8$outboundSchema: z.ZodType<
  InvolvedObjectUnion8$Outbound,
  InvolvedObjectUnion8
> = z.union([z.lazy(() => InvolvedObject8$outboundSchema), z.any()]);

export function involvedObjectUnion8ToJSON(
  involvedObjectUnion8: InvolvedObjectUnion8,
): string {
  return JSON.stringify(
    InvolvedObjectUnion8$outboundSchema.parse(involvedObjectUnion8),
  );
}

/** @internal */
export type SourceEvent8$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent8$outboundSchema: z.ZodType<
  SourceEvent8$Outbound,
  SourceEvent8
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent8ToJSON(sourceEvent8: SourceEvent8): string {
  return JSON.stringify(SourceEvent8$outboundSchema.parse(sourceEvent8));
}

/** @internal */
export type EventSourceUnion8$Outbound = SourceEvent8$Outbound | any;

/** @internal */
export const EventSourceUnion8$outboundSchema: z.ZodType<
  EventSourceUnion8$Outbound,
  EventSourceUnion8
> = z.union([z.lazy(() => SourceEvent8$outboundSchema), z.any()]);

export function eventSourceUnion8ToJSON(
  eventSourceUnion8: EventSourceUnion8,
): string {
  return JSON.stringify(
    EventSourceUnion8$outboundSchema.parse(eventSourceUnion8),
  );
}

/** @internal */
export type SyncReconcileRequestEvent10$Outbound = {
  count?: number | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject8$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent8$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent10$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent10$Outbound,
  SyncReconcileRequestEvent10
> = z.object({
  count: z.nullable(z.int()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject8$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent8$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent10ToJSON(
  syncReconcileRequestEvent10: SyncReconcileRequestEvent10,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent10$outboundSchema.parse(
      syncReconcileRequestEvent10,
    ),
  );
}

/** @internal */
export const MemoryUnit6$outboundSchema: z.ZodEnum<typeof MemoryUnit6> = z.enum(
  MemoryUnit6,
);

/** @internal */
export type SyncReconcileRequestMemory6$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory6$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory6$Outbound,
  SyncReconcileRequestMemory6
> = z.object({
  unit: MemoryUnit6$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory6ToJSON(
  syncReconcileRequestMemory6: SyncReconcileRequestMemory6,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory6$outboundSchema.parse(
      syncReconcileRequestMemory6,
    ),
  );
}

/** @internal */
export type MemoryUnion6$Outbound = SyncReconcileRequestMemory6$Outbound | any;

/** @internal */
export const MemoryUnion6$outboundSchema: z.ZodType<
  MemoryUnion6$Outbound,
  MemoryUnion6
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory6$outboundSchema),
  z.any(),
]);

export function memoryUnion6ToJSON(memoryUnion6: MemoryUnion6): string {
  return JSON.stringify(MemoryUnion6$outboundSchema.parse(memoryUnion6));
}

/** @internal */
export const CpuPodUnit3$outboundSchema: z.ZodEnum<typeof CpuPodUnit3> = z.enum(
  CpuPodUnit3,
);

/** @internal */
export type CpuPod3$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuPod3$outboundSchema: z.ZodType<CpuPod3$Outbound, CpuPod3> = z
  .object({
    unit: CpuPodUnit3$outboundSchema,
    value: z.number(),
  });

export function cpuPod3ToJSON(cpuPod3: CpuPod3): string {
  return JSON.stringify(CpuPod3$outboundSchema.parse(cpuPod3));
}

/** @internal */
export type PodCpuUnion3$Outbound = CpuPod3$Outbound | any;

/** @internal */
export const PodCpuUnion3$outboundSchema: z.ZodType<
  PodCpuUnion3$Outbound,
  PodCpuUnion3
> = z.union([z.lazy(() => CpuPod3$outboundSchema), z.any()]);

export function podCpuUnion3ToJSON(podCpuUnion3: PodCpuUnion3): string {
  return JSON.stringify(PodCpuUnion3$outboundSchema.parse(podCpuUnion3));
}

/** @internal */
export const MemoryPodUnit3$outboundSchema: z.ZodEnum<typeof MemoryPodUnit3> = z
  .enum(MemoryPodUnit3);

/** @internal */
export type MemoryPod3$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryPod3$outboundSchema: z.ZodType<
  MemoryPod3$Outbound,
  MemoryPod3
> = z.object({
  unit: MemoryPodUnit3$outboundSchema,
  value: z.number(),
});

export function memoryPod3ToJSON(memoryPod3: MemoryPod3): string {
  return JSON.stringify(MemoryPod3$outboundSchema.parse(memoryPod3));
}

/** @internal */
export type PodMemoryUnion3$Outbound = MemoryPod3$Outbound | any;

/** @internal */
export const PodMemoryUnion3$outboundSchema: z.ZodType<
  PodMemoryUnion3$Outbound,
  PodMemoryUnion3
> = z.union([z.lazy(() => MemoryPod3$outboundSchema), z.any()]);

export function podMemoryUnion3ToJSON(
  podMemoryUnion3: PodMemoryUnion3,
): string {
  return JSON.stringify(PodMemoryUnion3$outboundSchema.parse(podMemoryUnion3));
}

/** @internal */
export type OwnerReference3$Outbound = {
  controller: boolean;
  kind: string;
  name: string;
  uid: string;
};

/** @internal */
export const OwnerReference3$outboundSchema: z.ZodType<
  OwnerReference3$Outbound,
  OwnerReference3
> = z.object({
  controller: z.boolean(),
  kind: z.string(),
  name: z.string(),
  uid: z.string(),
});

export function ownerReference3ToJSON(
  ownerReference3: OwnerReference3,
): string {
  return JSON.stringify(OwnerReference3$outboundSchema.parse(ownerReference3));
}

/** @internal */
export type Pod3$Outbound = {
  cpu?: CpuPod3$Outbound | any | null | undefined;
  memory?: MemoryPod3$Outbound | any | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  ownerReferences: Array<OwnerReference3$Outbound>;
  phase?: string | null | undefined;
  podIp?: string | null | undefined;
  ready: boolean;
  restartCount: number;
  terminatedReason?: string | null | undefined;
  uid?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

/** @internal */
export const Pod3$outboundSchema: z.ZodType<Pod3$Outbound, Pod3> = z.object({
  cpu: z.nullable(z.union([z.lazy(() => CpuPod3$outboundSchema), z.any()]))
    .optional(),
  memory: z.nullable(
    z.union([z.lazy(() => MemoryPod3$outboundSchema), z.any()]),
  ).optional(),
  name: z.string(),
  nodeName: z.nullable(z.string()).optional(),
  ownerReferences: z.array(z.lazy(() => OwnerReference3$outboundSchema)),
  phase: z.nullable(z.string()).optional(),
  podIp: z.nullable(z.string()).optional(),
  ready: z.boolean(),
  restartCount: z.int(),
  terminatedReason: z.nullable(z.string()).optional(),
  uid: z.nullable(z.string()).optional(),
  waitingReason: z.nullable(z.string()).optional(),
});

export function pod3ToJSON(pod3: Pod3): string {
  return JSON.stringify(Pod3$outboundSchema.parse(pod3));
}

/** @internal */
export type Replicas4$Outbound = {
  available?: number | null | undefined;
  current?: number | null | undefined;
  desired?: number | null | undefined;
  misscheduled?: number | null | undefined;
  ready?: number | null | undefined;
  updated?: number | null | undefined;
};

/** @internal */
export const Replicas4$outboundSchema: z.ZodType<
  Replicas4$Outbound,
  Replicas4
> = z.object({
  available: z.nullable(z.int()).optional(),
  current: z.nullable(z.int()).optional(),
  desired: z.nullable(z.int()).optional(),
  misscheduled: z.nullable(z.int()).optional(),
  ready: z.nullable(z.int()).optional(),
  updated: z.nullable(z.int()).optional(),
});

export function replicas4ToJSON(replicas4: Replicas4): string {
  return JSON.stringify(Replicas4$outboundSchema.parse(replicas4));
}

/** @internal */
export const SyncReconcileRequestReason17$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason17
> = z.enum(SyncReconcileRequestReason17);

/** @internal */
export const StatusSeverity17$outboundSchema: z.ZodEnum<
  typeof StatusSeverity17
> = z.enum(StatusSeverity17);

/** @internal */
export type SyncReconcileRequestCollectionIssue17$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue17$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue17$Outbound,
  SyncReconcileRequestCollectionIssue17
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason17$outboundSchema,
  severity: StatusSeverity17$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue17ToJSON(
  syncReconcileRequestCollectionIssue17: SyncReconcileRequestCollectionIssue17,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue17$outboundSchema.parse(
      syncReconcileRequestCollectionIssue17,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth17$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth17
> = z.enum(SyncReconcileRequestHealth17);

/** @internal */
export const SyncReconcileRequestLifecycle17$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle17
> = z.enum(SyncReconcileRequestLifecycle17);

/** @internal */
export type SyncReconcileRequestStatus17$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue17$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus17$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus17$Outbound,
  SyncReconcileRequestStatus17
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue17$outboundSchema),
  ),
  health: SyncReconcileRequestHealth17$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle17$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus17ToJSON(
  syncReconcileRequestStatus17: SyncReconcileRequestStatus17,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus17$outboundSchema.parse(
      syncReconcileRequestStatus17,
    ),
  );
}

/** @internal */
export type WorkloadCondition3$Outbound = {
  lastTransitionTime?: string | null | undefined;
  message?: string | null | undefined;
  reason?: string | null | undefined;
  status: string;
  type: string;
};

/** @internal */
export const WorkloadCondition3$outboundSchema: z.ZodType<
  WorkloadCondition3$Outbound,
  WorkloadCondition3
> = z.object({
  lastTransitionTime: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.nullable(z.string()).optional(),
  reason: z.nullable(z.string()).optional(),
  status: z.string(),
  type: z.string(),
});

export function workloadCondition3ToJSON(
  workloadCondition3: WorkloadCondition3,
): string {
  return JSON.stringify(
    WorkloadCondition3$outboundSchema.parse(workloadCondition3),
  );
}

/** @internal */
export type Workload3$Outbound = {
  availableReplicas?: number | null | undefined;
  conditions: Array<WorkloadCondition3$Outbound>;
  desiredGeneration?: number | null | undefined;
  desiredReplicas?: number | null | undefined;
  observedGeneration?: number | null | undefined;
  readyReplicas?: number | null | undefined;
  rolloutReason?: string | null | undefined;
  updatedReplicas?: number | null | undefined;
};

/** @internal */
export const Workload3$outboundSchema: z.ZodType<
  Workload3$Outbound,
  Workload3
> = z.object({
  availableReplicas: z.nullable(z.int()).optional(),
  conditions: z.array(z.lazy(() => WorkloadCondition3$outboundSchema)),
  desiredGeneration: z.nullable(z.int()).optional(),
  desiredReplicas: z.nullable(z.int()).optional(),
  observedGeneration: z.nullable(z.int()).optional(),
  readyReplicas: z.nullable(z.int()).optional(),
  rolloutReason: z.nullable(z.string()).optional(),
  updatedReplicas: z.nullable(z.int()).optional(),
});

export function workload3ToJSON(workload3: Workload3): string {
  return JSON.stringify(Workload3$outboundSchema.parse(workload3));
}

/** @internal */
export type WorkloadUnion3$Outbound = Workload3$Outbound | any;

/** @internal */
export const WorkloadUnion3$outboundSchema: z.ZodType<
  WorkloadUnion3$Outbound,
  WorkloadUnion3
> = z.union([z.lazy(() => Workload3$outboundSchema), z.any()]);

export function workloadUnion3ToJSON(workloadUnion3: WorkloadUnion3): string {
  return JSON.stringify(WorkloadUnion3$outboundSchema.parse(workloadUnion3));
}

/** @internal */
export type DataKubernetes3$Outbound = {
  commandSupported: boolean;
  cpu?: SyncReconcileRequestCpu6$Outbound | any | null | undefined;
  events: Array<SyncReconcileRequestEvent10$Outbound>;
  memory?: SyncReconcileRequestMemory6$Outbound | any | null | undefined;
  name: string;
  namespace: string;
  pods: Array<Pod3$Outbound>;
  replicas: Replicas4$Outbound;
  restarts?: number | null | undefined;
  status: SyncReconcileRequestStatus17$Outbound;
  workload?: Workload3$Outbound | any | null | undefined;
  backend: "kubernetes";
};

/** @internal */
export const DataKubernetes3$outboundSchema: z.ZodType<
  DataKubernetes3$Outbound,
  DataKubernetes3
> = z.object({
  commandSupported: z.boolean(),
  cpu: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestCpu6$outboundSchema), z.any()]),
  ).optional(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent10$outboundSchema)),
  memory: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestMemory6$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  name: z.string(),
  namespace: z.string(),
  pods: z.array(z.lazy(() => Pod3$outboundSchema)),
  replicas: z.lazy(() => Replicas4$outboundSchema),
  restarts: z.nullable(z.int()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus17$outboundSchema),
  workload: z.nullable(
    z.union([z.lazy(() => Workload3$outboundSchema), z.any()]),
  ).optional(),
  backend: z.literal("kubernetes"),
});

export function dataKubernetes3ToJSON(
  dataKubernetes3: DataKubernetes3,
): string {
  return JSON.stringify(DataKubernetes3$outboundSchema.parse(dataKubernetes3));
}

/** @internal */
export const CpuDaemonInstanceUnit4$outboundSchema: z.ZodEnum<
  typeof CpuDaemonInstanceUnit4
> = z.enum(CpuDaemonInstanceUnit4);

/** @internal */
export type CpuDaemonInstance4$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuDaemonInstance4$outboundSchema: z.ZodType<
  CpuDaemonInstance4$Outbound,
  CpuDaemonInstance4
> = z.object({
  unit: CpuDaemonInstanceUnit4$outboundSchema,
  value: z.number(),
});

export function cpuDaemonInstance4ToJSON(
  cpuDaemonInstance4: CpuDaemonInstance4,
): string {
  return JSON.stringify(
    CpuDaemonInstance4$outboundSchema.parse(cpuDaemonInstance4),
  );
}

/** @internal */
export type DaemonInstanceCpuUnion4$Outbound =
  | CpuDaemonInstance4$Outbound
  | any;

/** @internal */
export const DaemonInstanceCpuUnion4$outboundSchema: z.ZodType<
  DaemonInstanceCpuUnion4$Outbound,
  DaemonInstanceCpuUnion4
> = z.union([z.lazy(() => CpuDaemonInstance4$outboundSchema), z.any()]);

export function daemonInstanceCpuUnion4ToJSON(
  daemonInstanceCpuUnion4: DaemonInstanceCpuUnion4,
): string {
  return JSON.stringify(
    DaemonInstanceCpuUnion4$outboundSchema.parse(daemonInstanceCpuUnion4),
  );
}

/** @internal */
export const MemoryDaemonInstanceUnit4$outboundSchema: z.ZodEnum<
  typeof MemoryDaemonInstanceUnit4
> = z.enum(MemoryDaemonInstanceUnit4);

/** @internal */
export type MemoryDaemonInstance4$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryDaemonInstance4$outboundSchema: z.ZodType<
  MemoryDaemonInstance4$Outbound,
  MemoryDaemonInstance4
> = z.object({
  unit: MemoryDaemonInstanceUnit4$outboundSchema,
  value: z.number(),
});

export function memoryDaemonInstance4ToJSON(
  memoryDaemonInstance4: MemoryDaemonInstance4,
): string {
  return JSON.stringify(
    MemoryDaemonInstance4$outboundSchema.parse(memoryDaemonInstance4),
  );
}

/** @internal */
export type DaemonInstanceMemoryUnion4$Outbound =
  | MemoryDaemonInstance4$Outbound
  | any;

/** @internal */
export const DaemonInstanceMemoryUnion4$outboundSchema: z.ZodType<
  DaemonInstanceMemoryUnion4$Outbound,
  DaemonInstanceMemoryUnion4
> = z.union([z.lazy(() => MemoryDaemonInstance4$outboundSchema), z.any()]);

export function daemonInstanceMemoryUnion4ToJSON(
  daemonInstanceMemoryUnion4: DaemonInstanceMemoryUnion4,
): string {
  return JSON.stringify(
    DaemonInstanceMemoryUnion4$outboundSchema.parse(daemonInstanceMemoryUnion4),
  );
}

/** @internal */
export type DaemonInstance4$Outbound = {
  cpu?: CpuDaemonInstance4$Outbound | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryDaemonInstance4$Outbound | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

/** @internal */
export const DaemonInstance4$outboundSchema: z.ZodType<
  DaemonInstance4$Outbound,
  DaemonInstance4
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => CpuDaemonInstance4$outboundSchema), z.any()]),
  ).optional(),
  ip: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  memory: z.nullable(
    z.union([z.lazy(() => MemoryDaemonInstance4$outboundSchema), z.any()]),
  ).optional(),
  message: z.nullable(z.string()).optional(),
  metricsHealthy: z.nullable(z.boolean()).optional(),
  metricsLastUpdated: z.nullable(z.string()).optional(),
  metricsStatus: z.nullable(z.string()).optional(),
  name: z.string(),
  nodeName: z.nullable(z.string()).optional(),
  phase: z.nullable(z.string()).optional(),
  ready: z.boolean(),
  reason: z.nullable(z.string()).optional(),
  replicaId: z.string(),
  restartCount: z.nullable(z.int()).optional(),
  status: z.nullable(z.string()).optional(),
  terminatedReason: z.nullable(z.string()).optional(),
  waitingReason: z.nullable(z.string()).optional(),
});

export function daemonInstance4ToJSON(
  daemonInstance4: DaemonInstance4,
): string {
  return JSON.stringify(DaemonInstance4$outboundSchema.parse(daemonInstance4));
}

/** @internal */
export type InvolvedObject7$Outbound = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

/** @internal */
export const InvolvedObject7$outboundSchema: z.ZodType<
  InvolvedObject7$Outbound,
  InvolvedObject7
> = z.object({
  details: z.nullable(z.any()).optional(),
  id: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  replicaId: z.nullable(z.string()).optional(),
});

export function involvedObject7ToJSON(
  involvedObject7: InvolvedObject7,
): string {
  return JSON.stringify(InvolvedObject7$outboundSchema.parse(involvedObject7));
}

/** @internal */
export type InvolvedObjectUnion7$Outbound = InvolvedObject7$Outbound | any;

/** @internal */
export const InvolvedObjectUnion7$outboundSchema: z.ZodType<
  InvolvedObjectUnion7$Outbound,
  InvolvedObjectUnion7
> = z.union([z.lazy(() => InvolvedObject7$outboundSchema), z.any()]);

export function involvedObjectUnion7ToJSON(
  involvedObjectUnion7: InvolvedObjectUnion7,
): string {
  return JSON.stringify(
    InvolvedObjectUnion7$outboundSchema.parse(involvedObjectUnion7),
  );
}

/** @internal */
export type SourceEvent7$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent7$outboundSchema: z.ZodType<
  SourceEvent7$Outbound,
  SourceEvent7
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent7ToJSON(sourceEvent7: SourceEvent7): string {
  return JSON.stringify(SourceEvent7$outboundSchema.parse(sourceEvent7));
}

/** @internal */
export type EventSourceUnion7$Outbound = SourceEvent7$Outbound | any;

/** @internal */
export const EventSourceUnion7$outboundSchema: z.ZodType<
  EventSourceUnion7$Outbound,
  EventSourceUnion7
> = z.union([z.lazy(() => SourceEvent7$outboundSchema), z.any()]);

export function eventSourceUnion7ToJSON(
  eventSourceUnion7: EventSourceUnion7,
): string {
  return JSON.stringify(
    EventSourceUnion7$outboundSchema.parse(eventSourceUnion7),
  );
}

/** @internal */
export type SyncReconcileRequestEvent9$Outbound = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject7$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent7$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent9$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent9$Outbound,
  SyncReconcileRequestEvent9
> = z.object({
  count: z.nullable(z.int()).optional(),
  details: z.nullable(z.any()).optional(),
  eventId: z.nullable(z.string()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject7$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent7$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent9ToJSON(
  syncReconcileRequestEvent9: SyncReconcileRequestEvent9,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent9$outboundSchema.parse(syncReconcileRequestEvent9),
  );
}

/** @internal */
export const SyncReconcileRequestReason16$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason16
> = z.enum(SyncReconcileRequestReason16);

/** @internal */
export const StatusSeverity16$outboundSchema: z.ZodEnum<
  typeof StatusSeverity16
> = z.enum(StatusSeverity16);

/** @internal */
export type SyncReconcileRequestCollectionIssue16$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue16$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue16$Outbound,
  SyncReconcileRequestCollectionIssue16
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason16$outboundSchema,
  severity: StatusSeverity16$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue16ToJSON(
  syncReconcileRequestCollectionIssue16: SyncReconcileRequestCollectionIssue16,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue16$outboundSchema.parse(
      syncReconcileRequestCollectionIssue16,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth16$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth16
> = z.enum(SyncReconcileRequestHealth16);

/** @internal */
export const SyncReconcileRequestLifecycle16$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle16
> = z.enum(SyncReconcileRequestLifecycle16);

/** @internal */
export type SyncReconcileRequestStatus16$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue16$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus16$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus16$Outbound,
  SyncReconcileRequestStatus16
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue16$outboundSchema),
  ),
  health: SyncReconcileRequestHealth16$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle16$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus16ToJSON(
  syncReconcileRequestStatus16: SyncReconcileRequestStatus16,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus16$outboundSchema.parse(
      syncReconcileRequestStatus16,
    ),
  );
}

/** @internal */
export type DataMachines1$Outbound = {
  assignedMachines: number;
  capacityGroup: string;
  commandSupported: boolean;
  daemonInstances: Array<DaemonInstance4$Outbound>;
  daemonName?: string | undefined;
  desiredMachines: number;
  events: Array<SyncReconcileRequestEvent9$Outbound>;
  healthyInstances: number;
  horizonClusterId: string;
  horizonStatus: string;
  horizonStatusMessage?: string | null | undefined;
  horizonStatusReason?: string | null | undefined;
  latestUpdateTimestamp: string;
  observedImage?: string | null | undefined;
  status: SyncReconcileRequestStatus16$Outbound;
  unavailableInstances: number;
  backend: "machines";
};

/** @internal */
export const DataMachines1$outboundSchema: z.ZodType<
  DataMachines1$Outbound,
  DataMachines1
> = z.object({
  assignedMachines: z.int(),
  capacityGroup: z.string(),
  commandSupported: z.boolean(),
  daemonInstances: z.array(z.lazy(() => DaemonInstance4$outboundSchema)),
  daemonName: z.string().optional(),
  desiredMachines: z.int(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent9$outboundSchema)),
  healthyInstances: z.int(),
  horizonClusterId: z.string(),
  horizonStatus: z.string(),
  horizonStatusMessage: z.nullable(z.string()).optional(),
  horizonStatusReason: z.nullable(z.string()).optional(),
  latestUpdateTimestamp: z.string(),
  observedImage: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus16$outboundSchema),
  unavailableInstances: z.int(),
  backend: z.literal("machines"),
});

export function dataMachines1ToJSON(dataMachines1: DataMachines1): string {
  return JSON.stringify(DataMachines1$outboundSchema.parse(dataMachines1));
}

/** @internal */
export const CpuDaemonInstanceUnit3$outboundSchema: z.ZodEnum<
  typeof CpuDaemonInstanceUnit3
> = z.enum(CpuDaemonInstanceUnit3);

/** @internal */
export type CpuDaemonInstance3$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuDaemonInstance3$outboundSchema: z.ZodType<
  CpuDaemonInstance3$Outbound,
  CpuDaemonInstance3
> = z.object({
  unit: CpuDaemonInstanceUnit3$outboundSchema,
  value: z.number(),
});

export function cpuDaemonInstance3ToJSON(
  cpuDaemonInstance3: CpuDaemonInstance3,
): string {
  return JSON.stringify(
    CpuDaemonInstance3$outboundSchema.parse(cpuDaemonInstance3),
  );
}

/** @internal */
export type DaemonInstanceCpuUnion3$Outbound =
  | CpuDaemonInstance3$Outbound
  | any;

/** @internal */
export const DaemonInstanceCpuUnion3$outboundSchema: z.ZodType<
  DaemonInstanceCpuUnion3$Outbound,
  DaemonInstanceCpuUnion3
> = z.union([z.lazy(() => CpuDaemonInstance3$outboundSchema), z.any()]);

export function daemonInstanceCpuUnion3ToJSON(
  daemonInstanceCpuUnion3: DaemonInstanceCpuUnion3,
): string {
  return JSON.stringify(
    DaemonInstanceCpuUnion3$outboundSchema.parse(daemonInstanceCpuUnion3),
  );
}

/** @internal */
export const MemoryDaemonInstanceUnit3$outboundSchema: z.ZodEnum<
  typeof MemoryDaemonInstanceUnit3
> = z.enum(MemoryDaemonInstanceUnit3);

/** @internal */
export type MemoryDaemonInstance3$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryDaemonInstance3$outboundSchema: z.ZodType<
  MemoryDaemonInstance3$Outbound,
  MemoryDaemonInstance3
> = z.object({
  unit: MemoryDaemonInstanceUnit3$outboundSchema,
  value: z.number(),
});

export function memoryDaemonInstance3ToJSON(
  memoryDaemonInstance3: MemoryDaemonInstance3,
): string {
  return JSON.stringify(
    MemoryDaemonInstance3$outboundSchema.parse(memoryDaemonInstance3),
  );
}

/** @internal */
export type DaemonInstanceMemoryUnion3$Outbound =
  | MemoryDaemonInstance3$Outbound
  | any;

/** @internal */
export const DaemonInstanceMemoryUnion3$outboundSchema: z.ZodType<
  DaemonInstanceMemoryUnion3$Outbound,
  DaemonInstanceMemoryUnion3
> = z.union([z.lazy(() => MemoryDaemonInstance3$outboundSchema), z.any()]);

export function daemonInstanceMemoryUnion3ToJSON(
  daemonInstanceMemoryUnion3: DaemonInstanceMemoryUnion3,
): string {
  return JSON.stringify(
    DaemonInstanceMemoryUnion3$outboundSchema.parse(daemonInstanceMemoryUnion3),
  );
}

/** @internal */
export type DaemonInstance3$Outbound = {
  cpu?: CpuDaemonInstance3$Outbound | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryDaemonInstance3$Outbound | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

/** @internal */
export const DaemonInstance3$outboundSchema: z.ZodType<
  DaemonInstance3$Outbound,
  DaemonInstance3
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => CpuDaemonInstance3$outboundSchema), z.any()]),
  ).optional(),
  ip: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  memory: z.nullable(
    z.union([z.lazy(() => MemoryDaemonInstance3$outboundSchema), z.any()]),
  ).optional(),
  message: z.nullable(z.string()).optional(),
  metricsHealthy: z.nullable(z.boolean()).optional(),
  metricsLastUpdated: z.nullable(z.string()).optional(),
  metricsStatus: z.nullable(z.string()).optional(),
  name: z.string(),
  nodeName: z.nullable(z.string()).optional(),
  phase: z.nullable(z.string()).optional(),
  ready: z.boolean(),
  reason: z.nullable(z.string()).optional(),
  replicaId: z.string(),
  restartCount: z.nullable(z.int()).optional(),
  status: z.nullable(z.string()).optional(),
  terminatedReason: z.nullable(z.string()).optional(),
  waitingReason: z.nullable(z.string()).optional(),
});

export function daemonInstance3ToJSON(
  daemonInstance3: DaemonInstance3,
): string {
  return JSON.stringify(DaemonInstance3$outboundSchema.parse(daemonInstance3));
}

/** @internal */
export type InvolvedObject6$Outbound = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

/** @internal */
export const InvolvedObject6$outboundSchema: z.ZodType<
  InvolvedObject6$Outbound,
  InvolvedObject6
> = z.object({
  details: z.nullable(z.any()).optional(),
  id: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  replicaId: z.nullable(z.string()).optional(),
});

export function involvedObject6ToJSON(
  involvedObject6: InvolvedObject6,
): string {
  return JSON.stringify(InvolvedObject6$outboundSchema.parse(involvedObject6));
}

/** @internal */
export type InvolvedObjectUnion6$Outbound = InvolvedObject6$Outbound | any;

/** @internal */
export const InvolvedObjectUnion6$outboundSchema: z.ZodType<
  InvolvedObjectUnion6$Outbound,
  InvolvedObjectUnion6
> = z.union([z.lazy(() => InvolvedObject6$outboundSchema), z.any()]);

export function involvedObjectUnion6ToJSON(
  involvedObjectUnion6: InvolvedObjectUnion6,
): string {
  return JSON.stringify(
    InvolvedObjectUnion6$outboundSchema.parse(involvedObjectUnion6),
  );
}

/** @internal */
export type SourceEvent6$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent6$outboundSchema: z.ZodType<
  SourceEvent6$Outbound,
  SourceEvent6
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent6ToJSON(sourceEvent6: SourceEvent6): string {
  return JSON.stringify(SourceEvent6$outboundSchema.parse(sourceEvent6));
}

/** @internal */
export type EventSourceUnion6$Outbound = SourceEvent6$Outbound | any;

/** @internal */
export const EventSourceUnion6$outboundSchema: z.ZodType<
  EventSourceUnion6$Outbound,
  EventSourceUnion6
> = z.union([z.lazy(() => SourceEvent6$outboundSchema), z.any()]);

export function eventSourceUnion6ToJSON(
  eventSourceUnion6: EventSourceUnion6,
): string {
  return JSON.stringify(
    EventSourceUnion6$outboundSchema.parse(eventSourceUnion6),
  );
}

/** @internal */
export type SyncReconcileRequestEvent8$Outbound = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject6$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent6$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent8$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent8$Outbound,
  SyncReconcileRequestEvent8
> = z.object({
  count: z.nullable(z.int()).optional(),
  details: z.nullable(z.any()).optional(),
  eventId: z.nullable(z.string()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject6$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent6$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent8ToJSON(
  syncReconcileRequestEvent8: SyncReconcileRequestEvent8,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent8$outboundSchema.parse(syncReconcileRequestEvent8),
  );
}

/** @internal */
export const SyncReconcileRequestReason15$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason15
> = z.enum(SyncReconcileRequestReason15);

/** @internal */
export const StatusSeverity15$outboundSchema: z.ZodEnum<
  typeof StatusSeverity15
> = z.enum(StatusSeverity15);

/** @internal */
export type SyncReconcileRequestCollectionIssue15$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue15$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue15$Outbound,
  SyncReconcileRequestCollectionIssue15
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason15$outboundSchema,
  severity: StatusSeverity15$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue15ToJSON(
  syncReconcileRequestCollectionIssue15: SyncReconcileRequestCollectionIssue15,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue15$outboundSchema.parse(
      syncReconcileRequestCollectionIssue15,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth15$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth15
> = z.enum(SyncReconcileRequestHealth15);

/** @internal */
export const SyncReconcileRequestLifecycle15$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle15
> = z.enum(SyncReconcileRequestLifecycle15);

/** @internal */
export type SyncReconcileRequestStatus15$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue15$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus15$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus15$Outbound,
  SyncReconcileRequestStatus15
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue15$outboundSchema),
  ),
  health: SyncReconcileRequestHealth15$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle15$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus15ToJSON(
  syncReconcileRequestStatus15: SyncReconcileRequestStatus15,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus15$outboundSchema.parse(
      syncReconcileRequestStatus15,
    ),
  );
}

/** @internal */
export type DataAzure1$Outbound = {
  assignedMachines: number;
  capacityGroup: string;
  commandSupported: boolean;
  daemonInstances: Array<DaemonInstance3$Outbound>;
  daemonName?: string | undefined;
  desiredMachines: number;
  events: Array<SyncReconcileRequestEvent8$Outbound>;
  healthyInstances: number;
  horizonClusterId: string;
  horizonStatus: string;
  horizonStatusMessage?: string | null | undefined;
  horizonStatusReason?: string | null | undefined;
  latestUpdateTimestamp: string;
  observedImage?: string | null | undefined;
  status: SyncReconcileRequestStatus15$Outbound;
  unavailableInstances: number;
  backend: "azure";
};

/** @internal */
export const DataAzure1$outboundSchema: z.ZodType<
  DataAzure1$Outbound,
  DataAzure1
> = z.object({
  assignedMachines: z.int(),
  capacityGroup: z.string(),
  commandSupported: z.boolean(),
  daemonInstances: z.array(z.lazy(() => DaemonInstance3$outboundSchema)),
  daemonName: z.string().optional(),
  desiredMachines: z.int(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent8$outboundSchema)),
  healthyInstances: z.int(),
  horizonClusterId: z.string(),
  horizonStatus: z.string(),
  horizonStatusMessage: z.nullable(z.string()).optional(),
  horizonStatusReason: z.nullable(z.string()).optional(),
  latestUpdateTimestamp: z.string(),
  observedImage: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus15$outboundSchema),
  unavailableInstances: z.int(),
  backend: z.literal("azure"),
});

export function dataAzure1ToJSON(dataAzure1: DataAzure1): string {
  return JSON.stringify(DataAzure1$outboundSchema.parse(dataAzure1));
}

/** @internal */
export const CpuDaemonInstanceUnit2$outboundSchema: z.ZodEnum<
  typeof CpuDaemonInstanceUnit2
> = z.enum(CpuDaemonInstanceUnit2);

/** @internal */
export type CpuDaemonInstance2$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuDaemonInstance2$outboundSchema: z.ZodType<
  CpuDaemonInstance2$Outbound,
  CpuDaemonInstance2
> = z.object({
  unit: CpuDaemonInstanceUnit2$outboundSchema,
  value: z.number(),
});

export function cpuDaemonInstance2ToJSON(
  cpuDaemonInstance2: CpuDaemonInstance2,
): string {
  return JSON.stringify(
    CpuDaemonInstance2$outboundSchema.parse(cpuDaemonInstance2),
  );
}

/** @internal */
export type DaemonInstanceCpuUnion2$Outbound =
  | CpuDaemonInstance2$Outbound
  | any;

/** @internal */
export const DaemonInstanceCpuUnion2$outboundSchema: z.ZodType<
  DaemonInstanceCpuUnion2$Outbound,
  DaemonInstanceCpuUnion2
> = z.union([z.lazy(() => CpuDaemonInstance2$outboundSchema), z.any()]);

export function daemonInstanceCpuUnion2ToJSON(
  daemonInstanceCpuUnion2: DaemonInstanceCpuUnion2,
): string {
  return JSON.stringify(
    DaemonInstanceCpuUnion2$outboundSchema.parse(daemonInstanceCpuUnion2),
  );
}

/** @internal */
export const MemoryDaemonInstanceUnit2$outboundSchema: z.ZodEnum<
  typeof MemoryDaemonInstanceUnit2
> = z.enum(MemoryDaemonInstanceUnit2);

/** @internal */
export type MemoryDaemonInstance2$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryDaemonInstance2$outboundSchema: z.ZodType<
  MemoryDaemonInstance2$Outbound,
  MemoryDaemonInstance2
> = z.object({
  unit: MemoryDaemonInstanceUnit2$outboundSchema,
  value: z.number(),
});

export function memoryDaemonInstance2ToJSON(
  memoryDaemonInstance2: MemoryDaemonInstance2,
): string {
  return JSON.stringify(
    MemoryDaemonInstance2$outboundSchema.parse(memoryDaemonInstance2),
  );
}

/** @internal */
export type DaemonInstanceMemoryUnion2$Outbound =
  | MemoryDaemonInstance2$Outbound
  | any;

/** @internal */
export const DaemonInstanceMemoryUnion2$outboundSchema: z.ZodType<
  DaemonInstanceMemoryUnion2$Outbound,
  DaemonInstanceMemoryUnion2
> = z.union([z.lazy(() => MemoryDaemonInstance2$outboundSchema), z.any()]);

export function daemonInstanceMemoryUnion2ToJSON(
  daemonInstanceMemoryUnion2: DaemonInstanceMemoryUnion2,
): string {
  return JSON.stringify(
    DaemonInstanceMemoryUnion2$outboundSchema.parse(daemonInstanceMemoryUnion2),
  );
}

/** @internal */
export type DaemonInstance2$Outbound = {
  cpu?: CpuDaemonInstance2$Outbound | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryDaemonInstance2$Outbound | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

/** @internal */
export const DaemonInstance2$outboundSchema: z.ZodType<
  DaemonInstance2$Outbound,
  DaemonInstance2
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => CpuDaemonInstance2$outboundSchema), z.any()]),
  ).optional(),
  ip: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  memory: z.nullable(
    z.union([z.lazy(() => MemoryDaemonInstance2$outboundSchema), z.any()]),
  ).optional(),
  message: z.nullable(z.string()).optional(),
  metricsHealthy: z.nullable(z.boolean()).optional(),
  metricsLastUpdated: z.nullable(z.string()).optional(),
  metricsStatus: z.nullable(z.string()).optional(),
  name: z.string(),
  nodeName: z.nullable(z.string()).optional(),
  phase: z.nullable(z.string()).optional(),
  ready: z.boolean(),
  reason: z.nullable(z.string()).optional(),
  replicaId: z.string(),
  restartCount: z.nullable(z.int()).optional(),
  status: z.nullable(z.string()).optional(),
  terminatedReason: z.nullable(z.string()).optional(),
  waitingReason: z.nullable(z.string()).optional(),
});

export function daemonInstance2ToJSON(
  daemonInstance2: DaemonInstance2,
): string {
  return JSON.stringify(DaemonInstance2$outboundSchema.parse(daemonInstance2));
}

/** @internal */
export type InvolvedObject5$Outbound = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

/** @internal */
export const InvolvedObject5$outboundSchema: z.ZodType<
  InvolvedObject5$Outbound,
  InvolvedObject5
> = z.object({
  details: z.nullable(z.any()).optional(),
  id: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  replicaId: z.nullable(z.string()).optional(),
});

export function involvedObject5ToJSON(
  involvedObject5: InvolvedObject5,
): string {
  return JSON.stringify(InvolvedObject5$outboundSchema.parse(involvedObject5));
}

/** @internal */
export type InvolvedObjectUnion5$Outbound = InvolvedObject5$Outbound | any;

/** @internal */
export const InvolvedObjectUnion5$outboundSchema: z.ZodType<
  InvolvedObjectUnion5$Outbound,
  InvolvedObjectUnion5
> = z.union([z.lazy(() => InvolvedObject5$outboundSchema), z.any()]);

export function involvedObjectUnion5ToJSON(
  involvedObjectUnion5: InvolvedObjectUnion5,
): string {
  return JSON.stringify(
    InvolvedObjectUnion5$outboundSchema.parse(involvedObjectUnion5),
  );
}

/** @internal */
export type SourceEvent5$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent5$outboundSchema: z.ZodType<
  SourceEvent5$Outbound,
  SourceEvent5
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent5ToJSON(sourceEvent5: SourceEvent5): string {
  return JSON.stringify(SourceEvent5$outboundSchema.parse(sourceEvent5));
}

/** @internal */
export type EventSourceUnion5$Outbound = SourceEvent5$Outbound | any;

/** @internal */
export const EventSourceUnion5$outboundSchema: z.ZodType<
  EventSourceUnion5$Outbound,
  EventSourceUnion5
> = z.union([z.lazy(() => SourceEvent5$outboundSchema), z.any()]);

export function eventSourceUnion5ToJSON(
  eventSourceUnion5: EventSourceUnion5,
): string {
  return JSON.stringify(
    EventSourceUnion5$outboundSchema.parse(eventSourceUnion5),
  );
}

/** @internal */
export type SyncReconcileRequestEvent7$Outbound = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject5$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent5$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent7$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent7$Outbound,
  SyncReconcileRequestEvent7
> = z.object({
  count: z.nullable(z.int()).optional(),
  details: z.nullable(z.any()).optional(),
  eventId: z.nullable(z.string()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject5$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent5$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent7ToJSON(
  syncReconcileRequestEvent7: SyncReconcileRequestEvent7,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent7$outboundSchema.parse(syncReconcileRequestEvent7),
  );
}

/** @internal */
export const SyncReconcileRequestReason14$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason14
> = z.enum(SyncReconcileRequestReason14);

/** @internal */
export const StatusSeverity14$outboundSchema: z.ZodEnum<
  typeof StatusSeverity14
> = z.enum(StatusSeverity14);

/** @internal */
export type SyncReconcileRequestCollectionIssue14$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue14$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue14$Outbound,
  SyncReconcileRequestCollectionIssue14
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason14$outboundSchema,
  severity: StatusSeverity14$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue14ToJSON(
  syncReconcileRequestCollectionIssue14: SyncReconcileRequestCollectionIssue14,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue14$outboundSchema.parse(
      syncReconcileRequestCollectionIssue14,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth14$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth14
> = z.enum(SyncReconcileRequestHealth14);

/** @internal */
export const SyncReconcileRequestLifecycle14$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle14
> = z.enum(SyncReconcileRequestLifecycle14);

/** @internal */
export type SyncReconcileRequestStatus14$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue14$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus14$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus14$Outbound,
  SyncReconcileRequestStatus14
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue14$outboundSchema),
  ),
  health: SyncReconcileRequestHealth14$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle14$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus14ToJSON(
  syncReconcileRequestStatus14: SyncReconcileRequestStatus14,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus14$outboundSchema.parse(
      syncReconcileRequestStatus14,
    ),
  );
}

/** @internal */
export type DataGcp1$Outbound = {
  assignedMachines: number;
  capacityGroup: string;
  commandSupported: boolean;
  daemonInstances: Array<DaemonInstance2$Outbound>;
  daemonName?: string | undefined;
  desiredMachines: number;
  events: Array<SyncReconcileRequestEvent7$Outbound>;
  healthyInstances: number;
  horizonClusterId: string;
  horizonStatus: string;
  horizonStatusMessage?: string | null | undefined;
  horizonStatusReason?: string | null | undefined;
  latestUpdateTimestamp: string;
  observedImage?: string | null | undefined;
  status: SyncReconcileRequestStatus14$Outbound;
  unavailableInstances: number;
  backend: "gcp";
};

/** @internal */
export const DataGcp1$outboundSchema: z.ZodType<DataGcp1$Outbound, DataGcp1> = z
  .object({
    assignedMachines: z.int(),
    capacityGroup: z.string(),
    commandSupported: z.boolean(),
    daemonInstances: z.array(z.lazy(() => DaemonInstance2$outboundSchema)),
    daemonName: z.string().optional(),
    desiredMachines: z.int(),
    events: z.array(z.lazy(() => SyncReconcileRequestEvent7$outboundSchema)),
    healthyInstances: z.int(),
    horizonClusterId: z.string(),
    horizonStatus: z.string(),
    horizonStatusMessage: z.nullable(z.string()).optional(),
    horizonStatusReason: z.nullable(z.string()).optional(),
    latestUpdateTimestamp: z.string(),
    observedImage: z.nullable(z.string()).optional(),
    status: z.lazy(() => SyncReconcileRequestStatus14$outboundSchema),
    unavailableInstances: z.int(),
    backend: z.literal("gcp"),
  });

export function dataGcp1ToJSON(dataGcp1: DataGcp1): string {
  return JSON.stringify(DataGcp1$outboundSchema.parse(dataGcp1));
}

/** @internal */
export const CpuDaemonInstanceUnit1$outboundSchema: z.ZodEnum<
  typeof CpuDaemonInstanceUnit1
> = z.enum(CpuDaemonInstanceUnit1);

/** @internal */
export type CpuDaemonInstance1$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuDaemonInstance1$outboundSchema: z.ZodType<
  CpuDaemonInstance1$Outbound,
  CpuDaemonInstance1
> = z.object({
  unit: CpuDaemonInstanceUnit1$outboundSchema,
  value: z.number(),
});

export function cpuDaemonInstance1ToJSON(
  cpuDaemonInstance1: CpuDaemonInstance1,
): string {
  return JSON.stringify(
    CpuDaemonInstance1$outboundSchema.parse(cpuDaemonInstance1),
  );
}

/** @internal */
export type DaemonInstanceCpuUnion1$Outbound =
  | CpuDaemonInstance1$Outbound
  | any;

/** @internal */
export const DaemonInstanceCpuUnion1$outboundSchema: z.ZodType<
  DaemonInstanceCpuUnion1$Outbound,
  DaemonInstanceCpuUnion1
> = z.union([z.lazy(() => CpuDaemonInstance1$outboundSchema), z.any()]);

export function daemonInstanceCpuUnion1ToJSON(
  daemonInstanceCpuUnion1: DaemonInstanceCpuUnion1,
): string {
  return JSON.stringify(
    DaemonInstanceCpuUnion1$outboundSchema.parse(daemonInstanceCpuUnion1),
  );
}

/** @internal */
export const MemoryDaemonInstanceUnit1$outboundSchema: z.ZodEnum<
  typeof MemoryDaemonInstanceUnit1
> = z.enum(MemoryDaemonInstanceUnit1);

/** @internal */
export type MemoryDaemonInstance1$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryDaemonInstance1$outboundSchema: z.ZodType<
  MemoryDaemonInstance1$Outbound,
  MemoryDaemonInstance1
> = z.object({
  unit: MemoryDaemonInstanceUnit1$outboundSchema,
  value: z.number(),
});

export function memoryDaemonInstance1ToJSON(
  memoryDaemonInstance1: MemoryDaemonInstance1,
): string {
  return JSON.stringify(
    MemoryDaemonInstance1$outboundSchema.parse(memoryDaemonInstance1),
  );
}

/** @internal */
export type DaemonInstanceMemoryUnion1$Outbound =
  | MemoryDaemonInstance1$Outbound
  | any;

/** @internal */
export const DaemonInstanceMemoryUnion1$outboundSchema: z.ZodType<
  DaemonInstanceMemoryUnion1$Outbound,
  DaemonInstanceMemoryUnion1
> = z.union([z.lazy(() => MemoryDaemonInstance1$outboundSchema), z.any()]);

export function daemonInstanceMemoryUnion1ToJSON(
  daemonInstanceMemoryUnion1: DaemonInstanceMemoryUnion1,
): string {
  return JSON.stringify(
    DaemonInstanceMemoryUnion1$outboundSchema.parse(daemonInstanceMemoryUnion1),
  );
}

/** @internal */
export type DaemonInstance1$Outbound = {
  cpu?: CpuDaemonInstance1$Outbound | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryDaemonInstance1$Outbound | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

/** @internal */
export const DaemonInstance1$outboundSchema: z.ZodType<
  DaemonInstance1$Outbound,
  DaemonInstance1
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => CpuDaemonInstance1$outboundSchema), z.any()]),
  ).optional(),
  ip: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  memory: z.nullable(
    z.union([z.lazy(() => MemoryDaemonInstance1$outboundSchema), z.any()]),
  ).optional(),
  message: z.nullable(z.string()).optional(),
  metricsHealthy: z.nullable(z.boolean()).optional(),
  metricsLastUpdated: z.nullable(z.string()).optional(),
  metricsStatus: z.nullable(z.string()).optional(),
  name: z.string(),
  nodeName: z.nullable(z.string()).optional(),
  phase: z.nullable(z.string()).optional(),
  ready: z.boolean(),
  reason: z.nullable(z.string()).optional(),
  replicaId: z.string(),
  restartCount: z.nullable(z.int()).optional(),
  status: z.nullable(z.string()).optional(),
  terminatedReason: z.nullable(z.string()).optional(),
  waitingReason: z.nullable(z.string()).optional(),
});

export function daemonInstance1ToJSON(
  daemonInstance1: DaemonInstance1,
): string {
  return JSON.stringify(DaemonInstance1$outboundSchema.parse(daemonInstance1));
}

/** @internal */
export type InvolvedObject4$Outbound = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

/** @internal */
export const InvolvedObject4$outboundSchema: z.ZodType<
  InvolvedObject4$Outbound,
  InvolvedObject4
> = z.object({
  details: z.nullable(z.any()).optional(),
  id: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  replicaId: z.nullable(z.string()).optional(),
});

export function involvedObject4ToJSON(
  involvedObject4: InvolvedObject4,
): string {
  return JSON.stringify(InvolvedObject4$outboundSchema.parse(involvedObject4));
}

/** @internal */
export type InvolvedObjectUnion4$Outbound = InvolvedObject4$Outbound | any;

/** @internal */
export const InvolvedObjectUnion4$outboundSchema: z.ZodType<
  InvolvedObjectUnion4$Outbound,
  InvolvedObjectUnion4
> = z.union([z.lazy(() => InvolvedObject4$outboundSchema), z.any()]);

export function involvedObjectUnion4ToJSON(
  involvedObjectUnion4: InvolvedObjectUnion4,
): string {
  return JSON.stringify(
    InvolvedObjectUnion4$outboundSchema.parse(involvedObjectUnion4),
  );
}

/** @internal */
export type SourceEvent4$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent4$outboundSchema: z.ZodType<
  SourceEvent4$Outbound,
  SourceEvent4
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent4ToJSON(sourceEvent4: SourceEvent4): string {
  return JSON.stringify(SourceEvent4$outboundSchema.parse(sourceEvent4));
}

/** @internal */
export type EventSourceUnion4$Outbound = SourceEvent4$Outbound | any;

/** @internal */
export const EventSourceUnion4$outboundSchema: z.ZodType<
  EventSourceUnion4$Outbound,
  EventSourceUnion4
> = z.union([z.lazy(() => SourceEvent4$outboundSchema), z.any()]);

export function eventSourceUnion4ToJSON(
  eventSourceUnion4: EventSourceUnion4,
): string {
  return JSON.stringify(
    EventSourceUnion4$outboundSchema.parse(eventSourceUnion4),
  );
}

/** @internal */
export type SyncReconcileRequestEvent6$Outbound = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject4$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent4$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent6$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent6$Outbound,
  SyncReconcileRequestEvent6
> = z.object({
  count: z.nullable(z.int()).optional(),
  details: z.nullable(z.any()).optional(),
  eventId: z.nullable(z.string()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject4$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent4$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent6ToJSON(
  syncReconcileRequestEvent6: SyncReconcileRequestEvent6,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent6$outboundSchema.parse(syncReconcileRequestEvent6),
  );
}

/** @internal */
export const SyncReconcileRequestReason13$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason13
> = z.enum(SyncReconcileRequestReason13);

/** @internal */
export const StatusSeverity13$outboundSchema: z.ZodEnum<
  typeof StatusSeverity13
> = z.enum(StatusSeverity13);

/** @internal */
export type SyncReconcileRequestCollectionIssue13$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue13$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue13$Outbound,
  SyncReconcileRequestCollectionIssue13
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason13$outboundSchema,
  severity: StatusSeverity13$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue13ToJSON(
  syncReconcileRequestCollectionIssue13: SyncReconcileRequestCollectionIssue13,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue13$outboundSchema.parse(
      syncReconcileRequestCollectionIssue13,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth13$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth13
> = z.enum(SyncReconcileRequestHealth13);

/** @internal */
export const SyncReconcileRequestLifecycle13$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle13
> = z.enum(SyncReconcileRequestLifecycle13);

/** @internal */
export type SyncReconcileRequestStatus13$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue13$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus13$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus13$Outbound,
  SyncReconcileRequestStatus13
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue13$outboundSchema),
  ),
  health: SyncReconcileRequestHealth13$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle13$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus13ToJSON(
  syncReconcileRequestStatus13: SyncReconcileRequestStatus13,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus13$outboundSchema.parse(
      syncReconcileRequestStatus13,
    ),
  );
}

/** @internal */
export type DataAws1$Outbound = {
  assignedMachines: number;
  capacityGroup: string;
  commandSupported: boolean;
  daemonInstances: Array<DaemonInstance1$Outbound>;
  daemonName?: string | undefined;
  desiredMachines: number;
  events: Array<SyncReconcileRequestEvent6$Outbound>;
  healthyInstances: number;
  horizonClusterId: string;
  horizonStatus: string;
  horizonStatusMessage?: string | null | undefined;
  horizonStatusReason?: string | null | undefined;
  latestUpdateTimestamp: string;
  observedImage?: string | null | undefined;
  status: SyncReconcileRequestStatus13$Outbound;
  unavailableInstances: number;
  backend: "aws";
};

/** @internal */
export const DataAws1$outboundSchema: z.ZodType<DataAws1$Outbound, DataAws1> = z
  .object({
    assignedMachines: z.int(),
    capacityGroup: z.string(),
    commandSupported: z.boolean(),
    daemonInstances: z.array(z.lazy(() => DaemonInstance1$outboundSchema)),
    daemonName: z.string().optional(),
    desiredMachines: z.int(),
    events: z.array(z.lazy(() => SyncReconcileRequestEvent6$outboundSchema)),
    healthyInstances: z.int(),
    horizonClusterId: z.string(),
    horizonStatus: z.string(),
    horizonStatusMessage: z.nullable(z.string()).optional(),
    horizonStatusReason: z.nullable(z.string()).optional(),
    latestUpdateTimestamp: z.string(),
    observedImage: z.nullable(z.string()).optional(),
    status: z.lazy(() => SyncReconcileRequestStatus13$outboundSchema),
    unavailableInstances: z.int(),
    backend: z.literal("aws"),
  });

export function dataAws1ToJSON(dataAws1: DataAws1): string {
  return JSON.stringify(DataAws1$outboundSchema.parse(dataAws1));
}

/** @internal */
export type SyncReconcileRequestDataUnion4$Outbound =
  | DataAws1$Outbound
  | DataGcp1$Outbound
  | DataAzure1$Outbound
  | DataMachines1$Outbound
  | DataKubernetes3$Outbound
  | DataLocal4$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion4$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion4$Outbound,
  SyncReconcileRequestDataUnion4
> = z.union([
  z.lazy(() => DataAws1$outboundSchema),
  z.lazy(() => DataGcp1$outboundSchema),
  z.lazy(() => DataAzure1$outboundSchema),
  z.lazy(() => DataMachines1$outboundSchema),
  z.lazy(() => DataKubernetes3$outboundSchema),
  z.lazy(() => DataLocal4$outboundSchema),
]);

export function syncReconcileRequestDataUnion4ToJSON(
  syncReconcileRequestDataUnion4: SyncReconcileRequestDataUnion4,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion4$outboundSchema.parse(
      syncReconcileRequestDataUnion4,
    ),
  );
}

/** @internal */
export type DataDaemon$Outbound = {
  data:
    | DataAws1$Outbound
    | DataGcp1$Outbound
    | DataAzure1$Outbound
    | DataMachines1$Outbound
    | DataKubernetes3$Outbound
    | DataLocal4$Outbound;
  resourceType: "daemon";
};

/** @internal */
export const DataDaemon$outboundSchema: z.ZodType<
  DataDaemon$Outbound,
  DataDaemon
> = z.object({
  data: z.union([
    z.lazy(() => DataAws1$outboundSchema),
    z.lazy(() => DataGcp1$outboundSchema),
    z.lazy(() => DataAzure1$outboundSchema),
    z.lazy(() => DataMachines1$outboundSchema),
    z.lazy(() => DataKubernetes3$outboundSchema),
    z.lazy(() => DataLocal4$outboundSchema),
  ]),
  resourceType: z.literal("daemon"),
});

export function dataDaemonToJSON(dataDaemon: DataDaemon): string {
  return JSON.stringify(DataDaemon$outboundSchema.parse(dataDaemon));
}

/** @internal */
export const ContainerUnitCpuUnit$outboundSchema: z.ZodEnum<
  typeof ContainerUnitCpuUnit
> = z.enum(ContainerUnitCpuUnit);

/** @internal */
export type ContainerUnitCpu$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const ContainerUnitCpu$outboundSchema: z.ZodType<
  ContainerUnitCpu$Outbound,
  ContainerUnitCpu
> = z.object({
  unit: ContainerUnitCpuUnit$outboundSchema,
  value: z.number(),
});

export function containerUnitCpuToJSON(
  containerUnitCpu: ContainerUnitCpu,
): string {
  return JSON.stringify(
    ContainerUnitCpu$outboundSchema.parse(containerUnitCpu),
  );
}

/** @internal */
export type ContainerUnitCpuUnion$Outbound = ContainerUnitCpu$Outbound | any;

/** @internal */
export const ContainerUnitCpuUnion$outboundSchema: z.ZodType<
  ContainerUnitCpuUnion$Outbound,
  ContainerUnitCpuUnion
> = z.union([z.lazy(() => ContainerUnitCpu$outboundSchema), z.any()]);

export function containerUnitCpuUnionToJSON(
  containerUnitCpuUnion: ContainerUnitCpuUnion,
): string {
  return JSON.stringify(
    ContainerUnitCpuUnion$outboundSchema.parse(containerUnitCpuUnion),
  );
}

/** @internal */
export const ContainerUnitKind$outboundSchema: z.ZodEnum<
  typeof ContainerUnitKind
> = z.enum(ContainerUnitKind);

/** @internal */
export const ContainerUnitMemoryUnit$outboundSchema: z.ZodEnum<
  typeof ContainerUnitMemoryUnit
> = z.enum(ContainerUnitMemoryUnit);

/** @internal */
export type ContainerUnitMemory$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const ContainerUnitMemory$outboundSchema: z.ZodType<
  ContainerUnitMemory$Outbound,
  ContainerUnitMemory
> = z.object({
  unit: ContainerUnitMemoryUnit$outboundSchema,
  value: z.number(),
});

export function containerUnitMemoryToJSON(
  containerUnitMemory: ContainerUnitMemory,
): string {
  return JSON.stringify(
    ContainerUnitMemory$outboundSchema.parse(containerUnitMemory),
  );
}

/** @internal */
export type ContainerUnitMemoryUnion$Outbound =
  | ContainerUnitMemory$Outbound
  | any;

/** @internal */
export const ContainerUnitMemoryUnion$outboundSchema: z.ZodType<
  ContainerUnitMemoryUnion$Outbound,
  ContainerUnitMemoryUnion
> = z.union([z.lazy(() => ContainerUnitMemory$outboundSchema), z.any()]);

export function containerUnitMemoryUnionToJSON(
  containerUnitMemoryUnion: ContainerUnitMemoryUnion,
): string {
  return JSON.stringify(
    ContainerUnitMemoryUnion$outboundSchema.parse(containerUnitMemoryUnion),
  );
}

/** @internal */
export type ContainerUnit$Outbound = {
  cpu?: ContainerUnitCpu$Outbound | any | null | undefined;
  kind: string;
  memory?: ContainerUnitMemory$Outbound | any | null | undefined;
  name: string;
  phase?: string | null | undefined;
  pid?: number | null | undefined;
  ready: boolean;
  restartCount?: number | null | undefined;
  unitId: string;
};

/** @internal */
export const ContainerUnit$outboundSchema: z.ZodType<
  ContainerUnit$Outbound,
  ContainerUnit
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => ContainerUnitCpu$outboundSchema), z.any()]),
  ).optional(),
  kind: ContainerUnitKind$outboundSchema,
  memory: z.nullable(
    z.union([z.lazy(() => ContainerUnitMemory$outboundSchema), z.any()]),
  ).optional(),
  name: z.string(),
  phase: z.nullable(z.string()).optional(),
  pid: z.nullable(z.int()).optional(),
  ready: z.boolean(),
  restartCount: z.nullable(z.int()).optional(),
  unitId: z.string(),
});

export function containerUnitToJSON(containerUnit: ContainerUnit): string {
  return JSON.stringify(ContainerUnit$outboundSchema.parse(containerUnit));
}

/** @internal */
export type ContainerUnitUnion$Outbound = ContainerUnit$Outbound | any;

/** @internal */
export const ContainerUnitUnion$outboundSchema: z.ZodType<
  ContainerUnitUnion$Outbound,
  ContainerUnitUnion
> = z.union([z.lazy(() => ContainerUnit$outboundSchema), z.any()]);

export function containerUnitUnionToJSON(
  containerUnitUnion: ContainerUnitUnion,
): string {
  return JSON.stringify(
    ContainerUnitUnion$outboundSchema.parse(containerUnitUnion),
  );
}

/** @internal */
export const CpuUnit5$outboundSchema: z.ZodEnum<typeof CpuUnit5> = z.enum(
  CpuUnit5,
);

/** @internal */
export type SyncReconcileRequestCpu5$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu5$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu5$Outbound,
  SyncReconcileRequestCpu5
> = z.object({
  unit: CpuUnit5$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu5ToJSON(
  syncReconcileRequestCpu5: SyncReconcileRequestCpu5,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu5$outboundSchema.parse(syncReconcileRequestCpu5),
  );
}

/** @internal */
export type CpuUnion5$Outbound = SyncReconcileRequestCpu5$Outbound | any;

/** @internal */
export const CpuUnion5$outboundSchema: z.ZodType<
  CpuUnion5$Outbound,
  CpuUnion5
> = z.union([z.lazy(() => SyncReconcileRequestCpu5$outboundSchema), z.any()]);

export function cpuUnion5ToJSON(cpuUnion5: CpuUnion5): string {
  return JSON.stringify(CpuUnion5$outboundSchema.parse(cpuUnion5));
}

/** @internal */
export const EventSeverity2$outboundSchema: z.ZodEnum<typeof EventSeverity2> = z
  .enum(EventSeverity2);

/** @internal */
export type SyncReconcileRequestSubject2$Outbound = {
  id?: string | null | undefined;
  kind: string;
  name?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestSubject2$outboundSchema: z.ZodType<
  SyncReconcileRequestSubject2$Outbound,
  SyncReconcileRequestSubject2
> = z.object({
  id: z.nullable(z.string()).optional(),
  kind: z.string(),
  name: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestSubject2ToJSON(
  syncReconcileRequestSubject2: SyncReconcileRequestSubject2,
): string {
  return JSON.stringify(
    SyncReconcileRequestSubject2$outboundSchema.parse(
      syncReconcileRequestSubject2,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestSubjectUnion2$Outbound =
  | SyncReconcileRequestSubject2$Outbound
  | any;

/** @internal */
export const SyncReconcileRequestSubjectUnion2$outboundSchema: z.ZodType<
  SyncReconcileRequestSubjectUnion2$Outbound,
  SyncReconcileRequestSubjectUnion2
> = z.union([
  z.lazy(() => SyncReconcileRequestSubject2$outboundSchema),
  z.any(),
]);

export function syncReconcileRequestSubjectUnion2ToJSON(
  syncReconcileRequestSubjectUnion2: SyncReconcileRequestSubjectUnion2,
): string {
  return JSON.stringify(
    SyncReconcileRequestSubjectUnion2$outboundSchema.parse(
      syncReconcileRequestSubjectUnion2,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestEvent5$Outbound = {
  kind: string;
  message: string;
  raw?: any | null | undefined;
  severity: string;
  subject?: SyncReconcileRequestSubject2$Outbound | any | null | undefined;
  timestamp: string;
};

/** @internal */
export const SyncReconcileRequestEvent5$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent5$Outbound,
  SyncReconcileRequestEvent5
> = z.object({
  kind: z.string(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  severity: EventSeverity2$outboundSchema,
  subject: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestSubject2$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  timestamp: z.date().transform(v => v.toISOString()),
});

export function syncReconcileRequestEvent5ToJSON(
  syncReconcileRequestEvent5: SyncReconcileRequestEvent5,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent5$outboundSchema.parse(syncReconcileRequestEvent5),
  );
}

/** @internal */
export const MemoryUnit5$outboundSchema: z.ZodEnum<typeof MemoryUnit5> = z.enum(
  MemoryUnit5,
);

/** @internal */
export type SyncReconcileRequestMemory5$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory5$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory5$Outbound,
  SyncReconcileRequestMemory5
> = z.object({
  unit: MemoryUnit5$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory5ToJSON(
  syncReconcileRequestMemory5: SyncReconcileRequestMemory5,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory5$outboundSchema.parse(
      syncReconcileRequestMemory5,
    ),
  );
}

/** @internal */
export type MemoryUnion5$Outbound = SyncReconcileRequestMemory5$Outbound | any;

/** @internal */
export const MemoryUnion5$outboundSchema: z.ZodType<
  MemoryUnion5$Outbound,
  MemoryUnion5
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory5$outboundSchema),
  z.any(),
]);

export function memoryUnion5ToJSON(memoryUnion5: MemoryUnion5): string {
  return JSON.stringify(MemoryUnion5$outboundSchema.parse(memoryUnion5));
}

/** @internal */
export const SyncReconcileRequestReason12$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason12
> = z.enum(SyncReconcileRequestReason12);

/** @internal */
export const StatusSeverity12$outboundSchema: z.ZodEnum<
  typeof StatusSeverity12
> = z.enum(StatusSeverity12);

/** @internal */
export type SyncReconcileRequestCollectionIssue12$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue12$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue12$Outbound,
  SyncReconcileRequestCollectionIssue12
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason12$outboundSchema,
  severity: StatusSeverity12$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue12ToJSON(
  syncReconcileRequestCollectionIssue12: SyncReconcileRequestCollectionIssue12,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue12$outboundSchema.parse(
      syncReconcileRequestCollectionIssue12,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth12$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth12
> = z.enum(SyncReconcileRequestHealth12);

/** @internal */
export const SyncReconcileRequestLifecycle12$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle12
> = z.enum(SyncReconcileRequestLifecycle12);

/** @internal */
export type SyncReconcileRequestStatus12$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue12$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus12$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus12$Outbound,
  SyncReconcileRequestStatus12
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue12$outboundSchema),
  ),
  health: SyncReconcileRequestHealth12$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle12$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus12ToJSON(
  syncReconcileRequestStatus12: SyncReconcileRequestStatus12,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus12$outboundSchema.parse(
      syncReconcileRequestStatus12,
    ),
  );
}

/** @internal */
export type DataLocal3$Outbound = {
  bindMountCount: number;
  containerId?: string | null | undefined;
  containerUnit?: ContainerUnit$Outbound | any | null | undefined;
  cpu?: SyncReconcileRequestCpu5$Outbound | any | null | undefined;
  events: Array<SyncReconcileRequestEvent5$Outbound>;
  image?: string | null | undefined;
  localUrl?: string | null | undefined;
  memory?: SyncReconcileRequestMemory5$Outbound | any | null | undefined;
  name?: string | null | undefined;
  portCount: number;
  restartCount?: number | null | undefined;
  runtimeReachable: boolean;
  runtimeStatus?: string | null | undefined;
  status: SyncReconcileRequestStatus12$Outbound;
  backend: "local";
};

/** @internal */
export const DataLocal3$outboundSchema: z.ZodType<
  DataLocal3$Outbound,
  DataLocal3
> = z.object({
  bindMountCount: z.int(),
  containerId: z.nullable(z.string()).optional(),
  containerUnit: z.nullable(
    z.union([z.lazy(() => ContainerUnit$outboundSchema), z.any()]),
  ).optional(),
  cpu: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestCpu5$outboundSchema), z.any()]),
  ).optional(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent5$outboundSchema)),
  image: z.nullable(z.string()).optional(),
  localUrl: z.nullable(z.string()).optional(),
  memory: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestMemory5$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  name: z.nullable(z.string()).optional(),
  portCount: z.int(),
  restartCount: z.nullable(z.int()).optional(),
  runtimeReachable: z.boolean(),
  runtimeStatus: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus12$outboundSchema),
  backend: z.literal("local"),
});

export function dataLocal3ToJSON(dataLocal3: DataLocal3): string {
  return JSON.stringify(DataLocal3$outboundSchema.parse(dataLocal3));
}

/** @internal */
export const CpuUnit4$outboundSchema: z.ZodEnum<typeof CpuUnit4> = z.enum(
  CpuUnit4,
);

/** @internal */
export type SyncReconcileRequestCpu4$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu4$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu4$Outbound,
  SyncReconcileRequestCpu4
> = z.object({
  unit: CpuUnit4$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu4ToJSON(
  syncReconcileRequestCpu4: SyncReconcileRequestCpu4,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu4$outboundSchema.parse(syncReconcileRequestCpu4),
  );
}

/** @internal */
export type CpuUnion4$Outbound = SyncReconcileRequestCpu4$Outbound | any;

/** @internal */
export const CpuUnion4$outboundSchema: z.ZodType<
  CpuUnion4$Outbound,
  CpuUnion4
> = z.union([z.lazy(() => SyncReconcileRequestCpu4$outboundSchema), z.any()]);

export function cpuUnion4ToJSON(cpuUnion4: CpuUnion4): string {
  return JSON.stringify(CpuUnion4$outboundSchema.parse(cpuUnion4));
}

/** @internal */
export type InvolvedObject3$Outbound = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

/** @internal */
export const InvolvedObject3$outboundSchema: z.ZodType<
  InvolvedObject3$Outbound,
  InvolvedObject3
> = z.object({
  apiVersion: z.nullable(z.string()).optional(),
  fieldPath: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  namespace: z.nullable(z.string()).optional(),
  resourceVersion: z.nullable(z.string()).optional(),
  uid: z.nullable(z.string()).optional(),
});

export function involvedObject3ToJSON(
  involvedObject3: InvolvedObject3,
): string {
  return JSON.stringify(InvolvedObject3$outboundSchema.parse(involvedObject3));
}

/** @internal */
export type InvolvedObjectUnion3$Outbound = InvolvedObject3$Outbound | any;

/** @internal */
export const InvolvedObjectUnion3$outboundSchema: z.ZodType<
  InvolvedObjectUnion3$Outbound,
  InvolvedObjectUnion3
> = z.union([z.lazy(() => InvolvedObject3$outboundSchema), z.any()]);

export function involvedObjectUnion3ToJSON(
  involvedObjectUnion3: InvolvedObjectUnion3,
): string {
  return JSON.stringify(
    InvolvedObjectUnion3$outboundSchema.parse(involvedObjectUnion3),
  );
}

/** @internal */
export type SourceEvent3$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent3$outboundSchema: z.ZodType<
  SourceEvent3$Outbound,
  SourceEvent3
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent3ToJSON(sourceEvent3: SourceEvent3): string {
  return JSON.stringify(SourceEvent3$outboundSchema.parse(sourceEvent3));
}

/** @internal */
export type EventSourceUnion3$Outbound = SourceEvent3$Outbound | any;

/** @internal */
export const EventSourceUnion3$outboundSchema: z.ZodType<
  EventSourceUnion3$Outbound,
  EventSourceUnion3
> = z.union([z.lazy(() => SourceEvent3$outboundSchema), z.any()]);

export function eventSourceUnion3ToJSON(
  eventSourceUnion3: EventSourceUnion3,
): string {
  return JSON.stringify(
    EventSourceUnion3$outboundSchema.parse(eventSourceUnion3),
  );
}

/** @internal */
export type SyncReconcileRequestEvent4$Outbound = {
  count?: number | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject3$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent3$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent4$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent4$Outbound,
  SyncReconcileRequestEvent4
> = z.object({
  count: z.nullable(z.int()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject3$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent3$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent4ToJSON(
  syncReconcileRequestEvent4: SyncReconcileRequestEvent4,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent4$outboundSchema.parse(syncReconcileRequestEvent4),
  );
}

/** @internal */
export const MemoryUnit4$outboundSchema: z.ZodEnum<typeof MemoryUnit4> = z.enum(
  MemoryUnit4,
);

/** @internal */
export type SyncReconcileRequestMemory4$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory4$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory4$Outbound,
  SyncReconcileRequestMemory4
> = z.object({
  unit: MemoryUnit4$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory4ToJSON(
  syncReconcileRequestMemory4: SyncReconcileRequestMemory4,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory4$outboundSchema.parse(
      syncReconcileRequestMemory4,
    ),
  );
}

/** @internal */
export type MemoryUnion4$Outbound = SyncReconcileRequestMemory4$Outbound | any;

/** @internal */
export const MemoryUnion4$outboundSchema: z.ZodType<
  MemoryUnion4$Outbound,
  MemoryUnion4
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory4$outboundSchema),
  z.any(),
]);

export function memoryUnion4ToJSON(memoryUnion4: MemoryUnion4): string {
  return JSON.stringify(MemoryUnion4$outboundSchema.parse(memoryUnion4));
}

/** @internal */
export const CpuPodUnit2$outboundSchema: z.ZodEnum<typeof CpuPodUnit2> = z.enum(
  CpuPodUnit2,
);

/** @internal */
export type CpuPod2$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuPod2$outboundSchema: z.ZodType<CpuPod2$Outbound, CpuPod2> = z
  .object({
    unit: CpuPodUnit2$outboundSchema,
    value: z.number(),
  });

export function cpuPod2ToJSON(cpuPod2: CpuPod2): string {
  return JSON.stringify(CpuPod2$outboundSchema.parse(cpuPod2));
}

/** @internal */
export type PodCpuUnion2$Outbound = CpuPod2$Outbound | any;

/** @internal */
export const PodCpuUnion2$outboundSchema: z.ZodType<
  PodCpuUnion2$Outbound,
  PodCpuUnion2
> = z.union([z.lazy(() => CpuPod2$outboundSchema), z.any()]);

export function podCpuUnion2ToJSON(podCpuUnion2: PodCpuUnion2): string {
  return JSON.stringify(PodCpuUnion2$outboundSchema.parse(podCpuUnion2));
}

/** @internal */
export const MemoryPodUnit2$outboundSchema: z.ZodEnum<typeof MemoryPodUnit2> = z
  .enum(MemoryPodUnit2);

/** @internal */
export type MemoryPod2$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryPod2$outboundSchema: z.ZodType<
  MemoryPod2$Outbound,
  MemoryPod2
> = z.object({
  unit: MemoryPodUnit2$outboundSchema,
  value: z.number(),
});

export function memoryPod2ToJSON(memoryPod2: MemoryPod2): string {
  return JSON.stringify(MemoryPod2$outboundSchema.parse(memoryPod2));
}

/** @internal */
export type PodMemoryUnion2$Outbound = MemoryPod2$Outbound | any;

/** @internal */
export const PodMemoryUnion2$outboundSchema: z.ZodType<
  PodMemoryUnion2$Outbound,
  PodMemoryUnion2
> = z.union([z.lazy(() => MemoryPod2$outboundSchema), z.any()]);

export function podMemoryUnion2ToJSON(
  podMemoryUnion2: PodMemoryUnion2,
): string {
  return JSON.stringify(PodMemoryUnion2$outboundSchema.parse(podMemoryUnion2));
}

/** @internal */
export type OwnerReference2$Outbound = {
  controller: boolean;
  kind: string;
  name: string;
  uid: string;
};

/** @internal */
export const OwnerReference2$outboundSchema: z.ZodType<
  OwnerReference2$Outbound,
  OwnerReference2
> = z.object({
  controller: z.boolean(),
  kind: z.string(),
  name: z.string(),
  uid: z.string(),
});

export function ownerReference2ToJSON(
  ownerReference2: OwnerReference2,
): string {
  return JSON.stringify(OwnerReference2$outboundSchema.parse(ownerReference2));
}

/** @internal */
export type Pod2$Outbound = {
  cpu?: CpuPod2$Outbound | any | null | undefined;
  memory?: MemoryPod2$Outbound | any | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  ownerReferences: Array<OwnerReference2$Outbound>;
  phase?: string | null | undefined;
  podIp?: string | null | undefined;
  ready: boolean;
  restartCount: number;
  terminatedReason?: string | null | undefined;
  uid?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

/** @internal */
export const Pod2$outboundSchema: z.ZodType<Pod2$Outbound, Pod2> = z.object({
  cpu: z.nullable(z.union([z.lazy(() => CpuPod2$outboundSchema), z.any()]))
    .optional(),
  memory: z.nullable(
    z.union([z.lazy(() => MemoryPod2$outboundSchema), z.any()]),
  ).optional(),
  name: z.string(),
  nodeName: z.nullable(z.string()).optional(),
  ownerReferences: z.array(z.lazy(() => OwnerReference2$outboundSchema)),
  phase: z.nullable(z.string()).optional(),
  podIp: z.nullable(z.string()).optional(),
  ready: z.boolean(),
  restartCount: z.int(),
  terminatedReason: z.nullable(z.string()).optional(),
  uid: z.nullable(z.string()).optional(),
  waitingReason: z.nullable(z.string()).optional(),
});

export function pod2ToJSON(pod2: Pod2): string {
  return JSON.stringify(Pod2$outboundSchema.parse(pod2));
}

/** @internal */
export type Replicas3$Outbound = {
  available?: number | null | undefined;
  current?: number | null | undefined;
  desired?: number | null | undefined;
  misscheduled?: number | null | undefined;
  ready?: number | null | undefined;
  updated?: number | null | undefined;
};

/** @internal */
export const Replicas3$outboundSchema: z.ZodType<
  Replicas3$Outbound,
  Replicas3
> = z.object({
  available: z.nullable(z.int()).optional(),
  current: z.nullable(z.int()).optional(),
  desired: z.nullable(z.int()).optional(),
  misscheduled: z.nullable(z.int()).optional(),
  ready: z.nullable(z.int()).optional(),
  updated: z.nullable(z.int()).optional(),
});

export function replicas3ToJSON(replicas3: Replicas3): string {
  return JSON.stringify(Replicas3$outboundSchema.parse(replicas3));
}

/** @internal */
export const SyncReconcileRequestReason11$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason11
> = z.enum(SyncReconcileRequestReason11);

/** @internal */
export const StatusSeverity11$outboundSchema: z.ZodEnum<
  typeof StatusSeverity11
> = z.enum(StatusSeverity11);

/** @internal */
export type SyncReconcileRequestCollectionIssue11$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue11$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue11$Outbound,
  SyncReconcileRequestCollectionIssue11
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason11$outboundSchema,
  severity: StatusSeverity11$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue11ToJSON(
  syncReconcileRequestCollectionIssue11: SyncReconcileRequestCollectionIssue11,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue11$outboundSchema.parse(
      syncReconcileRequestCollectionIssue11,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth11$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth11
> = z.enum(SyncReconcileRequestHealth11);

/** @internal */
export const SyncReconcileRequestLifecycle11$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle11
> = z.enum(SyncReconcileRequestLifecycle11);

/** @internal */
export type SyncReconcileRequestStatus11$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue11$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus11$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus11$Outbound,
  SyncReconcileRequestStatus11
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue11$outboundSchema),
  ),
  health: SyncReconcileRequestHealth11$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle11$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus11ToJSON(
  syncReconcileRequestStatus11: SyncReconcileRequestStatus11,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus11$outboundSchema.parse(
      syncReconcileRequestStatus11,
    ),
  );
}

/** @internal */
export type WorkloadCondition2$Outbound = {
  lastTransitionTime?: string | null | undefined;
  message?: string | null | undefined;
  reason?: string | null | undefined;
  status: string;
  type: string;
};

/** @internal */
export const WorkloadCondition2$outboundSchema: z.ZodType<
  WorkloadCondition2$Outbound,
  WorkloadCondition2
> = z.object({
  lastTransitionTime: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.nullable(z.string()).optional(),
  reason: z.nullable(z.string()).optional(),
  status: z.string(),
  type: z.string(),
});

export function workloadCondition2ToJSON(
  workloadCondition2: WorkloadCondition2,
): string {
  return JSON.stringify(
    WorkloadCondition2$outboundSchema.parse(workloadCondition2),
  );
}

/** @internal */
export type Workload2$Outbound = {
  availableReplicas?: number | null | undefined;
  conditions: Array<WorkloadCondition2$Outbound>;
  desiredGeneration?: number | null | undefined;
  desiredReplicas?: number | null | undefined;
  observedGeneration?: number | null | undefined;
  readyReplicas?: number | null | undefined;
  rolloutReason?: string | null | undefined;
  updatedReplicas?: number | null | undefined;
};

/** @internal */
export const Workload2$outboundSchema: z.ZodType<
  Workload2$Outbound,
  Workload2
> = z.object({
  availableReplicas: z.nullable(z.int()).optional(),
  conditions: z.array(z.lazy(() => WorkloadCondition2$outboundSchema)),
  desiredGeneration: z.nullable(z.int()).optional(),
  desiredReplicas: z.nullable(z.int()).optional(),
  observedGeneration: z.nullable(z.int()).optional(),
  readyReplicas: z.nullable(z.int()).optional(),
  rolloutReason: z.nullable(z.string()).optional(),
  updatedReplicas: z.nullable(z.int()).optional(),
});

export function workload2ToJSON(workload2: Workload2): string {
  return JSON.stringify(Workload2$outboundSchema.parse(workload2));
}

/** @internal */
export type WorkloadUnion2$Outbound = Workload2$Outbound | any;

/** @internal */
export const WorkloadUnion2$outboundSchema: z.ZodType<
  WorkloadUnion2$Outbound,
  WorkloadUnion2
> = z.union([z.lazy(() => Workload2$outboundSchema), z.any()]);

export function workloadUnion2ToJSON(workloadUnion2: WorkloadUnion2): string {
  return JSON.stringify(WorkloadUnion2$outboundSchema.parse(workloadUnion2));
}

/** @internal */
export const WorkloadKind2$outboundSchema: z.ZodEnum<typeof WorkloadKind2> = z
  .enum(WorkloadKind2);

/** @internal */
export type DataKubernetes2$Outbound = {
  cpu?: SyncReconcileRequestCpu4$Outbound | any | null | undefined;
  events: Array<SyncReconcileRequestEvent4$Outbound>;
  memory?: SyncReconcileRequestMemory4$Outbound | any | null | undefined;
  name: string;
  namespace: string;
  pods: Array<Pod2$Outbound>;
  replicas: Replicas3$Outbound;
  restarts?: number | null | undefined;
  status: SyncReconcileRequestStatus11$Outbound;
  workload?: Workload2$Outbound | any | null | undefined;
  workloadKind: string;
  backend: "kubernetes";
};

/** @internal */
export const DataKubernetes2$outboundSchema: z.ZodType<
  DataKubernetes2$Outbound,
  DataKubernetes2
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestCpu4$outboundSchema), z.any()]),
  ).optional(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent4$outboundSchema)),
  memory: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestMemory4$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  name: z.string(),
  namespace: z.string(),
  pods: z.array(z.lazy(() => Pod2$outboundSchema)),
  replicas: z.lazy(() => Replicas3$outboundSchema),
  restarts: z.nullable(z.int()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus11$outboundSchema),
  workload: z.nullable(
    z.union([z.lazy(() => Workload2$outboundSchema), z.any()]),
  ).optional(),
  workloadKind: WorkloadKind2$outboundSchema,
  backend: z.literal("kubernetes"),
});

export function dataKubernetes2ToJSON(
  dataKubernetes2: DataKubernetes2,
): string {
  return JSON.stringify(DataKubernetes2$outboundSchema.parse(dataKubernetes2));
}

/** @internal */
export const CpuUnit3$outboundSchema: z.ZodEnum<typeof CpuUnit3> = z.enum(
  CpuUnit3,
);

/** @internal */
export type SyncReconcileRequestCpu3$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu3$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu3$Outbound,
  SyncReconcileRequestCpu3
> = z.object({
  unit: CpuUnit3$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu3ToJSON(
  syncReconcileRequestCpu3: SyncReconcileRequestCpu3,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu3$outboundSchema.parse(syncReconcileRequestCpu3),
  );
}

/** @internal */
export type CpuUnion3$Outbound = SyncReconcileRequestCpu3$Outbound | any;

/** @internal */
export const CpuUnion3$outboundSchema: z.ZodType<
  CpuUnion3$Outbound,
  CpuUnion3
> = z.union([z.lazy(() => SyncReconcileRequestCpu3$outboundSchema), z.any()]);

export function cpuUnion3ToJSON(cpuUnion3: CpuUnion3): string {
  return JSON.stringify(CpuUnion3$outboundSchema.parse(cpuUnion3));
}

/** @internal */
export type InvolvedObject2$Outbound = {
  details?: any | null | undefined;
  id?: string | null | undefined;
  kind?: string | null | undefined;
  machineId?: string | null | undefined;
  name?: string | null | undefined;
  replicaId?: string | null | undefined;
};

/** @internal */
export const InvolvedObject2$outboundSchema: z.ZodType<
  InvolvedObject2$Outbound,
  InvolvedObject2
> = z.object({
  details: z.nullable(z.any()).optional(),
  id: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  replicaId: z.nullable(z.string()).optional(),
});

export function involvedObject2ToJSON(
  involvedObject2: InvolvedObject2,
): string {
  return JSON.stringify(InvolvedObject2$outboundSchema.parse(involvedObject2));
}

/** @internal */
export type InvolvedObjectUnion2$Outbound = InvolvedObject2$Outbound | any;

/** @internal */
export const InvolvedObjectUnion2$outboundSchema: z.ZodType<
  InvolvedObjectUnion2$Outbound,
  InvolvedObjectUnion2
> = z.union([z.lazy(() => InvolvedObject2$outboundSchema), z.any()]);

export function involvedObjectUnion2ToJSON(
  involvedObjectUnion2: InvolvedObjectUnion2,
): string {
  return JSON.stringify(
    InvolvedObjectUnion2$outboundSchema.parse(involvedObjectUnion2),
  );
}

/** @internal */
export type SourceEvent2$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent2$outboundSchema: z.ZodType<
  SourceEvent2$Outbound,
  SourceEvent2
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent2ToJSON(sourceEvent2: SourceEvent2): string {
  return JSON.stringify(SourceEvent2$outboundSchema.parse(sourceEvent2));
}

/** @internal */
export type EventSourceUnion2$Outbound = SourceEvent2$Outbound | any;

/** @internal */
export const EventSourceUnion2$outboundSchema: z.ZodType<
  EventSourceUnion2$Outbound,
  EventSourceUnion2
> = z.union([z.lazy(() => SourceEvent2$outboundSchema), z.any()]);

export function eventSourceUnion2ToJSON(
  eventSourceUnion2: EventSourceUnion2,
): string {
  return JSON.stringify(
    EventSourceUnion2$outboundSchema.parse(eventSourceUnion2),
  );
}

/** @internal */
export type SyncReconcileRequestEvent3$Outbound = {
  count?: number | null | undefined;
  details?: any | null | undefined;
  eventId?: string | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject2$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent2$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent3$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent3$Outbound,
  SyncReconcileRequestEvent3
> = z.object({
  count: z.nullable(z.int()).optional(),
  details: z.nullable(z.any()).optional(),
  eventId: z.nullable(z.string()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject2$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent2$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent3ToJSON(
  syncReconcileRequestEvent3: SyncReconcileRequestEvent3,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent3$outboundSchema.parse(syncReconcileRequestEvent3),
  );
}

/** @internal */
export const MemoryUnit3$outboundSchema: z.ZodEnum<typeof MemoryUnit3> = z.enum(
  MemoryUnit3,
);

/** @internal */
export type SyncReconcileRequestMemory3$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory3$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory3$Outbound,
  SyncReconcileRequestMemory3
> = z.object({
  unit: MemoryUnit3$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory3ToJSON(
  syncReconcileRequestMemory3: SyncReconcileRequestMemory3,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory3$outboundSchema.parse(
      syncReconcileRequestMemory3,
    ),
  );
}

/** @internal */
export type MemoryUnion3$Outbound = SyncReconcileRequestMemory3$Outbound | any;

/** @internal */
export const MemoryUnion3$outboundSchema: z.ZodType<
  MemoryUnion3$Outbound,
  MemoryUnion3
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory3$outboundSchema),
  z.any(),
]);

export function memoryUnion3ToJSON(memoryUnion3: MemoryUnion3): string {
  return JSON.stringify(MemoryUnion3$outboundSchema.parse(memoryUnion3));
}

/** @internal */
export const CpuReplicaUnitUnit$outboundSchema: z.ZodEnum<
  typeof CpuReplicaUnitUnit
> = z.enum(CpuReplicaUnitUnit);

/** @internal */
export type CpuReplicaUnit$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuReplicaUnit$outboundSchema: z.ZodType<
  CpuReplicaUnit$Outbound,
  CpuReplicaUnit
> = z.object({
  unit: CpuReplicaUnitUnit$outboundSchema,
  value: z.number(),
});

export function cpuReplicaUnitToJSON(cpuReplicaUnit: CpuReplicaUnit): string {
  return JSON.stringify(CpuReplicaUnit$outboundSchema.parse(cpuReplicaUnit));
}

/** @internal */
export type ReplicaUnitCpuUnion$Outbound = CpuReplicaUnit$Outbound | any;

/** @internal */
export const ReplicaUnitCpuUnion$outboundSchema: z.ZodType<
  ReplicaUnitCpuUnion$Outbound,
  ReplicaUnitCpuUnion
> = z.union([z.lazy(() => CpuReplicaUnit$outboundSchema), z.any()]);

export function replicaUnitCpuUnionToJSON(
  replicaUnitCpuUnion: ReplicaUnitCpuUnion,
): string {
  return JSON.stringify(
    ReplicaUnitCpuUnion$outboundSchema.parse(replicaUnitCpuUnion),
  );
}

/** @internal */
export const MemoryReplicaUnitUnit$outboundSchema: z.ZodEnum<
  typeof MemoryReplicaUnitUnit
> = z.enum(MemoryReplicaUnitUnit);

/** @internal */
export type MemoryReplicaUnit$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryReplicaUnit$outboundSchema: z.ZodType<
  MemoryReplicaUnit$Outbound,
  MemoryReplicaUnit
> = z.object({
  unit: MemoryReplicaUnitUnit$outboundSchema,
  value: z.number(),
});

export function memoryReplicaUnitToJSON(
  memoryReplicaUnit: MemoryReplicaUnit,
): string {
  return JSON.stringify(
    MemoryReplicaUnit$outboundSchema.parse(memoryReplicaUnit),
  );
}

/** @internal */
export type ReplicaUnitMemoryUnion$Outbound = MemoryReplicaUnit$Outbound | any;

/** @internal */
export const ReplicaUnitMemoryUnion$outboundSchema: z.ZodType<
  ReplicaUnitMemoryUnion$Outbound,
  ReplicaUnitMemoryUnion
> = z.union([z.lazy(() => MemoryReplicaUnit$outboundSchema), z.any()]);

export function replicaUnitMemoryUnionToJSON(
  replicaUnitMemoryUnion: ReplicaUnitMemoryUnion,
): string {
  return JSON.stringify(
    ReplicaUnitMemoryUnion$outboundSchema.parse(replicaUnitMemoryUnion),
  );
}

/** @internal */
export type ReplicaUnit$Outbound = {
  cpu?: CpuReplicaUnit$Outbound | any | null | undefined;
  ip?: string | null | undefined;
  machineId?: string | null | undefined;
  memory?: MemoryReplicaUnit$Outbound | any | null | undefined;
  message?: string | null | undefined;
  metricsHealthy?: boolean | null | undefined;
  metricsLastUpdated?: string | null | undefined;
  metricsStatus?: string | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  phase?: string | null | undefined;
  ready: boolean;
  reason?: string | null | undefined;
  replicaId: string;
  restartCount?: number | null | undefined;
  status?: string | null | undefined;
  terminatedReason?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

/** @internal */
export const ReplicaUnit$outboundSchema: z.ZodType<
  ReplicaUnit$Outbound,
  ReplicaUnit
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => CpuReplicaUnit$outboundSchema), z.any()]),
  ).optional(),
  ip: z.nullable(z.string()).optional(),
  machineId: z.nullable(z.string()).optional(),
  memory: z.nullable(
    z.union([z.lazy(() => MemoryReplicaUnit$outboundSchema), z.any()]),
  ).optional(),
  message: z.nullable(z.string()).optional(),
  metricsHealthy: z.nullable(z.boolean()).optional(),
  metricsLastUpdated: z.nullable(z.string()).optional(),
  metricsStatus: z.nullable(z.string()).optional(),
  name: z.string(),
  nodeName: z.nullable(z.string()).optional(),
  phase: z.nullable(z.string()).optional(),
  ready: z.boolean(),
  reason: z.nullable(z.string()).optional(),
  replicaId: z.string(),
  restartCount: z.nullable(z.int()).optional(),
  status: z.nullable(z.string()).optional(),
  terminatedReason: z.nullable(z.string()).optional(),
  waitingReason: z.nullable(z.string()).optional(),
});

export function replicaUnitToJSON(replicaUnit: ReplicaUnit): string {
  return JSON.stringify(ReplicaUnit$outboundSchema.parse(replicaUnit));
}

/** @internal */
export type Replicas2$Outbound = {
  available?: number | null | undefined;
  current?: number | null | undefined;
  desired?: number | null | undefined;
  misscheduled?: number | null | undefined;
  ready?: number | null | undefined;
  updated?: number | null | undefined;
};

/** @internal */
export const Replicas2$outboundSchema: z.ZodType<
  Replicas2$Outbound,
  Replicas2
> = z.object({
  available: z.nullable(z.int()).optional(),
  current: z.nullable(z.int()).optional(),
  desired: z.nullable(z.int()).optional(),
  misscheduled: z.nullable(z.int()).optional(),
  ready: z.nullable(z.int()).optional(),
  updated: z.nullable(z.int()).optional(),
});

export function replicas2ToJSON(replicas2: Replicas2): string {
  return JSON.stringify(Replicas2$outboundSchema.parse(replicas2));
}

/** @internal */
export const SchedulingMode$outboundSchema: z.ZodEnum<typeof SchedulingMode> = z
  .enum(SchedulingMode);

/** @internal */
export const SyncReconcileRequestReason10$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason10
> = z.enum(SyncReconcileRequestReason10);

/** @internal */
export const StatusSeverity10$outboundSchema: z.ZodEnum<
  typeof StatusSeverity10
> = z.enum(StatusSeverity10);

/** @internal */
export type SyncReconcileRequestCollectionIssue10$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue10$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue10$Outbound,
  SyncReconcileRequestCollectionIssue10
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason10$outboundSchema,
  severity: StatusSeverity10$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue10ToJSON(
  syncReconcileRequestCollectionIssue10: SyncReconcileRequestCollectionIssue10,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue10$outboundSchema.parse(
      syncReconcileRequestCollectionIssue10,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth10$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth10
> = z.enum(SyncReconcileRequestHealth10);

/** @internal */
export const SyncReconcileRequestLifecycle10$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle10
> = z.enum(SyncReconcileRequestLifecycle10);

/** @internal */
export type SyncReconcileRequestStatus10$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue10$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus10$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus10$Outbound,
  SyncReconcileRequestStatus10
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue10$outboundSchema),
  ),
  health: SyncReconcileRequestHealth10$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle10$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus10ToJSON(
  syncReconcileRequestStatus10: SyncReconcileRequestStatus10,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus10$outboundSchema.parse(
      syncReconcileRequestStatus10,
    ),
  );
}

/** @internal */
export type DataHorizonPlatform$Outbound = {
  attentionCount: number;
  containerId: string;
  cpu?: SyncReconcileRequestCpu3$Outbound | any | null | undefined;
  events: Array<SyncReconcileRequestEvent3$Outbound>;
  image?: string | null | undefined;
  latestUpdateTimestamp?: string | null | undefined;
  memory?: SyncReconcileRequestMemory3$Outbound | any | null | undefined;
  observedImage?: string | null | undefined;
  replicaUnits: Array<ReplicaUnit$Outbound>;
  replicas: Replicas2$Outbound;
  schedulingMode: string;
  status: SyncReconcileRequestStatus10$Outbound;
  backend: "horizonPlatform";
};

/** @internal */
export const DataHorizonPlatform$outboundSchema: z.ZodType<
  DataHorizonPlatform$Outbound,
  DataHorizonPlatform
> = z.object({
  attentionCount: z.int(),
  containerId: z.string(),
  cpu: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestCpu3$outboundSchema), z.any()]),
  ).optional(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent3$outboundSchema)),
  image: z.nullable(z.string()).optional(),
  latestUpdateTimestamp: z.nullable(z.string()).optional(),
  memory: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestMemory3$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  observedImage: z.nullable(z.string()).optional(),
  replicaUnits: z.array(z.lazy(() => ReplicaUnit$outboundSchema)),
  replicas: z.lazy(() => Replicas2$outboundSchema),
  schedulingMode: SchedulingMode$outboundSchema,
  status: z.lazy(() => SyncReconcileRequestStatus10$outboundSchema),
  backend: z.literal("horizonPlatform"),
});

export function dataHorizonPlatformToJSON(
  dataHorizonPlatform: DataHorizonPlatform,
): string {
  return JSON.stringify(
    DataHorizonPlatform$outboundSchema.parse(dataHorizonPlatform),
  );
}

/** @internal */
export type SyncReconcileRequestDataUnion3$Outbound =
  | DataHorizonPlatform$Outbound
  | DataKubernetes2$Outbound
  | DataLocal3$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion3$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion3$Outbound,
  SyncReconcileRequestDataUnion3
> = z.union([
  z.lazy(() => DataHorizonPlatform$outboundSchema),
  z.lazy(() => DataKubernetes2$outboundSchema),
  z.lazy(() => DataLocal3$outboundSchema),
]);

export function syncReconcileRequestDataUnion3ToJSON(
  syncReconcileRequestDataUnion3: SyncReconcileRequestDataUnion3,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion3$outboundSchema.parse(
      syncReconcileRequestDataUnion3,
    ),
  );
}

/** @internal */
export type DataContainer$Outbound = {
  data:
    | DataHorizonPlatform$Outbound
    | DataKubernetes2$Outbound
    | DataLocal3$Outbound;
  resourceType: "container";
};

/** @internal */
export const DataContainer$outboundSchema: z.ZodType<
  DataContainer$Outbound,
  DataContainer
> = z.object({
  data: z.union([
    z.lazy(() => DataHorizonPlatform$outboundSchema),
    z.lazy(() => DataKubernetes2$outboundSchema),
    z.lazy(() => DataLocal3$outboundSchema),
  ]),
  resourceType: z.literal("container"),
});

export function dataContainerToJSON(dataContainer: DataContainer): string {
  return JSON.stringify(DataContainer$outboundSchema.parse(dataContainer));
}

/** @internal */
export const CpuUnit2$outboundSchema: z.ZodEnum<typeof CpuUnit2> = z.enum(
  CpuUnit2,
);

/** @internal */
export type SyncReconcileRequestCpu2$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu2$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu2$Outbound,
  SyncReconcileRequestCpu2
> = z.object({
  unit: CpuUnit2$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu2ToJSON(
  syncReconcileRequestCpu2: SyncReconcileRequestCpu2,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu2$outboundSchema.parse(syncReconcileRequestCpu2),
  );
}

/** @internal */
export type CpuUnion2$Outbound = SyncReconcileRequestCpu2$Outbound | any;

/** @internal */
export const CpuUnion2$outboundSchema: z.ZodType<
  CpuUnion2$Outbound,
  CpuUnion2
> = z.union([z.lazy(() => SyncReconcileRequestCpu2$outboundSchema), z.any()]);

export function cpuUnion2ToJSON(cpuUnion2: CpuUnion2): string {
  return JSON.stringify(CpuUnion2$outboundSchema.parse(cpuUnion2));
}

/** @internal */
export const EventSeverity1$outboundSchema: z.ZodEnum<typeof EventSeverity1> = z
  .enum(EventSeverity1);

/** @internal */
export type SyncReconcileRequestSubject1$Outbound = {
  id?: string | null | undefined;
  kind: string;
  name?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestSubject1$outboundSchema: z.ZodType<
  SyncReconcileRequestSubject1$Outbound,
  SyncReconcileRequestSubject1
> = z.object({
  id: z.nullable(z.string()).optional(),
  kind: z.string(),
  name: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestSubject1ToJSON(
  syncReconcileRequestSubject1: SyncReconcileRequestSubject1,
): string {
  return JSON.stringify(
    SyncReconcileRequestSubject1$outboundSchema.parse(
      syncReconcileRequestSubject1,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestSubjectUnion1$Outbound =
  | SyncReconcileRequestSubject1$Outbound
  | any;

/** @internal */
export const SyncReconcileRequestSubjectUnion1$outboundSchema: z.ZodType<
  SyncReconcileRequestSubjectUnion1$Outbound,
  SyncReconcileRequestSubjectUnion1
> = z.union([
  z.lazy(() => SyncReconcileRequestSubject1$outboundSchema),
  z.any(),
]);

export function syncReconcileRequestSubjectUnion1ToJSON(
  syncReconcileRequestSubjectUnion1: SyncReconcileRequestSubjectUnion1,
): string {
  return JSON.stringify(
    SyncReconcileRequestSubjectUnion1$outboundSchema.parse(
      syncReconcileRequestSubjectUnion1,
    ),
  );
}

/** @internal */
export type SyncReconcileRequestEvent2$Outbound = {
  kind: string;
  message: string;
  raw?: any | null | undefined;
  severity: string;
  subject?: SyncReconcileRequestSubject1$Outbound | any | null | undefined;
  timestamp: string;
};

/** @internal */
export const SyncReconcileRequestEvent2$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent2$Outbound,
  SyncReconcileRequestEvent2
> = z.object({
  kind: z.string(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  severity: EventSeverity1$outboundSchema,
  subject: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestSubject1$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  timestamp: z.date().transform(v => v.toISOString()),
});

export function syncReconcileRequestEvent2ToJSON(
  syncReconcileRequestEvent2: SyncReconcileRequestEvent2,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent2$outboundSchema.parse(syncReconcileRequestEvent2),
  );
}

/** @internal */
export const MemoryUnit2$outboundSchema: z.ZodEnum<typeof MemoryUnit2> = z.enum(
  MemoryUnit2,
);

/** @internal */
export type SyncReconcileRequestMemory2$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory2$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory2$Outbound,
  SyncReconcileRequestMemory2
> = z.object({
  unit: MemoryUnit2$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory2ToJSON(
  syncReconcileRequestMemory2: SyncReconcileRequestMemory2,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory2$outboundSchema.parse(
      syncReconcileRequestMemory2,
    ),
  );
}

/** @internal */
export type MemoryUnion2$Outbound = SyncReconcileRequestMemory2$Outbound | any;

/** @internal */
export const MemoryUnion2$outboundSchema: z.ZodType<
  MemoryUnion2$Outbound,
  MemoryUnion2
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory2$outboundSchema),
  z.any(),
]);

export function memoryUnion2ToJSON(memoryUnion2: MemoryUnion2): string {
  return JSON.stringify(MemoryUnion2$outboundSchema.parse(memoryUnion2));
}

/** @internal */
export const ProcessCpuUnit$outboundSchema: z.ZodEnum<typeof ProcessCpuUnit> = z
  .enum(ProcessCpuUnit);

/** @internal */
export type ProcessCpu$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const ProcessCpu$outboundSchema: z.ZodType<
  ProcessCpu$Outbound,
  ProcessCpu
> = z.object({
  unit: ProcessCpuUnit$outboundSchema,
  value: z.number(),
});

export function processCpuToJSON(processCpu: ProcessCpu): string {
  return JSON.stringify(ProcessCpu$outboundSchema.parse(processCpu));
}

/** @internal */
export type ProcessCpuUnion$Outbound = ProcessCpu$Outbound | any;

/** @internal */
export const ProcessCpuUnion$outboundSchema: z.ZodType<
  ProcessCpuUnion$Outbound,
  ProcessCpuUnion
> = z.union([z.lazy(() => ProcessCpu$outboundSchema), z.any()]);

export function processCpuUnionToJSON(
  processCpuUnion: ProcessCpuUnion,
): string {
  return JSON.stringify(ProcessCpuUnion$outboundSchema.parse(processCpuUnion));
}

/** @internal */
export const ProcessKind$outboundSchema: z.ZodEnum<typeof ProcessKind> = z.enum(
  ProcessKind,
);

/** @internal */
export const ProcessMemoryUnit$outboundSchema: z.ZodEnum<
  typeof ProcessMemoryUnit
> = z.enum(ProcessMemoryUnit);

/** @internal */
export type ProcessMemory$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const ProcessMemory$outboundSchema: z.ZodType<
  ProcessMemory$Outbound,
  ProcessMemory
> = z.object({
  unit: ProcessMemoryUnit$outboundSchema,
  value: z.number(),
});

export function processMemoryToJSON(processMemory: ProcessMemory): string {
  return JSON.stringify(ProcessMemory$outboundSchema.parse(processMemory));
}

/** @internal */
export type ProcessMemoryUnion$Outbound = ProcessMemory$Outbound | any;

/** @internal */
export const ProcessMemoryUnion$outboundSchema: z.ZodType<
  ProcessMemoryUnion$Outbound,
  ProcessMemoryUnion
> = z.union([z.lazy(() => ProcessMemory$outboundSchema), z.any()]);

export function processMemoryUnionToJSON(
  processMemoryUnion: ProcessMemoryUnion,
): string {
  return JSON.stringify(
    ProcessMemoryUnion$outboundSchema.parse(processMemoryUnion),
  );
}

/** @internal */
export type Process$Outbound = {
  cpu?: ProcessCpu$Outbound | any | null | undefined;
  kind: string;
  memory?: ProcessMemory$Outbound | any | null | undefined;
  name: string;
  phase?: string | null | undefined;
  pid?: number | null | undefined;
  ready: boolean;
  restartCount?: number | null | undefined;
  unitId: string;
};

/** @internal */
export const Process$outboundSchema: z.ZodType<Process$Outbound, Process> = z
  .object({
    cpu: z.nullable(z.union([z.lazy(() => ProcessCpu$outboundSchema), z.any()]))
      .optional(),
    kind: ProcessKind$outboundSchema,
    memory: z.nullable(
      z.union([z.lazy(() => ProcessMemory$outboundSchema), z.any()]),
    ).optional(),
    name: z.string(),
    phase: z.nullable(z.string()).optional(),
    pid: z.nullable(z.int()).optional(),
    ready: z.boolean(),
    restartCount: z.nullable(z.int()).optional(),
    unitId: z.string(),
  });

export function processToJSON(process: Process): string {
  return JSON.stringify(Process$outboundSchema.parse(process));
}

/** @internal */
export type ProcessUnion$Outbound = Process$Outbound | any;

/** @internal */
export const ProcessUnion$outboundSchema: z.ZodType<
  ProcessUnion$Outbound,
  ProcessUnion
> = z.union([z.lazy(() => Process$outboundSchema), z.any()]);

export function processUnionToJSON(processUnion: ProcessUnion): string {
  return JSON.stringify(ProcessUnion$outboundSchema.parse(processUnion));
}

/** @internal */
export const SyncReconcileRequestReason9$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason9
> = z.enum(SyncReconcileRequestReason9);

/** @internal */
export const StatusSeverity9$outboundSchema: z.ZodEnum<typeof StatusSeverity9> =
  z.enum(StatusSeverity9);

/** @internal */
export type SyncReconcileRequestCollectionIssue9$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue9$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue9$Outbound,
  SyncReconcileRequestCollectionIssue9
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason9$outboundSchema,
  severity: StatusSeverity9$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue9ToJSON(
  syncReconcileRequestCollectionIssue9: SyncReconcileRequestCollectionIssue9,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue9$outboundSchema.parse(
      syncReconcileRequestCollectionIssue9,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth9$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth9
> = z.enum(SyncReconcileRequestHealth9);

/** @internal */
export const SyncReconcileRequestLifecycle9$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle9
> = z.enum(SyncReconcileRequestLifecycle9);

/** @internal */
export type SyncReconcileRequestStatus9$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue9$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus9$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus9$Outbound,
  SyncReconcileRequestStatus9
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue9$outboundSchema),
  ),
  health: SyncReconcileRequestHealth9$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle9$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus9ToJSON(
  syncReconcileRequestStatus9: SyncReconcileRequestStatus9,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus9$outboundSchema.parse(
      syncReconcileRequestStatus9,
    ),
  );
}

/** @internal */
export type DataLocal2$Outbound = {
  commandSupported: boolean;
  cpu?: SyncReconcileRequestCpu2$Outbound | any | null | undefined;
  events: Array<SyncReconcileRequestEvent2$Outbound>;
  imagePathPresent: boolean;
  memory?: SyncReconcileRequestMemory2$Outbound | any | null | undefined;
  pid?: number | null | undefined;
  process?: Process$Outbound | any | null | undefined;
  readinessProbeOk?: boolean | null | undefined;
  status: SyncReconcileRequestStatus9$Outbound;
  triggerCount: number;
  backend: "local";
};

/** @internal */
export const DataLocal2$outboundSchema: z.ZodType<
  DataLocal2$Outbound,
  DataLocal2
> = z.object({
  commandSupported: z.boolean(),
  cpu: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestCpu2$outboundSchema), z.any()]),
  ).optional(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent2$outboundSchema)),
  imagePathPresent: z.boolean(),
  memory: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestMemory2$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  pid: z.nullable(z.int()).optional(),
  process: z.nullable(z.union([z.lazy(() => Process$outboundSchema), z.any()]))
    .optional(),
  readinessProbeOk: z.nullable(z.boolean()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus9$outboundSchema),
  triggerCount: z.int(),
  backend: z.literal("local"),
});

export function dataLocal2ToJSON(dataLocal2: DataLocal2): string {
  return JSON.stringify(DataLocal2$outboundSchema.parse(dataLocal2));
}

/** @internal */
export const CpuUnit1$outboundSchema: z.ZodEnum<typeof CpuUnit1> = z.enum(
  CpuUnit1,
);

/** @internal */
export type SyncReconcileRequestCpu1$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestCpu1$outboundSchema: z.ZodType<
  SyncReconcileRequestCpu1$Outbound,
  SyncReconcileRequestCpu1
> = z.object({
  unit: CpuUnit1$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestCpu1ToJSON(
  syncReconcileRequestCpu1: SyncReconcileRequestCpu1,
): string {
  return JSON.stringify(
    SyncReconcileRequestCpu1$outboundSchema.parse(syncReconcileRequestCpu1),
  );
}

/** @internal */
export type CpuUnion1$Outbound = SyncReconcileRequestCpu1$Outbound | any;

/** @internal */
export const CpuUnion1$outboundSchema: z.ZodType<
  CpuUnion1$Outbound,
  CpuUnion1
> = z.union([z.lazy(() => SyncReconcileRequestCpu1$outboundSchema), z.any()]);

export function cpuUnion1ToJSON(cpuUnion1: CpuUnion1): string {
  return JSON.stringify(CpuUnion1$outboundSchema.parse(cpuUnion1));
}

/** @internal */
export type InvolvedObject1$Outbound = {
  apiVersion?: string | null | undefined;
  fieldPath?: string | null | undefined;
  kind?: string | null | undefined;
  name?: string | null | undefined;
  namespace?: string | null | undefined;
  resourceVersion?: string | null | undefined;
  uid?: string | null | undefined;
};

/** @internal */
export const InvolvedObject1$outboundSchema: z.ZodType<
  InvolvedObject1$Outbound,
  InvolvedObject1
> = z.object({
  apiVersion: z.nullable(z.string()).optional(),
  fieldPath: z.nullable(z.string()).optional(),
  kind: z.nullable(z.string()).optional(),
  name: z.nullable(z.string()).optional(),
  namespace: z.nullable(z.string()).optional(),
  resourceVersion: z.nullable(z.string()).optional(),
  uid: z.nullable(z.string()).optional(),
});

export function involvedObject1ToJSON(
  involvedObject1: InvolvedObject1,
): string {
  return JSON.stringify(InvolvedObject1$outboundSchema.parse(involvedObject1));
}

/** @internal */
export type InvolvedObjectUnion1$Outbound = InvolvedObject1$Outbound | any;

/** @internal */
export const InvolvedObjectUnion1$outboundSchema: z.ZodType<
  InvolvedObjectUnion1$Outbound,
  InvolvedObjectUnion1
> = z.union([z.lazy(() => InvolvedObject1$outboundSchema), z.any()]);

export function involvedObjectUnion1ToJSON(
  involvedObjectUnion1: InvolvedObjectUnion1,
): string {
  return JSON.stringify(
    InvolvedObjectUnion1$outboundSchema.parse(involvedObjectUnion1),
  );
}

/** @internal */
export type SourceEvent1$Outbound = {
  component?: string | null | undefined;
  host?: string | null | undefined;
};

/** @internal */
export const SourceEvent1$outboundSchema: z.ZodType<
  SourceEvent1$Outbound,
  SourceEvent1
> = z.object({
  component: z.nullable(z.string()).optional(),
  host: z.nullable(z.string()).optional(),
});

export function sourceEvent1ToJSON(sourceEvent1: SourceEvent1): string {
  return JSON.stringify(SourceEvent1$outboundSchema.parse(sourceEvent1));
}

/** @internal */
export type EventSourceUnion1$Outbound = SourceEvent1$Outbound | any;

/** @internal */
export const EventSourceUnion1$outboundSchema: z.ZodType<
  EventSourceUnion1$Outbound,
  EventSourceUnion1
> = z.union([z.lazy(() => SourceEvent1$outboundSchema), z.any()]);

export function eventSourceUnion1ToJSON(
  eventSourceUnion1: EventSourceUnion1,
): string {
  return JSON.stringify(
    EventSourceUnion1$outboundSchema.parse(eventSourceUnion1),
  );
}

/** @internal */
export type SyncReconcileRequestEvent1$Outbound = {
  count?: number | null | undefined;
  eventTime?: string | null | undefined;
  firstTimestamp?: string | null | undefined;
  involvedObject?: InvolvedObject1$Outbound | any | null | undefined;
  lastTimestamp?: string | null | undefined;
  message: string;
  raw?: any | null | undefined;
  reason: string;
  source?: SourceEvent1$Outbound | any | null | undefined;
  type?: string | null | undefined;
};

/** @internal */
export const SyncReconcileRequestEvent1$outboundSchema: z.ZodType<
  SyncReconcileRequestEvent1$Outbound,
  SyncReconcileRequestEvent1
> = z.object({
  count: z.nullable(z.int()).optional(),
  eventTime: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  firstTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  involvedObject: z.nullable(
    z.union([z.lazy(() => InvolvedObject1$outboundSchema), z.any()]),
  ).optional(),
  lastTimestamp: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.string(),
  raw: z.nullable(z.any()).optional(),
  reason: z.string(),
  source: z.nullable(
    z.union([z.lazy(() => SourceEvent1$outboundSchema), z.any()]),
  ).optional(),
  type: z.nullable(z.string()).optional(),
});

export function syncReconcileRequestEvent1ToJSON(
  syncReconcileRequestEvent1: SyncReconcileRequestEvent1,
): string {
  return JSON.stringify(
    SyncReconcileRequestEvent1$outboundSchema.parse(syncReconcileRequestEvent1),
  );
}

/** @internal */
export const MemoryUnit1$outboundSchema: z.ZodEnum<typeof MemoryUnit1> = z.enum(
  MemoryUnit1,
);

/** @internal */
export type SyncReconcileRequestMemory1$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const SyncReconcileRequestMemory1$outboundSchema: z.ZodType<
  SyncReconcileRequestMemory1$Outbound,
  SyncReconcileRequestMemory1
> = z.object({
  unit: MemoryUnit1$outboundSchema,
  value: z.number(),
});

export function syncReconcileRequestMemory1ToJSON(
  syncReconcileRequestMemory1: SyncReconcileRequestMemory1,
): string {
  return JSON.stringify(
    SyncReconcileRequestMemory1$outboundSchema.parse(
      syncReconcileRequestMemory1,
    ),
  );
}

/** @internal */
export type MemoryUnion1$Outbound = SyncReconcileRequestMemory1$Outbound | any;

/** @internal */
export const MemoryUnion1$outboundSchema: z.ZodType<
  MemoryUnion1$Outbound,
  MemoryUnion1
> = z.union([
  z.lazy(() => SyncReconcileRequestMemory1$outboundSchema),
  z.any(),
]);

export function memoryUnion1ToJSON(memoryUnion1: MemoryUnion1): string {
  return JSON.stringify(MemoryUnion1$outboundSchema.parse(memoryUnion1));
}

/** @internal */
export const CpuPodUnit1$outboundSchema: z.ZodEnum<typeof CpuPodUnit1> = z.enum(
  CpuPodUnit1,
);

/** @internal */
export type CpuPod1$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const CpuPod1$outboundSchema: z.ZodType<CpuPod1$Outbound, CpuPod1> = z
  .object({
    unit: CpuPodUnit1$outboundSchema,
    value: z.number(),
  });

export function cpuPod1ToJSON(cpuPod1: CpuPod1): string {
  return JSON.stringify(CpuPod1$outboundSchema.parse(cpuPod1));
}

/** @internal */
export type PodCpuUnion1$Outbound = CpuPod1$Outbound | any;

/** @internal */
export const PodCpuUnion1$outboundSchema: z.ZodType<
  PodCpuUnion1$Outbound,
  PodCpuUnion1
> = z.union([z.lazy(() => CpuPod1$outboundSchema), z.any()]);

export function podCpuUnion1ToJSON(podCpuUnion1: PodCpuUnion1): string {
  return JSON.stringify(PodCpuUnion1$outboundSchema.parse(podCpuUnion1));
}

/** @internal */
export const MemoryPodUnit1$outboundSchema: z.ZodEnum<typeof MemoryPodUnit1> = z
  .enum(MemoryPodUnit1);

/** @internal */
export type MemoryPod1$Outbound = {
  unit: string;
  value: number;
};

/** @internal */
export const MemoryPod1$outboundSchema: z.ZodType<
  MemoryPod1$Outbound,
  MemoryPod1
> = z.object({
  unit: MemoryPodUnit1$outboundSchema,
  value: z.number(),
});

export function memoryPod1ToJSON(memoryPod1: MemoryPod1): string {
  return JSON.stringify(MemoryPod1$outboundSchema.parse(memoryPod1));
}

/** @internal */
export type PodMemoryUnion1$Outbound = MemoryPod1$Outbound | any;

/** @internal */
export const PodMemoryUnion1$outboundSchema: z.ZodType<
  PodMemoryUnion1$Outbound,
  PodMemoryUnion1
> = z.union([z.lazy(() => MemoryPod1$outboundSchema), z.any()]);

export function podMemoryUnion1ToJSON(
  podMemoryUnion1: PodMemoryUnion1,
): string {
  return JSON.stringify(PodMemoryUnion1$outboundSchema.parse(podMemoryUnion1));
}

/** @internal */
export type OwnerReference1$Outbound = {
  controller: boolean;
  kind: string;
  name: string;
  uid: string;
};

/** @internal */
export const OwnerReference1$outboundSchema: z.ZodType<
  OwnerReference1$Outbound,
  OwnerReference1
> = z.object({
  controller: z.boolean(),
  kind: z.string(),
  name: z.string(),
  uid: z.string(),
});

export function ownerReference1ToJSON(
  ownerReference1: OwnerReference1,
): string {
  return JSON.stringify(OwnerReference1$outboundSchema.parse(ownerReference1));
}

/** @internal */
export type Pod1$Outbound = {
  cpu?: CpuPod1$Outbound | any | null | undefined;
  memory?: MemoryPod1$Outbound | any | null | undefined;
  name: string;
  nodeName?: string | null | undefined;
  ownerReferences: Array<OwnerReference1$Outbound>;
  phase?: string | null | undefined;
  podIp?: string | null | undefined;
  ready: boolean;
  restartCount: number;
  terminatedReason?: string | null | undefined;
  uid?: string | null | undefined;
  waitingReason?: string | null | undefined;
};

/** @internal */
export const Pod1$outboundSchema: z.ZodType<Pod1$Outbound, Pod1> = z.object({
  cpu: z.nullable(z.union([z.lazy(() => CpuPod1$outboundSchema), z.any()]))
    .optional(),
  memory: z.nullable(
    z.union([z.lazy(() => MemoryPod1$outboundSchema), z.any()]),
  ).optional(),
  name: z.string(),
  nodeName: z.nullable(z.string()).optional(),
  ownerReferences: z.array(z.lazy(() => OwnerReference1$outboundSchema)),
  phase: z.nullable(z.string()).optional(),
  podIp: z.nullable(z.string()).optional(),
  ready: z.boolean(),
  restartCount: z.int(),
  terminatedReason: z.nullable(z.string()).optional(),
  uid: z.nullable(z.string()).optional(),
  waitingReason: z.nullable(z.string()).optional(),
});

export function pod1ToJSON(pod1: Pod1): string {
  return JSON.stringify(Pod1$outboundSchema.parse(pod1));
}

/** @internal */
export type Replicas1$Outbound = {
  available?: number | null | undefined;
  current?: number | null | undefined;
  desired?: number | null | undefined;
  misscheduled?: number | null | undefined;
  ready?: number | null | undefined;
  updated?: number | null | undefined;
};

/** @internal */
export const Replicas1$outboundSchema: z.ZodType<
  Replicas1$Outbound,
  Replicas1
> = z.object({
  available: z.nullable(z.int()).optional(),
  current: z.nullable(z.int()).optional(),
  desired: z.nullable(z.int()).optional(),
  misscheduled: z.nullable(z.int()).optional(),
  ready: z.nullable(z.int()).optional(),
  updated: z.nullable(z.int()).optional(),
});

export function replicas1ToJSON(replicas1: Replicas1): string {
  return JSON.stringify(Replicas1$outboundSchema.parse(replicas1));
}

/** @internal */
export const SyncReconcileRequestReason8$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason8
> = z.enum(SyncReconcileRequestReason8);

/** @internal */
export const StatusSeverity8$outboundSchema: z.ZodEnum<typeof StatusSeverity8> =
  z.enum(StatusSeverity8);

/** @internal */
export type SyncReconcileRequestCollectionIssue8$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue8$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue8$Outbound,
  SyncReconcileRequestCollectionIssue8
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason8$outboundSchema,
  severity: StatusSeverity8$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue8ToJSON(
  syncReconcileRequestCollectionIssue8: SyncReconcileRequestCollectionIssue8,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue8$outboundSchema.parse(
      syncReconcileRequestCollectionIssue8,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth8$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth8
> = z.enum(SyncReconcileRequestHealth8);

/** @internal */
export const SyncReconcileRequestLifecycle8$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle8
> = z.enum(SyncReconcileRequestLifecycle8);

/** @internal */
export type SyncReconcileRequestStatus8$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue8$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus8$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus8$Outbound,
  SyncReconcileRequestStatus8
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue8$outboundSchema),
  ),
  health: SyncReconcileRequestHealth8$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle8$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus8ToJSON(
  syncReconcileRequestStatus8: SyncReconcileRequestStatus8,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus8$outboundSchema.parse(
      syncReconcileRequestStatus8,
    ),
  );
}

/** @internal */
export type WorkloadCondition1$Outbound = {
  lastTransitionTime?: string | null | undefined;
  message?: string | null | undefined;
  reason?: string | null | undefined;
  status: string;
  type: string;
};

/** @internal */
export const WorkloadCondition1$outboundSchema: z.ZodType<
  WorkloadCondition1$Outbound,
  WorkloadCondition1
> = z.object({
  lastTransitionTime: z.nullable(z.date().transform(v => v.toISOString()))
    .optional(),
  message: z.nullable(z.string()).optional(),
  reason: z.nullable(z.string()).optional(),
  status: z.string(),
  type: z.string(),
});

export function workloadCondition1ToJSON(
  workloadCondition1: WorkloadCondition1,
): string {
  return JSON.stringify(
    WorkloadCondition1$outboundSchema.parse(workloadCondition1),
  );
}

/** @internal */
export type Workload1$Outbound = {
  availableReplicas?: number | null | undefined;
  conditions: Array<WorkloadCondition1$Outbound>;
  desiredGeneration?: number | null | undefined;
  desiredReplicas?: number | null | undefined;
  observedGeneration?: number | null | undefined;
  readyReplicas?: number | null | undefined;
  rolloutReason?: string | null | undefined;
  updatedReplicas?: number | null | undefined;
};

/** @internal */
export const Workload1$outboundSchema: z.ZodType<
  Workload1$Outbound,
  Workload1
> = z.object({
  availableReplicas: z.nullable(z.int()).optional(),
  conditions: z.array(z.lazy(() => WorkloadCondition1$outboundSchema)),
  desiredGeneration: z.nullable(z.int()).optional(),
  desiredReplicas: z.nullable(z.int()).optional(),
  observedGeneration: z.nullable(z.int()).optional(),
  readyReplicas: z.nullable(z.int()).optional(),
  rolloutReason: z.nullable(z.string()).optional(),
  updatedReplicas: z.nullable(z.int()).optional(),
});

export function workload1ToJSON(workload1: Workload1): string {
  return JSON.stringify(Workload1$outboundSchema.parse(workload1));
}

/** @internal */
export type WorkloadUnion1$Outbound = Workload1$Outbound | any;

/** @internal */
export const WorkloadUnion1$outboundSchema: z.ZodType<
  WorkloadUnion1$Outbound,
  WorkloadUnion1
> = z.union([z.lazy(() => Workload1$outboundSchema), z.any()]);

export function workloadUnion1ToJSON(workloadUnion1: WorkloadUnion1): string {
  return JSON.stringify(WorkloadUnion1$outboundSchema.parse(workloadUnion1));
}

/** @internal */
export const WorkloadKind1$outboundSchema: z.ZodEnum<typeof WorkloadKind1> = z
  .enum(WorkloadKind1);

/** @internal */
export type DataKubernetes1$Outbound = {
  cpu?: SyncReconcileRequestCpu1$Outbound | any | null | undefined;
  events: Array<SyncReconcileRequestEvent1$Outbound>;
  memory?: SyncReconcileRequestMemory1$Outbound | any | null | undefined;
  name: string;
  namespace: string;
  pods: Array<Pod1$Outbound>;
  replicas: Replicas1$Outbound;
  restarts?: number | null | undefined;
  status: SyncReconcileRequestStatus8$Outbound;
  triggerCount: number;
  workload?: Workload1$Outbound | any | null | undefined;
  workloadKind: string;
  backend: "kubernetes";
};

/** @internal */
export const DataKubernetes1$outboundSchema: z.ZodType<
  DataKubernetes1$Outbound,
  DataKubernetes1
> = z.object({
  cpu: z.nullable(
    z.union([z.lazy(() => SyncReconcileRequestCpu1$outboundSchema), z.any()]),
  ).optional(),
  events: z.array(z.lazy(() => SyncReconcileRequestEvent1$outboundSchema)),
  memory: z.nullable(
    z.union([
      z.lazy(() => SyncReconcileRequestMemory1$outboundSchema),
      z.any(),
    ]),
  ).optional(),
  name: z.string(),
  namespace: z.string(),
  pods: z.array(z.lazy(() => Pod1$outboundSchema)),
  replicas: z.lazy(() => Replicas1$outboundSchema),
  restarts: z.nullable(z.int()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus8$outboundSchema),
  triggerCount: z.int(),
  workload: z.nullable(
    z.union([z.lazy(() => Workload1$outboundSchema), z.any()]),
  ).optional(),
  workloadKind: WorkloadKind1$outboundSchema,
  backend: z.literal("kubernetes"),
});

export function dataKubernetes1ToJSON(
  dataKubernetes1: DataKubernetes1,
): string {
  return JSON.stringify(DataKubernetes1$outboundSchema.parse(dataKubernetes1));
}

/** @internal */
export const SyncReconcileRequestReason7$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason7
> = z.enum(SyncReconcileRequestReason7);

/** @internal */
export const StatusSeverity7$outboundSchema: z.ZodEnum<typeof StatusSeverity7> =
  z.enum(StatusSeverity7);

/** @internal */
export type SyncReconcileRequestCollectionIssue7$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue7$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue7$Outbound,
  SyncReconcileRequestCollectionIssue7
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason7$outboundSchema,
  severity: StatusSeverity7$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue7ToJSON(
  syncReconcileRequestCollectionIssue7: SyncReconcileRequestCollectionIssue7,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue7$outboundSchema.parse(
      syncReconcileRequestCollectionIssue7,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth7$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth7
> = z.enum(SyncReconcileRequestHealth7);

/** @internal */
export const SyncReconcileRequestLifecycle7$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle7
> = z.enum(SyncReconcileRequestLifecycle7);

/** @internal */
export type SyncReconcileRequestStatus7$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue7$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus7$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus7$Outbound,
  SyncReconcileRequestStatus7
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue7$outboundSchema),
  ),
  health: SyncReconcileRequestHealth7$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle7$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus7ToJSON(
  syncReconcileRequestStatus7: SyncReconcileRequestStatus7,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus7$outboundSchema.parse(
      syncReconcileRequestStatus7,
    ),
  );
}

/** @internal */
export type DataAzureContainerApps1$Outbound = {
  appName: string;
  cpu?: number | null | undefined;
  environmentName?: string | null | undefined;
  ingressFqdn?: string | null | undefined;
  maxReplicas?: number | null | undefined;
  memory?: string | null | undefined;
  minReplicas?: number | null | undefined;
  provisioningState?: string | null | undefined;
  revision?: string | null | undefined;
  runningStatus?: string | null | undefined;
  status: SyncReconcileRequestStatus7$Outbound;
  backend: "azureContainerApps";
};

/** @internal */
export const DataAzureContainerApps1$outboundSchema: z.ZodType<
  DataAzureContainerApps1$Outbound,
  DataAzureContainerApps1
> = z.object({
  appName: z.string(),
  cpu: z.nullable(z.number()).optional(),
  environmentName: z.nullable(z.string()).optional(),
  ingressFqdn: z.nullable(z.string()).optional(),
  maxReplicas: z.nullable(z.int()).optional(),
  memory: z.nullable(z.string()).optional(),
  minReplicas: z.nullable(z.int()).optional(),
  provisioningState: z.nullable(z.string()).optional(),
  revision: z.nullable(z.string()).optional(),
  runningStatus: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus7$outboundSchema),
  backend: z.literal("azureContainerApps"),
});

export function dataAzureContainerApps1ToJSON(
  dataAzureContainerApps1: DataAzureContainerApps1,
): string {
  return JSON.stringify(
    DataAzureContainerApps1$outboundSchema.parse(dataAzureContainerApps1),
  );
}

/** @internal */
export const SyncReconcileRequestReason6$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason6
> = z.enum(SyncReconcileRequestReason6);

/** @internal */
export const StatusSeverity6$outboundSchema: z.ZodEnum<typeof StatusSeverity6> =
  z.enum(StatusSeverity6);

/** @internal */
export type SyncReconcileRequestCollectionIssue6$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue6$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue6$Outbound,
  SyncReconcileRequestCollectionIssue6
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason6$outboundSchema,
  severity: StatusSeverity6$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue6ToJSON(
  syncReconcileRequestCollectionIssue6: SyncReconcileRequestCollectionIssue6,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue6$outboundSchema.parse(
      syncReconcileRequestCollectionIssue6,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth6$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth6
> = z.enum(SyncReconcileRequestHealth6);

/** @internal */
export const SyncReconcileRequestLifecycle6$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle6
> = z.enum(SyncReconcileRequestLifecycle6);

/** @internal */
export type SyncReconcileRequestStatus6$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue6$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus6$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus6$Outbound,
  SyncReconcileRequestStatus6
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue6$outboundSchema),
  ),
  health: SyncReconcileRequestHealth6$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle6$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus6ToJSON(
  syncReconcileRequestStatus6: SyncReconcileRequestStatus6,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus6$outboundSchema.parse(
      syncReconcileRequestStatus6,
    ),
  );
}

/** @internal */
export type DataGcpCloudRun$Outbound = {
  containerImage?: string | null | undefined;
  cpuLimit?: string | null | undefined;
  generation?: number | null | undefined;
  latestCreatedRevision?: string | null | undefined;
  latestReadyRevision?: string | null | undefined;
  maxInstanceCount?: number | null | undefined;
  memoryLimit?: string | null | undefined;
  minInstanceCount?: number | null | undefined;
  observedGeneration?: number | null | undefined;
  region?: string | null | undefined;
  service: string;
  status: SyncReconcileRequestStatus6$Outbound;
  trafficCount: number;
  uri?: string | null | undefined;
  urls: Array<string>;
  backend: "gcpCloudRun";
};

/** @internal */
export const DataGcpCloudRun$outboundSchema: z.ZodType<
  DataGcpCloudRun$Outbound,
  DataGcpCloudRun
> = z.object({
  containerImage: z.nullable(z.string()).optional(),
  cpuLimit: z.nullable(z.string()).optional(),
  generation: z.nullable(z.int()).optional(),
  latestCreatedRevision: z.nullable(z.string()).optional(),
  latestReadyRevision: z.nullable(z.string()).optional(),
  maxInstanceCount: z.nullable(z.int()).optional(),
  memoryLimit: z.nullable(z.string()).optional(),
  minInstanceCount: z.nullable(z.int()).optional(),
  observedGeneration: z.nullable(z.int()).optional(),
  region: z.nullable(z.string()).optional(),
  service: z.string(),
  status: z.lazy(() => SyncReconcileRequestStatus6$outboundSchema),
  trafficCount: z.int(),
  uri: z.nullable(z.string()).optional(),
  urls: z.array(z.string()),
  backend: z.literal("gcpCloudRun"),
});

export function dataGcpCloudRunToJSON(
  dataGcpCloudRun: DataGcpCloudRun,
): string {
  return JSON.stringify(DataGcpCloudRun$outboundSchema.parse(dataGcpCloudRun));
}

/** @internal */
export const SyncReconcileRequestReason5$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason5
> = z.enum(SyncReconcileRequestReason5);

/** @internal */
export const StatusSeverity5$outboundSchema: z.ZodEnum<typeof StatusSeverity5> =
  z.enum(StatusSeverity5);

/** @internal */
export type SyncReconcileRequestCollectionIssue5$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue5$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue5$Outbound,
  SyncReconcileRequestCollectionIssue5
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason5$outboundSchema,
  severity: StatusSeverity5$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue5ToJSON(
  syncReconcileRequestCollectionIssue5: SyncReconcileRequestCollectionIssue5,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue5$outboundSchema.parse(
      syncReconcileRequestCollectionIssue5,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth5$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth5
> = z.enum(SyncReconcileRequestHealth5);

/** @internal */
export const SyncReconcileRequestLifecycle5$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle5
> = z.enum(SyncReconcileRequestLifecycle5);

/** @internal */
export type SyncReconcileRequestStatus5$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue5$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus5$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus5$Outbound,
  SyncReconcileRequestStatus5
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue5$outboundSchema),
  ),
  health: SyncReconcileRequestHealth5$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle5$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus5ToJSON(
  syncReconcileRequestStatus5: SyncReconcileRequestStatus5,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus5$outboundSchema.parse(
      syncReconcileRequestStatus5,
    ),
  );
}

/** @internal */
export type DataAwsLambda$Outbound = {
  codeSha256?: string | null | undefined;
  functionName: string;
  functionUrlAuthType?: string | null | undefined;
  functionUrlCorsPresent: boolean;
  lastModified?: string | null | undefined;
  lastUpdateStatus?: string | null | undefined;
  lastUpdateStatusReason?: string | null | undefined;
  lastUpdateStatusReasonCode?: string | null | undefined;
  layerCount: number;
  memorySizeMb?: number | null | undefined;
  packageType?: string | null | undefined;
  revisionId?: string | null | undefined;
  runtime?: string | null | undefined;
  state?: string | null | undefined;
  stateReason?: string | null | undefined;
  stateReasonCode?: string | null | undefined;
  status: SyncReconcileRequestStatus5$Outbound;
  timeoutSeconds?: number | null | undefined;
  triggerCount: number;
  version?: string | null | undefined;
  backend: "awsLambda";
};

/** @internal */
export const DataAwsLambda$outboundSchema: z.ZodType<
  DataAwsLambda$Outbound,
  DataAwsLambda
> = z.object({
  codeSha256: z.nullable(z.string()).optional(),
  functionName: z.string(),
  functionUrlAuthType: z.nullable(z.string()).optional(),
  functionUrlCorsPresent: z.boolean(),
  lastModified: z.nullable(z.string()).optional(),
  lastUpdateStatus: z.nullable(z.string()).optional(),
  lastUpdateStatusReason: z.nullable(z.string()).optional(),
  lastUpdateStatusReasonCode: z.nullable(z.string()).optional(),
  layerCount: z.int(),
  memorySizeMb: z.nullable(z.int()).optional(),
  packageType: z.nullable(z.string()).optional(),
  revisionId: z.nullable(z.string()).optional(),
  runtime: z.nullable(z.string()).optional(),
  state: z.nullable(z.string()).optional(),
  stateReason: z.nullable(z.string()).optional(),
  stateReasonCode: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus5$outboundSchema),
  timeoutSeconds: z.nullable(z.int()).optional(),
  triggerCount: z.int(),
  version: z.nullable(z.string()).optional(),
  backend: z.literal("awsLambda"),
});

export function dataAwsLambdaToJSON(dataAwsLambda: DataAwsLambda): string {
  return JSON.stringify(DataAwsLambda$outboundSchema.parse(dataAwsLambda));
}

/** @internal */
export type SyncReconcileRequestDataUnion2$Outbound =
  | DataAwsLambda$Outbound
  | DataGcpCloudRun$Outbound
  | DataAzureContainerApps1$Outbound
  | DataKubernetes1$Outbound
  | DataLocal2$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion2$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion2$Outbound,
  SyncReconcileRequestDataUnion2
> = z.union([
  z.lazy(() => DataAwsLambda$outboundSchema),
  z.lazy(() => DataGcpCloudRun$outboundSchema),
  z.lazy(() => DataAzureContainerApps1$outboundSchema),
  z.lazy(() => DataKubernetes1$outboundSchema),
  z.lazy(() => DataLocal2$outboundSchema),
]);

export function syncReconcileRequestDataUnion2ToJSON(
  syncReconcileRequestDataUnion2: SyncReconcileRequestDataUnion2,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion2$outboundSchema.parse(
      syncReconcileRequestDataUnion2,
    ),
  );
}

/** @internal */
export type DataWorker$Outbound = {
  data:
    | DataAwsLambda$Outbound
    | DataGcpCloudRun$Outbound
    | DataAzureContainerApps1$Outbound
    | DataKubernetes1$Outbound
    | DataLocal2$Outbound;
  resourceType: "worker";
};

/** @internal */
export const DataWorker$outboundSchema: z.ZodType<
  DataWorker$Outbound,
  DataWorker
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsLambda$outboundSchema),
    z.lazy(() => DataGcpCloudRun$outboundSchema),
    z.lazy(() => DataAzureContainerApps1$outboundSchema),
    z.lazy(() => DataKubernetes1$outboundSchema),
    z.lazy(() => DataLocal2$outboundSchema),
  ]),
  resourceType: z.literal("worker"),
});

export function dataWorkerToJSON(dataWorker: DataWorker): string {
  return JSON.stringify(DataWorker$outboundSchema.parse(dataWorker));
}

/** @internal */
export const SyncReconcileRequestReason4$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason4
> = z.enum(SyncReconcileRequestReason4);

/** @internal */
export const StatusSeverity4$outboundSchema: z.ZodEnum<typeof StatusSeverity4> =
  z.enum(StatusSeverity4);

/** @internal */
export type SyncReconcileRequestCollectionIssue4$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue4$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue4$Outbound,
  SyncReconcileRequestCollectionIssue4
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason4$outboundSchema,
  severity: StatusSeverity4$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue4ToJSON(
  syncReconcileRequestCollectionIssue4: SyncReconcileRequestCollectionIssue4,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue4$outboundSchema.parse(
      syncReconcileRequestCollectionIssue4,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth4$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth4
> = z.enum(SyncReconcileRequestHealth4);

/** @internal */
export const SyncReconcileRequestLifecycle4$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle4
> = z.enum(SyncReconcileRequestLifecycle4);

/** @internal */
export type SyncReconcileRequestStatus4$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue4$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus4$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus4$Outbound,
  SyncReconcileRequestStatus4
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue4$outboundSchema),
  ),
  health: SyncReconcileRequestHealth4$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle4$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus4ToJSON(
  syncReconcileRequestStatus4: SyncReconcileRequestStatus4,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus4$outboundSchema.parse(
      syncReconcileRequestStatus4,
    ),
  );
}

/** @internal */
export type DataLocal1$Outbound = {
  isDirectory?: boolean | null | undefined;
  modifiedAt?: string | null | undefined;
  path: string;
  pathExists: boolean;
  readonly?: boolean | null | undefined;
  status: SyncReconcileRequestStatus4$Outbound;
  backend: "local";
};

/** @internal */
export const DataLocal1$outboundSchema: z.ZodType<
  DataLocal1$Outbound,
  DataLocal1
> = z.object({
  isDirectory: z.nullable(z.boolean()).optional(),
  modifiedAt: z.nullable(z.date().transform(v => v.toISOString())).optional(),
  path: z.string(),
  pathExists: z.boolean(),
  readonly: z.nullable(z.boolean()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus4$outboundSchema),
  backend: z.literal("local"),
});

export function dataLocal1ToJSON(dataLocal1: DataLocal1): string {
  return JSON.stringify(DataLocal1$outboundSchema.parse(dataLocal1));
}

/** @internal */
export const SyncReconcileRequestReason3$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason3
> = z.enum(SyncReconcileRequestReason3);

/** @internal */
export const StatusSeverity3$outboundSchema: z.ZodEnum<typeof StatusSeverity3> =
  z.enum(StatusSeverity3);

/** @internal */
export type SyncReconcileRequestCollectionIssue3$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue3$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue3$Outbound,
  SyncReconcileRequestCollectionIssue3
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason3$outboundSchema,
  severity: StatusSeverity3$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue3ToJSON(
  syncReconcileRequestCollectionIssue3: SyncReconcileRequestCollectionIssue3,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue3$outboundSchema.parse(
      syncReconcileRequestCollectionIssue3,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth3$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth3
> = z.enum(SyncReconcileRequestHealth3);

/** @internal */
export const SyncReconcileRequestLifecycle3$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle3
> = z.enum(SyncReconcileRequestLifecycle3);

/** @internal */
export type SyncReconcileRequestStatus3$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue3$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus3$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus3$Outbound,
  SyncReconcileRequestStatus3
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue3$outboundSchema),
  ),
  health: SyncReconcileRequestHealth3$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle3$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus3ToJSON(
  syncReconcileRequestStatus3: SyncReconcileRequestStatus3,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus3$outboundSchema.parse(
      syncReconcileRequestStatus3,
    ),
  );
}

/** @internal */
export type DataAzureBlob$Outbound = {
  accessTier?: string | null | undefined;
  accountKind?: string | null | undefined;
  allowBlobPublicAccess?: boolean | null | undefined;
  blobDeleteRetentionDays?: number | null | undefined;
  blobDeleteRetentionEnabled?: boolean | null | undefined;
  blobEncryptionEnabled?: boolean | null | undefined;
  blobVersioningEnabled?: boolean | null | undefined;
  changeFeedEnabled?: boolean | null | undefined;
  changeFeedRetentionDays?: number | null | undefined;
  containerDeleteRetentionDays?: number | null | undefined;
  containerDeleteRetentionEnabled?: boolean | null | undefined;
  containerPublicAccess?: string | null | undefined;
  encryptionKeySource?: string | null | undefined;
  fileEncryptionEnabled?: boolean | null | undefined;
  location?: string | null | undefined;
  name: string;
  primaryLocation?: string | null | undefined;
  provisioningState?: string | null | undefined;
  publicNetworkAccess?: string | null | undefined;
  queueEncryptionEnabled?: boolean | null | undefined;
  resourceGroup?: string | null | undefined;
  secondaryLocation?: string | null | undefined;
  skuName?: string | null | undefined;
  skuTier?: string | null | undefined;
  status: SyncReconcileRequestStatus3$Outbound;
  statusOfPrimary?: string | null | undefined;
  statusOfSecondary?: string | null | undefined;
  storageAccountName?: string | null | undefined;
  tableEncryptionEnabled?: boolean | null | undefined;
  backend: "azureBlob";
};

/** @internal */
export const DataAzureBlob$outboundSchema: z.ZodType<
  DataAzureBlob$Outbound,
  DataAzureBlob
> = z.object({
  accessTier: z.nullable(z.string()).optional(),
  accountKind: z.nullable(z.string()).optional(),
  allowBlobPublicAccess: z.nullable(z.boolean()).optional(),
  blobDeleteRetentionDays: z.nullable(z.int()).optional(),
  blobDeleteRetentionEnabled: z.nullable(z.boolean()).optional(),
  blobEncryptionEnabled: z.nullable(z.boolean()).optional(),
  blobVersioningEnabled: z.nullable(z.boolean()).optional(),
  changeFeedEnabled: z.nullable(z.boolean()).optional(),
  changeFeedRetentionDays: z.nullable(z.int()).optional(),
  containerDeleteRetentionDays: z.nullable(z.int()).optional(),
  containerDeleteRetentionEnabled: z.nullable(z.boolean()).optional(),
  containerPublicAccess: z.nullable(z.string()).optional(),
  encryptionKeySource: z.nullable(z.string()).optional(),
  fileEncryptionEnabled: z.nullable(z.boolean()).optional(),
  location: z.nullable(z.string()).optional(),
  name: z.string(),
  primaryLocation: z.nullable(z.string()).optional(),
  provisioningState: z.nullable(z.string()).optional(),
  publicNetworkAccess: z.nullable(z.string()).optional(),
  queueEncryptionEnabled: z.nullable(z.boolean()).optional(),
  resourceGroup: z.nullable(z.string()).optional(),
  secondaryLocation: z.nullable(z.string()).optional(),
  skuName: z.nullable(z.string()).optional(),
  skuTier: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus3$outboundSchema),
  statusOfPrimary: z.nullable(z.string()).optional(),
  statusOfSecondary: z.nullable(z.string()).optional(),
  storageAccountName: z.nullable(z.string()).optional(),
  tableEncryptionEnabled: z.nullable(z.boolean()).optional(),
  backend: z.literal("azureBlob"),
});

export function dataAzureBlobToJSON(dataAzureBlob: DataAzureBlob): string {
  return JSON.stringify(DataAzureBlob$outboundSchema.parse(dataAzureBlob));
}

/** @internal */
export const SyncReconcileRequestReason2$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason2
> = z.enum(SyncReconcileRequestReason2);

/** @internal */
export const StatusSeverity2$outboundSchema: z.ZodEnum<typeof StatusSeverity2> =
  z.enum(StatusSeverity2);

/** @internal */
export type SyncReconcileRequestCollectionIssue2$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue2$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue2$Outbound,
  SyncReconcileRequestCollectionIssue2
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason2$outboundSchema,
  severity: StatusSeverity2$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue2ToJSON(
  syncReconcileRequestCollectionIssue2: SyncReconcileRequestCollectionIssue2,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue2$outboundSchema.parse(
      syncReconcileRequestCollectionIssue2,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth2$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth2
> = z.enum(SyncReconcileRequestHealth2);

/** @internal */
export const SyncReconcileRequestLifecycle2$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle2
> = z.enum(SyncReconcileRequestLifecycle2);

/** @internal */
export type SyncReconcileRequestStatus2$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue2$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus2$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus2$Outbound,
  SyncReconcileRequestStatus2
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue2$outboundSchema),
  ),
  health: SyncReconcileRequestHealth2$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle2$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus2ToJSON(
  syncReconcileRequestStatus2: SyncReconcileRequestStatus2,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus2$outboundSchema.parse(
      syncReconcileRequestStatus2,
    ),
  );
}

/** @internal */
export type DataGcpCloudStorage$Outbound = {
  bucketId?: string | null | undefined;
  defaultKmsKeyName?: string | null | undefined;
  encryptionConfigPresent: boolean;
  lifecyclePresent: boolean;
  lifecycleRuleCount?: number | null | undefined;
  location?: string | null | undefined;
  locationType?: string | null | undefined;
  name: string;
  publicAccessPrevention?: string | null | undefined;
  retentionPeriod?: string | null | undefined;
  retentionPolicyEffectiveTime?: string | null | undefined;
  retentionPolicyIsLocked?: boolean | null | undefined;
  softDeleteEffectiveTime?: string | null | undefined;
  softDeleteRetentionDurationSeconds?: string | null | undefined;
  status: SyncReconcileRequestStatus2$Outbound;
  storageClass?: string | null | undefined;
  uniformBucketLevelAccessEnabled?: boolean | null | undefined;
  uniformBucketLevelAccessLockedTime?: string | null | undefined;
  versioningEnabled?: boolean | null | undefined;
  backend: "gcpCloudStorage";
};

/** @internal */
export const DataGcpCloudStorage$outboundSchema: z.ZodType<
  DataGcpCloudStorage$Outbound,
  DataGcpCloudStorage
> = z.object({
  bucketId: z.nullable(z.string()).optional(),
  defaultKmsKeyName: z.nullable(z.string()).optional(),
  encryptionConfigPresent: z.boolean(),
  lifecyclePresent: z.boolean(),
  lifecycleRuleCount: z.nullable(z.int()).optional(),
  location: z.nullable(z.string()).optional(),
  locationType: z.nullable(z.string()).optional(),
  name: z.string(),
  publicAccessPrevention: z.nullable(z.string()).optional(),
  retentionPeriod: z.nullable(z.string()).optional(),
  retentionPolicyEffectiveTime: z.nullable(z.string()).optional(),
  retentionPolicyIsLocked: z.nullable(z.boolean()).optional(),
  softDeleteEffectiveTime: z.nullable(z.string()).optional(),
  softDeleteRetentionDurationSeconds: z.nullable(z.string()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus2$outboundSchema),
  storageClass: z.nullable(z.string()).optional(),
  uniformBucketLevelAccessEnabled: z.nullable(z.boolean()).optional(),
  uniformBucketLevelAccessLockedTime: z.nullable(z.string()).optional(),
  versioningEnabled: z.nullable(z.boolean()).optional(),
  backend: z.literal("gcpCloudStorage"),
});

export function dataGcpCloudStorageToJSON(
  dataGcpCloudStorage: DataGcpCloudStorage,
): string {
  return JSON.stringify(
    DataGcpCloudStorage$outboundSchema.parse(dataGcpCloudStorage),
  );
}

/** @internal */
export const SyncReconcileRequestReason1$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestReason1
> = z.enum(SyncReconcileRequestReason1);

/** @internal */
export const StatusSeverity1$outboundSchema: z.ZodEnum<typeof StatusSeverity1> =
  z.enum(StatusSeverity1);

/** @internal */
export type SyncReconcileRequestCollectionIssue1$Outbound = {
  message: string;
  reason: string;
  severity: string;
  source: string;
};

/** @internal */
export const SyncReconcileRequestCollectionIssue1$outboundSchema: z.ZodType<
  SyncReconcileRequestCollectionIssue1$Outbound,
  SyncReconcileRequestCollectionIssue1
> = z.object({
  message: z.string(),
  reason: SyncReconcileRequestReason1$outboundSchema,
  severity: StatusSeverity1$outboundSchema,
  source: z.string(),
});

export function syncReconcileRequestCollectionIssue1ToJSON(
  syncReconcileRequestCollectionIssue1: SyncReconcileRequestCollectionIssue1,
): string {
  return JSON.stringify(
    SyncReconcileRequestCollectionIssue1$outboundSchema.parse(
      syncReconcileRequestCollectionIssue1,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestHealth1$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestHealth1
> = z.enum(SyncReconcileRequestHealth1);

/** @internal */
export const SyncReconcileRequestLifecycle1$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestLifecycle1
> = z.enum(SyncReconcileRequestLifecycle1);

/** @internal */
export type SyncReconcileRequestStatus1$Outbound = {
  collectionIssues: Array<SyncReconcileRequestCollectionIssue1$Outbound>;
  health: string;
  lifecycle: string;
  message?: string | null | undefined;
  partial: boolean;
  stale: boolean;
};

/** @internal */
export const SyncReconcileRequestStatus1$outboundSchema: z.ZodType<
  SyncReconcileRequestStatus1$Outbound,
  SyncReconcileRequestStatus1
> = z.object({
  collectionIssues: z.array(
    z.lazy(() => SyncReconcileRequestCollectionIssue1$outboundSchema),
  ),
  health: SyncReconcileRequestHealth1$outboundSchema,
  lifecycle: SyncReconcileRequestLifecycle1$outboundSchema,
  message: z.nullable(z.string()).optional(),
  partial: z.boolean(),
  stale: z.boolean(),
});

export function syncReconcileRequestStatus1ToJSON(
  syncReconcileRequestStatus1: SyncReconcileRequestStatus1,
): string {
  return JSON.stringify(
    SyncReconcileRequestStatus1$outboundSchema.parse(
      syncReconcileRequestStatus1,
    ),
  );
}

/** @internal */
export type DataAwsS3$Outbound = {
  blockPublicAcls?: boolean | null | undefined;
  blockPublicPolicy?: boolean | null | undefined;
  bucketAclPresent?: boolean | null | undefined;
  bucketLocation?: string | null | undefined;
  bucketPolicyPresent?: boolean | null | undefined;
  encryptionConfigPresent: boolean;
  encryptionEnabled?: boolean | null | undefined;
  ignorePublicAcls?: boolean | null | undefined;
  lifecyclePresent: boolean;
  lifecycleRuleCount?: number | null | undefined;
  name: string;
  publicAccessBlockPresent: boolean;
  region?: string | null | undefined;
  restrictPublicBuckets?: boolean | null | undefined;
  status: SyncReconcileRequestStatus1$Outbound;
  versioningEnabled?: boolean | null | undefined;
  versioningStatus?: string | null | undefined;
  backend: "awsS3";
};

/** @internal */
export const DataAwsS3$outboundSchema: z.ZodType<
  DataAwsS3$Outbound,
  DataAwsS3
> = z.object({
  blockPublicAcls: z.nullable(z.boolean()).optional(),
  blockPublicPolicy: z.nullable(z.boolean()).optional(),
  bucketAclPresent: z.nullable(z.boolean()).optional(),
  bucketLocation: z.nullable(z.string()).optional(),
  bucketPolicyPresent: z.nullable(z.boolean()).optional(),
  encryptionConfigPresent: z.boolean(),
  encryptionEnabled: z.nullable(z.boolean()).optional(),
  ignorePublicAcls: z.nullable(z.boolean()).optional(),
  lifecyclePresent: z.boolean(),
  lifecycleRuleCount: z.nullable(z.int()).optional(),
  name: z.string(),
  publicAccessBlockPresent: z.boolean(),
  region: z.nullable(z.string()).optional(),
  restrictPublicBuckets: z.nullable(z.boolean()).optional(),
  status: z.lazy(() => SyncReconcileRequestStatus1$outboundSchema),
  versioningEnabled: z.nullable(z.boolean()).optional(),
  versioningStatus: z.nullable(z.string()).optional(),
  backend: z.literal("awsS3"),
});

export function dataAwsS3ToJSON(dataAwsS3: DataAwsS3): string {
  return JSON.stringify(DataAwsS3$outboundSchema.parse(dataAwsS3));
}

/** @internal */
export type SyncReconcileRequestDataUnion1$Outbound =
  | DataAwsS3$Outbound
  | DataGcpCloudStorage$Outbound
  | DataAzureBlob$Outbound
  | DataLocal1$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion1$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion1$Outbound,
  SyncReconcileRequestDataUnion1
> = z.union([
  z.lazy(() => DataAwsS3$outboundSchema),
  z.lazy(() => DataGcpCloudStorage$outboundSchema),
  z.lazy(() => DataAzureBlob$outboundSchema),
  z.lazy(() => DataLocal1$outboundSchema),
]);

export function syncReconcileRequestDataUnion1ToJSON(
  syncReconcileRequestDataUnion1: SyncReconcileRequestDataUnion1,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion1$outboundSchema.parse(
      syncReconcileRequestDataUnion1,
    ),
  );
}

/** @internal */
export type DataStorage$Outbound = {
  data:
    | DataAwsS3$Outbound
    | DataGcpCloudStorage$Outbound
    | DataAzureBlob$Outbound
    | DataLocal1$Outbound;
  resourceType: "storage";
};

/** @internal */
export const DataStorage$outboundSchema: z.ZodType<
  DataStorage$Outbound,
  DataStorage
> = z.object({
  data: z.union([
    z.lazy(() => DataAwsS3$outboundSchema),
    z.lazy(() => DataGcpCloudStorage$outboundSchema),
    z.lazy(() => DataAzureBlob$outboundSchema),
    z.lazy(() => DataLocal1$outboundSchema),
  ]),
  resourceType: z.literal("storage"),
});

export function dataStorageToJSON(dataStorage: DataStorage): string {
  return JSON.stringify(DataStorage$outboundSchema.parse(dataStorage));
}

/** @internal */
export type SyncReconcileRequestDataUnion19$Outbound =
  | DataStorage$Outbound
  | DataWorker$Outbound
  | DataContainer$Outbound
  | DataDaemon$Outbound
  | DataComputeCluster$Outbound
  | DataKubernetesCluster$Outbound
  | DataQueue$Outbound
  | DataKv$Outbound
  | DataPostgres$Outbound
  | DataVault$Outbound
  | DataServiceAccount$Outbound
  | DataNetwork$Outbound
  | DataRemoteStackManagement$Outbound
  | DataArtifactRegistry$Outbound
  | DataBuild$Outbound
  | DataServiceActivation$Outbound
  | DataAzureResourceGroup$Outbound
  | DataAzureStorageAccount$Outbound
  | DataAzureContainerAppsEnvironment$Outbound
  | DataAzureServiceBusNamespace$Outbound
  | DataAi$Outbound
  | DataKey$Outbound
  | DataSandbox$Outbound;

/** @internal */
export const SyncReconcileRequestDataUnion19$outboundSchema: z.ZodType<
  SyncReconcileRequestDataUnion19$Outbound,
  SyncReconcileRequestDataUnion19
> = z.union([
  z.lazy(() => DataStorage$outboundSchema),
  z.lazy(() => DataWorker$outboundSchema),
  z.lazy(() => DataContainer$outboundSchema),
  z.lazy(() => DataDaemon$outboundSchema),
  z.lazy(() => DataComputeCluster$outboundSchema),
  z.lazy(() => DataKubernetesCluster$outboundSchema),
  z.lazy(() => DataQueue$outboundSchema),
  z.lazy(() => DataKv$outboundSchema),
  z.lazy(() => DataPostgres$outboundSchema),
  z.lazy(() => DataVault$outboundSchema),
  z.lazy(() => DataServiceAccount$outboundSchema),
  z.lazy(() => DataNetwork$outboundSchema),
  z.lazy(() => DataRemoteStackManagement$outboundSchema),
  z.lazy(() => DataArtifactRegistry$outboundSchema),
  z.lazy(() => DataBuild$outboundSchema),
  z.lazy(() => DataServiceActivation$outboundSchema),
  z.lazy(() => DataAzureResourceGroup$outboundSchema),
  z.lazy(() => DataAzureStorageAccount$outboundSchema),
  z.lazy(() => DataAzureContainerAppsEnvironment$outboundSchema),
  z.lazy(() => DataAzureServiceBusNamespace$outboundSchema),
  z.lazy(() => DataAi$outboundSchema),
  z.lazy(() => DataKey$outboundSchema),
  z.lazy(() => DataSandbox$outboundSchema),
]);

export function syncReconcileRequestDataUnion19ToJSON(
  syncReconcileRequestDataUnion19: SyncReconcileRequestDataUnion19,
): string {
  return JSON.stringify(
    SyncReconcileRequestDataUnion19$outboundSchema.parse(
      syncReconcileRequestDataUnion19,
    ),
  );
}

/** @internal */
export const SyncReconcileRequestFormat$outboundSchema: z.ZodEnum<
  typeof SyncReconcileRequestFormat
> = z.enum(SyncReconcileRequestFormat);

/** @internal */
export type SyncReconcileRequestRaw$Outbound = {
  body: string;
  collectedAt: string;
  format: string;
  source: string;
  truncated: boolean;
};

/** @internal */
export const SyncReconcileRequestRaw$outboundSchema: z.ZodType<
  SyncReconcileRequestRaw$Outbound,
  SyncReconcileRequestRaw
> = z.object({
  body: z.string(),
  collectedAt: z.date().transform(v => v.toISOString()),
  format: SyncReconcileRequestFormat$outboundSchema,
  source: z.string(),
  truncated: z.boolean(),
});

export function syncReconcileRequestRawToJSON(
  syncReconcileRequestRaw: SyncReconcileRequestRaw,
): string {
  return JSON.stringify(
    SyncReconcileRequestRaw$outboundSchema.parse(syncReconcileRequestRaw),
  );
}

/** @internal */
export type ResourceHeartbeat$Outbound = {
  backend: string;
  controllerPlatform: string;
  data:
    | DataStorage$Outbound
    | DataWorker$Outbound
    | DataContainer$Outbound
    | DataDaemon$Outbound
    | DataComputeCluster$Outbound
    | DataKubernetesCluster$Outbound
    | DataQueue$Outbound
    | DataKv$Outbound
    | DataPostgres$Outbound
    | DataVault$Outbound
    | DataServiceAccount$Outbound
    | DataNetwork$Outbound
    | DataRemoteStackManagement$Outbound
    | DataArtifactRegistry$Outbound
    | DataBuild$Outbound
    | DataServiceActivation$Outbound
    | DataAzureResourceGroup$Outbound
    | DataAzureStorageAccount$Outbound
    | DataAzureContainerAppsEnvironment$Outbound
    | DataAzureServiceBusNamespace$Outbound
    | DataAi$Outbound
    | DataKey$Outbound
    | DataSandbox$Outbound;
  deploymentId?: string | null | undefined;
  observedAt: string;
  raw: Array<SyncReconcileRequestRaw$Outbound>;
  resourceId: string;
  resourceType: string;
};

/** @internal */
export const ResourceHeartbeat$outboundSchema: z.ZodType<
  ResourceHeartbeat$Outbound,
  ResourceHeartbeat
> = z.object({
  backend: SyncReconcileRequestBackendEnum$outboundSchema,
  controllerPlatform: SyncReconcileRequestControllerPlatform$outboundSchema,
  data: z.union([
    z.lazy(() => DataStorage$outboundSchema),
    z.lazy(() => DataWorker$outboundSchema),
    z.lazy(() => DataContainer$outboundSchema),
    z.lazy(() => DataDaemon$outboundSchema),
    z.lazy(() => DataComputeCluster$outboundSchema),
    z.lazy(() => DataKubernetesCluster$outboundSchema),
    z.lazy(() => DataQueue$outboundSchema),
    z.lazy(() => DataKv$outboundSchema),
    z.lazy(() => DataPostgres$outboundSchema),
    z.lazy(() => DataVault$outboundSchema),
    z.lazy(() => DataServiceAccount$outboundSchema),
    z.lazy(() => DataNetwork$outboundSchema),
    z.lazy(() => DataRemoteStackManagement$outboundSchema),
    z.lazy(() => DataArtifactRegistry$outboundSchema),
    z.lazy(() => DataBuild$outboundSchema),
    z.lazy(() => DataServiceActivation$outboundSchema),
    z.lazy(() => DataAzureResourceGroup$outboundSchema),
    z.lazy(() => DataAzureStorageAccount$outboundSchema),
    z.lazy(() => DataAzureContainerAppsEnvironment$outboundSchema),
    z.lazy(() => DataAzureServiceBusNamespace$outboundSchema),
    z.lazy(() => DataAi$outboundSchema),
    z.lazy(() => DataKey$outboundSchema),
    z.lazy(() => DataSandbox$outboundSchema),
  ]),
  deploymentId: z.nullable(z.string()).optional(),
  observedAt: z.date().transform(v => v.toISOString()),
  raw: z.array(z.lazy(() => SyncReconcileRequestRaw$outboundSchema)),
  resourceId: z.string(),
  resourceType: z.string(),
});

export function resourceHeartbeatToJSON(
  resourceHeartbeat: ResourceHeartbeat,
): string {
  return JSON.stringify(
    ResourceHeartbeat$outboundSchema.parse(resourceHeartbeat),
  );
}

/** @internal */
export type SyncReconcileRequest$Outbound = {
  deploymentId: string;
  session?: string | undefined;
  operationId?: string | undefined;
  attemptId?: string | undefined;
  state: DeploymentState$Outbound;
  updateHeartbeat?: boolean | undefined;
  suggestedDelayMs?: number | undefined;
  resourceHeartbeats?: Array<ResourceHeartbeat$Outbound> | undefined;
  observedInventoryBatches?: Array<ObservedInventoryBatch$Outbound> | undefined;
  capabilities?: Array<OperatorCapabilityReport$Outbound> | undefined;
  operatorVersion?: string | undefined;
  operatorImage?: RemoteOperatorImageIdentity$Outbound | undefined;
  operationsReport?: OperationsReport$Outbound | undefined;
};

/** @internal */
export const SyncReconcileRequest$outboundSchema: z.ZodType<
  SyncReconcileRequest$Outbound,
  SyncReconcileRequest
> = z.object({
  deploymentId: z.string(),
  session: z.string().optional(),
  operationId: z.string().optional(),
  attemptId: z.string().optional(),
  state: DeploymentState$outboundSchema,
  updateHeartbeat: z.boolean().optional(),
  suggestedDelayMs: z.int().optional(),
  resourceHeartbeats: z.array(z.lazy(() => ResourceHeartbeat$outboundSchema))
    .optional(),
  observedInventoryBatches: z.array(ObservedInventoryBatch$outboundSchema)
    .optional(),
  capabilities: z.array(OperatorCapabilityReport$outboundSchema).optional(),
  operatorVersion: z.string().optional(),
  operatorImage: RemoteOperatorImageIdentity$outboundSchema.optional(),
  operationsReport: OperationsReport$outboundSchema.optional(),
});

export function syncReconcileRequestToJSON(
  syncReconcileRequest: SyncReconcileRequest,
): string {
  return JSON.stringify(
    SyncReconcileRequest$outboundSchema.parse(syncReconcileRequest),
  );
}