@linode/api-v4/lib/index.js

JavaScript wrapper around the Linode APIv4

var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));

// src/account/account.ts
import {
  updateAccountSchema,
  UpdateAccountSettingsSchema
} from "@linode/validation/lib/account.schema";

// src/constants.ts
var API_ROOT = "https://api.linode.com/v4";
var BETA_API_ROOT = API_ROOT + "beta";

// src/request.ts
import Axios, { AxiosHeaders } from "axios";
var baseRequest = Axios.create({
  baseURL: "https://api.linode.com/v4"
});
baseRequest.interceptors.request.use((config) => {
  const isRunningInNode = typeof process === "object";
  if (!isRunningInNode) {
    return config;
  }
  const headers = new AxiosHeaders(config.headers);
  headers.set("User-Agent", "linodejs");
  return __spreadProps(__spreadValues({}, config), { headers });
});
var setToken = (token) => {
  return baseRequest.interceptors.request.use((config) => {
    const headers = new AxiosHeaders(config.headers);
    headers.set("Authorization", `Bearer ${token}`);
    return __spreadProps(__spreadValues({}, config), { headers });
  });
};
var set = (field, value) => (object) => {
  return !isEmpty(value) ? __spreadProps(__spreadValues({}, object), { [field]: value }) : object;
};
var isEmpty = (v) => v === void 0 || v === null || v.length === 0 || typeof v === "object" && Object.keys(v).length === 0 && v.constructor === Object;
var setURL = (url) => set("url", url);
var setMethod = (method) => set("method", method);
var setParams = (params) => set("params", params);
var setHeaders = (newHeaders = {}) => (object) => {
  return !isEmpty(newHeaders) ? __spreadProps(__spreadValues({}, object), { headers: __spreadValues(__spreadValues({}, object.headers), newHeaders) }) : object;
};
var setData = (data, schema, postValidationTransform) => {
  if (!schema) {
    return set("data", data);
  }
  const updatedData = typeof postValidationTransform === "function" ? postValidationTransform(data) : data;
  try {
    schema.validateSync(data, { abortEarly: false });
    return set("data", updatedData);
  } catch (error) {
    return (object) => __spreadProps(__spreadValues({}, object), {
      data: updatedData,
      validationErrors: convertYupToLinodeErrors(error)
    });
  }
};
var convertYupToLinodeErrors = (validationError) => {
  const { inner } = validationError;
  if (inner && inner.length > 0) {
    return inner.reduce((result, innerValidationError) => {
      const err = convertYupToLinodeErrors(innerValidationError);
      return Array.isArray(err) ? [...result, ...err] : [...result, err];
    }, []);
  }
  return [mapYupToLinodeAPIError(validationError)];
};
var mapYupToLinodeAPIError = ({
  message,
  path
}) => __spreadValues({
  reason: message
}, path && { field: path });
var setXFilter = (xFilter) => {
  return (object) => !isEmpty(xFilter) ? __spreadProps(__spreadValues({}, object), {
    headers: __spreadProps(__spreadValues({}, object.headers), { "X-Filter": JSON.stringify(xFilter) })
  }) : object;
};
var reduceRequestConfig = (...fns) => fns.reduceRight((result, fn) => fn(result), {
  url: "https://api.linode.com/v4",
  headers: {}
});
var requestGenerator = (...fns) => {
  const config = reduceRequestConfig(...fns);
  if (config.validationErrors) {
    return Promise.reject(
      config.validationErrors
      // All failed requests, client or server errors, should be APIError[]
    );
  }
  return baseRequest(config).then((response) => response.data);
};
var request_default = requestGenerator;

// src/account/account.ts
var getAccountInfo = () => {
  return request_default(setURL(`${BETA_API_ROOT}/account`), setMethod("GET"));
};
var getNetworkUtilization = () => request_default(
  setURL(`${API_ROOT}/account/transfer`),
  setMethod("GET")
);
var updateAccountInfo = (data) => request_default(
  setURL(`${BETA_API_ROOT}/account`),
  setMethod("PUT"),
  setData(data, updateAccountSchema)
);
var getAccountSettings = () => request_default(
  setURL(`${BETA_API_ROOT}/account/settings`),
  setMethod("GET")
);
var updateAccountSettings = (data) => request_default(
  setURL(`${BETA_API_ROOT}/account/settings`),
  setMethod("PUT"),
  setData(data, UpdateAccountSettingsSchema)
);
var cancelAccount = (data) => {
  return request_default(
    setURL(`${API_ROOT}/account/cancel`),
    setMethod("POST"),
    setData(data)
  );
};
var getAccountAgreements = () => request_default(
  setURL(`${BETA_API_ROOT}/account/agreements`),
  setMethod("GET")
);
var getAccountAvailabilities = (params, filter) => request_default(
  setURL(`${BETA_API_ROOT}/account/availability`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getAccountAvailability = (regionId) => request_default(
  setURL(
    `${BETA_API_ROOT}/account/availability/${encodeURIComponent(regionId)}`
  ),
  setMethod("GET")
);
var signAgreement = (data) => {
  return request_default(
    setURL(`${BETA_API_ROOT}/account/agreements`),
    setMethod("POST"),
    setData(data)
  );
};
var getChildAccounts = ({ filter, params, headers }) => request_default(
  setURL(`${API_ROOT}/account/child-accounts`),
  setMethod("GET"),
  setHeaders(headers),
  setParams(params),
  setXFilter(filter)
);
var getChildAccount = ({ euuid, headers }) => request_default(
  setURL(`${API_ROOT}/account/child-accounts/${encodeURIComponent(euuid)}`),
  setMethod("GET"),
  setHeaders(headers)
);
var createChildAccountPersonalAccessToken = ({
  euuid,
  headers
}) => request_default(
  setURL(
    `${API_ROOT}/account/child-accounts/${encodeURIComponent(euuid)}/token`
  ),
  setMethod("POST"),
  setHeaders(headers),
  setData(euuid)
);

// src/account/betas.ts
var getAccountBetas = (params, filter) => request_default(
  setURL(`${API_ROOT}/account/betas`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getAccountBeta = (betaId) => request_default(
  setURL(`${API_ROOT}/account/betas/${encodeURIComponent(betaId)}`),
  setMethod("GET")
);
var enrollInBeta = (data) => request_default(
  setURL(`${API_ROOT}/account/betas`),
  setMethod("POST"),
  setData(data)
);

// src/account/events.ts
var getEvents = (params = {}, filter = {}) => request_default(
  setURL(`${API_ROOT}/account/events`),
  setMethod("GET"),
  setXFilter(filter),
  setParams(params)
);
var getEvent = (eventId) => request_default(
  setURL(`${API_ROOT}/account/events/${encodeURIComponent(eventId)}`),
  setMethod("GET")
);
var markEventSeen = (eventId) => request_default(
  setURL(`${API_ROOT}/account/events/${encodeURIComponent(eventId)}/seen`),
  setMethod("POST")
);
var markEventRead = (eventId) => request_default(
  setURL(`${API_ROOT}/account/events/${encodeURIComponent(eventId)}/read`),
  setMethod("POST")
);
var getNotifications = (params, filter) => request_default(
  setURL(`${API_ROOT}/account/notifications`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);

// src/account/invoices.ts
var getInvoices = (params, filter) => request_default(
  setURL(`${API_ROOT}/account/invoices`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getInvoice = (invoiceId) => request_default(
  setURL(`${API_ROOT}/account/invoices/${encodeURIComponent(invoiceId)}`),
  setMethod("GET")
);
var getInvoiceItems = (invoiceId, params, filter) => request_default(
  setURL(
    `${API_ROOT}/account/invoices/${encodeURIComponent(invoiceId)}/items`
  ),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);

// src/account/logins.ts
var getAccountLogins = (params, filter) => request_default(
  setURL(`${API_ROOT}/account/logins`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getAccountLogin = (loginId) => request_default(
  setURL(`${API_ROOT}/account/logins/${encodeURIComponent(loginId)}`),
  setMethod("GET")
);

// src/account/maintenance.ts
var getAccountMaintenance = (params, filter) => request_default(
  setURL(`${BETA_API_ROOT}/account/maintenance`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getMaintenancePolicies = (params, filter) => request_default(
  setURL(`${BETA_API_ROOT}/maintenance/policies`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);

// src/account/oauth.ts
import {
  createOAuthClientSchema,
  updateOAuthClientSchema
} from "@linode/validation/lib/account.schema";
var getOAuthClients = (params, filter) => request_default(
  setURL(`${API_ROOT}/account/oauth-clients`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getOAuthClient = (clientId) => request_default(
  setURL(`${API_ROOT}/account/oauth-clients/${encodeURIComponent(clientId)}`),
  setMethod("GET")
);
var createOAuthClient = (data) => request_default(
  setURL(`${API_ROOT}/account/oauth-clients`),
  setMethod("POST"),
  setData(data, createOAuthClientSchema)
);
var resetOAuthClientSecret = (clientId) => request_default(
  setURL(
    `${API_ROOT}/account/oauth-clients/${encodeURIComponent(
      clientId
    )}/reset-secret`
  ),
  setMethod("POST")
);
var updateOAuthClient = (clientId, data) => request_default(
  setURL(`${API_ROOT}/account/oauth-clients/${encodeURIComponent(clientId)}`),
  setMethod("PUT"),
  setData(data, updateOAuthClientSchema)
);
var deleteOAuthClient = (clientId) => request_default(
  setURL(`${API_ROOT}/account/oauth-clients/${encodeURIComponent(clientId)}`),
  setMethod("DELETE")
);

// src/account/payments.ts
import {
  CreditCardSchema,
  PaymentMethodSchema,
  PaymentSchema
} from "@linode/validation/lib/account.schema";
var getPayments = (params, filter) => request_default(
  setURL(`${API_ROOT}/account/payments`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var makePayment = (data) => {
  if (!data.cvv) {
    delete data.cvv;
  }
  return request_default(
    setURL(`${API_ROOT}/account/payments`),
    setMethod("POST"),
    setData(data, PaymentSchema)
  );
};
var saveCreditCard = (data) => {
  return request_default(
    setURL(`${API_ROOT}/account/credit-card`),
    setMethod("POST"),
    setData(data, CreditCardSchema)
  );
};
var getPaymentMethods = (params) => {
  return request_default(
    setURL(`${API_ROOT}/account/payment-methods`),
    setMethod("GET"),
    setParams(params)
  );
};
var getPaymentMethod = (id) => {
  return request_default(
    setURL(`${API_ROOT}/account/payment-method/${encodeURIComponent(id)}`),
    setMethod("GET")
  );
};
var getClientToken = () => {
  return request_default(
    setURL(`${API_ROOT}/account/client-token`),
    setMethod("GET")
  );
};
var addPaymentMethod = (data) => {
  return request_default(
    setURL(`${API_ROOT}/account/payment-methods`),
    setMethod("POST"),
    setData(data, PaymentMethodSchema)
  );
};
var makeDefaultPaymentMethod = (id) => {
  return request_default(
    setURL(
      `${API_ROOT}/account/payment-methods/${encodeURIComponent(
        id
      )}/make-default`
    ),
    setMethod("POST")
  );
};
var deletePaymentMethod = (id) => {
  return request_default(
    setURL(`${API_ROOT}/account/payment-methods/${encodeURIComponent(id)}`),
    setMethod("DELETE")
  );
};

// src/account/promos.ts
import { PromoCodeSchema } from "@linode/validation/lib/account.schema";
var addPromotion = (code) => request_default(
  setURL(`${API_ROOT}/account/promo-codes`),
  setMethod("POST"),
  setData({ promo_code: code }, PromoCodeSchema)
);

// src/account/types.ts
var accountCapabilities = [
  "Akamai Cloud Load Balancer",
  "Akamai Cloud Pulse",
  "Akamai Cloud Pulse Logs",
  "Akamai Cloud Pulse Logs LKE-E Audit",
  "Block Storage",
  "Block Storage Encryption",
  "Cloud Firewall",
  "Cloud Firewall Rule Set",
  "CloudPulse",
  "Disk Encryption",
  "Kubernetes",
  "Kubernetes Enterprise",
  "Kubernetes Enterprise BYO VPC",
  "Kubernetes Enterprise Dual Stack",
  "Linodes",
  "Linode Interfaces",
  "LKE HA Control Planes",
  "LKE Network Access Control List (IP ACL)",
  "Machine Images",
  "Managed Databases",
  "Managed Databases Beta",
  "NETINT Quadra T1U",
  "Network LoadBalancer",
  "NodeBalancers",
  "Object Storage Access Key Regions",
  "Object Storage Endpoint Types",
  "Object Storage",
  "Placement Group",
  "SMTP Enabled",
  "Support Ticket Severity",
  "Vlans",
  "VPCs",
  "VPC Dual Stack",
  "VPC IPv6 Large Prefixes"
];
var linodeInterfaceAccountSettings = [
  "legacy_config_only",
  "legacy_config_default_but_linode_allowed",
  "linode_default_but_legacy_config_allowed",
  "linode_only"
];
var EventActionKeys = [
  "account_agreement_eu_model",
  "account_promo_apply",
  "account_settings_update",
  "account_update",
  "backups_cancel",
  "backups_enable",
  "backups_restore",
  "community_like",
  "community_mention",
  "community_question_reply",
  "credit_card_updated",
  "database_backup_create",
  "database_backup_delete",
  "database_backup_restore",
  "database_create",
  "database_credentials_reset",
  "database_degraded",
  "database_delete",
  "database_failed",
  "database_low_disk_space",
  "database_resize_create",
  "database_resize",
  "database_scale",
  "database_update_failed",
  "database_update",
  "database_migrate",
  "database_upgrade",
  "destination_create",
  "destination_delete",
  "destination_update",
  "disk_create",
  "disk_delete",
  "disk_duplicate",
  "disk_imagize",
  "disk_resize",
  "disk_update",
  "dns_record_create",
  "dns_record_delete",
  "dns_zone_create",
  "dns_zone_delete",
  "domain_create",
  "domain_delete",
  "domain_import",
  "domain_record_create",
  "domain_record_delete",
  "domain_record_update",
  "domain_record_updated",
  "domain_update",
  "entity_transfer_accept_recipient",
  "entity_transfer_accept",
  "entity_transfer_cancel",
  "entity_transfer_create",
  "entity_transfer_fail",
  "entity_transfer_stale",
  "firewall_apply",
  "firewall_create",
  "firewall_delete",
  "firewall_device_add",
  "firewall_device_remove",
  "firewall_disable",
  "firewall_enable",
  "firewall_rules_update",
  "firewall_update",
  "host_reboot",
  "image_delete",
  "image_update",
  "image_upload",
  "interface_create",
  "interface_delete",
  "interface_update",
  "ipaddress_update",
  "ipv6pool_add",
  "ipv6pool_delete",
  "lassie_reboot",
  "linode_addip",
  "linode_boot",
  "linode_clone",
  "linode_config_create",
  "linode_config_delete",
  "linode_config_update",
  "linode_create",
  "linode_delete",
  "linode_deleteip",
  "linode_migrate_datacenter_create",
  "linode_migrate_datacenter",
  "linode_migrate",
  "linode_mutate_create",
  "linode_mutate",
  "linode_poweroff_on",
  "linode_reboot",
  "linode_rebuild",
  "linode_resize_create",
  "linode_resize_warm_create",
  "linode_resize",
  "linode_shutdown",
  "linode_snapshot",
  "linode_update",
  "lish_boot",
  "lke_cluster_create",
  "lke_cluster_delete",
  "lke_cluster_recycle",
  "lke_cluster_regenerate",
  "lke_cluster_update",
  "lke_control_plane_acl_create",
  "lke_control_plane_acl_delete",
  "lke_control_plane_acl_update",
  "lke_kubeconfig_regenerate",
  "lke_node_create",
  "lke_node_recycle",
  "lke_pool_create",
  "lke_pool_delete",
  "lke_pool_recycle",
  "lke_token_rotate",
  "longviewclient_create",
  "longviewclient_delete",
  "longviewclient_update",
  "managed_enabled",
  "managed_service_create",
  "managed_service_delete",
  "nodebalancer_config_create",
  "nodebalancer_config_delete",
  "nodebalancer_config_update",
  "nodebalancer_create",
  "nodebalancer_delete",
  "nodebalancer_node_create",
  "nodebalancer_node_delete",
  "nodebalancer_node_update",
  "nodebalancer_update",
  "oauth_client_create",
  "oauth_client_delete",
  "oauth_client_secret_reset",
  "oauth_client_update",
  "obj_access_key_create",
  "obj_access_key_delete",
  "obj_access_key_update",
  "password_reset",
  "payment_method_add",
  "payment_submitted",
  "placement_group_assign",
  "placement_group_became_compliant",
  "placement_group_became_non_compliant",
  "placement_group_create",
  "placement_group_delete",
  "placement_group_unassign",
  "placement_group_update",
  "profile_update",
  "reserved_ip_assign",
  "reserved_ip_create",
  "reserved_ip_delete",
  "reserved_ip_unassign",
  "stackscript_create",
  "stackscript_delete",
  "stackscript_publicize",
  "stackscript_revise",
  "stackscript_update",
  "stream_create",
  "stream_delete",
  "stream_update",
  "subnet_create",
  "subnet_delete",
  "subnet_update",
  "tag_create",
  "tag_delete",
  "tax_id_invalid",
  "tax_id_valid",
  "tfa_disabled",
  "tfa_enabled",
  "ticket_attachment_upload",
  "ticket_create",
  "ticket_update",
  "token_create",
  "token_delete",
  "token_update",
  "user_create",
  "user_delete",
  "user_ssh_key_add",
  "user_ssh_key_delete",
  "user_ssh_key_update",
  "user_update",
  "volume_attach",
  "volume_clone",
  "volume_create",
  "volume_delete",
  "volume_detach",
  "volume_migrate_scheduled",
  "volume_migrate",
  "volume_resize",
  "volume_update",
  "vpc_create",
  "vpc_delete",
  "vpc_update"
];

// src/account/users.ts
import {
  CreateUserSchema,
  UpdateUserSchema
} from "@linode/validation/lib/account.schema";
var getUsers = (params, filters) => request_default(
  setURL(`${API_ROOT}/account/users`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filters)
);
var getUser = (username) => request_default(
  setURL(`${API_ROOT}/account/users/${encodeURIComponent(username)}`),
  setMethod("GET")
);
var createUser = (data) => request_default(
  setURL(`${API_ROOT}/account/users`),
  setMethod("POST"),
  setData(data, CreateUserSchema)
);
var updateUser = (username, data) => request_default(
  setURL(`${API_ROOT}/account/users/${encodeURIComponent(username)}`),
  setMethod("PUT"),
  setData(data, UpdateUserSchema)
);
var deleteUser = (username) => request_default(
  setURL(`${API_ROOT}/account/users/${encodeURIComponent(username)}`),
  setMethod("DELETE")
);
var getGrants = (username) => request_default(
  setURL(`${API_ROOT}/account/users/${encodeURIComponent(username)}/grants`),
  setMethod("GET")
);
var updateGrants = (username, data) => request_default(
  setURL(`${API_ROOT}/account/users/${encodeURIComponent(username)}/grants`),
  setMethod("PUT"),
  setData(data)
);

// src/betas/betas.ts
var getBetas = (params, filter) => request_default(
  setURL(`${API_ROOT}/betas`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getBeta = (betaId) => request_default(
  setURL(`${API_ROOT}/betas/${encodeURIComponent(betaId)}`),
  setMethod("GET")
);

// src/cloudnat/cloudnats.ts
import { createCloudNATSchema } from "@linode/validation";
var getCloudNATs = (params, filter) => request_default(
  setURL(`${API_ROOT}/networking/cloudnats`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getCloudNAT = (id) => request_default(
  setURL(`${API_ROOT}/networking/cloudnats/${id}`),
  setMethod("GET")
);
var createCloudNAT = (data) => request_default(
  setURL(`${API_ROOT}/networking/cloudnats`),
  setMethod("POST"),
  setData(data, createCloudNATSchema)
);
var updateCloudNAT = (id, data) => request_default(
  setURL(`${API_ROOT}/networking/cloudnats/${id}`),
  setMethod("PUT"),
  setData(data, createCloudNATSchema)
);
var deleteCloudNAT = (id) => request_default(
  setURL(`${API_ROOT}/networking/cloudnats/${id}`),
  setMethod("DELETE")
);

// src/cloudnat/types.ts
var VALID_PORT_SIZES = [
  64,
  128,
  256,
  512,
  1024,
  2048,
  4096,
  8192,
  16384
];

// src/cloudpulse/alerts.ts
import {
  createAlertDefinitionSchema,
  editAlertDefinitionSchema
} from "@linode/validation";
var createAlertDefinition = (data, serviceType) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(
      serviceType
    )}/alert-definitions`
  ),
  setMethod("POST"),
  setData(data, createAlertDefinitionSchema)
);
var getAlertDefinitions = (params, filters) => request_default(
  setURL(`${BETA_API_ROOT}/monitor/alert-definitions`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filters)
);
var getAlertDefinitionByServiceTypeAndId = (serviceType, alertId) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(
      serviceType
    )}/alert-definitions/${encodeURIComponent(alertId)}`
  ),
  setMethod("GET")
);
var editAlertDefinition = (data, serviceType, alertId) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(
      serviceType
    )}/alert-definitions/${encodeURIComponent(alertId)}`
  ),
  setMethod("PUT"),
  setData(data, editAlertDefinitionSchema)
);
var getNotificationChannels = (params, filters) => request_default(
  setURL(`${BETA_API_ROOT}/monitor/alert-channels`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filters)
);
var getAlertDefinitionByServiceType = (serviceType) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(
      serviceType
    )}/alert-definitions`
  ),
  setMethod("GET")
);
var addEntityToAlert = (serviceType, entityId, data) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/service/${encodeURIComponent(
      serviceType
    )}/entity/${encodeURIComponent(entityId)}/alert-definition`
  ),
  setMethod("POST"),
  setData(data)
);
var deleteEntityFromAlert = (serviceType, entityId, alertId) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/service/${encodeURIComponent(
      serviceType
    )}/entity/${encodeURIComponent(
      entityId
    )}/alert-definition/${encodeURIComponent(alertId)}`
  ),
  setMethod("DELETE")
);
var deleteAlertDefinition = (serviceType, alertId) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(serviceType)}/alert-definitions/${encodeURIComponent(alertId)}`
  ),
  setMethod("DELETE")
);
var updateServiceAlerts = (serviceType, entityId, payload) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(serviceType)}/alert-definitions/${encodeURIComponent(entityId)}`
  ),
  setMethod("PUT"),
  setData(payload)
);

// src/cloudpulse/dashboards.ts
var getDashboards = (serviceType) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(
      serviceType
    )}/dashboards`
  ),
  setMethod("GET")
);
var getDashboardById = (dashboardId) => request_default(
  setURL(`${BETA_API_ROOT}/monitor/dashboards/${encodeURIComponent(dashboardId)}`),
  setMethod("GET")
);

// src/cloudpulse/services.ts
var getMetricDefinitionsByServiceType = (serviceType, params, filters) => {
  return request_default(
    setURL(
      `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(
        serviceType
      )}/metric-definitions`
    ),
    setMethod("GET"),
    setParams(params),
    setXFilter(filters)
  );
};
var getJWEToken = (data, serviceType) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(serviceType)}/token`
  ),
  setMethod("POST"),
  setData(data)
);
var getCloudPulseServiceTypes = () => request_default(
  setURL(`${BETA_API_ROOT}/monitor/services`),
  setMethod("GET")
);
var getCloudPulseServiceByServiceType = (serviceType) => request_default(
  setURL(`${BETA_API_ROOT}/monitor/services/${encodeURIComponent(serviceType)}`),
  setMethod("GET")
);

// src/cloudpulse/types.ts
var capabilityServiceTypeMapping = {
  linode: "Linodes",
  dbaas: "Managed Databases",
  nodebalancer: "NodeBalancers",
  firewall: "Cloud Firewall",
  objectstorage: "Object Storage",
  blockstorage: "Block Storage",
  lke: "Kubernetes"
};

// src/databases/databases.ts
import {
  createDatabaseConnectionPoolSchema,
  createDatabaseSchema,
  updateDatabaseConnectionPoolSchema,
  updateDatabaseSchema
} from "@linode/validation/lib/databases.schema";
var getDatabases = (params, filter) => request_default(
  setURL(`${BETA_API_ROOT}/databases/instances`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getDatabaseTypes = (params, filter) => request_default(
  setURL(`${BETA_API_ROOT}/databases/types`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getDatabaseType = (typeSlug) => request_default(
  setURL(`${BETA_API_ROOT}/databases/types/${encodeURIComponent(typeSlug)}`),
  setMethod("GET")
);
var getDatabaseEngines = (params, filter) => request_default(
  setURL(`${BETA_API_ROOT}/databases/engines`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getDatabaseEngine = (engineSlug) => request_default(
  setURL(`${BETA_API_ROOT}/databases/engines/${encodeURIComponent(engineSlug)}`),
  setMethod("GET")
);
var createDatabase = (engine = "mysql", data) => request_default(
  setURL(`${BETA_API_ROOT}/databases/${encodeURIComponent(engine)}/instances`),
  setMethod("POST"),
  setData(data, createDatabaseSchema)
);
var getEngineDatabases = (engine, params, filter) => request_default(
  setURL(`${BETA_API_ROOT}/databases/${encodeURIComponent(engine)}/instances`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getEngineDatabase = (engine, databaseID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}`
  ),
  setMethod("GET")
);
var updateDatabase = (engine, databaseID, data) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}`
  ),
  setMethod("PUT"),
  setData(data, updateDatabaseSchema)
);
var patchDatabase = (engine, databaseID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}/patch`
  ),
  setMethod("POST")
);
var deleteDatabase = (engine, databaseID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}`
  ),
  setMethod("DELETE")
);
var getDatabaseBackups = (engine, databaseID, params, filter) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}/backups`
  ),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getDatabaseBackup = (engine, databaseID, backupID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(
      databaseID
    )}/backups/${encodeURIComponent(backupID)}`
  ),
  setMethod("GET")
);
var legacyRestoreWithBackup = (engine, databaseID, backupID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(
      databaseID
    )}/backups/${encodeURIComponent(backupID)}/restore`
  ),
  setMethod("POST")
);
var restoreWithBackup = (engine, data) => request_default(
  setURL(`${BETA_API_ROOT}/databases/${encodeURIComponent(engine)}/instances`),
  setMethod("POST"),
  setData(data)
);
var getDatabaseCredentials = (engine, databaseID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}/credentials`
  ),
  setMethod("GET")
);
var resetDatabaseCredentials = (engine, databaseID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}/credentials/reset`
  ),
  setMethod("POST")
);
var getSSLFields = (engine, databaseID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}/ssl`
  ),
  setMethod("GET")
);
var suspendDatabase = (engine, databaseID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}/suspend`
  ),
  setMethod("POST")
);
var resumeDatabase = (engine, databaseID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/${encodeURIComponent(
      engine
    )}/instances/${encodeURIComponent(databaseID)}/resume`
  ),
  setMethod("POST")
);
var getDatabaseEngineConfig = (engine) => request_default(
  setURL(`${BETA_API_ROOT}/databases/${encodeURIComponent(engine)}/config`),
  setMethod("GET")
);
var getDatabaseConnectionPools = (databaseID) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/postgresql/instances/${encodeURIComponent(databaseID)}/connection-pools`
  ),
  setMethod("GET")
);
var getDatabaseConnectionPool = (databaseID, poolName) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/postgresql/instances/${encodeURIComponent(databaseID)}/connection-pools/${encodeURIComponent(poolName)}`
  ),
  setMethod("GET")
);
var createDatabaseConnectionPool = (databaseID, data) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/postgresql/instances/${encodeURIComponent(databaseID)}/connection-pools`
  ),
  setMethod("POST"),
  setData(data, createDatabaseConnectionPoolSchema)
);
var updateDatabaseConnectionPool = (databaseID, poolName, data) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/postgresql/instances/${encodeURIComponent(databaseID)}/connection-pools/${encodeURIComponent(poolName)}`
  ),
  setMethod("PUT"),
  setData(data, updateDatabaseConnectionPoolSchema)
);
var deleteDatabaseConnectionPool = (databaseID, poolName) => request_default(
  setURL(
    `${BETA_API_ROOT}/databases/postgresql/instances/${encodeURIComponent(databaseID)}/connection-pools/${encodeURIComponent(poolName)}`
  ),
  setMethod("DELETE")
);

// src/delivery/destinations.ts
import {
  createDestinationSchema,
  updateDestinationSchema
} from "@linode/validation";
var getDestination = (destinationId) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/streams/destinations/${encodeURIComponent(destinationId)}`
  ),
  setMethod("GET")
);
var getDestinations = (params, filter) => request_default(
  setURL(`${BETA_API_ROOT}/monitor/streams/destinations`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var createDestination = (data) => request_default(
  setData(data, createDestinationSchema),
  setURL(`${BETA_API_ROOT}/monitor/streams/destinations`),
  setMethod("POST")
);
var updateDestination = (destinationId, data) => request_default(
  setData(data, updateDestinationSchema),
  setURL(
    `${BETA_API_ROOT}/monitor/streams/destinations/${encodeURIComponent(destinationId)}`
  ),
  setMethod("PUT")
);
var deleteDestination = (destinationId) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/streams/destinations/${encodeURIComponent(destinationId)}`
  ),
  setMethod("DELETE")
);
var verifyDestination = (data) => request_default(
  setData(data, createDestinationSchema),
  setURL(`${BETA_API_ROOT}/monitor/streams/destinations/verify`),
  setMethod("POST")
);

// src/delivery/streams.ts
import { createStreamSchema, updateStreamSchema } from "@linode/validation";
var getStream = (streamId) => request_default(
  setURL(`${BETA_API_ROOT}/monitor/streams/${encodeURIComponent(streamId)}`),
  setMethod("GET")
);
var getStreams = (params, filter) => request_default(
  setURL(`${BETA_API_ROOT}/monitor/streams`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var createStream = (data) => request_default(
  setData(data, createStreamSchema),
  setURL(`${BETA_API_ROOT}/monitor/streams`),
  setMethod("POST")
);
var updateStream = (streamId, data) => request_default(
  setData(data, updateStreamSchema),
  setURL(`${BETA_API_ROOT}/monitor/streams/${encodeURIComponent(streamId)}`),
  setMethod("PUT")
);
var deleteStream = (streamId) => request_default(
  setURL(`${BETA_API_ROOT}/monitor/streams/${encodeURIComponent(streamId)}`),
  setMethod("DELETE")
);

// src/delivery/types.ts
var streamStatus = {
  Active: "active",
  Inactive: "inactive"
};
var streamType = {
  AuditLogs: "audit_logs",
  LKEAuditLogs: "lke_audit_logs"
};
var destinationType = {
  CustomHttps: "custom_https",
  AkamaiObjectStorage: "akamai_object_storage"
};

// src/domains/domains.ts
import {
  createDomainSchema,
  importZoneSchema,
  updateDomainSchema
} from "@linode/validation/lib/domains.schema";
var getDomains = (params, filter) => request_default(
  setURL(`${API_ROOT}/domains`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getDomain = (domainId) => request_default(
  setURL(`${API_ROOT}/domains/${encodeURIComponent(domainId)}`),
  setMethod("GET")
);
var createDomain = (data) => request_default(
  setData(data, createDomainSchema),
  setURL(`${API_ROOT}/domains`),
  setMethod("POST")
);
var updateDomain = (domainId, data) => request_default(
  setURL(`${API_ROOT}/domains/${encodeURIComponent(domainId)}`),
  setMethod("PUT"),
  setData(data, updateDomainSchema)
);
var deleteDomain = (domainId) => request_default(
  setURL(`${API_ROOT}/domains/${encodeURIComponent(domainId)}`),
  setMethod("DELETE")
);
var cloneDomain = (domainId, data) => request_default(
  setData(data),
  setURL(`${API_ROOT}/domains/${encodeURIComponent(domainId)}/clone`),
  setMethod("POST")
);
var importZone = (data) => request_default(
  setData(data, importZoneSchema),
  setURL(`${API_ROOT}/domains/import`),
  setMethod("POST")
);
var getDNSZoneFile = (domainId) => request_default(
  setURL(`${API_ROOT}/domains/${encodeURIComponent(domainId)}/zone-file`),
  setMethod("GET")
);

// src/domains/records.ts
import {
  createRecordSchema,
  updateRecordSchema
} from "@linode/validation/lib/records.schema";
var getDomainRecords = (domainId, params) => request_default(
  setURL(`${API_ROOT}/domains/${encodeURIComponent(domainId)}/records`),
  setParams(params),
  setMethod("GET")
);
var getDomainRecord = (domainId, recordId) => request_default(
  setURL(
    `${API_ROOT}/domains/${encodeURIComponent(
      domainId
    )}/records/${encodeURIComponent(recordId)}`
  ),
  setMethod("GET")
);
var createDomainRecord = (domainId, data) => request_default(
  setURL(`${API_ROOT}/domains/${encodeURIComponent(domainId)}/records`),
  setMethod("POST"),
  setData(data, createRecordSchema)
);
var updateDomainRecord = (domainId, recordId, data) => request_default(
  setURL(
    `${API_ROOT}/domains/${encodeURIComponent(
      domainId
    )}/records/${encodeURIComponent(recordId)}`
  ),
  setMethod("PUT"),
  setData(data, updateRecordSchema)
);
var deleteDomainRecord = (domainId, recordId) => request_default(
  setURL(
    `${API_ROOT}/domains/${encodeURIComponent(
      domainId
    )}/records/${encodeURIComponent(recordId)}`
  ),
  setMethod("DELETE")
);

// src/entities/entities.ts
var getAccountEntities = (params) => {
  return request_default(
    setURL(`${BETA_API_ROOT}/entities`),
    setMethod("GET"),
    setParams(params)
  );
};

// src/firewalls/firewalls.ts
import {
  CreateFirewallSchema,
  FirewallDeviceSchema,
  UpdateFirewallSchema,
  UpdateFirewallSettingsSchema
} from "@linode/validation/lib/firewalls.schema";
var getFirewalls = (params, filter) => request_default(
  setMethod("GET"),
  setParams(params),
  setXFilter(filter),
  setURL(`${BETA_API_ROOT}/networking/firewalls`)
);
var getFirewall = (firewallID) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/${encodeURIComponent(firewallID)}`
  )
);
var createFirewall = (data) => request_default(
  setMethod("POST"),
  setData(data, CreateFirewallSchema),
  setURL(`${BETA_API_ROOT}/networking/firewalls`)
);
var updateFirewall = (firewallID, data) => request_default(
  setMethod("PUT"),
  setData(data, UpdateFirewallSchema),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/${encodeURIComponent(firewallID)}`
  )
);
var enableFirewall = (firewallID) => updateFirewall(firewallID, { status: "enabled" });
var disableFirewall = (firewallID) => updateFirewall(firewallID, { status: "disabled" });
var deleteFirewall = (firewallID) => request_default(
  setMethod("DELETE"),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/${encodeURIComponent(firewallID)}`
  )
);
var getFirewallRules = (firewallID, params, filter) => request_default(
  setMethod("GET"),
  setParams(params),
  setXFilter(filter),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/${encodeURIComponent(
      firewallID
    )}/rules`
  )
);
var updateFirewallRules = (firewallID, data) => request_default(
  setMethod("PUT"),
  setData(data),
  // Validation is too complicated for these; leave it to the API.
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/${encodeURIComponent(
      firewallID
    )}/rules`
  )
);
var getFirewallDevices = (firewallID, params, filter) => request_default(
  setMethod("GET"),
  setParams(params),
  setXFilter(filter),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/${encodeURIComponent(
      firewallID
    )}/devices`
  )
);
var getFirewallDevice = (firewallID, deviceID) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/${encodeURIComponent(
      firewallID
    )}/devices/${encodeURIComponent(deviceID)}`
  )
);
var addFirewallDevice = (firewallID, data) => request_default(
  setMethod("POST"),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/${encodeURIComponent(
      firewallID
    )}/devices`
  ),
  setData(data, FirewallDeviceSchema)
);
var deleteFirewallDevice = (firewallID, deviceID) => request_default(
  setMethod("DELETE"),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/${encodeURIComponent(
      firewallID
    )}/devices/${encodeURIComponent(deviceID)}`
  )
);
var getFirewallSettings = () => request_default(
  setMethod("GET"),
  setURL(`${BETA_API_ROOT}/networking/firewalls/settings`)
);
var updateFirewallSettings = (data) => request_default(
  setMethod("PUT"),
  setURL(`${BETA_API_ROOT}/networking/firewalls/settings`),
  setData(data, UpdateFirewallSettingsSchema)
);
var getTemplates = () => request_default(
  setMethod("GET"),
  setURL(`${BETA_API_ROOT}/networking/firewalls/templates`)
);
var getTemplate = (templateSlug) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/templates/${encodeURIComponent(
      templateSlug
    )}`
  )
);
var getFirewallRuleSets = (params, filter) => request_default(
  setMethod("GET"),
  setParams(params),
  setXFilter(filter),
  setURL(`${BETA_API_ROOT}/networking/firewalls/rulesets`)
);
var getFirewallRuleSet = (ruleSetID) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/networking/firewalls/rulesets/${encodeURIComponent(ruleSetID)}`
  )
);
var getFirewallPrefixLists = (params, filter) => request_default(
  setMethod("GET"),
  setParams(params),
  setXFilter(filter),
  setURL(`${BETA_API_ROOT}/networking/prefixlists`)
);
var getFirewallPrefixList = (prefixListID) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/networking/prefixlists/${encodeURIComponent(prefixListID)}`
  )
);

// src/iam/delegation.ts
var getChildAccountsIam = ({
  params,
  users
}) => users ? request_default(
  setURL(`${BETA_API_ROOT}/iam/delegation/child-accounts?users=true`),
  setMethod("GET"),
  setParams(__spreadValues({}, params))
) : request_default(
  setURL(`${BETA_API_ROOT}/iam/delegation/child-accounts`),
  setMethod("GET"),
  setParams(__spreadValues({}, params))
);
var getDelegatedChildAccountsForUser = ({
  username,
  params
}) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/delegation/users/${encodeURIComponent(username)}/child-accounts`
  ),
  setMethod("GET"),
  setParams(params)
);
var getChildAccountDelegates = ({
  euuid,
  params
}) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/delegation/child-accounts/${encodeURIComponent(euuid)}/users`
  ),
  setMethod("GET"),
  setParams(params)
);
var updateChildAccountDelegates = ({
  euuid,
  users
}) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/delegation/child-accounts/${encodeURIComponent(euuid)}/users`
  ),
  setMethod("PUT"),
  setData(users)
);
var getMyDelegatedChildAccounts = ({
  params
}) => request_default(
  setURL(`${BETA_API_ROOT}/iam/delegation/profile/child-accounts`),
  setMethod("GET"),
  setParams(params)
);
var getDelegatedChildAccount = ({ euuid }) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/delegation/profile/child-accounts/${encodeURIComponent(euuid)}`
  ),
  setMethod("GET")
);
var generateChildAccountToken = ({ euuid }) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/delegation/profile/child-accounts/${encodeURIComponent(euuid)}/token`
  ),
  setMethod("POST"),
  setData(euuid)
);
var getDefaultDelegationAccess = () => request_default(
  setURL(`${BETA_API_ROOT}/iam/delegation/default-role-permissions`),
  setMethod("GET")
);
var updateDefaultDelegationAccess = (data) => request_default(
  setURL(`${BETA_API_ROOT}/iam/delegation/default-role-permissions`),
  setMethod("PUT"),
  setData(data)
);

// src/iam/iam.ts
var getUserRoles = (username) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/users/${encodeURIComponent(
      username
    )}/role-permissions`
  ),
  setMethod("GET")
);
var updateUserRoles = (username, data) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/users/${encodeURIComponent(
      username
    )}/role-permissions`
  ),
  setMethod("PUT"),
  setData(data)
);
var getAccountRoles = () => {
  return request_default(
    setURL(`${BETA_API_ROOT}/iam/role-permissions`),
    setMethod("GET")
  );
};
var getUserAccountPermissions = (username) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/users/${encodeURIComponent(
      username
    )}/permissions/account`
  ),
  setMethod("GET")
);
var getUserEntityPermissions = (username, entityType, entityId, params, filter) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/users/${encodeURIComponent(
      username
    )}/permissions/${entityType}/${entityId}`
  ),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);
var getUserEntitiesByPermission = ({
  username,
  entityType,
  permission,
  params,
  filter
}) => request_default(
  setURL(
    `${BETA_API_ROOT}/iam/users/${username}/entities/${entityType}?permission=${permission}`
  ),
  setMethod("GET"),
  setParams(params),
  setXFilter(filter)
);

// src/images/images.ts
import {
  createImageSchema,
  updateImageRegionsSchema,
  updateImageSchema,
  uploadImageSchema
} from "@linode/validation/lib/images.schema";
var getImage = (imageId) => request_default(
  setURL(`${API_ROOT}/images/${encodeURIComponent(imageId)}`),
  setMethod("GET")
);
var getImages = (params = {}, filters = {}) => request_default(
  setURL(`${API_ROOT}/images`),
  setMethod("GET"),
  setParams(params),
  setXFilter(filters)
);
var createImage = (data) => {
  return request_default(
    setURL(`${API_ROOT}/images`),
    setMethod("POST"),
    setData(data, createImageSchema)
  );
};
var updateImage = (imageId, data) => {
  return request_default(
    setURL(`${API_ROOT}/images/${encodeURIComponent(imageId)}`),
    setMethod("PUT"),
    setData(data, updateImageSchema)
  );
};
var deleteImage = (imageId) => {
  return request_default(
    setURL(`${API_ROOT}/images/${encodeURIComponent(imageId)}`),
    setMethod("DELETE")
  );
};
var uploadImage = (data) => {
  return request_default(
    setURL(`${API_ROOT}/images/upload`),
    setMethod("POST"),
    setData(data, uploadImageSchema)
  );
};
var updateImageRegions = (imageId, data) => {
  return request_default(
    setURL(`${API_ROOT}/images/${encodeURIComponent(imageId)}/regions`),
    setMethod("POST"),
    setData(data, updateImageRegionsSchema)
  );
};

// src/kubernetes/kubernetes.ts
import { createKubeClusterSchema } from "@linode/validation/lib/kubernetes.schema";
var getKubernetesClusters = (params, filters) => request_default(
  setMethod("GET"),
  setParams(params),
  setXFilter(filters),
  setURL(`${BETA_API_ROOT}/lke/clusters`)
);
var getKubernetesCluster = (clusterID) => request_default(
  setMethod("GET"),
  setURL(`${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterID)}`)
);
var createKubernetesCluster = (data) => {
  return request_default(
    setMethod("POST"),
    setURL(`${BETA_API_ROOT}/lke/clusters`),
    setData(data, createKubeClusterSchema)
  );
};
var updateKubernetesCluster = (clusterID, data) => request_default(
  setMethod("PUT"),
  setURL(`${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterID)}`),
  setData(data)
);
var deleteKubernetesCluster = (clusterID) => request_default(
  setMethod("DELETE"),
  setURL(`${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterID)}`)
);
var getKubeConfig = (clusterId) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterId)}/kubeconfig`
  )
);
var resetKubeConfig = (clusterId) => request_default(
  setMethod("DELETE"),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterId)}/kubeconfig`
  )
);
var getKubernetesVersions = (params, filters) => request_default(
  setMethod("GET"),
  setXFilter(filters),
  setParams(params),
  setURL(`${BETA_API_ROOT}/lke/versions`)
);
var getKubernetesTieredVersions = (tier, params, filters) => request_default(
  setMethod("GET"),
  setXFilter(filters),
  setParams(params),
  setURL(`${BETA_API_ROOT}/lke/tiers/${encodeURIComponent(tier)}/versions`)
);
var getKubernetesVersion = (versionID) => request_default(
  setMethod("GET"),
  setURL(`${BETA_API_ROOT}/lke/versions/${encodeURIComponent(versionID)}`)
);
var getKubernetesTieredVersion = (tier, versionID) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/lke/tiers/${encodeURIComponent(
      tier
    )}/versions/${encodeURIComponent(versionID)}`
  )
);
var getKubernetesClusterEndpoints = (clusterID, params, filters) => request_default(
  setMethod("GET"),
  setXFilter(filters),
  setParams(params),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterID)}/api-endpoints`
  )
);
var getKubernetesClusterDashboard = (clusterID) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterID)}/dashboard`
  )
);
var recycleClusterNodes = (clusterID) => request_default(
  setMethod("POST"),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterID)}/recycle`
  )
);
var getKubernetesTypes = (params) => request_default(
  setURL(`${BETA_API_ROOT}/lke/types`),
  setMethod("GET"),
  setParams(params)
);
var getKubernetesClusterControlPlaneACL = (clusterId) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(
      clusterId
    )}/control_plane_acl`
  )
);
var updateKubernetesClusterControlPlaneACL = (clusterID, data) => request_default(
  setMethod("PUT"),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(
      clusterID
    )}/control_plane_acl`
  ),
  setData(data)
);

// src/kubernetes/nodePools.ts
import { CreateNodePoolSchema, EditNodePoolSchema } from "@linode/validation";
var getNodePools = (clusterID, params, filters) => request_default(
  setMethod("GET"),
  setParams(params),
  setXFilter(filters),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterID)}/pools`
  )
);
var getNodePool = (clusterID, nodePoolID) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(
      clusterID
    )}/pools/${encodeURIComponent(nodePoolID)}`
  )
);
var createNodePool = (clusterID, data) => request_default(
  setMethod("POST"),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(clusterID)}/pools`
  ),
  setData(data, CreateNodePoolSchema)
);
var updateNodePool = (clusterID, nodePoolID, data) => request_default(
  setMethod("PUT"),
  setURL(
    `${BETA_API_ROOT}/lke/clusters/${encodeURIComponent(
      clusterID
    )}/pools/${encodeURIComponent(nodePoolID)}`
  ),
  setData(data, EditNodePoolSchema)
);
var deleteNodePool = (clusterID, nodePoolID) => request_default(
  setMethod("DELETE"),
  setURL(
    `${API_ROOT}/lke/clusters/${encodeURIComponent(
      clusterID
    )}/pools/${encodeURIComponent(nodePoolID)}`
  )
);
var recycleAllNodes = (clusterID, nodePoolID) => request_default(
  setMethod("POST"),
  setURL(
    `${API_ROOT}/lke/clusters/${encodeURIComponent(
      clusterID
    )}/pools/${encodeURIComponent(nodePoolID)}/recycle`
  )
);
var recycleNode = (clusterID, nodeID) => request_default(
  setMethod("POST"),
  setURL(
    `${API_ROOT}/lke/clusters/${encodeURIComponent(
      clusterID
    )}/nodes/${encodeURIComponent(nodeID)}/recycle`
  )
);

// src/linodes/actions.ts
import { RebuildLinodeSchema } from "@linode/validation/lib/linodes.schema";
var linodeBoot = (linodeId, config_id) => request_default(
  setURL(`${API_ROOT}/linode/instances/${encodeURIComponent(linodeId)}/boot`),
  setMethod("POST"),
  setData({ config_id })
);
var linodeReboot = (linodeId, config_id) => request_default(
  setURL(
    `${API_ROOT}/linode/instances/${encodeURIComponent(linodeId)}/reboot`
  ),
  setMethod("POST"),
  setData({ config_id })
);
var linodeShutdown = (linodeId) => request_default(
  setURL(
    `${API_ROOT}/linode/instances/${encodeURIComponent(linodeId)}/shutdown`
  ),
  setMethod("POST")
);
var resizeLinode = (linodeId, data) => request_default(
  setURL(
    `${API_ROOT}/linode/instances/${encodeURIComponent(linodeId)}/resize`
  ),
  setMethod("POST"),
  setData(data)
);
var rebuildLinode