import { API_BASE_URL, apiClient, apiEndpointKeys } from "./api";
import type {
  CloudDescriptor,
  CloudProvider,
  CloudServiceDescriptor,
  CloudServiceStatus,
  CloudServiceType,
  CloudStatus,
  RuntimeDiagnostics,
} from "@/types/cloud";
import type {
  AppConfigConfigurationProfile,
  AppConfigDeployment,
  AppConfigDeploymentStrategy,
  AppConfigEnvironment,
  AppConfigHostedConfigurationVersion,
  ChildCollection,
  ChildItem,
  CloudResource,
  CollectionPage,
  CosmosContainer,
  CosmosItem,
  CosmosQueryResult,
  CreateDatabaseSnapshotInput,
  CreateKubernetesFargateProfileInput,
  CreateKubernetesNodegroupInput,
  DatabaseSnapshot,
  KubernetesFargateProfile,
  KubernetesNodegroup,
  CreateUserPoolGroupInput,
  UserPoolGroup,
  UserPoolSignInTestInput,
  UserPoolSignInTestResult,
  UserPoolClientSettings,
  DistributionInvalidation,
  CertificatePem,
  CertificateRevocationReason,
  ExportedCertificate,
  AlarmHistoryItem,
  AlarmStateValue,
  MetricSeries,
  MetricSeriesQuery,
  MetricSummary,
  UpdateUserPoolClientOAuthInput,
  UserPoolUserAction,
  LogsInsightsQueryInput,
  LogsInsightsQueryResult,
  LogsFilterInput,
  SqsMessage,
  SqsSendMessageInput,
  SqlCredentials,
  SqlDatabase,
  SqlEngine,
  SqlQueryResult,
  SqlTable,
  StorageObjectList,
  S3BucketWebsiteConfiguration,
} from "@/types/resource";
import type { ServiceSchema } from "@/types/schema";
import { getAccountId } from "@/lib/accountStore";

type CloudPathParams = Record<string, string>;

const DATABASE_MUTATION_TIMEOUT_MS = 5 * 60_000;
const LIGHTSAIL_CREATION_TIMEOUT_MS = 3 * 60_000;
const SQL_DATA_TIMEOUT_MS = 45_000;
/** Floci completes Insights queries instantly by default, but bounded server-side polling can take longer. */
const LOGS_QUERY_TIMEOUT_MS = 20_000;
/** Cold starts pull a container image; measured at ~60s on a first invoke. */
const INVOKE_TIMEOUT_MS = 120_000;

export async function listClouds(
  signal?: AbortSignal,
): Promise<CloudDescriptor[]> {
  const res = await apiClient.call<CloudDescriptor[]>(
    apiEndpointKeys.clouds.list,
    { signal },
  );
  return res.data;
}

export async function listCloudServices(
  cloud: CloudProvider,
  signal?: AbortSignal,
): Promise<CloudServiceDescriptor[]> {
  const res = await apiClient.call<CloudServiceDescriptor[]>(
    apiEndpointKeys.clouds.services,
    requestOptions(cloud, "cloud-proxy", { signal }),
    { cloud },
  );
  return res.data;
}

export async function getCloudStatus(
  cloud: CloudProvider,
  signal?: AbortSignal,
): Promise<CloudStatus> {
  const res = await apiClient.call<CloudStatus>(
    apiEndpointKeys.clouds.status,
    requestOptions(cloud, "cloud-proxy", { signal }),
    { cloud },
  );
  return res.data;
}

export async function getCloudDiagnostics(
  cloud: CloudProvider,
  signal?: AbortSignal,
): Promise<RuntimeDiagnostics> {
  const res = await apiClient.call<RuntimeDiagnostics>(
    apiEndpointKeys.clouds.diagnostics,
    requestOptions(cloud, "cloud-proxy", { signal }),
    { cloud },
  );
  return res.data;
}

export async function getCloudServiceStatus(
  cloud: CloudProvider,
  service: CloudServiceType,
  signal?: AbortSignal,
): Promise<CloudServiceStatus> {
  const res = await apiClient.call<CloudServiceStatus>(
    apiEndpointKeys.clouds.serviceStatus,
    requestOptions(cloud, service, { signal }),
    { cloud, service },
  );
  return res.data;
}

export async function getServiceSchema(
  cloud: CloudProvider,
  service: CloudServiceType,
  signal?: AbortSignal,
): Promise<ServiceSchema> {
  const res = await apiClient.call<ServiceSchema>(
    apiEndpointKeys.clouds.schema,
    requestOptions(cloud, service, { signal }),
    { cloud, service },
  );
  return res.data;
}

export type LoadBalancingDependencies = {
  vpcs: Array<{id: string; cidrBlock: string}>;
  subnets: Array<{id: string; vpcId: string; availabilityZone: string; cidrBlock: string}>;
  securityGroups: Array<{id: string; vpcId: string; name: string; description: string}>;
};

export async function getLoadBalancingDependencies(
  service: "loadbalancing" | "targetgroups" = "loadbalancing",
  signal?: AbortSignal,
): Promise<LoadBalancingDependencies & {instances?: Array<{id: string; name: string; privateIp: string | null}>}> {
  const res = await apiClient.call<LoadBalancingDependencies>(
    apiEndpointKeys.clouds.dependencies,
    requestOptions("aws", service, {signal}),
    {cloud: "aws", service},
  );
  return res.data;
}

export async function listCloudResources(
  cloud: CloudProvider,
  service: CloudServiceType,
  search?: string,
  signal?: AbortSignal,
  state?: string,
): Promise<CloudResource[]> {
  const res = await apiClient.call<CloudResource[]>(
    apiEndpointKeys.clouds.resources.list,
    requestOptions(cloud, service, { signal, params: { search, state } }),
    { cloud, service },
  );
  return res.data;
}

export async function getCloudResource(
  cloud: CloudProvider,
  service: CloudServiceType,
  id: string,
  signal?: AbortSignal,
): Promise<CloudResource> {
  const res = await apiClient.call<CloudResource>(
    apiEndpointKeys.clouds.resources.get,
    requestOptions(cloud, service, { signal }),
    { cloud, service, id },
  );
  return res.data;
}

export async function createCloudResource(
  cloud: CloudProvider,
  service: CloudServiceType,
  values: Record<string, unknown>,
  signal?: AbortSignal,
): Promise<CloudResource> {
    const timeout =
      (cloud === "azure" || cloud === "aws") && service === "database"
        ? DATABASE_MUTATION_TIMEOUT_MS
        : cloud === "aws" && service === "lightsail"
          ? LIGHTSAIL_CREATION_TIMEOUT_MS
          : undefined;
  const res = await apiClient.call<CloudResource, Record<string, unknown>>(
    apiEndpointKeys.clouds.resources.create,
    requestOptions(cloud, service, { signal, body: values, timeout }),
    { cloud, service },
  );
  return res.data;
}

export async function updateCloudResource(
  cloud: CloudProvider,
  service: CloudServiceType,
  id: string,
  values: Record<string, unknown>,
  signal?: AbortSignal,
): Promise<CloudResource> {
  const timeout =
    (cloud === "azure" || cloud === "aws") && service === "database"
      ? DATABASE_MUTATION_TIMEOUT_MS
      : undefined;
  const res = await apiClient.call<CloudResource, Record<string, unknown>>(
    apiEndpointKeys.clouds.resources.update,
    requestOptions(cloud, service, { signal, body: values, timeout }),
    { cloud, service, id },
  );
  return res.data;
}

export async function deleteCloudResource(
  cloud: CloudProvider,
  service: CloudServiceType,
  id: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.delete,
    requestOptions(cloud, service, { signal }),
    { cloud, service, id },
  );
}

export async function startCloudResource(
  cloud: CloudProvider,
  service: CloudServiceType,
  id: string,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.start,
    requestOptions(cloud, service),
    { cloud, service, id },
  );
}

export async function stopCloudResource(
  cloud: CloudProvider,
  service: CloudServiceType,
  id: string,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.stop,
    requestOptions(cloud, service),
    { cloud, service, id },
  );
}

export async function rebootCloudResource(
  cloud: CloudProvider,
  service: CloudServiceType,
  id: string,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.reboot,
    requestOptions(cloud, service),
    { cloud, service, id },
  );
}

export async function clearEmailInbox(
  cloud: CloudProvider,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.email.inbox.clear,
    requestOptions(cloud, "email", { signal }),
    { cloud },
  );
}
export interface ServerlessInvokeResult {
  statusCode: number;
  payload: string;
  functionError?: string;
  logResult?: string;
  executionDuration?: number;
}

export interface PublishNotificationInput {
  message: string;
  subject?: string;
  messageAttributes?: Record<string, string>;
}

export interface PublishNotificationResult {
  messageId: string | null;
}

export interface WorkflowExecutionSummary {
  executionArn: string;
  name: string;
  status: string;
  startDate: string;
  stopDate?: string;
}

export interface WorkflowExecutionDetail extends WorkflowExecutionSummary {
  stateMachineArn: string;
  input?: string;
  output?: string;
  error?: string;
  cause?: string;
}

export interface WorkflowExecutionHistoryPage {
  events: Array<Record<string, unknown>>;
  nextToken?: string;
}

export interface CodeBuildEnvironmentVariableOverride {
  name: string;
  value: string;
  type?: "PLAINTEXT" | "PARAMETER_STORE" | "SECRETS_MANAGER";
}

export interface CodeBuildBuild {
  id: string;
  arn?: string;
  projectName: string;
  buildNumber?: number;
  buildStatus?: string;
  currentPhase?: string;
  startTime?: string;
  endTime?: string;
  phases: Array<{phaseType: string; phaseStatus?: string; startTime?: string; endTime?: string; contexts: Array<{statusCode?: string; message?: string}>}>;
  logGroupName?: string;
  logStreamName?: string;
}

export interface PipelineExecutionSummary {
  id: string;
  status?: string;
  statusSummary?: string;
  startTime?: string;
  lastUpdateTime?: string;
}

export interface PipelineState {
  stages: Array<{
    name: string;
    status?: string;
    lastStatusChange?: string;
    actions: Array<{name: string; status?: string; summary?: string; lastStatusChange?: string; externalExecutionId?: string; externalExecutionUrl?: string; entityUrl?: string; revisionUrl?: string; codeBuildProject?: string; codeDeployDeploymentId?: string; codeDeployApplication?: string; codeDeployDeploymentGroup?: string}>;
  }>;
}

export interface CodeDeployDeployment { id: string; applicationName: string; deploymentGroupName: string; status: string | null; creator: string | null; deploymentConfigName: string | null; createTime?: string; completeTime?: string; errorInformation: {code?: string; message?: string} | null; currentVersion: string | null; targetVersion: string | null; trafficPercent: number | null }
export interface StartCodeDeployDeploymentInput { functionName: string; alias: string; currentVersion: string; targetVersion: string; beforeAllowTrafficHook?: string; afterAllowTrafficHook?: string }
export interface CodeDeployDependencies { lambdaFunctions: Array<{name: string; aliases: string[]; versions: string[]}> }

export interface CreateApiGatewayLambdaRouteInput {
  path: string;
  parentResourceId?: string;
  pathPart?: string;
  method: string;
  stage: string;
  functionName: string;
}

export interface ApiGatewayLambdaRoute {
  resourceId: string;
  deploymentId: string;
  invokeUrl: string;
}

export interface TestApiGatewayRouteInput {
  path: string;
  method: string;
  stage: string;
  body: string;
  headers: Record<string, string>;
  query: string;
}

export interface ApiGatewayTestRouteResult {
  statusCode: number;
  headers: Record<string, string>;
  body: string;
  durationMs: number;
}

export interface TestApiGatewayMethodInput {
  resourceId: string;
  httpMethod: string;
  pathWithQueryString: string;
  body: string;
  headers: Record<string, string>;
  multiValueHeaders: Record<string, string[]>;
  stageVariables: Record<string, string>;
}

export interface ApiGatewayMethodTestResult {
  statusCode: number;
  body: string;
  headers: Record<string, string>;
  multiValueHeaders: Record<string, string[]>;
  log: string | null;
  latency: number | null;
}

export interface ApiGatewayRouteOverview {
  resourceId: string;
  path: string;
  method: string;
  functionName: string | null;
  integrationType: string | null;
}

export interface ApiGatewayResourceOverview {
  resourceId: string;
  parentId: string | null;
  path: string;
  pathPart: string | null;
  methods: ApiGatewayRouteOverview[];
}

export interface ApiGatewayRoutesResult {
  resources: ApiGatewayResourceOverview[];
  routes: ApiGatewayRouteOverview[];
  stages: string[];
}

export interface DeleteApiGatewayRouteInput {
  resourceId: string;
  path: string;
  method: string;
  stage: string;
}

export interface EnableApiGatewayCorsInput {
  resourceId: string;
  stage: string;
  origin: string;
  headers: string;
  methods: string[];
}

export interface ApiGatewayCorsResult {
  configuredMethods: string[];
  proxyMethods: string[];
}

export interface CreateS3LambdaTriggerInput {
  functionName: string;
  events: string[];
  prefix?: string;
  suffix?: string;
}

export interface S3LambdaTriggerOverview {
  id: string;
  functionName: string;
  functionArn: string;
  events: string[];
  prefix: string | null;
  suffix: string | null;
}

export interface CreateSnsSubscriptionInput {
  protocol: string;
  endpoint: string;
}

export interface SnsSubscriptionOverview {
  arn: string | null;
  protocol: string;
  endpoint: string;
  status: "Confirmed" | "PendingConfirmation";
  filterPolicy: string | null;
}

export interface CreateEventBridgeLambdaTriggerInput {
  ruleName: string;
  scheduleExpression: string;
}

export interface EventBridgeLambdaTriggerOverview {
  id: string;
  ruleName: string;
  ruleArn: string;
  functionName: string;
  functionArn: string;
  scheduleExpression: string;
  state: string | null;
}

export interface EventBridgeRuleTarget {
  id: string;
  arn: string;
}

export interface CreateEventBridgeRuleInput {
  name: string;
  scheduleExpression?: string;
  eventPattern?: string;
  state?: "ENABLED" | "DISABLED";
  description?: string;
  targets: EventBridgeRuleTarget[];
}

export interface EventBridgeRuleOverview extends CreateEventBridgeRuleInput {
  busName: string;
  busId: string;
  arn: string | null;
  state: "ENABLED" | "DISABLED";
}

export interface PutEventBridgeEventInput {
  source: string;
  detailType: string;
  detail: string;
  resources?: string[];
}

export interface PutEventBridgeEventResult {
  eventId: string | null;
  errorCode: string | null;
  errorMessage: string | null;
}
export interface CloudFormationChangeSet { name: string; id: string; status: string | null; executionStatus: string | null; changes: Array<{action: string | null; logicalResourceId: string | null; resourceType: string | null}> }

export interface CreateSqsLambdaEventSourceMappingInput {
  queueArn: string;
  batchSize?: number;
}

export interface SqsLambdaEventSourceMappingOverview {
  id: string;
  uuid: string;
  functionName: string;
  functionArn: string | null;
  queueArn: string;
  batchSize: number | null;
  state: string | null;
  stateTransitionReason: string | null;
}

export interface KinesisRecord {sequenceNumber: string; partitionKey: string | null; data: string; approximateArrivalTimestamp: string | null}
export interface LambdaEventSourceMappingOverview {id: string; uuid: string; functionName: string | null; functionArn: string | null; eventSourceArn: string; batchSize: number | null; startingPosition: string | null; state: string | null; stateTransitionReason: string | null}
export interface CreateLambdaEventSourceMappingInput {functionName: string; eventSourceArn: string; batchSize?: number; startingPosition?: "TRIM_HORIZON" | "LATEST"}

export async function putKinesisRecord(cloud: CloudProvider, streamName: string, input: {partitionKey: string; data: string}): Promise<{sequenceNumber: string; shardId: string}> {
  const res = await apiClient.call<{sequenceNumber: string; shardId: string}, typeof input>(apiEndpointKeys.clouds.resources.putKinesisRecord, requestOptions(cloud, "kinesis", {body: input}), {cloud, id: streamName})
  return res.data
}

export async function listKinesisRecords(cloud: CloudProvider, streamName: string, signal?: AbortSignal): Promise<KinesisRecord[]> {
  const res = await apiClient.call<KinesisRecord[]>(apiEndpointKeys.clouds.resources.listKinesisRecords, requestOptions(cloud, "kinesis", {signal}), {cloud, id: streamName})
  return res.data
}

export async function createLambdaEventSourceMapping(cloud: CloudProvider, input: CreateLambdaEventSourceMappingInput): Promise<LambdaEventSourceMappingOverview> {
  const res = await apiClient.call<LambdaEventSourceMappingOverview, CreateLambdaEventSourceMappingInput>(apiEndpointKeys.clouds.resources.createLambdaEventSourceMapping, requestOptions(cloud, "serverless", {body: input}), {cloud})
  return res.data
}

export async function listLambdaEventSourceMappings(cloud: CloudProvider, filter: {functionName?: string; eventSourceArn?: string}, signal?: AbortSignal): Promise<LambdaEventSourceMappingOverview[]> {
  const res = await apiClient.call<LambdaEventSourceMappingOverview[]>(apiEndpointKeys.clouds.resources.listLambdaEventSourceMappings, requestOptions(cloud, "serverless", {signal, params: filter}), {cloud})
  return res.data
}

export async function updateLambdaEventSourceMapping(cloud: CloudProvider, mappingId: string, input: {batchSize?: number; enabled?: boolean}): Promise<LambdaEventSourceMappingOverview> {
  const res = await apiClient.call<LambdaEventSourceMappingOverview, typeof input>(apiEndpointKeys.clouds.resources.updateLambdaEventSourceMapping, requestOptions(cloud, "serverless", {body: input}), {cloud, mappingId})
  return res.data
}

export async function deleteLambdaEventSourceMapping(cloud: CloudProvider, mappingId: string): Promise<void> {
  await apiClient.call<void>(apiEndpointKeys.clouds.resources.deleteLambdaEventSourceMapping, requestOptions(cloud, "serverless"), {cloud, mappingId})
}

export async function createApiGatewayLambdaRoute(
  cloud: CloudProvider,
  apiId: string,
  input: CreateApiGatewayLambdaRouteInput,
  signal?: AbortSignal,
): Promise<ApiGatewayLambdaRoute> {
  const res = await apiClient.call<ApiGatewayLambdaRoute, CreateApiGatewayLambdaRouteInput>(
    apiEndpointKeys.clouds.resources.createApiGatewayRoute,
    requestOptions(cloud, "apigateway", { signal, body: input }),
    { cloud, id: apiId },
  );
  return res.data;
}

export async function listApiGatewayRoutes(
  cloud: CloudProvider,
  apiId: string,
  signal?: AbortSignal,
): Promise<ApiGatewayRoutesResult> {
  const res = await apiClient.call<ApiGatewayRoutesResult>(
    apiEndpointKeys.clouds.resources.listApiGatewayRoutes,
    requestOptions(cloud, "apigateway", { signal }),
    { cloud, id: apiId },
  );
  return res.data;
}

export async function deleteApiGatewayRoute(
  cloud: CloudProvider,
  apiId: string,
  input: DeleteApiGatewayRouteInput,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.deleteApiGatewayRoute,
    requestOptions(cloud, "apigateway", {signal, params: {stage: input.stage, path: input.path}}),
    {cloud, id: apiId, resourceId: input.resourceId, method: input.method},
  );
}

export async function enableApiGatewayCors(
  cloud: CloudProvider,
  apiId: string,
  input: EnableApiGatewayCorsInput,
  signal?: AbortSignal,
): Promise<ApiGatewayCorsResult> {
  const res = await apiClient.call<ApiGatewayCorsResult, EnableApiGatewayCorsInput>(
    apiEndpointKeys.clouds.resources.enableApiGatewayCors,
    requestOptions(cloud, "apigateway", {signal, body: input}),
    {cloud, id: apiId},
  );
  return res.data;
}

export async function testApiGatewayRoute(
  cloud: CloudProvider,
  apiId: string,
  input: TestApiGatewayRouteInput,
  signal?: AbortSignal,
): Promise<ApiGatewayTestRouteResult> {
  const res = await apiClient.call<ApiGatewayTestRouteResult, TestApiGatewayRouteInput>(
    apiEndpointKeys.clouds.resources.testApiGatewayRoute,
    requestOptions(cloud, "apigateway", { signal, body: input, timeout: INVOKE_TIMEOUT_MS }),
    { cloud, id: apiId },
  );
  return res.data;
}

export async function testApiGatewayMethod(
  cloud: CloudProvider,
  apiId: string,
  input: TestApiGatewayMethodInput,
  signal?: AbortSignal,
): Promise<ApiGatewayMethodTestResult> {
  const res = await apiClient.call<ApiGatewayMethodTestResult, TestApiGatewayMethodInput>(
    apiEndpointKeys.clouds.resources.testApiGatewayMethod,
    requestOptions(cloud, "apigateway", { signal, body: input, timeout: INVOKE_TIMEOUT_MS }),
    { cloud, id: apiId },
  );
  return res.data;
}

export async function createS3LambdaTrigger(
  cloud: CloudProvider,
  bucketName: string,
  input: CreateS3LambdaTriggerInput,
  signal?: AbortSignal,
): Promise<S3LambdaTriggerOverview> {
  const res = await apiClient.call<S3LambdaTriggerOverview, CreateS3LambdaTriggerInput>(
    apiEndpointKeys.clouds.resources.createS3LambdaTrigger,
    requestOptions(cloud, "storage", {signal, body: input}),
    {cloud, id: bucketName},
  );
  return res.data;
}

export async function listS3LambdaTriggers(
  cloud: CloudProvider,
  bucketName: string,
  signal?: AbortSignal,
): Promise<S3LambdaTriggerOverview[]> {
  const res = await apiClient.call<S3LambdaTriggerOverview[]>(
    apiEndpointKeys.clouds.resources.listS3LambdaTriggers,
    requestOptions(cloud, "storage", {signal}),
    {cloud, id: bucketName},
  );
  return res.data;
}

export async function deleteS3LambdaTrigger(
  cloud: CloudProvider,
  bucketName: string,
  triggerId: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.deleteS3LambdaTrigger,
    requestOptions(cloud, "storage", {signal}),
    {cloud, id: bucketName, triggerId},
  );
}

export async function getS3BucketWebsite(
  cloud: CloudProvider,
  bucketName: string,
  signal?: AbortSignal,
): Promise<S3BucketWebsiteConfiguration | null> {
  const res = await apiClient.call<S3BucketWebsiteConfiguration | null>(
    apiEndpointKeys.clouds.resources.getS3BucketWebsite,
    requestOptions(cloud, "storage", {signal}),
    {cloud, id: bucketName},
  );
  return res.data;
}

export async function putS3BucketWebsite(
  cloud: CloudProvider,
  bucketName: string,
  configuration: S3BucketWebsiteConfiguration,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void, S3BucketWebsiteConfiguration>(
    apiEndpointKeys.clouds.resources.putS3BucketWebsite,
    requestOptions(cloud, "storage", {signal, body: configuration}),
    {cloud, id: bucketName},
  );
}

export async function deleteS3BucketWebsite(
  cloud: CloudProvider,
  bucketName: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.deleteS3BucketWebsite,
    requestOptions(cloud, "storage", {signal}),
    {cloud, id: bucketName},
  );
}

export async function createSnsSubscription(
  cloud: CloudProvider,
  topicArn: string,
  input: CreateSnsSubscriptionInput,
  signal?: AbortSignal,
): Promise<SnsSubscriptionOverview> {
  const res = await apiClient.call<SnsSubscriptionOverview, CreateSnsSubscriptionInput>(
    apiEndpointKeys.clouds.resources.createSnsSubscription,
    requestOptions(cloud, "notifications", {signal, body: input}),
    {cloud, id: topicArn},
  );
  return res.data;
}

export async function listSnsSubscriptions(
  cloud: CloudProvider,
  topicArn: string,
  signal?: AbortSignal,
): Promise<SnsSubscriptionOverview[]> {
  const res = await apiClient.call<SnsSubscriptionOverview[]>(
    apiEndpointKeys.clouds.resources.listSnsSubscriptions,
    requestOptions(cloud, "notifications", {signal}),
    {cloud, id: topicArn},
  );
  return res.data;
}

export async function deleteSnsSubscription(
  cloud: CloudProvider,
  topicArn: string,
  subscriptionArn: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.deleteSnsSubscription,
    requestOptions(cloud, "notifications", {signal}),
    {cloud, id: topicArn, subscriptionArn},
  );
}

export async function createEventBridgeLambdaTrigger(
  cloud: CloudProvider,
  functionName: string,
  input: CreateEventBridgeLambdaTriggerInput,
  signal?: AbortSignal,
): Promise<EventBridgeLambdaTriggerOverview> {
  const res = await apiClient.call<EventBridgeLambdaTriggerOverview, CreateEventBridgeLambdaTriggerInput>(
    apiEndpointKeys.clouds.resources.createEventBridgeLambdaTrigger,
    requestOptions(cloud, "serverless", {signal, body: input}),
    {cloud, id: functionName},
  );
  return res.data;
}

export async function listEventBridgeLambdaTriggers(
  cloud: CloudProvider,
  functionName: string,
  signal?: AbortSignal,
): Promise<EventBridgeLambdaTriggerOverview[]> {
  const res = await apiClient.call<EventBridgeLambdaTriggerOverview[]>(
    apiEndpointKeys.clouds.resources.listEventBridgeLambdaTriggers,
    requestOptions(cloud, "serverless", {signal}),
    {cloud, id: functionName},
  );
  return res.data;
}

export async function deleteEventBridgeLambdaTrigger(
  cloud: CloudProvider,
  functionName: string,
  triggerId: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.deleteEventBridgeLambdaTrigger,
    requestOptions(cloud, "serverless", {signal}),
    {cloud, id: functionName, triggerId},
  );
}

export async function createEventBridgeRule(
  cloud: CloudProvider,
  eventBusId: string,
  input: CreateEventBridgeRuleInput,
  signal?: AbortSignal,
): Promise<EventBridgeRuleOverview> {
  const res = await apiClient.call<EventBridgeRuleOverview, CreateEventBridgeRuleInput>(
    apiEndpointKeys.clouds.resources.createEventBridgeRule,
    requestOptions(cloud, "events", {signal, body: input}),
    {cloud, id: eventBusId},
  );
  return res.data;
}

export async function listEventBridgeRules(
  cloud: CloudProvider,
  eventBusId: string,
  signal?: AbortSignal,
): Promise<EventBridgeRuleOverview[]> {
  const res = await apiClient.call<EventBridgeRuleOverview[]>(
    apiEndpointKeys.clouds.resources.listEventBridgeRules,
    requestOptions(cloud, "events", {signal}),
    {cloud, id: eventBusId},
  );
  return res.data;
}

export async function deleteEventBridgeRule(
  cloud: CloudProvider,
  eventBusId: string,
  ruleName: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.deleteEventBridgeRule,
    requestOptions(cloud, "events", {signal}),
    {cloud, id: eventBusId, ruleName},
  );
}

export async function putEventBridgeEvent(
  cloud: CloudProvider,
  eventBusId: string,
  input: PutEventBridgeEventInput,
  signal?: AbortSignal,
): Promise<PutEventBridgeEventResult> {
  const res = await apiClient.call<PutEventBridgeEventResult, PutEventBridgeEventInput>(
    apiEndpointKeys.clouds.resources.putEventBridgeEvent,
    requestOptions(cloud, "events", {signal, body: input}),
    {cloud, id: eventBusId},
  );
  return res.data;
}

export async function listCloudFormationChangeSets(cloud: CloudProvider, stackName: string, signal?: AbortSignal): Promise<CloudFormationChangeSet[]> { const res = await apiClient.call<CloudFormationChangeSet[]>(apiEndpointKeys.clouds.resources.listCloudFormationChangeSets, requestOptions(cloud, 'iac', {signal}), {cloud, id: stackName}); return res.data }
export async function createCloudFormationChangeSet(cloud: CloudProvider, stackName: string, input: {name: string; templateBody: string; parameters?: Record<string, string>; capabilities?: string[]}): Promise<CloudFormationChangeSet> { const res = await apiClient.call<CloudFormationChangeSet, typeof input>(apiEndpointKeys.clouds.resources.createCloudFormationChangeSet, requestOptions(cloud, 'iac', {body: input}), {cloud, id: stackName}); return res.data }
export async function executeCloudFormationChangeSet(cloud: CloudProvider, stackName: string, name: string): Promise<void> { await apiClient.call<void>(apiEndpointKeys.clouds.resources.executeCloudFormationChangeSet, requestOptions(cloud, 'iac', {}), {cloud, id: stackName, name}) }
export async function deleteCloudFormationChangeSet(cloud: CloudProvider, stackName: string, name: string): Promise<void> { await apiClient.call<void>(apiEndpointKeys.clouds.resources.deleteCloudFormationChangeSet, requestOptions(cloud, 'iac', {}), {cloud, id: stackName, name}) }
export async function updateCloudFormationTerminationProtection(cloud: CloudProvider, stackName: string, enabled: boolean): Promise<void> { await apiClient.call<void, {enabled: boolean}>(apiEndpointKeys.clouds.resources.updateCloudFormationTerminationProtection, requestOptions(cloud, 'iac', {body: {enabled}}), {cloud, id: stackName}) }

export async function createSqsLambdaEventSourceMapping(
  cloud: CloudProvider,
  functionName: string,
  input: CreateSqsLambdaEventSourceMappingInput,
  signal?: AbortSignal,
): Promise<SqsLambdaEventSourceMappingOverview> {
  const res = await apiClient.call<SqsLambdaEventSourceMappingOverview, CreateSqsLambdaEventSourceMappingInput>(
    apiEndpointKeys.clouds.resources.createSqsLambdaEventSourceMapping,
    requestOptions(cloud, "serverless", {signal, body: input}),
    {cloud, id: functionName},
  );
  return res.data;
}

export async function listSqsLambdaEventSourceMappings(
  cloud: CloudProvider,
  functionName: string,
  signal?: AbortSignal,
): Promise<SqsLambdaEventSourceMappingOverview[]> {
  const res = await apiClient.call<SqsLambdaEventSourceMappingOverview[]>(
    apiEndpointKeys.clouds.resources.listSqsLambdaEventSourceMappings,
    requestOptions(cloud, "serverless", {signal}),
    {cloud, id: functionName},
  );
  return res.data;
}

export async function deleteSqsLambdaEventSourceMapping(
  cloud: CloudProvider,
  functionName: string,
  mappingId: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.deleteSqsLambdaEventSourceMapping,
    requestOptions(cloud, "serverless", {signal}),
    {cloud, id: functionName, mappingId},
  );
}

export type KmsEncryptionAlgorithm =
  | "SYMMETRIC_DEFAULT"
  | "RSAES_OAEP_SHA_1"
  | "RSAES_OAEP_SHA_256";

export interface KmsEncryptRequest {
  plaintextBase64: string;
  encryptionAlgorithm: KmsEncryptionAlgorithm;
  encryptionContext?: Record<string, string>;
}

export interface KmsEncryptResponse {
  ciphertextBlobBase64: string;
  keyId: string;
  encryptionAlgorithm: KmsEncryptionAlgorithm;
}

export interface KmsDecryptRequest {
  ciphertextBlobBase64: string;
  encryptionAlgorithm: KmsEncryptionAlgorithm;
  encryptionContext?: Record<string, string>;
}

export interface KmsDecryptResponse {
  plaintextBase64: string;
  keyId: string;
  encryptionAlgorithm: KmsEncryptionAlgorithm;
}

export async function invokeCloudResource(
  cloud: CloudProvider,
  service: CloudServiceType,
  id: string,
  payload: string,
  signal?: AbortSignal,
): Promise<ServerlessInvokeResult> {
  const res = await apiClient.call<ServerlessInvokeResult, { payload: string }>(
    apiEndpointKeys.clouds.resources.invoke,
    requestOptions(cloud, service, {
      signal,
      body: { payload },
      // A cold invoke can exceed a minute while the runtime pulls and starts the
      // function container, so the 10s default would abort a request that is
      // working. The user-visible alternative is a timeout error for a function
      // that in fact ran.
      timeout: INVOKE_TIMEOUT_MS,
    }),
    { cloud, service, id },
  );
  return res.data;
}

export async function startWorkflowExecution(
  stateMachineArn: string,
  input: {input: string; name?: string},
): Promise<{executionArn: string; startDate: string}> {
  const res = await apiClient.call<{executionArn: string; startDate: string}, {input: string; name?: string}>(
    apiEndpointKeys.clouds.resources.startWorkflowExecution,
    requestOptions("aws", "workflows", {body: input}),
    {cloud: "aws", id: stateMachineArn},
  );
  return res.data;
}

export async function listWorkflowExecutions(stateMachineArn: string, signal?: AbortSignal): Promise<WorkflowExecutionSummary[]> {
  const res = await apiClient.call<WorkflowExecutionSummary[]>(
    apiEndpointKeys.clouds.resources.listWorkflowExecutions,
    requestOptions("aws", "workflows", {signal}),
    {cloud: "aws", id: stateMachineArn},
  );
  return res.data;
}

export async function describeWorkflowExecution(stateMachineArn: string, executionArn: string, signal?: AbortSignal): Promise<WorkflowExecutionDetail> {
  const res = await apiClient.call<WorkflowExecutionDetail>(
    apiEndpointKeys.clouds.resources.describeWorkflowExecution,
    requestOptions("aws", "workflows", {signal}),
    {cloud: "aws", id: stateMachineArn, executionArn},
  );
  return res.data;
}

export async function getWorkflowExecutionHistory(stateMachineArn: string, executionArn: string, nextToken?: string, signal?: AbortSignal): Promise<WorkflowExecutionHistoryPage> {
  const res = await apiClient.call<WorkflowExecutionHistoryPage>(
    apiEndpointKeys.clouds.resources.getWorkflowExecutionHistory,
    requestOptions("aws", "workflows", {signal, params: {nextToken}}),
    {cloud: "aws", id: stateMachineArn, executionArn},
  );
  return res.data;
}

export async function stopWorkflowExecution(stateMachineArn: string, executionArn: string): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.resources.stopWorkflowExecution,
    requestOptions("aws", "workflows"),
    {cloud: "aws", id: stateMachineArn, executionArn},
  );
}

export async function startCodeBuild(projectName: string, input: {environmentVariablesOverride?: CodeBuildEnvironmentVariableOverride[]; buildspecOverride?: string}): Promise<CodeBuildBuild> {
  const res = await apiClient.call<CodeBuildBuild, typeof input>(apiEndpointKeys.clouds.resources.startCodeBuild, requestOptions("aws", "codebuild", {body: input}), {cloud: "aws", id: projectName});
  return res.data;
}

export async function listCodeBuilds(projectName: string, signal?: AbortSignal): Promise<CodeBuildBuild[]> {
  const res = await apiClient.call<CodeBuildBuild[]>(apiEndpointKeys.clouds.resources.listCodeBuilds, requestOptions("aws", "codebuild", {signal}), {cloud: "aws", id: projectName});
  return res.data;
}

export async function getCodeBuild(projectName: string, buildId: string, signal?: AbortSignal): Promise<CodeBuildBuild> {
  const res = await apiClient.call<CodeBuildBuild>(apiEndpointKeys.clouds.resources.getCodeBuild, requestOptions("aws", "codebuild", {signal}), {cloud: "aws", id: projectName, buildId});
  return res.data;
}

export async function startCodePipeline(name: string): Promise<{id: string}> {
  const res = await apiClient.call<{id: string}>(apiEndpointKeys.clouds.resources.startCodePipeline, requestOptions('aws', 'codepipeline'), {cloud: 'aws', id: name});
  return res.data;
}

export async function listCodePipelineExecutions(name: string, signal?: AbortSignal): Promise<PipelineExecutionSummary[]> {
  const res = await apiClient.call<PipelineExecutionSummary[]>(apiEndpointKeys.clouds.resources.listCodePipelineExecutions, requestOptions('aws', 'codepipeline', {signal}), {cloud: 'aws', id: name});
  return res.data;
}

export async function getCodePipelineState(name: string, signal?: AbortSignal): Promise<PipelineState> {
  const res = await apiClient.call<PipelineState>(apiEndpointKeys.clouds.resources.getCodePipelineState, requestOptions('aws', 'codepipeline', {signal}), {cloud: 'aws', id: name});
  return res.data;
}

export async function getCodeDeployDependencies(signal?: AbortSignal): Promise<CodeDeployDependencies> { const res = await apiClient.call<CodeDeployDependencies>(apiEndpointKeys.clouds.dependencies, requestOptions('aws', 'codedeploy', {signal}), {cloud: 'aws', service: 'codedeploy'}); return res.data }
export async function startCodeDeployDeployment(groupId: string, input: StartCodeDeployDeploymentInput): Promise<CodeDeployDeployment> { const res = await apiClient.call<CodeDeployDeployment, StartCodeDeployDeploymentInput>(apiEndpointKeys.clouds.resources.startCodeDeployDeployment, requestOptions('aws', 'codedeploy', {body: input}), {cloud: 'aws', id: groupId}); return res.data }
export async function listCodeDeployDeployments(groupId: string, signal?: AbortSignal): Promise<CodeDeployDeployment[]> { const res = await apiClient.call<CodeDeployDeployment[]>(apiEndpointKeys.clouds.resources.listCodeDeployDeployments, requestOptions('aws', 'codedeploy', {signal}), {cloud: 'aws', id: groupId}); return res.data }
export async function getCodeDeployDeployment(id: string, signal?: AbortSignal): Promise<CodeDeployDeployment> { const res = await apiClient.call<CodeDeployDeployment>(apiEndpointKeys.clouds.resources.getCodeDeployDeployment, requestOptions('aws', 'codedeploy', {signal}), {cloud: 'aws', deploymentId: id}); return res.data }
export async function stopCodeDeployDeployment(id: string, rollback: boolean): Promise<void> { await apiClient.call<void, {rollback: boolean}>(apiEndpointKeys.clouds.resources.stopCodeDeployDeployment, requestOptions('aws', 'codedeploy', {body: {rollback}}), {cloud: 'aws', deploymentId: id}) }

export async function publishNotification(
  cloud: CloudProvider,
  topicArn: string,
  input: PublishNotificationInput,
  signal?: AbortSignal,
): Promise<PublishNotificationResult> {
  const res = await apiClient.call<PublishNotificationResult, PublishNotificationInput>(
    apiEndpointKeys.clouds.resources.publish,
    requestOptions(cloud, "notifications", { signal, body: input }),
    { cloud, id: topicArn },
  );
  return res.data;
}

export async function encryptKmsResource(
  cloud: CloudProvider,
  id: string,
  body: KmsEncryptRequest,
  signal?: AbortSignal,
): Promise<KmsEncryptResponse> {
  const res = await apiClient.call<KmsEncryptResponse, KmsEncryptRequest>(
    apiEndpointKeys.clouds.resources.encrypt,
    requestOptions(cloud, "kms", { signal, body }),
    { cloud, id },
  );
  return res.data;
}

export async function decryptKmsResource(
  cloud: CloudProvider,
  id: string,
  body: KmsDecryptRequest,
  signal?: AbortSignal,
): Promise<KmsDecryptResponse> {
  const res = await apiClient.call<KmsDecryptResponse, KmsDecryptRequest>(
    apiEndpointKeys.clouds.resources.decrypt,
    requestOptions(cloud, "kms", { signal, body }),
    { cloud, id },
  );
  return res.data;
}

export async function listStorageObjects(
  cloud: CloudProvider,
  resourceId: string,
  prefix?: string,
  signal?: AbortSignal,
): Promise<StorageObjectList> {
  const res = await apiClient.call<StorageObjectList>(
    apiEndpointKeys.clouds.storage.objects.list,
    requestOptions(cloud, "storage", { signal, params: { prefix } }),
    storagePathParams(cloud, resourceId),
  );
  return res.data;
}

export async function uploadStorageObject(
  cloud: CloudProvider,
  resourceId: string,
  key: string,
  file: File | Blob,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.storage.objects.upload,
    requestOptions(cloud, "storage", {
      signal,
      rawBody: file,
      params: { key },
      headers: { "Content-Type": file.type || "application/octet-stream" },
    }),
    storagePathParams(cloud, resourceId),
  );
}

export type LightsailStaticDeployment = {status: 'deployed'; files: number}
export type LightsailNodeDeployment = {status: 'deployed'; files: number; port: number; releaseId: string}

export async function deployLightsailStaticFiles(instanceId: string, files: File[]): Promise<LightsailStaticDeployment> {
  const form = new FormData()
  for (const file of files) {
    const path = file.webkitRelativePath || file.name
    form.append('files', file, path)
  }
  const res = await apiClient.call<LightsailStaticDeployment>(
    apiEndpointKeys.clouds.resources.deployLightsailStaticFiles,
    requestOptions('aws', 'lightsail', {rawBody: form}),
    {id: instanceId},
  )
  return res.data
}

export async function deployLightsailNodeApplication(instanceId: string, files: File[], startCommand: string, port: number): Promise<LightsailNodeDeployment> {
  const form = new FormData()
  for (const file of files) form.append('files', file, file.webkitRelativePath || file.name)
  if (startCommand.trim()) form.append('startCommand', startCommand.trim())
  form.append('port', String(port))
  const res = await apiClient.call<LightsailNodeDeployment>(
    apiEndpointKeys.clouds.resources.deployLightsailNodeApplication,
    requestOptions('aws', 'lightsail', {rawBody: form, timeout: 370_000}),
    {id: instanceId},
  )
  return res.data
}

export function storageObjectDownloadUrl(
  cloud: CloudProvider,
  resourceId: string,
  key: string,
): string {
  const path = `/clouds/${encodeURIComponent(
    cloud,
  )}/services/storage/resources/${encodeURIComponent(resourceId)}/object`;
  // This URL is opened directly by the browser (anchor/img), so it bypasses the
  // request interceptor — pass the account as a query param the API also reads.
  return `${API_BASE_URL}${path}?key=${encodeURIComponent(
    key,
  )}&account=${encodeURIComponent(getAccountId())}`;
}

export async function deleteStorageObject(
  cloud: CloudProvider,
  resourceId: string,
  key: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.storage.objects.delete,
    requestOptions(cloud, "storage", { signal, params: { key } }),
    storagePathParams(cloud, resourceId),
  );
}

export async function copyStorageObject(
  cloud: CloudProvider,
  srcResourceId: string,
  srcKey: string,
  destKey: string,
  destResourceId?: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void, Record<string, unknown>>(
    apiEndpointKeys.clouds.storage.objects.copy,
    requestOptions(cloud, "storage", {
      signal,
      body: { srcKey, destKey, ...(destResourceId ? { destResourceId } : {}) },
    }),
    storagePathParams(cloud, srcResourceId),
  );
}

export async function listCosmosContainers(
  cloud: CloudProvider,
  databaseId: string,
  signal?: AbortSignal,
): Promise<CosmosContainer[]> {
  const res = await apiClient.call<CosmosContainer[]>(
    apiEndpointKeys.clouds.nosql.cosmos.containers.list,
    requestOptions(cloud, "nosql", { signal }),
    databasePathParams(cloud, databaseId),
  );
  return res.data;
}

export async function createCosmosContainer(
  cloud: CloudProvider,
  databaseId: string,
  values: Record<string, unknown>,
  signal?: AbortSignal,
): Promise<CosmosContainer> {
  const res = await apiClient.call<CosmosContainer, Record<string, unknown>>(
    apiEndpointKeys.clouds.nosql.cosmos.containers.create,
    requestOptions(cloud, "nosql", { signal, body: values }),
    databasePathParams(cloud, databaseId),
  );
  return res.data;
}

export async function deleteCosmosContainer(
  cloud: CloudProvider,
  databaseId: string,
  containerId: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.nosql.cosmos.containers.delete,
    requestOptions(cloud, "nosql", { signal }),
    { ...databasePathParams(cloud, databaseId), containerId },
  );
}



export async function listCosmosItems(
  cloud: CloudProvider,
  databaseId: string,
  containerId: string,
  signal?: AbortSignal,
): Promise<CosmosItem[]> {
  const res = await apiClient.call<CosmosItem[]>(
    apiEndpointKeys.clouds.nosql.cosmos.items.list,
    requestOptions(cloud, "nosql", { signal }),
    { ...databasePathParams(cloud, databaseId), containerId },
  );
  return res.data;
}

export async function upsertCosmosItem(
  cloud: CloudProvider,
  databaseId: string,
  containerId: string,
  document: Record<string, unknown>,
  signal?: AbortSignal,
): Promise<CosmosItem> {
  const res = await apiClient.call<CosmosItem, Record<string, unknown>>(
    apiEndpointKeys.clouds.nosql.cosmos.items.upsert,
    requestOptions(cloud, "nosql", { signal, body: document }),
    { ...databasePathParams(cloud, databaseId), containerId },
  );
  return res.data;
}

export async function deleteCosmosItem(
  cloud: CloudProvider,
  databaseId: string,
  containerId: string,
  itemId: string,
  partitionKey?: string | null,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.nosql.cosmos.items.delete,
    requestOptions(cloud, "nosql", {
      signal,
      params: partitionKey ? { partitionKey } : undefined,
    }),
    { ...databasePathParams(cloud, databaseId), containerId, itemId },
  );
}

export async function queryCosmosItems(
  cloud: CloudProvider,
  databaseId: string,
  containerId: string,
  query: string,
  signal?: AbortSignal,
): Promise<CosmosQueryResult> {
  const res = await apiClient.call<CosmosQueryResult, { query: string }>(
    apiEndpointKeys.clouds.nosql.cosmos.items.query,
    requestOptions(cloud, "nosql", { signal, body: { query } }),
    { ...databasePathParams(cloud, databaseId), containerId },
  );
  return res.data;
}

export async function listChildCollections(
  cloud: CloudProvider,
  service: CloudServiceType,
  resourceId: string,
  cursor?: string,
  signal?: AbortSignal,
): Promise<CollectionPage<ChildCollection>> {
  const res = await apiClient.call<CollectionPage<ChildCollection>>(
    apiEndpointKeys.clouds.childCollections.list,
    requestOptions(cloud, service, { signal, params: cursor ? { cursor } : undefined }),
    { cloud, service, id: resourceId },
  );
  return res.data;
}

export async function listCollectionItems(
  cloud: CloudProvider,
  service: CloudServiceType,
  resourceId: string,
  collectionId: string,
  cursor?: string,
  signal?: AbortSignal,
): Promise<CollectionPage<ChildItem>> {
  const res = await apiClient.call<CollectionPage<ChildItem>>(
    apiEndpointKeys.clouds.childCollections.items.list,
    requestOptions(cloud, service, { signal, params: cursor ? { cursor } : undefined }),
    { cloud, service, id: resourceId, cid: collectionId },
  );
  return res.data;
}

export async function listFlatItems(
  cloud: CloudProvider,
  service: CloudServiceType,
  resourceId: string,
  cursor?: string,
  signal?: AbortSignal,
): Promise<CollectionPage<ChildItem>> {
  const res = await apiClient.call<CollectionPage<ChildItem>>(
    apiEndpointKeys.clouds.flatItems.list,
    requestOptions(cloud, service, { signal, params: cursor ? { cursor } : undefined }),
    { cloud, service, id: resourceId },
  );
  return res.data;
}

export async function queryFlatItems(
  cloud: CloudProvider,
  service: CloudServiceType,
  resourceId: string,
  query: Record<string, unknown>,
  cursor?: string,
  limit = 100,
  signal?: AbortSignal,
): Promise<CollectionPage<ChildItem>> {
  const res = await apiClient.call<CollectionPage<ChildItem>, {query: Record<string, unknown>}>(
    apiEndpointKeys.clouds.flatItems.query,
    requestOptions(cloud, service, {signal, params: {cursor, limit}, body: {query}}),
    {cloud, service, id: resourceId},
  );
  return res.data;
}

export async function deleteFlatItem(
  cloud: CloudProvider,
  service: CloudServiceType,
  resourceId: string,
  itemId: string,
  signal?: AbortSignal,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.flatItems.delete,
    requestOptions(cloud, service, { signal }),
    { cloud, service, id: resourceId, itemId },
  );
}

export async function getFlatItem(
  cloud: CloudProvider,
  service: CloudServiceType,
  resourceId: string,
  itemId: string,
  signal?: AbortSignal,
): Promise<ChildItem> {
  const res = await apiClient.call<ChildItem>(
    apiEndpointKeys.clouds.flatItems.get,
    requestOptions(cloud, service, { signal }),
    { cloud, service, id: resourceId, itemId },
  );
  return res.data;
}

export async function updateUserPoolUser(
  cloud: CloudProvider,
  poolId: string,
  username: string,
  input: UserPoolUserAction,
): Promise<void> {
  await apiClient.call<void, UserPoolUserAction>(
    apiEndpointKeys.clouds.userpools.userAction,
    requestOptions(cloud, "userpools", { body: input }),
    { cloud, id: poolId, username },
  );
}

export async function setUserPoolUserGroups(
  cloud: CloudProvider,
  poolId: string,
  username: string,
  groups: string[],
): Promise<void> {
  await apiClient.call<void, { groups: string[] }>(
    apiEndpointKeys.clouds.userpools.userGroups,
    requestOptions(cloud, "userpools", { body: { groups } }),
    { cloud, id: poolId, username },
  );
}

export async function listUserPoolGroups(
  cloud: CloudProvider,
  poolId: string,
  signal?: AbortSignal,
): Promise<UserPoolGroup[]> {
  const res = await apiClient.call<UserPoolGroup[]>(
    apiEndpointKeys.clouds.userpools.groups.list,
    requestOptions(cloud, "userpools", { signal }),
    { cloud, id: poolId },
  );
  return res.data;
}

export async function createUserPoolGroup(
  cloud: CloudProvider,
  poolId: string,
  input: CreateUserPoolGroupInput,
): Promise<UserPoolGroup> {
  const res = await apiClient.call<UserPoolGroup, CreateUserPoolGroupInput>(
    apiEndpointKeys.clouds.userpools.groups.create,
    requestOptions(cloud, "userpools", { body: input }),
    { cloud, id: poolId },
  );
  return res.data;
}

export async function deleteUserPoolGroup(
  cloud: CloudProvider,
  poolId: string,
  groupName: string,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.userpools.groups.delete,
    requestOptions(cloud, "userpools"),
    { cloud, id: poolId, groupName },
  );
}

export async function testUserPoolSignIn(
  cloud: CloudProvider,
  poolId: string,
  input: UserPoolSignInTestInput,
): Promise<UserPoolSignInTestResult> {
  const res = await apiClient.call<UserPoolSignInTestResult, UserPoolSignInTestInput>(
    apiEndpointKeys.clouds.userpools.signInTest,
    requestOptions(cloud, "userpools", { body: input }),
    { cloud, id: poolId },
  );
  return res.data;
}

export async function listMetrics(
  cloud: CloudProvider,
  query: { namespace?: string; search?: string } = {},
  signal?: AbortSignal,
): Promise<MetricSummary[]> {
  const res = await apiClient.call<MetricSummary[]>(
    apiEndpointKeys.clouds.monitoring.metrics,
    requestOptions(cloud, "monitoring", { signal, params: { namespace: query.namespace || undefined, search: query.search || undefined } }),
    { cloud },
  );
  return res.data;
}

export async function getMetricSeries(
  cloud: CloudProvider,
  query: MetricSeriesQuery,
  signal?: AbortSignal,
): Promise<MetricSeries> {
  const res = await apiClient.call<MetricSeries, MetricSeriesQuery>(
    apiEndpointKeys.clouds.monitoring.metricData,
    requestOptions(cloud, "monitoring", { signal, body: query }),
    { cloud },
  );
  return res.data;
}

export async function describeAlarmHistory(
  cloud: CloudProvider,
  alarmName: string,
  signal?: AbortSignal,
): Promise<AlarmHistoryItem[]> {
  const res = await apiClient.call<AlarmHistoryItem[]>(
    apiEndpointKeys.clouds.monitoring.history,
    requestOptions(cloud, "monitoring", { signal }),
    { cloud, id: alarmName },
  );
  return res.data;
}

export async function setAlarmState(
  cloud: CloudProvider,
  alarmName: string,
  state: AlarmStateValue,
  reason: string,
): Promise<void> {
  await apiClient.call<void, { state: AlarmStateValue; reason: string }>(
    apiEndpointKeys.clouds.monitoring.state,
    requestOptions(cloud, "monitoring", { body: { state, reason } }),
    { cloud, id: alarmName },
  );
}

export async function setAlarmActionsEnabled(
  cloud: CloudProvider,
  alarmName: string,
  enabled: boolean,
): Promise<void> {
  await apiClient.call<void, { enabled: boolean }>(
    apiEndpointKeys.clouds.monitoring.actions,
    requestOptions(cloud, "monitoring", { body: { enabled } }),
    { cloud, id: alarmName },
  );
}

export type HttpApiProtocol = "HTTP" | "WEBSOCKET";

export interface HttpApiIntegrationOverview {
  integrationId: string;
  type: string;
  uri: string | null;
  functionName: string | null;
  payloadFormatVersion: string | null;
}

export interface HttpApiRouteOverview {
  routeId: string;
  routeKey: string;
  integration: HttpApiIntegrationOverview | null;
  authorizationType: string;
  authorizerId: string | null;
  authorizationScopes: string[];
  returnsResponse: boolean;
}

export interface HttpApiStageOverview {
  stageName: string;
  autoDeploy: boolean;
  deploymentId: string | null;
  lastUpdatedAt: string | null;
  invokePath: string;
}

export interface HttpApiAuthorizerOverview {
  authorizerId: string;
  name: string;
  type: string;
  identitySource: string[];
  issuer: string | null;
  audience: string[];
}

export interface HttpApiCors {
  allowOrigins: string[];
  allowMethods: string[];
  allowHeaders: string[];
  exposeHeaders: string[];
  maxAgeSeconds: number | null;
  allowCredentials: boolean;
}

export interface HttpApiOverview {
  apiId: string;
  protocol: HttpApiProtocol;
  apiEndpoint: string | null;
  routeSelectionExpression: string | null;
  routes: HttpApiRouteOverview[];
  stages: HttpApiStageOverview[];
  authorizers: HttpApiAuthorizerOverview[];
  cors: HttpApiCors | null;
}

export interface HttpApiRouteInput {
  routeKey: string;
  functionName?: string;
  httpUrl?: string;
  authorizerId?: string;
  returnsResponse?: boolean;
}

export interface HttpApiAuthorizerInput {
  name: string;
  userPoolId?: string;
  userPoolClientId?: string;
  issuer?: string;
  audience?: string[];
}

export interface HttpApiWebSocketTestResult {
  connected: boolean;
  messages: string[];
  closeCode: number | null;
  error: string | null;
  durationMs: number;
}

export async function describeHttpApi(cloud: CloudProvider, apiId: string, signal?: AbortSignal): Promise<HttpApiOverview> {
  const res = await apiClient.call<HttpApiOverview>(apiEndpointKeys.clouds.httpApi.describe, requestOptions(cloud, "apigateway", { signal }), { cloud, id: apiId });
  return res.data;
}

export async function createHttpApiRoute(cloud: CloudProvider, apiId: string, input: HttpApiRouteInput): Promise<HttpApiRouteOverview> {
  const res = await apiClient.call<HttpApiRouteOverview, HttpApiRouteInput>(apiEndpointKeys.clouds.httpApi.createRoute, requestOptions(cloud, "apigateway", { body: input }), { cloud, id: apiId });
  return res.data;
}

export async function deleteHttpApiRoute(cloud: CloudProvider, apiId: string, routeId: string): Promise<void> {
  await apiClient.call<void>(apiEndpointKeys.clouds.httpApi.deleteRoute, requestOptions(cloud, "apigateway"), { cloud, id: apiId, routeId });
}

export async function setHttpApiRouteAuthorizer(cloud: CloudProvider, apiId: string, routeId: string, authorizerId: string | null): Promise<HttpApiRouteOverview> {
  const res = await apiClient.call<HttpApiRouteOverview, { authorizerId: string | null }>(apiEndpointKeys.clouds.httpApi.setRouteAuthorizer, requestOptions(cloud, "apigateway", { body: { authorizerId } }), { cloud, id: apiId, routeId });
  return res.data;
}

export async function createHttpApiStage(cloud: CloudProvider, apiId: string, input: { stageName: string; autoDeploy: boolean }): Promise<HttpApiStageOverview> {
  const res = await apiClient.call<HttpApiStageOverview, typeof input>(apiEndpointKeys.clouds.httpApi.createStage, requestOptions(cloud, "apigateway", { body: input }), { cloud, id: apiId });
  return res.data;
}

export async function deleteHttpApiStage(cloud: CloudProvider, apiId: string, stageName: string): Promise<void> {
  await apiClient.call<void>(apiEndpointKeys.clouds.httpApi.deleteStage, requestOptions(cloud, "apigateway"), { cloud, id: apiId, stageName });
}

export async function deployHttpApi(cloud: CloudProvider, apiId: string, stageName: string): Promise<HttpApiStageOverview> {
  const res = await apiClient.call<HttpApiStageOverview>(apiEndpointKeys.clouds.httpApi.deploy, requestOptions(cloud, "apigateway"), { cloud, id: apiId, stageName });
  return res.data;
}

export async function createHttpApiAuthorizer(cloud: CloudProvider, apiId: string, input: HttpApiAuthorizerInput): Promise<HttpApiAuthorizerOverview> {
  const res = await apiClient.call<HttpApiAuthorizerOverview, HttpApiAuthorizerInput>(apiEndpointKeys.clouds.httpApi.createAuthorizer, requestOptions(cloud, "apigateway", { body: input }), { cloud, id: apiId });
  return res.data;
}

export async function deleteHttpApiAuthorizer(cloud: CloudProvider, apiId: string, authorizerId: string): Promise<void> {
  await apiClient.call<void>(apiEndpointKeys.clouds.httpApi.deleteAuthorizer, requestOptions(cloud, "apigateway"), { cloud, id: apiId, authorizerId });
}

export async function updateHttpApiCors(cloud: CloudProvider, apiId: string, cors: HttpApiCors | null): Promise<HttpApiCors | null> {
  const res = await apiClient.call<{ cors: HttpApiCors | null }, { cors: HttpApiCors | null }>(apiEndpointKeys.clouds.httpApi.cors, requestOptions(cloud, "apigateway", { body: { cors } }), { cloud, id: apiId });
  return res.data.cors;
}

export async function testWebSocketApi(cloud: CloudProvider, apiId: string, input: { stage: string; message: string; query?: string }): Promise<HttpApiWebSocketTestResult> {
  const res = await apiClient.call<HttpApiWebSocketTestResult, typeof input>(apiEndpointKeys.clouds.httpApi.webSocketTest, requestOptions(cloud, "apigateway", { body: input }), { cloud, id: apiId });
  return res.data;
}

export async function getCertificatePem(
  cloud: CloudProvider,
  certificateId: string,
): Promise<CertificatePem> {
  const res = await apiClient.call<CertificatePem>(
    apiEndpointKeys.clouds.certificates.pem,
    requestOptions(cloud, "certificates"),
    { cloud, id: certificateId },
  );
  return res.data;
}

export async function exportCertificate(
  cloud: CloudProvider,
  certificateId: string,
  passphrase: string,
): Promise<ExportedCertificate> {
  const res = await apiClient.call<ExportedCertificate, { passphrase: string }>(
    apiEndpointKeys.clouds.certificates.export,
    requestOptions(cloud, "certificates", { body: { passphrase } }),
    { cloud, id: certificateId },
  );
  return res.data;
}

export async function revokeCertificate(
  cloud: CloudProvider,
  certificateId: string,
  reason: CertificateRevocationReason,
): Promise<CloudResource> {
  const res = await apiClient.call<CloudResource, { reason: CertificateRevocationReason }>(
    apiEndpointKeys.clouds.certificates.revoke,
    requestOptions(cloud, "certificates", { body: { reason } }),
    { cloud, id: certificateId },
  );
  return res.data;
}

export async function setDistributionEnabled(
  cloud: CloudProvider,
  distributionId: string,
  enabled: boolean,
): Promise<CloudResource> {
  const res = await apiClient.call<CloudResource, { enabled: boolean }>(
    apiEndpointKeys.clouds.cdn.enabled,
    requestOptions(cloud, "cdn", { body: { enabled } }),
    { cloud, id: distributionId },
  );
  return res.data;
}

export async function createDistributionInvalidation(
  cloud: CloudProvider,
  distributionId: string,
  paths: string[],
): Promise<DistributionInvalidation> {
  const res = await apiClient.call<DistributionInvalidation, { paths: string[] }>(
    apiEndpointKeys.clouds.cdn.invalidations,
    requestOptions(cloud, "cdn", { body: { paths } }),
    { cloud, id: distributionId },
  );
  return res.data;
}

export async function describeUserPoolClient(
  cloud: CloudProvider,
  poolId: string,
  clientId: string,
  signal?: AbortSignal,
): Promise<UserPoolClientSettings> {
  const res = await apiClient.call<UserPoolClientSettings>(
    apiEndpointKeys.clouds.userpools.client.get,
    requestOptions(cloud, "userpools", { signal }),
    { cloud, id: poolId, clientId },
  );
  return res.data;
}

export async function updateUserPoolClientOAuth(
  cloud: CloudProvider,
  poolId: string,
  clientId: string,
  input: UpdateUserPoolClientOAuthInput,
): Promise<UserPoolClientSettings> {
  const res = await apiClient.call<UserPoolClientSettings, UpdateUserPoolClientOAuthInput>(
    apiEndpointKeys.clouds.userpools.client.updateOAuth,
    requestOptions(cloud, "userpools", { body: input }),
    { cloud, id: poolId, clientId },
  );
  return res.data;
}

export async function putFlatItem(
  cloud: CloudProvider,
  service: CloudServiceType,
  resourceId: string,
  body: Record<string, unknown>,
): Promise<ChildItem> {
  const res = await apiClient.call<ChildItem, Record<string, unknown>>(
    apiEndpointKeys.clouds.flatItems.create,
    requestOptions(cloud, service, {body}),
    {cloud, service, id: resourceId},
  );
  return res.data;
}

export async function listSqlDatabases(
  cloud: CloudProvider,
  serverId: string,
  engine: SqlEngine,
  credentials: SqlCredentials,
  signal?: AbortSignal,
): Promise<SqlDatabase[]> {
  const res = await apiClient.call<SqlDatabase[], SqlCredentials & { engine: SqlEngine }>(
    apiEndpointKeys.clouds.database.sql.databases,
    requestOptions(cloud, "database", {
      signal,
      body: { ...credentials, engine },
      timeout: SQL_DATA_TIMEOUT_MS,
    }),
    { cloud, id: serverId },
  );
  return res.data;
}

export async function listSqlTables(
  cloud: CloudProvider,
  serverId: string,
  engine: SqlEngine,
  database: string,
  credentials: SqlCredentials,
  signal?: AbortSignal,
): Promise<SqlTable[]> {
  const res = await apiClient.call<
    SqlTable[],
    SqlCredentials & { database: string; engine: SqlEngine }
  >(
    apiEndpointKeys.clouds.database.sql.tables,
    requestOptions(cloud, "database", {
      signal,
      body: { ...credentials, database, engine },
      timeout: SQL_DATA_TIMEOUT_MS,
    }),
    { cloud, id: serverId },
  );
  return res.data;
}

export async function querySql(
  cloud: CloudProvider,
  serverId: string,
  engine: SqlEngine,
  database: string,
  credentials: SqlCredentials,
  query: string,
  signal?: AbortSignal,
): Promise<SqlQueryResult> {
  const res = await apiClient.call<
    SqlQueryResult,
    SqlCredentials & { database: string; engine: SqlEngine; query: string }
  >(
    apiEndpointKeys.clouds.database.sql.query,
    requestOptions(cloud, "database", {
      signal,
      body: { ...credentials, database, engine, query },
      timeout: SQL_DATA_TIMEOUT_MS,
    }),
    { cloud, id: serverId },
  );
  return res.data;
}

export async function queryLogs(
  cloud: CloudProvider,
  logGroupName: string,
  input: LogsInsightsQueryInput,
  signal?: AbortSignal,
): Promise<LogsInsightsQueryResult> {
  const res = await apiClient.call<LogsInsightsQueryResult, LogsInsightsQueryInput>(
    apiEndpointKeys.clouds.logs.query,
    requestOptions(cloud, "logs", { signal, body: input, timeout: LOGS_QUERY_TIMEOUT_MS }),
    { cloud, id: logGroupName },
  );
  return res.data;
}

export async function filterLogEvents(
  cloud: CloudProvider,
  logGroupName: string,
  input: LogsFilterInput,
  cursor?: string,
  signal?: AbortSignal,
): Promise<CollectionPage<ChildItem>> {
  const res = await apiClient.call<CollectionPage<ChildItem>, LogsFilterInput>(
    apiEndpointKeys.clouds.logs.filter,
    requestOptions(cloud, "logs", { signal, body: input, params: cursor ? { cursor } : undefined }),
    { cloud, id: logGroupName },
  );
  return res.data;
}

export async function sendSqsMessage(cloud: CloudProvider, queueId: string, input: SqsSendMessageInput): Promise<{messageId: string}> {
  const res = await apiClient.call<{messageId: string}, SqsSendMessageInput>(apiEndpointKeys.clouds.messaging.messages.send, requestOptions(cloud, 'messaging', {body: input}), {cloud, id: queueId})
  return res.data
}

export async function receiveSqsMessages(cloud: CloudProvider, queueId: string, maxNumberOfMessages: number): Promise<SqsMessage[]> {
  const res = await apiClient.call<SqsMessage[], {maxNumberOfMessages: number}>(apiEndpointKeys.clouds.messaging.messages.receive, requestOptions(cloud, 'messaging', {body: {maxNumberOfMessages}}), {cloud, id: queueId})
  return res.data
}

export async function deleteSqsMessage(cloud: CloudProvider, queueId: string, receiptHandle: string): Promise<void> {
  await apiClient.call(apiEndpointKeys.clouds.messaging.messages.delete, requestOptions(cloud, 'messaging', {body: {receiptHandle}}), {cloud, id: queueId})
}

export async function purgeSqsQueue(cloud: CloudProvider, queueId: string): Promise<void> {
  await apiClient.call(apiEndpointKeys.clouds.messaging.messages.purge, requestOptions(cloud, 'messaging'), {cloud, id: queueId})
}

export async function startSqsMoveTask(cloud: CloudProvider, queueId: string, destinationArn?: string): Promise<{taskHandle: string}> {
  const res = await apiClient.call<{taskHandle: string}, {destinationArn?: string}>(apiEndpointKeys.clouds.messaging.moveTasks, requestOptions(cloud, 'messaging', {body: {destinationArn}}), {cloud, id: queueId})
  return res.data
}

export async function listDatabaseSnapshots(
  cloud: CloudProvider,
  instanceIdentifier?: string,
  signal?: AbortSignal,
): Promise<DatabaseSnapshot[]> {
  const res = await apiClient.call<DatabaseSnapshot[]>(
    apiEndpointKeys.clouds.database.snapshots.list,
    requestOptions(cloud, "database", {
      signal,
      params: instanceIdentifier ? { instanceIdentifier } : undefined,
    }),
    { cloud },
  );
  return res.data;
}

export async function createDatabaseSnapshot(
  cloud: CloudProvider,
  input: CreateDatabaseSnapshotInput,
  signal?: AbortSignal,
): Promise<DatabaseSnapshot> {
  const res = await apiClient.call<DatabaseSnapshot, CreateDatabaseSnapshotInput>(
    apiEndpointKeys.clouds.database.snapshots.create,
    requestOptions(cloud, "database", { signal, body: input }),
    { cloud },
  );
  return res.data;
}

export async function listDatabaseOrderableClasses(
  cloud: CloudProvider,
  engine?: string,
  signal?: AbortSignal,
): Promise<string[]> {
  const res = await apiClient.call<string[]>(
    apiEndpointKeys.clouds.database.orderableClasses.list,
    requestOptions(cloud, "database", {
      signal,
      params: engine ? { engine } : undefined,
    }),
    { cloud },
  );
  return res.data;
}

export async function listKubernetesNodegroups(
  cloud: CloudProvider,
  clusterId: string,
  signal?: AbortSignal,
): Promise<KubernetesNodegroup[]> {
  const res = await apiClient.call<KubernetesNodegroup[]>(
    apiEndpointKeys.clouds.k8s.nodegroups.list,
    requestOptions(cloud, "k8s", {signal}),
    {cloud, id: clusterId},
  )
  return res.data
}

export async function createKubernetesNodegroup(
  cloud: CloudProvider,
  clusterId: string,
  input: CreateKubernetesNodegroupInput,
): Promise<KubernetesNodegroup> {
  const res = await apiClient.call<KubernetesNodegroup, CreateKubernetesNodegroupInput>(
    apiEndpointKeys.clouds.k8s.nodegroups.create,
    requestOptions(cloud, "k8s", {body: input}),
    {cloud, id: clusterId},
  )
  return res.data
}

export async function deleteKubernetesNodegroup(
  cloud: CloudProvider,
  clusterId: string,
  nodegroupId: string,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.k8s.nodegroups.delete,
    requestOptions(cloud, "k8s"),
    {cloud, id: clusterId, nodegroupId},
  )
}

export async function listKubernetesFargateProfiles(
  cloud: CloudProvider,
  clusterId: string,
  signal?: AbortSignal,
): Promise<KubernetesFargateProfile[]> {
  const res = await apiClient.call<KubernetesFargateProfile[]>(
    apiEndpointKeys.clouds.k8s.fargateProfiles.list,
    requestOptions(cloud, "k8s", {signal}),
    {cloud, id: clusterId},
  )
  return res.data
}

export async function createKubernetesFargateProfile(
  cloud: CloudProvider,
  clusterId: string,
  input: CreateKubernetesFargateProfileInput,
): Promise<KubernetesFargateProfile> {
  const res = await apiClient.call<KubernetesFargateProfile, CreateKubernetesFargateProfileInput>(
    apiEndpointKeys.clouds.k8s.fargateProfiles.create,
    requestOptions(cloud, "k8s", {body: input}),
    {cloud, id: clusterId},
  )
  return res.data
}

export async function deleteKubernetesFargateProfile(
  cloud: CloudProvider,
  clusterId: string,
  profileId: string,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.k8s.fargateProfiles.delete,
    requestOptions(cloud, "k8s"),
    {cloud, id: clusterId, profileId},
  )
}

export async function listAppConfigEnvironments(
  cloud: CloudProvider,
  applicationId: string,
  signal?: AbortSignal,
): Promise<AppConfigEnvironment[]> {
  const res = await apiClient.call<AppConfigEnvironment[]>(
    apiEndpointKeys.clouds.configuration.environments.list,
    requestOptions(cloud, "configuration", {signal}),
    {cloud, id: applicationId},
  );
  return res.data;
}

export async function createAppConfigEnvironment(
  cloud: CloudProvider,
  applicationId: string,
  values: Record<string, unknown>,
): Promise<AppConfigEnvironment> {
  const res = await apiClient.call<AppConfigEnvironment, Record<string, unknown>>(
    apiEndpointKeys.clouds.configuration.environments.create,
    requestOptions(cloud, "configuration", {body: values}),
    {cloud, id: applicationId},
  );
  return res.data;
}

export async function deleteAppConfigEnvironment(
  cloud: CloudProvider,
  applicationId: string,
  environmentId: string,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.configuration.environments.delete,
    requestOptions(cloud, "configuration"),
    {cloud, id: applicationId, environmentId},
  );
}

export async function listAppConfigConfigurationProfiles(
  cloud: CloudProvider,
  applicationId: string,
  signal?: AbortSignal,
): Promise<AppConfigConfigurationProfile[]> {
  const res = await apiClient.call<AppConfigConfigurationProfile[]>(
    apiEndpointKeys.clouds.configuration.configurationProfiles.list,
    requestOptions(cloud, "configuration", {signal}),
    {cloud, id: applicationId},
  );
  return res.data;
}

export async function createAppConfigConfigurationProfile(
  cloud: CloudProvider,
  applicationId: string,
  values: Record<string, unknown>,
): Promise<AppConfigConfigurationProfile> {
  const res = await apiClient.call<AppConfigConfigurationProfile, Record<string, unknown>>(
    apiEndpointKeys.clouds.configuration.configurationProfiles.create,
    requestOptions(cloud, "configuration", {body: values}),
    {cloud, id: applicationId},
  );
  return res.data;
}

export async function deleteAppConfigConfigurationProfile(
  cloud: CloudProvider,
  applicationId: string,
  profileId: string,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.configuration.configurationProfiles.delete,
    requestOptions(cloud, "configuration"),
    {cloud, id: applicationId, profileId},
  );
}

export async function listAppConfigHostedConfigurationVersions(
  cloud: CloudProvider,
  applicationId: string,
  profileId: string,
  signal?: AbortSignal,
): Promise<AppConfigHostedConfigurationVersion[]> {
  const res = await apiClient.call<AppConfigHostedConfigurationVersion[]>(
    apiEndpointKeys.clouds.configuration.configurationProfiles.hostedVersions.list,
    requestOptions(cloud, "configuration", {signal}),
    {cloud, id: applicationId, profileId},
  );
  return res.data;
}

export async function getAppConfigHostedConfigurationVersion(
  cloud: CloudProvider,
  applicationId: string,
  profileId: string,
  versionNumber: number,
  signal?: AbortSignal,
): Promise<AppConfigHostedConfigurationVersion> {
  const res = await apiClient.call<AppConfigHostedConfigurationVersion>(
    apiEndpointKeys.clouds.configuration.configurationProfiles.hostedVersions.get,
    requestOptions(cloud, "configuration", {signal}),
    {cloud, id: applicationId, profileId, versionNumber: String(versionNumber)},
  );
  return res.data;
}

export async function createAppConfigHostedConfigurationVersion(
  cloud: CloudProvider,
  applicationId: string,
  profileId: string,
  values: Record<string, unknown>,
): Promise<AppConfigHostedConfigurationVersion> {
  const res = await apiClient.call<AppConfigHostedConfigurationVersion, Record<string, unknown>>(
    apiEndpointKeys.clouds.configuration.configurationProfiles.hostedVersions.create,
    requestOptions(cloud, "configuration", {body: values}),
    {cloud, id: applicationId, profileId},
  );
  return res.data;
}

export async function deleteAppConfigHostedConfigurationVersion(
  cloud: CloudProvider,
  applicationId: string,
  profileId: string,
  versionNumber: number,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.configuration.configurationProfiles.hostedVersions.delete,
    requestOptions(cloud, "configuration"),
    {cloud, id: applicationId, profileId, versionNumber: String(versionNumber)},
  );
}

export async function listAppConfigDeploymentStrategies(
  cloud: CloudProvider,
  signal?: AbortSignal,
): Promise<AppConfigDeploymentStrategy[]> {
  const res = await apiClient.call<AppConfigDeploymentStrategy[]>(
    apiEndpointKeys.clouds.configuration.deploymentStrategies.list,
    requestOptions(cloud, "configuration", {signal}),
    {cloud},
  );
  return res.data;
}

export async function createAppConfigDeploymentStrategy(
  cloud: CloudProvider,
  values: Record<string, unknown>,
): Promise<AppConfigDeploymentStrategy> {
  const res = await apiClient.call<AppConfigDeploymentStrategy, Record<string, unknown>>(
    apiEndpointKeys.clouds.configuration.deploymentStrategies.create,
    requestOptions(cloud, "configuration", {body: values}),
    {cloud},
  );
  return res.data;
}

export async function deleteAppConfigDeploymentStrategy(
  cloud: CloudProvider,
  strategyId: string,
): Promise<void> {
  await apiClient.call<void>(
    apiEndpointKeys.clouds.configuration.deploymentStrategies.delete,
    requestOptions(cloud, "configuration"),
    {cloud, strategyId},
  );
}

export async function startAppConfigDeployment(
  cloud: CloudProvider,
  applicationId: string,
  environmentId: string,
  values: Record<string, unknown>,
): Promise<AppConfigDeployment> {
  const res = await apiClient.call<AppConfigDeployment, Record<string, unknown>>(
    apiEndpointKeys.clouds.configuration.environments.deployments.start,
    requestOptions(cloud, "configuration", {body: values}),
    {cloud, id: applicationId, environmentId},
  );
  return res.data;
}

export async function getAppConfigDeployment(
  cloud: CloudProvider,
  applicationId: string,
  environmentId: string,
  deploymentNumber: number,
  signal?: AbortSignal,
): Promise<AppConfigDeployment> {
  const res = await apiClient.call<AppConfigDeployment>(
    apiEndpointKeys.clouds.configuration.environments.deployments.get,
    requestOptions(cloud, "configuration", {signal}),
    {cloud, id: applicationId, environmentId, deploymentNumber: String(deploymentNumber)},
  );
  return res.data;
}

function requestOptions<TBody = unknown>(
  _cloud: CloudProvider,
  _service: string,
  options: {
    signal?: AbortSignal;
    params?: Record<string, string | number | boolean | undefined>;
    body?: TBody;
    rawBody?: BodyInit;
    headers?: HeadersInit;
    /** Overrides the client default; needed for calls that can legitimately run long. */
    timeout?: number;
  } = {},
) {
  return {
    ...options,
  };
}

function storagePathParams(
  cloud: CloudProvider,
  resourceId: string,
): CloudPathParams {
  return { cloud, id: resourceId };
}

function databasePathParams(
  cloud: CloudProvider,
  databaseId: string,
): CloudPathParams {
  return { cloud, id: databaseId };
}