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

JavaScript wrapper around the Linode APIv4

"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __getProtoOf = Object.getPrototypeOf;
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));
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  CONTINENT_CODE_TO_CONTINENT: () => CONTINENT_CODE_TO_CONTINENT,
  COUNTRY_CODE_TO_CONTINENT_CODE: () => COUNTRY_CODE_TO_CONTINENT_CODE,
  EventActionKeys: () => EventActionKeys,
  PLACEMENT_GROUP_POLICIES: () => PLACEMENT_GROUP_POLICIES,
  PLACEMENT_GROUP_TYPES: () => PLACEMENT_GROUP_TYPES,
  acceptEntityTransfer: () => acceptEntityTransfer,
  acceptServiceTransfer: () => acceptServiceTransfer,
  accountCapabilities: () => accountCapabilities,
  addEntityToAlert: () => addEntityToAlert,
  addFirewallDevice: () => addFirewallDevice,
  addPaymentMethod: () => addPaymentMethod,
  addPromotion: () => addPromotion,
  allocateIPAddress: () => allocateIPAddress,
  allocateIp: () => allocateIp,
  appendConfigInterface: () => appendConfigInterface,
  assignAddresses: () => assignAddresses,
  assignLinodesToPlacementGroup: () => assignLinodesToPlacementGroup,
  attachVolume: () => attachVolume,
  baseRequest: () => baseRequest,
  cancelAccount: () => cancelAccount,
  cancelBackups: () => cancelBackups,
  cancelObjectStorage: () => cancelObjectStorage,
  cancelServiceTransfer: () => cancelServiceTransfer,
  cancelTransfer: () => cancelTransfer,
  changeLinodeDiskPassword: () => changeLinodeDiskPassword,
  changeLinodePassword: () => changeLinodePassword,
  cloneDomain: () => cloneDomain,
  cloneLinode: () => cloneLinode,
  cloneLinodeDisk: () => cloneLinodeDisk,
  cloneVolume: () => cloneVolume,
  closeSupportTicket: () => closeSupportTicket,
  confirmTwoFactor: () => confirmTwoFactor,
  convertYupToLinodeErrors: () => convertYupToLinodeErrors,
  createAlertDefinition: () => createAlertDefinition,
  createBucket: () => createBucket,
  createChildAccountPersonalAccessToken: () => createChildAccountPersonalAccessToken,
  createContact: () => createContact,
  createCredential: () => createCredential,
  createDatabase: () => createDatabase,
  createDomain: () => createDomain,
  createDomainRecord: () => createDomainRecord,
  createEntityTransfer: () => createEntityTransfer,
  createFirewall: () => createFirewall,
  createIPv6Range: () => createIPv6Range,
  createImage: () => createImage,
  createKubernetesCluster: () => createKubernetesCluster,
  createKubernetesClusterBeta: () => createKubernetesClusterBeta,
  createLinode: () => createLinode,
  createLinodeConfig: () => createLinodeConfig,
  createLinodeDisk: () => createLinodeDisk,
  createLinodeInterface: () => createLinodeInterface,
  createLongviewClient: () => createLongviewClient,
  createNodeBalancer: () => createNodeBalancer,
  createNodeBalancerBeta: () => createNodeBalancerBeta,
  createNodeBalancerConfig: () => createNodeBalancerConfig,
  createNodeBalancerConfigBeta: () => createNodeBalancerConfigBeta,
  createNodeBalancerConfigNode: () => createNodeBalancerConfigNode,
  createNodeBalancerConfigNodeBeta: () => createNodeBalancerConfigNodeBeta,
  createNodePool: () => createNodePool,
  createOAuthClient: () => createOAuthClient,
  createObjectStorageKeys: () => createObjectStorageKeys,
  createPersonalAccessToken: () => createPersonalAccessToken,
  createPlacementGroup: () => createPlacementGroup,
  createReply: () => createReply,
  createSSHKey: () => createSSHKey,
  createServiceMonitor: () => createServiceMonitor,
  createServiceTransfer: () => createServiceTransfer,
  createStackScript: () => createStackScript,
  createSubnet: () => createSubnet,
  createSupportTicket: () => createSupportTicket,
  createTag: () => createTag,
  createUser: () => createUser,
  createVPC: () => createVPC,
  createVolume: () => createVolume,
  deleteAppToken: () => deleteAppToken,
  deleteBucket: () => deleteBucket,
  deleteBucketWithRegion: () => deleteBucketWithRegion,
  deleteContact: () => deleteContact,
  deleteCredential: () => deleteCredential,
  deleteDatabase: () => deleteDatabase,
  deleteDomain: () => deleteDomain,
  deleteDomainRecord: () => deleteDomainRecord,
  deleteEntityFromAlert: () => deleteEntityFromAlert,
  deleteFirewall: () => deleteFirewall,
  deleteFirewallDevice: () => deleteFirewallDevice,
  deleteImage: () => deleteImage,
  deleteKubernetesCluster: () => deleteKubernetesCluster,
  deleteLinode: () => deleteLinode,
  deleteLinodeConfig: () => deleteLinodeConfig,
  deleteLinodeConfigInterface: () => deleteLinodeConfigInterface,
  deleteLinodeDisk: () => deleteLinodeDisk,
  deleteLinodeInterface: () => deleteLinodeInterface,
  deleteLongviewClient: () => deleteLongviewClient,
  deleteNodeBalancer: () => deleteNodeBalancer,
  deleteNodeBalancerConfig: () => deleteNodeBalancerConfig,
  deleteNodeBalancerConfigNode: () => deleteNodeBalancerConfigNode,
  deleteNodePool: () => deleteNodePool,
  deleteOAuthClient: () => deleteOAuthClient,
  deletePaymentMethod: () => deletePaymentMethod,
  deletePersonalAccessToken: () => deletePersonalAccessToken,
  deletePlacementGroup: () => deletePlacementGroup,
  deleteSSHKey: () => deleteSSHKey,
  deleteSSLCert: () => deleteSSLCert,
  deleteServiceMonitor: () => deleteServiceMonitor,
  deleteStackScript: () => deleteStackScript,
  deleteSubnet: () => deleteSubnet,
  deleteTag: () => deleteTag,
  deleteTrustedDevice: () => deleteTrustedDevice,
  deleteUser: () => deleteUser,
  deleteVPC: () => deleteVPC,
  deleteVolume: () => deleteVolume,
  detachVolume: () => detachVolume,
  disableFirewall: () => disableFirewall,
  disableServiceMonitor: () => disableServiceMonitor,
  disableTwoFactor: () => disableTwoFactor,
  editAlertDefinition: () => editAlertDefinition,
  enableBackups: () => enableBackups,
  enableFirewall: () => enableFirewall,
  enableManaged: () => enableManaged,
  enableServiceMonitor: () => enableServiceMonitor,
  enrollInBeta: () => enrollInBeta,
  getAccountAgreements: () => getAccountAgreements,
  getAccountAvailabilities: () => getAccountAvailabilities,
  getAccountAvailability: () => getAccountAvailability,
  getAccountBeta: () => getAccountBeta,
  getAccountBetas: () => getAccountBetas,
  getAccountEntities: () => getAccountEntities,
  getAccountInfo: () => getAccountInfo,
  getAccountLogin: () => getAccountLogin,
  getAccountLogins: () => getAccountLogins,
  getAccountMaintenance: () => getAccountMaintenance,
  getAccountPermissions: () => getAccountPermissions,
  getAccountSettings: () => getAccountSettings,
  getActiveLongviewPlan: () => getActiveLongviewPlan,
  getAlertDefinitionByServiceType: () => getAlertDefinitionByServiceType,
  getAlertDefinitionByServiceTypeAndId: () => getAlertDefinitionByServiceTypeAndId,
  getAlertDefinitions: () => getAlertDefinitions,
  getAppToken: () => getAppToken,
  getAppTokens: () => getAppTokens,
  getBeta: () => getBeta,
  getBetas: () => getBetas,
  getBucket: () => getBucket,
  getBucketAccess: () => getBucketAccess,
  getBuckets: () => getBuckets,
  getBucketsInCluster: () => getBucketsInCluster,
  getBucketsInRegion: () => getBucketsInRegion,
  getChildAccount: () => getChildAccount,
  getChildAccounts: () => getChildAccounts,
  getClientToken: () => getClientToken,
  getCloudPulseServiceTypes: () => getCloudPulseServiceTypes,
  getClusters: () => getClusters,
  getConfigInterface: () => getConfigInterface,
  getConfigInterfaces: () => getConfigInterfaces,
  getCredentials: () => getCredentials,
  getDNSZoneFile: () => getDNSZoneFile,
  getDashboardById: () => getDashboardById,
  getDashboards: () => getDashboards,
  getDatabaseBackup: () => getDatabaseBackup,
  getDatabaseBackups: () => getDatabaseBackups,
  getDatabaseCredentials: () => getDatabaseCredentials,
  getDatabaseEngine: () => getDatabaseEngine,
  getDatabaseEngineConfig: () => getDatabaseEngineConfig,
  getDatabaseEngines: () => getDatabaseEngines,
  getDatabaseType: () => getDatabaseType,
  getDatabaseTypes: () => getDatabaseTypes,
  getDatabases: () => getDatabases,
  getDeprecatedLinodeTypes: () => getDeprecatedLinodeTypes,
  getDomain: () => getDomain,
  getDomainRecord: () => getDomainRecord,
  getDomainRecords: () => getDomainRecords,
  getDomains: () => getDomains,
  getEngineDatabase: () => getEngineDatabase,
  getEngineDatabases: () => getEngineDatabases,
  getEntityTransfer: () => getEntityTransfer,
  getEntityTransfers: () => getEntityTransfers,
  getEvent: () => getEvent,
  getEvents: () => getEvents,
  getFirewall: () => getFirewall,
  getFirewallDevice: () => getFirewallDevice,
  getFirewallDevices: () => getFirewallDevices,
  getFirewallRules: () => getFirewallRules,
  getFirewallSettings: () => getFirewallSettings,
  getFirewalls: () => getFirewalls,
  getGrants: () => getGrants,
  getIP: () => getIP,
  getIPs: () => getIPs,
  getIPv6Pools: () => getIPv6Pools,
  getIPv6RangeInfo: () => getIPv6RangeInfo,
  getIPv6Ranges: () => getIPv6Ranges,
  getImage: () => getImage,
  getImages: () => getImages,
  getInvoice: () => getInvoice,
  getInvoiceItems: () => getInvoiceItems,
  getInvoices: () => getInvoices,
  getJWEToken: () => getJWEToken,
  getKubeConfig: () => getKubeConfig,
  getKubernetesCluster: () => getKubernetesCluster,
  getKubernetesClusterBeta: () => getKubernetesClusterBeta,
  getKubernetesClusterControlPlaneACL: () => getKubernetesClusterControlPlaneACL,
  getKubernetesClusterDashboard: () => getKubernetesClusterDashboard,
  getKubernetesClusterEndpoints: () => getKubernetesClusterEndpoints,
  getKubernetesClusters: () => getKubernetesClusters,
  getKubernetesClustersBeta: () => getKubernetesClustersBeta,
  getKubernetesTieredVersionBeta: () => getKubernetesTieredVersionBeta,
  getKubernetesTieredVersionsBeta: () => getKubernetesTieredVersionsBeta,
  getKubernetesTypes: () => getKubernetesTypes,
  getKubernetesTypesBeta: () => getKubernetesTypesBeta,
  getKubernetesVersion: () => getKubernetesVersion,
  getKubernetesVersions: () => getKubernetesVersions,
  getLinode: () => getLinode,
  getLinodeBackups: () => getLinodeBackups,
  getLinodeConfig: () => getLinodeConfig,
  getLinodeConfigs: () => getLinodeConfigs,
  getLinodeDisk: () => getLinodeDisk,
  getLinodeDisks: () => getLinodeDisks,
  getLinodeFirewalls: () => getLinodeFirewalls,
  getLinodeIPs: () => getLinodeIPs,
  getLinodeInterface: () => getLinodeInterface,
  getLinodeInterfaceFirewalls: () => getLinodeInterfaceFirewalls,
  getLinodeInterfaces: () => getLinodeInterfaces,
  getLinodeInterfacesHistory: () => getLinodeInterfacesHistory,
  getLinodeInterfacesSettings: () => getLinodeInterfacesSettings,
  getLinodeKernel: () => getLinodeKernel,
  getLinodeKernels: () => getLinodeKernels,
  getLinodeLish: () => getLinodeLish,
  getLinodeSettings: () => getLinodeSettings,
  getLinodeStats: () => getLinodeStats,
  getLinodeStatsByDate: () => getLinodeStatsByDate,
  getLinodeTransfer: () => getLinodeTransfer,
  getLinodeTransferByDate: () => getLinodeTransferByDate,
  getLinodeTypes: () => getLinodeTypes,
  getLinodeVolumes: () => getLinodeVolumes,
  getLinodes: () => getLinodes,
  getLogins: () => getLogins,
  getLongviewClients: () => getLongviewClients,
  getLongviewSubscriptions: () => getLongviewSubscriptions,
  getManagedContacts: () => getManagedContacts,
  getManagedIssues: () => getManagedIssues,
  getManagedStats: () => getManagedStats,
  getMetricDefinitionsByServiceType: () => getMetricDefinitionsByServiceType,
  getMyGrants: () => getMyGrants,
  getNetworkTransferPrices: () => getNetworkTransferPrices,
  getNetworkUtilization: () => getNetworkUtilization,
  getNodeBalancer: () => getNodeBalancer,
  getNodeBalancerBeta: () => getNodeBalancerBeta,
  getNodeBalancerConfig: () => getNodeBalancerConfig,
  getNodeBalancerConfigNode: () => getNodeBalancerConfigNode,
  getNodeBalancerConfigNodeBeta: () => getNodeBalancerConfigNodeBeta,
  getNodeBalancerConfigNodes: () => getNodeBalancerConfigNodes,
  getNodeBalancerConfigNodesBeta: () => getNodeBalancerConfigNodesBeta,
  getNodeBalancerConfigs: () => getNodeBalancerConfigs,
  getNodeBalancerFirewalls: () => getNodeBalancerFirewalls,
  getNodeBalancerStats: () => getNodeBalancerStats,
  getNodeBalancerTypes: () => getNodeBalancerTypes,
  getNodeBalancerVPCConfigBeta: () => getNodeBalancerVPCConfigBeta,
  getNodeBalancerVPCConfigsBeta: () => getNodeBalancerVPCConfigsBeta,
  getNodeBalancers: () => getNodeBalancers,
  getNodePool: () => getNodePool,
  getNodePools: () => getNodePools,
  getNotificationChannels: () => getNotificationChannels,
  getNotifications: () => getNotifications,
  getOAuthClient: () => getOAuthClient,
  getOAuthClients: () => getOAuthClients,
  getObjectACL: () => getObjectACL,
  getObjectList: () => getObjectList,
  getObjectStorageEndpoints: () => getObjectStorageEndpoints,
  getObjectStorageKeys: () => getObjectStorageKeys,
  getObjectStorageTypes: () => getObjectStorageTypes,
  getObjectURL: () => getObjectURL,
  getPaymentMethod: () => getPaymentMethod,
  getPaymentMethods: () => getPaymentMethods,
  getPayments: () => getPayments,
  getPersonalAccessToken: () => getPersonalAccessToken,
  getPersonalAccessTokens: () => getPersonalAccessTokens,
  getPlacementGroup: () => getPlacementGroup,
  getPlacementGroups: () => getPlacementGroups,
  getProfile: () => getProfile,
  getQuota: () => getQuota,
  getQuotaUsage: () => getQuotaUsage,
  getQuotas: () => getQuotas,
  getRegion: () => getRegion,
  getRegionAvailabilities: () => getRegionAvailabilities,
  getRegionAvailability: () => getRegionAvailability,
  getRegions: () => getRegions,
  getSSHKey: () => getSSHKey,
  getSSHKeys: () => getSSHKeys,
  getSSHPubKey: () => getSSHPubKey,
  getSSLCert: () => getSSLCert,
  getSSLFields: () => getSSLFields,
  getSecurityQuestions: () => getSecurityQuestions,
  getServiceTransfer: () => getServiceTransfer,
  getServiceTransfers: () => getServiceTransfers,
  getServices: () => getServices,
  getStackScript: () => getStackScript,
  getStackScripts: () => getStackScripts,
  getSubnet: () => getSubnet,
  getSubnets: () => getSubnets,
  getTFAToken: () => getTFAToken,
  getTags: () => getTags,
  getTemplate: () => getTemplate,
  getTemplates: () => getTemplates,
  getTicket: () => getTicket,
  getTicketReplies: () => getTicketReplies,
  getTickets: () => getTickets,
  getTrustedDevices: () => getTrustedDevices,
  getType: () => getType,
  getUser: () => getUser,
  getUserPermissions: () => getUserPermissions,
  getUserPreferences: () => getUserPreferences,
  getUsers: () => getUsers,
  getVPC: () => getVPC,
  getVPCIPs: () => getVPCIPs,
  getVPCs: () => getVPCs,
  getVPCsIPs: () => getVPCsIPs,
  getVlan: () => getVlan,
  getVlans: () => getVlans,
  getVolume: () => getVolume,
  getVolumeTypes: () => getVolumeTypes,
  getVolumes: () => getVolumes,
  getVolumesMigrationQueue: () => getVolumesMigrationQueue,
  importZone: () => importZone,
  isEmpty: () => isEmpty,
  legacyRestoreWithBackup: () => legacyRestoreWithBackup,
  linodeBoot: () => linodeBoot,
  linodeInterfaceAccountSettings: () => linodeInterfaceAccountSettings,
  linodeReboot: () => linodeReboot,
  linodeShutdown: () => linodeShutdown,
  listGrants: () => listGrants,
  makeDefaultPaymentMethod: () => makeDefaultPaymentMethod,
  makePayment: () => makePayment,
  markEventRead: () => markEventRead,
  markEventSeen: () => markEventSeen,
  migrateVolumes: () => migrateVolumes,
  modifySubnet: () => modifySubnet,
  patchDatabase: () => patchDatabase,
  quotaTypes: () => quotaTypes,
  rebuildLinode: () => rebuildLinode,
  rebuildNodeBalancerConfig: () => rebuildNodeBalancerConfig,
  rebuildNodeBalancerConfigBeta: () => rebuildNodeBalancerConfigBeta,
  recycleAllNodes: () => recycleAllNodes,
  recycleClusterNodes: () => recycleClusterNodes,
  recycleNode: () => recycleNode,
  removeIPAddress: () => removeIPAddress,
  removeIPv6Range: () => removeIPv6Range,
  rescueLinode: () => rescueLinode,
  rescueMetalLinode: () => rescueMetalLinode,
  resetDatabaseCredentials: () => resetDatabaseCredentials,
  resetKubeConfig: () => resetKubeConfig,
  resetOAuthClientSecret: () => resetOAuthClientSecret,
  resizeLinode: () => resizeLinode,
  resizeLinodeDisk: () => resizeLinodeDisk,
  resizeVolume: () => resizeVolume,
  restoreBackup: () => restoreBackup,
  restoreWithBackup: () => restoreWithBackup,
  resumeDatabase: () => resumeDatabase,
  revokeObjectStorageKey: () => revokeObjectStorageKey,
  saveCreditCard: () => saveCreditCard,
  scheduleOrQueueMigration: () => scheduleOrQueueMigration,
  sendCodeToPhoneNumber: () => sendCodeToPhoneNumber,
  setToken: () => setToken,
  shareAddresses: () => shareAddresses,
  shareAddressesv4: () => shareAddressesv4,
  signAgreement: () => signAgreement,
  smsOptOut: () => smsOptOut,
  startMutation: () => startMutation,
  suspendDatabase: () => suspendDatabase,
  takeSnapshot: () => takeSnapshot,
  unassignLinodesFromPlacementGroup: () => unassignLinodesFromPlacementGroup,
  updateAccountInfo: () => updateAccountInfo,
  updateAccountSettings: () => updateAccountSettings,
  updateActiveLongviewPlan: () => updateActiveLongviewPlan,
  updateBucketAccess: () => updateBucketAccess,
  updateConfigInterface: () => updateConfigInterface,
  updateContact: () => updateContact,
  updateCredential: () => updateCredential,
  updateDatabase: () => updateDatabase,
  updateDomain: () => updateDomain,
  updateDomainRecord: () => updateDomainRecord,
  updateFirewall: () => updateFirewall,
  updateFirewallRules: () => updateFirewallRules,
  updateFirewallSettings: () => updateFirewallSettings,
  updateGrants: () => updateGrants,
  updateIP: () => updateIP,
  updateImage: () => updateImage,
  updateImageRegions: () => updateImageRegions,
  updateKubernetesCluster: () => updateKubernetesCluster,
  updateKubernetesClusterControlPlaneACL: () => updateKubernetesClusterControlPlaneACL,
  updateLinode: () => updateLinode,
  updateLinodeConfig: () => updateLinodeConfig,
  updateLinodeConfigOrder: () => updateLinodeConfigOrder,
  updateLinodeDisk: () => updateLinodeDisk,
  updateLinodeInterface: () => updateLinodeInterface,
  updateLinodeInterfacesSettings: () => updateLinodeInterfacesSettings,
  updateLinodeSettings: () => updateLinodeSettings,
  updateLongviewClient: () => updateLongviewClient,
  updateNodeBalancer: () => updateNodeBalancer,
  updateNodeBalancerConfig: () => updateNodeBalancerConfig,
  updateNodeBalancerConfigNode: () => updateNodeBalancerConfigNode,
  updateNodeBalancerConfigNodeBeta: () => updateNodeBalancerConfigNodeBeta,
  updateNodePool: () => updateNodePool,
  updateOAuthClient: () => updateOAuthClient,
  updateObjectACL: () => updateObjectACL,
  updateObjectStorageKey: () => updateObjectStorageKey,
  updatePassword: () => updatePassword,
  updatePersonalAccessToken: () => updatePersonalAccessToken,
  updatePlacementGroup: () => updatePlacementGroup,
  updateProfile: () => updateProfile,
  updateSSHKey: () => updateSSHKey,
  updateSecurityQuestions: () => updateSecurityQuestions,
  updateServiceMonitor: () => updateServiceMonitor,
  updateStackScript: () => updateStackScript,
  updateUser: () => updateUser,
  updateUserPermissions: () => updateUserPermissions,
  updateUserPreferences: () => updateUserPreferences,
  updateVPC: () => updateVPC,
  updateVolume: () => updateVolume,
  upgradeToLinodeInterface: () => upgradeToLinodeInterface,
  uploadAttachment: () => uploadAttachment,
  uploadImage: () => uploadImage,
  uploadSSLCert: () => uploadSSLCert,
  verifyPhoneNumberCode: () => verifyPhoneNumberCode
});
module.exports = __toCommonJS(index_exports);

// src/account/account.ts
var import_account = require("@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
var import_axios = __toESM(require("axios"), 1);
var baseRequest = import_axios.default.create({
  baseURL: "https://api.linode.com/v4"
});
baseRequest.interceptors.request.use((config) => {
  const isRunningInNode = typeof process === "object";
  if (!isRunningInNode) {
    return config;
  }
  const headers = new import_axios.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 import_axios.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(`${API_ROOT}/account`), setMethod("GET"));
};
var getNetworkUtilization = () => request_default(
  setURL(`${API_ROOT}/account/transfer`),
  setMethod("GET")
);
var updateAccountInfo = (data) => request_default(
  setURL(`${API_ROOT}/account`),
  setMethod("PUT"),
  setData(data, import_account.updateAccountSchema)
);
var getAccountSettings = () => request_default(
  setURL(`${API_ROOT}/account/settings`),
  setMethod("GET")
);
var updateAccountSettings = (data) => request_default(
  setURL(`${API_ROOT}/account/settings`),
  setMethod("PUT"),
  setData(data, import_account.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/payments.ts
var import_account2 = require("@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, import_account2.PaymentSchema)
  );
};
var saveCreditCard = (data) => {
  return request_default(
    setURL(`${API_ROOT}/account/credit-card`),
    setMethod("POST"),
    setData(data, import_account2.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, import_account2.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/users.ts
var import_account3 = require("@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, import_account3.CreateUserSchema)
);
var updateUser = (username, data) => request_default(
  setURL(`${API_ROOT}/account/users/${encodeURIComponent(username)}`),
  setMethod("PUT"),
  setData(data, import_account3.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/account/oauth.ts
var import_account4 = require("@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, import_account4.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, import_account4.updateOAuthClientSchema)
);
var deleteOAuthClient = (clientId) => request_default(
  setURL(`${API_ROOT}/account/oauth-clients/${encodeURIComponent(clientId)}`),
  setMethod("DELETE")
);

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

// src/account/types.ts
var accountCapabilities = [
  "Akamai Cloud Load Balancer",
  "Akamai Cloud Pulse",
  "Block Storage",
  "Block Storage Encryption",
  "Cloud Firewall",
  "CloudPulse",
  "Disk Encryption",
  "Kubernetes",
  "Kubernetes Enterprise",
  "Linodes",
  "Linode Interfaces",
  "LKE HA Control Planes",
  "LKE Network Access Control List (IP ACL)",
  "Machine Images",
  "Managed Databases",
  "Managed Databases Beta",
  "NETINT Quadra T1U",
  "NodeBalancers",
  "Object Storage Access Key Regions",
  "Object Storage Endpoint Types",
  "Object Storage",
  "Placement Group",
  "SMTP Enabled",
  "Support Ticket Severity",
  "Vlans",
  "VPCs"
];
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",
  "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_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",
  "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/maintenance.ts
var getAccountMaintenance = (params, filter) => request_default(
  setURL(`${API_ROOT}/account/maintenance`),
  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/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")
);

// src/cloudpulse/alerts.ts
var import_validation = require("@linode/validation");
var createAlertDefinition = (data, serviceType) => request_default(
  setURL(
    `${BETA_API_ROOT}/monitor/services/${encodeURIComponent(
      serviceType
    )}/alert-definitions`
  ),
  setMethod("POST"),
  setData(data, import_validation.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, import_validation.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")
);

// src/databases/databases.ts
var import_databases = require("@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, import_databases.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, import_databases.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, fork) => request_default(
  setURL(`${BETA_API_ROOT}/databases/${encodeURIComponent(engine)}/instances`),
  setMethod("POST"),
  setData({ fork })
);
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")
);

// src/domains/domains.ts
var import_domains = require("@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, import_domains.createDomainSchema),
  setURL(`${API_ROOT}/domains`),
  setMethod("POST")
);
var updateDomain = (domainId, data) => request_default(
  setURL(`${API_ROOT}/domains/${encodeURIComponent(domainId)}`),
  setMethod("PUT"),
  setData(data, import_domains.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, import_domains.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
var import_records = require("@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, import_records.createRecordSchema)
);
var updateDomainRecord = (domainId, recordId, data) => request_default(
  setURL(
    `${API_ROOT}/domains/${encodeURIComponent(
      domainId
    )}/records/${encodeURIComponent(recordId)}`
  ),
  setMethod("PUT"),
  setData(data, import_records.updateRecordSchema)
);
var deleteDomainRecord = (domainId, recordId) => request_default(
  setURL(
    `${API_ROOT}/domains/${encodeURIComponent(
      domainId
    )}/records/${encodeURIComponent(recordId)}`
  ),
  setMethod("DELETE")
);

// src/entity-transfers/transfers.ts
var import_transfers = require("@linode/validation/lib/transfers.schema");
var getEntityTransfers = (params, filter) => request_default(
  setMethod("GET"),
  setParams(params),
  setXFilter(filter),
  setURL(`${BETA_API_ROOT}/account/entity-transfers`)
);
var getEntityTransfer = (token) => request_default(
  setMethod("GET"),
  setURL(
    `${BETA_API_ROOT}/account/entity-transfers/${encodeURIComponent(token)}`
  )
);
var createEntityTransfer = (data) => request_default(
  setMethod("POST"),
  setData(data, import_transfers.CreateTransferSchema),
  setURL(`${BETA_API_ROOT}/account/entity-transfers`)
);
var acceptEntityTransfer = (token) => request_default(
  setMethod("POST"),
  setURL(