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

import * as z from "zod/v4";
import { safeParse } from "../lib/schemas.js";
import { ClosedEnum } from "../types/enums.js";
import { Result as SafeParseResult } from "../types/fp.js";
import { SDKValidationError } from "./errors/sdkvalidationerror.js";
import {
  OperationsCatalogKubernetesPermissions,
  OperationsCatalogKubernetesPermissions$inboundSchema,
} from "./operationscatalogkubernetespermissions.js";

/**
 * Effective risk tier for this operation.
 */
export const OperationsPluginOperationTier = {
  ReadOnly: "read-only",
  Mutating: "mutating",
  Destructive: "destructive",
} as const;
/**
 * Effective risk tier for this operation.
 */
export type OperationsPluginOperationTier = ClosedEnum<
  typeof OperationsPluginOperationTier
>;

export type OperationsPluginOperationRetries = {
  maxAttempts: number;
  intervalSeconds: number;
};

export type OperationsPluginOperationRetry = {
  maxAttempts: number;
  intervalSeconds: number;
};

export type OperationsPluginOperationVerification = {
  changes: string;
  pollOperation: string;
  pollParamsFromResult: { [k: string]: string };
  successField: string;
  successValue: string;
  retry?: OperationsPluginOperationRetry | undefined;
  timeoutSeconds: number;
};

export type OperationsPluginOperationSensitiveOutputRequireConfirmation = {
  kind: "requireConfirmation";
};

export type OperationsPluginOperationSensitiveOutputRedact = {
  kind: "redact";
  fields: Array<string>;
};

export type OperationsPluginOperationSensitiveOutputNone = {
  kind: "none";
};

export type OperationsPluginOperationSensitiveOutputUnion =
  | OperationsPluginOperationSensitiveOutputNone
  | OperationsPluginOperationSensitiveOutputRedact
  | OperationsPluginOperationSensitiveOutputRequireConfirmation;

export const OperationsPluginOperationEffect = {
  Allow: "Allow",
  Deny: "Deny",
} as const;
export type OperationsPluginOperationEffect = ClosedEnum<
  typeof OperationsPluginOperationEffect
>;

export type OperationsPluginOperationAw = {
  effect: OperationsPluginOperationEffect;
  actions: Array<string>;
  resources: Array<string>;
  condition: { [k: string]: { [k: string]: string } } | null;
  reason: string;
};

export const OperationsPluginOperationScope = {
  ProjectsDollarProjectName: "projects/${projectName}",
} as const;
export type OperationsPluginOperationScope = ClosedEnum<
  typeof OperationsPluginOperationScope
>;

export type OperationsPluginOperationGcp = {
  permissions: Array<string>;
  scope: OperationsPluginOperationScope;
  reason: string;
};

/**
 * Cloud permissions required to execute this operation.
 */
export type OperationsPluginOperationPermissions = {
  /**
   * No Azure resource permissions are supported. Kubernetes API permissions are separate.
   */
  azure: Array<string>;
  aws: Array<OperationsPluginOperationAw>;
  gcp: Array<OperationsPluginOperationGcp>;
};

export type OperationsPluginOperation = {
  /**
   * Operation name, unique within the plugin.
   */
  name: string;
  /**
   * Effective risk tier for this operation.
   */
  tier: OperationsPluginOperationTier;
  /**
   * Human-readable description.
   */
  description: string | null;
  /**
   * JSON Schema for operation parameters when the plugin publishes one.
   */
  inputSchema: { [k: string]: any | null } | null;
  /**
   * JSON Schema for a successful result when the plugin publishes one.
   */
  outputSchema: { [k: string]: any | null } | null;
  timeoutSeconds: number | null;
  retries: OperationsPluginOperationRetries | null;
  verification: OperationsPluginOperationVerification | null;
  sensitiveOutput:
    | OperationsPluginOperationSensitiveOutputNone
    | OperationsPluginOperationSensitiveOutputRedact
    | OperationsPluginOperationSensitiveOutputRequireConfirmation;
  /**
   * IDs of permission sets (see alien-permissions) this operation requires. Empty when the operation declares none.
   */
  requiredPermissions: Array<string>;
  /**
   * Cloud permissions required to execute this operation.
   */
  permissions: OperationsPluginOperationPermissions;
  /**
   * Kubernetes RBAC required to execute this operation. Omitted by older servers and null when the operation declares none.
   */
  kubernetesPermissions?:
    | OperationsCatalogKubernetesPermissions
    | null
    | undefined;
};

/** @internal */
export const OperationsPluginOperationTier$inboundSchema: z.ZodEnum<
  typeof OperationsPluginOperationTier
> = z.enum(OperationsPluginOperationTier);

/** @internal */
export const OperationsPluginOperationRetries$inboundSchema: z.ZodType<
  OperationsPluginOperationRetries,
  unknown
> = z.object({
  maxAttempts: z.int(),
  intervalSeconds: z.int(),
});

export function operationsPluginOperationRetriesFromJSON(
  jsonString: string,
): SafeParseResult<OperationsPluginOperationRetries, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OperationsPluginOperationRetries$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OperationsPluginOperationRetries' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperationRetry$inboundSchema: z.ZodType<
  OperationsPluginOperationRetry,
  unknown
> = z.object({
  maxAttempts: z.int(),
  intervalSeconds: z.int(),
});

export function operationsPluginOperationRetryFromJSON(
  jsonString: string,
): SafeParseResult<OperationsPluginOperationRetry, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OperationsPluginOperationRetry$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OperationsPluginOperationRetry' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperationVerification$inboundSchema: z.ZodType<
  OperationsPluginOperationVerification,
  unknown
> = z.object({
  changes: z.string(),
  pollOperation: z.string(),
  pollParamsFromResult: z.record(z.string(), z.string()),
  successField: z.string(),
  successValue: z.string(),
  retry: z.lazy(() => OperationsPluginOperationRetry$inboundSchema).optional(),
  timeoutSeconds: z.int(),
});

export function operationsPluginOperationVerificationFromJSON(
  jsonString: string,
): SafeParseResult<OperationsPluginOperationVerification, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      OperationsPluginOperationVerification$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OperationsPluginOperationVerification' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperationSensitiveOutputRequireConfirmation$inboundSchema:
  z.ZodType<
    OperationsPluginOperationSensitiveOutputRequireConfirmation,
    unknown
  > = z.object({
    kind: z.literal("requireConfirmation"),
  });

export function operationsPluginOperationSensitiveOutputRequireConfirmationFromJSON(
  jsonString: string,
): SafeParseResult<
  OperationsPluginOperationSensitiveOutputRequireConfirmation,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      OperationsPluginOperationSensitiveOutputRequireConfirmation$inboundSchema
        .parse(JSON.parse(x)),
    `Failed to parse 'OperationsPluginOperationSensitiveOutputRequireConfirmation' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperationSensitiveOutputRedact$inboundSchema:
  z.ZodType<OperationsPluginOperationSensitiveOutputRedact, unknown> = z.object(
    {
      kind: z.literal("redact"),
      fields: z.array(z.string()),
    },
  );

export function operationsPluginOperationSensitiveOutputRedactFromJSON(
  jsonString: string,
): SafeParseResult<
  OperationsPluginOperationSensitiveOutputRedact,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      OperationsPluginOperationSensitiveOutputRedact$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'OperationsPluginOperationSensitiveOutputRedact' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperationSensitiveOutputNone$inboundSchema:
  z.ZodType<OperationsPluginOperationSensitiveOutputNone, unknown> = z.object({
    kind: z.literal("none"),
  });

export function operationsPluginOperationSensitiveOutputNoneFromJSON(
  jsonString: string,
): SafeParseResult<
  OperationsPluginOperationSensitiveOutputNone,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      OperationsPluginOperationSensitiveOutputNone$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'OperationsPluginOperationSensitiveOutputNone' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperationSensitiveOutputUnion$inboundSchema:
  z.ZodType<OperationsPluginOperationSensitiveOutputUnion, unknown> = z.union([
    z.lazy(() => OperationsPluginOperationSensitiveOutputNone$inboundSchema),
    z.lazy(() => OperationsPluginOperationSensitiveOutputRedact$inboundSchema),
    z.lazy(() =>
      OperationsPluginOperationSensitiveOutputRequireConfirmation$inboundSchema
    ),
  ]);

export function operationsPluginOperationSensitiveOutputUnionFromJSON(
  jsonString: string,
): SafeParseResult<
  OperationsPluginOperationSensitiveOutputUnion,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      OperationsPluginOperationSensitiveOutputUnion$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'OperationsPluginOperationSensitiveOutputUnion' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperationEffect$inboundSchema: z.ZodEnum<
  typeof OperationsPluginOperationEffect
> = z.enum(OperationsPluginOperationEffect);

/** @internal */
export const OperationsPluginOperationAw$inboundSchema: z.ZodType<
  OperationsPluginOperationAw,
  unknown
> = z.object({
  effect: OperationsPluginOperationEffect$inboundSchema,
  actions: z.array(z.string()),
  resources: z.array(z.string()),
  condition: z.nullable(z.record(z.string(), z.record(z.string(), z.string()))),
  reason: z.string(),
});

export function operationsPluginOperationAwFromJSON(
  jsonString: string,
): SafeParseResult<OperationsPluginOperationAw, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OperationsPluginOperationAw$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OperationsPluginOperationAw' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperationScope$inboundSchema: z.ZodEnum<
  typeof OperationsPluginOperationScope
> = z.enum(OperationsPluginOperationScope);

/** @internal */
export const OperationsPluginOperationGcp$inboundSchema: z.ZodType<
  OperationsPluginOperationGcp,
  unknown
> = z.object({
  permissions: z.array(z.string()),
  scope: OperationsPluginOperationScope$inboundSchema,
  reason: z.string(),
});

export function operationsPluginOperationGcpFromJSON(
  jsonString: string,
): SafeParseResult<OperationsPluginOperationGcp, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OperationsPluginOperationGcp$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OperationsPluginOperationGcp' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperationPermissions$inboundSchema: z.ZodType<
  OperationsPluginOperationPermissions,
  unknown
> = z.object({
  azure: z.array(z.string()),
  aws: z.array(z.lazy(() => OperationsPluginOperationAw$inboundSchema)),
  gcp: z.array(z.lazy(() => OperationsPluginOperationGcp$inboundSchema)),
});

export function operationsPluginOperationPermissionsFromJSON(
  jsonString: string,
): SafeParseResult<OperationsPluginOperationPermissions, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      OperationsPluginOperationPermissions$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OperationsPluginOperationPermissions' from JSON`,
  );
}

/** @internal */
export const OperationsPluginOperation$inboundSchema: z.ZodType<
  OperationsPluginOperation,
  unknown
> = z.object({
  name: z.string(),
  tier: OperationsPluginOperationTier$inboundSchema,
  description: z.nullable(z.string()),
  inputSchema: z.nullable(z.record(z.string(), z.nullable(z.any()))),
  outputSchema: z.nullable(z.record(z.string(), z.nullable(z.any()))),
  timeoutSeconds: z.nullable(z.int()),
  retries: z.nullable(
    z.lazy(() => OperationsPluginOperationRetries$inboundSchema),
  ),
  verification: z.nullable(
    z.lazy(() => OperationsPluginOperationVerification$inboundSchema),
  ),
  sensitiveOutput: z.union([
    z.lazy(() => OperationsPluginOperationSensitiveOutputNone$inboundSchema),
    z.lazy(() => OperationsPluginOperationSensitiveOutputRedact$inboundSchema),
    z.lazy(() =>
      OperationsPluginOperationSensitiveOutputRequireConfirmation$inboundSchema
    ),
  ]),
  requiredPermissions: z.array(z.string()),
  permissions: z.lazy(() => OperationsPluginOperationPermissions$inboundSchema),
  kubernetesPermissions: z.nullable(
    OperationsCatalogKubernetesPermissions$inboundSchema,
  ).optional(),
});

export function operationsPluginOperationFromJSON(
  jsonString: string,
): SafeParseResult<OperationsPluginOperation, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => OperationsPluginOperation$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'OperationsPluginOperation' from JSON`,
  );
}