azion
Version:
Azion Packages for Edge Computing.
1,563 lines (1,541 loc) • 110 kB
TypeScript
import { BuildOptions, Plugin } from 'esbuild';
import { Configuration, WebpackPluginInstance } from 'webpack';
declare const RULE_OPERATORS_WITH_VALUE: readonly ["is_equal", "is_not_equal", "starts_with", "does_not_start_with", "matches", "does_not_match"];
declare const RULE_OPERATORS_WITHOUT_VALUE: readonly ["exists", "does_not_exist"];
declare const RULE_CONDITIONALS: readonly ["if", "and", "or"];
declare const RULE_VARIABLES: readonly ("device_group" | "request" | "args" | "domain" | "geoip_city" | "geoip_city_continent_code" | "geoip_city_country_code" | "geoip_city_country_name" | "geoip_continent_code" | "geoip_country_code" | "geoip_country_name" | "geoip_region" | "geoip_region_name" | "host" | "remote_addr" | "remote_port" | "remote_user" | "request_body" | "request_method" | "request_uri" | "scheme" | "uri" | "server_addr" | "server_port" | "ssl_client_fingerprint" | "ssl_client_escaped_cert" | "ssl_client_s_dn" | "ssl_client_s_dn_parsed" | "ssl_client_cert" | "ssl_client_i_dn" | "ssl_client_serial" | "ssl_client_v_end" | "ssl_client_v_remain" | "ssl_client_v_start" | "ssl_client_verify" | "sent_http_name" | "status" | "tcpinfo_rtt" | "upstream_addr" | "upstream_status")[];
declare const FIREWALL_RATE_LIMIT_TYPES: readonly ["second", "minute"];
declare const FIREWALL_RATE_LIMIT_BY: readonly ["clientIp", "global"];
declare const FIREWALL_WAF_MODES: readonly ["learning", "blocking"];
type RuleOperatorWithValue = (typeof RULE_OPERATORS_WITH_VALUE)[number];
type RuleOperatorWithoutValue = (typeof RULE_OPERATORS_WITHOUT_VALUE)[number];
type RuleConditional = (typeof RULE_CONDITIONALS)[number];
type WithDollarBraces<T extends string> = `\${${T}}` | T;
type DynamicVariable = `arg_${string}` | `cookie_${string}` | `http_${string}` | `sent_http_${string}` | `upstream_cookie_${string}` | `upstream_http_${string}`;
type RuleVariable = WithDollarBraces<(typeof RULE_VARIABLES)[number]> | DynamicVariable | WithDollarBraces<DynamicVariable>;
type FirewallRateLimitType = (typeof FIREWALL_RATE_LIMIT_TYPES)[number];
type FirewallRateLimitBy = (typeof FIREWALL_RATE_LIMIT_BY)[number];
type FirewallWafMode = (typeof FIREWALL_WAF_MODES)[number];
declare const NETWORK_LIST_TYPES: readonly ["ip_cidr", "asn", "countries"];
type NetworkListType = (typeof NETWORK_LIST_TYPES)[number];
declare const WAF_MODE: readonly ["learning", "blocking", "counting"];
type WafMode = (typeof WAF_MODE)[number];
declare const WAF_SENSITIVITY: readonly ["low", "medium", "high"];
type WafSensitivity = (typeof WAF_SENSITIVITY)[number];
interface Metadata {
geoip_asn: string;
geoip_city: string;
geoip_city_continent_code: string;
geoip_city_country_code: string;
geoip_city_country_name: string;
geoip_continent_code: string;
geoip_country_code: string;
geoip_country_name: string;
geoip_region: string;
geoip_region_name: string;
remote_addr: string;
remote_port: string;
remote_user: string;
server_protocol: string;
ssl_cipher: string;
ssl_protocol: string;
[key: string]: string;
}
/**
* Represents the FetchEvent interface.
*/
interface FetchEvent extends Event {
request: Request & {
metadata: Metadata;
};
waitUntil(promise: Promise<any>): void;
respondWith(response: Response | Promise<Response>): void;
}
/**
* Domain configuration for Azion.
*/
type AzionDomain$1 = {
/** Domain name */
name: string;
/** Indicates if access is restricted to CNAME only */
cnameAccessOnly?: boolean;
/** List of CNAMEs associated with the domain */
cnames?: string[];
/** Associated edge application ID */
id?: number;
/** Associated edge appliaction ID */
edgeApplicationId?: number;
/** Associated edge firewall ID */
edgeFirewallId?: number;
/** Digital certificate ID */
digitalCertificateId?: string | number | null;
/** Indicates if the domain is active */
active?: boolean;
/** Mutual TLS configuration */
mtls?: {
/** Verification mode for MTLS */
verification: 'enforce' | 'permissive';
/** ID of the trusted CA certificate */
trustedCaCertificateId: number;
/** List of CRL (Certificate Revocation List) IDs */
crlList?: number[];
};
};
/**
* Origin configuration for Azion.
*/
type AzionOrigin$1 = {
/** Origin ID */
id?: number;
/** Origin key */
key?: string;
/** Origin name */
name: string;
/** Origin type */
type: string;
/** Bucket name for S3-like origins */
bucket?: string | null;
/** Prefix for S3-like origins */
prefix?: string | null;
/** Addresses for the origin */
addresses?: string[] | {
/** Address of the origin */
address: string;
/** Weight for load balancing */
weight?: number;
}[];
/** Host header to be sent to the origin */
hostHeader?: string;
/** Protocol policy for communicating with the origin */
protocolPolicy?: 'http' | 'https' | 'preserve';
/** Indicates if redirection should be used */
redirection?: boolean;
/** Load balancing method */
method?: 'ip_hash' | 'least_connections' | 'round_robin';
/** Path to be appended to the origin address */
path?: string;
/** Connection timeout in seconds */
connectionTimeout?: number;
/** Timeout between bytes in seconds */
timeoutBetweenBytes?: number;
/** HMAC authentication configuration */
hmac?: {
/** AWS region */
region: string;
/** AWS access key */
accessKey: string;
/** AWS secret key */
secretKey: string;
};
};
/**
* Cache configuration for Azion.
*/
type AzionCache = {
/** Cache name */
name: string;
/** Indicates if stale content should be served */
stale?: boolean;
/** Indicates if query string parameters should be sorted */
queryStringSort?: boolean;
/** HTTP methods to be cached */
methods?: {
/** Cache POST requests */
post?: boolean;
/** Cache OPTIONS requests */
options?: boolean;
};
/** Browser cache settings */
browser?: {
/** Maximum age for browser cache in seconds */
maxAgeSeconds: number | string;
};
/** Edge cache settings */
edge?: {
/** Maximum age for edge cache in seconds */
maxAgeSeconds: number | string;
};
/** Cache by cookie configuration */
cacheByCookie?: {
/** Cookie caching option */
option: 'ignore' | 'varies' | 'whitelist' | 'blacklist';
/** List of cookies to be considered */
list?: string[];
};
/** Cache by query string configuration */
cacheByQueryString?: {
/** Query string caching option */
option: 'ignore' | 'varies' | 'whitelist' | 'blacklist';
/** List of query string parameters to be considered */
list?: string[];
};
};
type AzionRuleCriteriaBase = {
/** Variable to be evaluated */
variable: RuleVariable;
/** Conditional type */
conditional: RuleConditional;
};
type AzionRuleCriteriaWithValue = AzionRuleCriteriaBase & {
/** Operator for comparison that requires input value */
operator: RuleOperatorWithValue;
/** Input value for comparison */
inputValue: string;
};
type AzionRuleCriteriaWithoutValue = AzionRuleCriteriaBase & {
/** Operator for comparison that doesn't require input value */
operator: RuleOperatorWithoutValue;
};
type AzionRuleCriteria = AzionRuleCriteriaWithValue | AzionRuleCriteriaWithoutValue;
/**
* Request rule configuration for Azion.
*/
type AzionRequestRule = {
/** Rule name */
name: string;
/** Rule description */
description?: string;
/** Indicates if the rule is active */
active?: boolean;
/** Match criteria for the rule */
match?: string;
/** Variable to be used in the match */
variable?: RuleVariable;
/** Array of criteria for complex conditions */
criteria?: AzionRuleCriteria[];
/** Behavior to be applied when the rule matches */
behavior?: {
/** Set a new origin */
setOrigin?: {
/** Origin name */
name: string;
/** Origin type */
type: string;
};
/** Rewrite the request */
rewrite?: string;
/** Set headers */
setHeaders?: string[];
/** Bypass cache */
bypassCache?: boolean | null;
/** Force HTTPS */
httpToHttps?: boolean | null;
/** Redirect with 301 status */
redirectTo301?: string | null;
/** Redirect with 302 status */
redirectTo302?: string | null;
/** Forward cookies */
forwardCookies?: boolean | null;
/** Set a cookie */
setCookie?: string | null;
/** Deliver the content */
deliver?: boolean | null;
/** Deny */
deny?: boolean | null;
/** No content */
noContent?: boolean | null;
/** enable GZIP compression */
enableGZIP?: boolean | null;
/** Filter cookie */
filterCookie?: string | null;
/** Filter header */
filterHeader?: string | null;
/** Optimize images */
optimizeImages?: boolean | null;
/** Capture configuration */
capture?: {
/** Match pattern */
match: string;
/** Captured value */
captured: string;
/** Subject to capture from */
subject: string;
};
/** Run a serverless function */
runFunction?: string;
/** Set cache configuration */
setCache?: string | {
/** Cache name */
name: string;
/** Browser cache TTL */
browser_cache_settings_maximum_ttl?: number | null;
/** CDN cache TTL */
cdn_cache_settings_maximum_ttl?: number | null;
};
};
};
/**
* Response rule configuration for Azion.
*/
type AzionResponseRule = {
/** Rule name */
name: string;
/** Rule description */
description?: string;
/** Indicates if the rule is active */
active?: boolean;
/** Match criteria for the rule */
match?: string;
/** Variable to be used in the match */
variable?: RuleVariable;
/** Array of criteria for complex conditions */
criteria?: AzionRuleCriteria[];
/** Behavior to be applied when the rule matches */
behavior?: {
/** Set a cookie */
setCookie?: string | null;
/** Set headers */
setHeaders?: string[];
/** Deliver the content */
deliver?: boolean | null;
/** Capture configuration */
capture?: {
/** Match pattern */
match: string;
/** Captured value */
captured: string;
/** Subject to capture from */
subject: string;
};
/** Enable GZIP compression */
enableGZIP?: boolean | null;
/** Filter a cookie */
filterCookie?: string | null;
/** Filter a header */
filterHeader?: string | null;
/** Run a serverless function */
runFunction?: string;
/** Redirect with 301 status */
redirectTo301?: string | null;
/** Redirect with 302 status */
redirectTo302?: string | null;
};
};
/**
* Rules configuration for Azion.
*/
type AzionRules = {
/** Request rules */
request?: AzionRequestRule[];
/** Response rules */
response?: AzionResponseRule[];
};
/**
* Purge configuration for Azion.
*/
type AzionPurge$1 = {
/** Purge type */
type: 'url' | 'cachekey' | 'wildcard';
/** URLs to be purged */
urls: string[];
/** HTTP method for purge request */
method?: 'delete';
/** Cache layer to be purged */
layer?: 'edge_caching' | 'l2_caching';
};
type PresetInput = string | AzionBuildPreset;
type BuildEntryPoint = string | string[] | Record<string, string>;
interface AzionBuild<T extends Configuration | BuildOptions | unknown = Configuration | BuildOptions> {
entry?: BuildEntryPoint;
bundler?: 'webpack' | 'esbuild';
preset?: PresetInput;
polyfills?: boolean;
extend?: (context: T) => T;
memoryFS?: {
injectionDirs: string[];
removePathPrefix: string;
};
}
/**
* Network list configuration for Azion.
*/
type AzionNetworkList = {
/** Network list identifier */
id: number;
/** Network list type */
listType: NetworkListType;
/** List of networks */
listContent: string[] | number[];
};
/**
* Function configuration for Azion.
*/
type AzionFunction = {
/** Function name */
name: string;
/** Function path */
path: string;
/** Optional arguments to be passed to the function */
args?: Record<string, unknown>;
};
/**
* Main configuration type for Azion.
*/
type AzionConfig = {
/** Build configuration */
build?: AzionBuild;
/** Domain configuration */
domain?: AzionDomain$1;
/** Origin configurations */
origin?: AzionOrigin$1[];
/** Cache configurations */
cache?: AzionCache[];
/** Functions configurations */
functions?: AzionFunction[];
/** Rules configuration */
rules?: AzionRules;
/** Purge configurations */
purge?: AzionPurge$1[];
/** Firewall configuration */
firewall?: AzionFirewall;
/** Network list configurations */
networkList?: AzionNetworkList[];
/** WAF configuration */
waf?: AzionWaf[];
};
/**
* Firewall behavior configuration for Azion.
*/
type AzionFirewallBehavior = {
/** Run a serverless function */
runFunction?: string;
/** Set WAF ruleset */
setWafRuleset?: {
/** WAF mode */
wafMode: FirewallWafMode;
/** WAF ID */
wafId: string;
};
/** Set rate limit */
setRateLimit?: {
/** Rate limit type */
type: FirewallRateLimitType;
/** Rate limit by */
limitBy: FirewallRateLimitBy;
/** Average rate limit */
averageRateLimit: string;
/** Maximum burst size */
maximumBurstSize: string;
};
/** Deny the request */
deny?: boolean;
/** Drop the request */
drop?: boolean;
/** Set custom response */
setCustomResponse?: {
/** HTTP status code (200-499) */
statusCode: number | string;
/** Response content type */
contentType: string;
/** Response content body */
contentBody: string;
};
};
type AzionFirewallCriteriaBase = {
/** Variable to be evaluated */
variable: RuleVariable;
/** Conditional type */
conditional: RuleConditional;
};
type AzionFirewallCriteriaWithValue = AzionFirewallCriteriaBase & {
/** Operator for comparison that requires input value */
operator: RuleOperatorWithValue;
/** Input value for comparison */
inputValue: string;
};
type AzionFirewallCriteriaWithoutValue = AzionFirewallCriteriaBase & {
/** Operator for comparison that doesn't require input value */
operator: RuleOperatorWithoutValue;
};
type AzionFirewallCriteria = AzionFirewallCriteriaWithValue | AzionFirewallCriteriaWithoutValue;
/**
* Firewall rule configuration for Azion.
*/
type AzionFirewallRule = {
/** Rule name */
name: string;
/** Rule description */
description?: string;
/** Indicates if the rule is active */
active?: boolean;
/** Match criteria for the rule */
match?: string;
/** Variable to be used in the match */
variable?: RuleVariable;
/** Array of criteria for complex conditions */
criteria?: AzionFirewallCriteria[];
/** Behavior to be applied when the rule matches */
behavior: AzionFirewallBehavior;
};
/**
* Firewall configuration for Azion.
*/
type AzionFirewall = {
/** Firewall name */
name: string;
/** List of domains */
domains?: string[];
/** Indicates if the firewall is active */
active?: boolean;
/** Indicates if Edge Functions are enabled */
edgeFunctions?: boolean;
/** Indicates if Network Protection is enabled */
networkProtection?: boolean;
/** Indicates if WAF is enabled */
waf?: boolean;
/** Variable to be used in the match */
variable?: RuleVariable;
/** List of firewall rules */
rules?: AzionFirewallRule[];
/** Debug mode */
debugRules?: boolean;
};
type AzionWaf = {
/** WAF ID */
id?: number;
/** WAF name */
name: string;
/** WAF mode */
mode: WafMode;
/** WAF active */
active: boolean;
/** WAF sqlInjection */
sqlInjection?: {
sensitivity: WafSensitivity;
};
/** WAF remoteFileInclusion */
remoteFileInclusion?: {
sensitivity: WafSensitivity;
};
/** WAF directoryTraversal */
directoryTraversal?: {
sensitivity: WafSensitivity;
};
/** WAF crossSiteScripting */
crossSiteScripting?: {
sensitivity: WafSensitivity;
};
/** WAF evadingTricks */
evadingTricks?: {
sensitivity: WafSensitivity;
};
/** WAF fileUpload */
fileUpload?: {
sensitivity: WafSensitivity;
};
/** WAF unwantedAccess */
unwantedAccess?: {
sensitivity: WafSensitivity;
};
/** WAF identifiedAttack */
identifiedAttack?: {
sensitivity: WafSensitivity;
};
/** WAF bypassAddress */
bypassAddresses?: string[];
};
type BuildConfiguration = Omit<AzionBuild<Configuration | BuildOptions>, 'preset' | 'entry'> & {
entry: Record<string, string>;
baseOutputDir?: string;
preset: AzionBuildPreset;
setup: BundlerSetup;
};
interface BundlerSetup {
contentToInject?: string;
defineVars?: Record<string, string>;
}
interface BuildContext {
production: boolean;
handler: BuildEntryPoint;
skipFrameworkBuild?: boolean;
}
type PresetMetadata = {
name: string;
registry?: string;
ext?: string;
};
interface AzionBuildPreset {
config: AzionConfig;
handler?: (event: FetchEvent) => Promise<Response>;
prebuild?: (config: BuildConfiguration, ctx: BuildContext) => Promise<void | AzionPrebuildResult>;
postbuild?: (config: BuildConfiguration, ctx: BuildContext) => Promise<void>;
metadata: PresetMetadata;
}
interface AzionPrebuildResult {
/** Files to be injected into memory during build process */
filesToInject: string[];
injection: {
globals: {
_ENTRIES?: string;
AsyncLocalStorage?: string;
[key: string]: string | undefined;
};
entry?: string;
banner?: string;
};
bundler: {
defineVars: {
__CONFIG__?: string;
__BUILD_METADATA__?: string;
[key: string]: string | undefined;
};
plugins: (Plugin | WebpackPluginInstance)[];
};
}
/**
* Converts a JSON string to an AzionConfig object.
* @param {string} config - The JSON string to be converted.
* @returns {AzionConfig} The AzionConfig object.
* @throws {Error} Throws an error if the provided JSON string is invalid.
*
* @example
* const config = `{
* "origin": [
* {
* "name": "My Origin",
* "origin_type": "single_origin",
* "origin_path": '',
* "method": 'ip_hash',
* "addresses": [
* {
* "address": "origin.example.com",
* "weight": 100
* }
* ],
* }
* ]
*}`;
* const configObject = convertJsonConfigToObject(config);
* console.log(configObject);
*
*/
declare function convertJsonConfigToObject(config: string): AzionConfig;
/**
* Processes the provided configuration object and returns a JSON object that can be used to create or update an Azion CDN configuration.
* @param inputConfig AzionConfig
* @returns
*
* @example
* const config = {
* origin: [
* {
* name: 'My Origin',
* type: 'single_origin',
* addresses: [
* {
* address: 'origin.example.com',
* weight: 100,
* },
* ],
* protocolPolicy: 'https',
* },
* ],
* }
* const payloadCDN = processConfig(config);
* console.log(payloadCDN);
*/
declare function processConfig(inputConfig: AzionConfig): any;
/**
* Helper function to provide IntelliSense for Azion configuration.
* Similar to Vite's defineConfig - provides type safety without runtime overhead.
*
* @param {AzionConfig} config - The configuration object for the Azion Platform.
* @returns {AzionConfig} The same configuration object (no validation or processing)
*
* @example
* import { defineConfig } from 'azion/config';
*
* export default defineConfig({
* build: {
* preset: 'typescript',
* },
* domain: {
* name: 'example.com',
* },
* // ... other configurations
* });
*/
declare function defineConfig(config: AzionConfig): AzionConfig;
/**
* AzionDomainsResponse<T> is a generic type that represents the response of the Azion API.
* It can be either a success response with the data or an error response with the error message and operation.
*
* @param T The type of the data that the response contains.
* @returns An object with the data or an error message and operation.
*/
type AzionDomainsResponse<T> = {
data?: T;
error?: {
message: string;
operation: string;
};
};
/**
* ResponseState is a type that represents the state of the response of the Azion API.
* It can be either pending, executed or failed.
* @returns A string with the state of the response.
*/
type ResponseState = 'pending' | 'executed' | 'failed';
/**
* AzionDomain is a type that represents the domain object in the Azion API.
* @param state The state of the response.
* @param id The id of the domain.
* @param url The url of the domain.
* @param environment The environment of the domain.
* @param active The status of the domain.
* @param name The name of the domain.
* @param cnameAccessOnly The status of the domain.
* @param cnames The cnames of the domain.
* @param edgeApplicationId The id of the edge application.
* @param edgeFirewallId The id of the edge firewall.
* @param digitalCertificateId The id of the digital certificate.
* @param mtls The mtls object.
* @returns An object with the domain data.
*/
type AzionDomain = {
state?: ResponseState;
id?: number;
url?: string;
environment?: string;
active?: boolean;
name: string;
cnameAccessOnly?: boolean;
cnames?: string[];
edgeApplicationId?: number;
edgeFirewallId?: number;
digitalCertificateId?: string | number | null;
mtls?: {
verification: 'enforce' | 'permissive';
trustedCaCertificateId: number;
crlList?: number[];
};
};
/**
* AzionDomainCollection is a type that represents the domains object in the Azion API.
* @param state The state of the response.
* @param count The count of the domains.
* @param pages The number of pages.
* @param results The list of domains.
* @returns An object with the domains data.
*/
type AzionCreateDomain = Omit<AzionDomain, 'id' | 'environment' | 'active' | 'url' | 'state' | 'edgeApplicationId'> & {
edgeApplicationId: number;
};
/**
* AzionUpdateDomain is a type that represents the domain object in the Azion API.
* @param active The status of the domain.
* @param name The name of the domain.
* @param cnameAccessOnly The status of the domain.
* @param cnames The cnames of the domain.
* @param edgeApplicationId The id of the edge application.
* @param edgeFirewallId The id of the edge firewall.
* @param digitalCertificateId The id of the digital certificate.
* @param mtls The mtls object.
* @returns An object with the domain data.
*/
type AzionUpdateDomain = Omit<AzionDomain, 'id' | 'environment' | 'url' | 'edgeApplicationId' | 'state'> & {
edgeApplicationId: number;
};
/**
* AzionDeletedDomain is a type that represents the domain object in the Azion API.
* @param id The id of the domain.
* @param state The state of the response.
* @returns An object with the domain data.
*/
type AzionDeletedDomain = Pick<AzionDomain, 'id' | 'state'>;
/**
* AzionClientOptions is a type that represents the options of the Azion API client.
* @param debug The debug option.
* @param force The force option.
* @returns An object with the options of the client.
*/
type AzionClientOptions$3 = {
debug?: boolean | undefined;
force?: boolean | undefined;
};
/**
* AzionDomainCollection is a type that represents the domains object in the Azion API.
* @param state The state of the response.
* @param count The count of the domains.
* @param pages The number of pages.
* @param results The list of domains.
* @returns An object with the domains data.
*/
type AzionDomainCollection = {
state: ResponseState;
count: number;
pages: number;
results: AzionDomain[];
};
/**
* AzionDomainsClient is a type that represents the client of the Azion domains API.
* @param createDomain The function to create a domain.
* @param getDomains The function to get the domains.
* @param getDomain The function to get a domain.
* @param updateDomain The function to update a domain.
* @param deleteDomain The function to delete a domain.
* @returns An object with the client functions.
*/
interface AzionDomainsClient {
/**
* createDomain is a function that creates a domain in the Azion API.
* @param {AzionCreateDomain} domain The domain object.
* @param { AzionClientOptions } options The options of the client.
* @returns {Promise<AzionDomainsResponse<AzionDomain>>} The response of the API.
* @example
* const domain = {
* name: 'example.com',
* edgeApplicationId: 1,
* };
* const { data, error } = await client.createDomain(domain);
* if (error) {
* console.error(error.message);
* } else {
* console.log(data);
* }
*/
createDomain: (domain: AzionCreateDomain, options?: AzionClientOptions$3) => Promise<AzionDomainsResponse<AzionDomain>>;
/**
* getDomains is a function that gets the domains in the Azion API.
* @param {AzionClientOptions} options The options of the client.
* @param {{ orderBy?: 'id' | 'name'; page?: number; pageSize?: number; sort?: 'asc' | 'desc' }} queryParams The query parameters of the request.
* @returns {Promise<AzionDomainsResponse<AzionDomainCollection>>} The response of the API.
* @example
* const { data, error } = await client.getDomains();
* if (error) {
* console.error(error.message);
* } else {
* console.log(data.results);
* }
*/
getDomains: (options?: AzionClientOptions$3, queryParams?: {
orderBy?: 'id' | 'name';
page?: number;
pageSize?: number;
sort?: 'asc' | 'desc';
}) => Promise<AzionDomainsResponse<AzionDomainCollection>>;
/**
* getDomain is a function that gets a domain in the Azion API.
* @param {number} domainId The id of the domain.
* @param {AzionClientOptions} options The options of the client.
* @returns {Promise<AzionDomainsResponse<AzionDomain>>} The response of the API.
* @example
* const { data, error } = await client.getDomain(1);
* if (error) {
* console.error(error.message);
* } else {
* console.log(data);
* }
*/
getDomain: (domainId: number, options?: AzionClientOptions$3) => Promise<AzionDomainsResponse<AzionDomain>>;
/**
* updateDomain is a function that updates a domain in the Azion API.
* @param {number} domainId The id of the domain.
* @param {AzionUpdateDomain} domain The domain object.
* @param {AzionClientOptions} options The options of the client.
* @returns {Promise<AzionDomainsResponse<AzionDomain>>} The response of the API.
* @example
* const domain = {
* name: 'example.com',
* edgeApplicationId: 1,
* };
* const { data, error } = await client.updateDomain(1, domain);
* if (error) {
* console.error(error.message);
* } else {
* console.log(data);
* }
*/
updateDomain: (domainId: number, domain: AzionUpdateDomain, options?: AzionClientOptions$3) => Promise<AzionDomainsResponse<AzionDomain>>;
/**
* deleteDomain is a function that deletes a domain in the Azion API.
* @param {number} domainId The id of the domain.
* @param {AzionClientOptions} options The options of the client.
* @returns {Promise<AzionDomainsResponse<AzionDeletedDomain>>} The response of the API.
* @example
* const { data, error } = await client.deleteDomain(1);
* if (error) {
* console.error(error.message);
* } else {
* console.log(data.id);
* }
*/
deleteDomain: (domainId: number, options?: AzionClientOptions$3) => Promise<AzionDomainsResponse<AzionDeletedDomain>>;
}
/**
* Represents a message in the AI conversation.
*
* @property {('system' | 'user' | 'assistant')} role - The role of the message sender.
* @property {string} content - The content of the message.
*/
interface AzionAIMessage {
role: 'system' | 'user' | 'assistant';
content: string;
}
/**
* Configuration options for the Azion AI request.
*
* @property {string} [session_id] - Unique identifier for the session.
* @property {string} [url] - URL associated with the request.
* @property {string} [app] - Application identifier.
* @property {string} [user_name] - Name of the user.
* @property {string} [client_id] - Client identifier.
* @property {string} [system_prompt] - System-level prompt.
* @property {string} [user_prompt] - User-level prompt.
*/
interface AzionAIConfig {
session_id?: string;
url?: string;
app?: string;
user_name?: string;
client_id?: string;
system_prompt?: string;
user_prompt?: string;
}
/**
* Structure of an AI request to be sent to the Azion AI service.
*
* @property {AzionAIMessage[]} messages - Array of messages in the conversation.
* @property {AzionAIConfig} [azion] - Additional Azion-specific configuration.
* @property {boolean} [stream] - Whether to use streaming for the response.
*/
interface AzionAIRequest {
messages: AzionAIMessage[];
azion?: AzionAIConfig;
stream?: boolean;
}
/**
* Structure of the AI response received from the Azion AI service.
*
* @property {Object[]} choices - Array of response choices.
* @property {string} choices[].finish_reason - Reason for finishing the response.
* @property {number} choices[].index - Index of the choice.
* @property {Object} choices[].message - Message content and role.
* @property {string} choices[].message.content - Content of the message.
* @property {string} choices[].message.role - Role of the message sender.
* @property {null} choices[].logprobs - Log probabilities (null in this case).
* @property {number} created - Timestamp of when the response was created.
* @property {string} id - Unique identifier for the response.
* @property {string} model - Model used for generating the response.
* @property {string} object - Type of object returned.
* @property {Object} usage - Token usage statistics.
* @property {number} usage.completion_tokens - Number of tokens in the completion.
* @property {number} usage.prompt_tokens - Number of tokens in the prompt.
* @property {number} usage.total_tokens - Total number of tokens used.
* @property {Object} usage.completion_tokens_details - Detailed token usage for completion.
* @property {number} usage.completion_tokens_details.reasoning_tokens - Number of tokens used for reasoning.
*/
interface AzionAIResponse {
choices: {
finish_reason: string;
index: number;
message: {
content: string;
role: string;
};
logprobs: null;
}[];
created: number;
id: string;
model: string;
object: string;
usage: {
completion_tokens: number;
prompt_tokens: number;
total_tokens: number;
completion_tokens_details: {
reasoning_tokens: number;
};
};
}
/**
* Structure of a streaming AI response from the Azion AI service.
*
* @property {Object[]} choices - Array of response choices.
* @property {Object} choices[].delta - Delta of the response content.
* @property {string} [choices[].delta.content] - Content of the delta, if any.
* @property {string | null} choices[].finish_reason - Reason for finishing the response, if applicable.
* @property {number} choices[].index - Index of the choice.
* @property {null} choices[].logprobs - Log probabilities (null in this case).
* @property {number} created - Timestamp of when the response was created.
* @property {string} id - Unique identifier for the response.
* @property {string} model - Model used for generating the response.
* @property {string} object - Type of object returned.
* @property {string} system_fingerprint - Fingerprint of the system.
*/
interface AzionAIStreamResponse {
choices: {
delta: {
content?: string;
};
finish_reason: string | null;
index: number;
logprobs: null;
}[];
created: number;
id: string;
model: string;
object: string;
system_fingerprint: string;
}
/**
* Generic result type for Azion AI operations.
*
* @template T - The type of data expected in the result.
* @property {T | null} data - The data returned from the operation, if successful.
* @property {Error | null} error - The error object, if the operation failed.
*/
interface AzionAIResult<T> {
data: T | null;
error: Error | null;
}
/**
* Interface for the Azion AI client, providing methods to interact with the AI service.
*/
interface AzionAIClient {
/**
* Sends a chat request to the AI service.
*
* @param {AzionAIRequest} request - The chat request to be sent.
* @param {AzionClientOptions} [options] - Additional options for the request.
* @returns {Promise<AzionAIResult<AzionAIResponse>>} A promise that resolves to the chat result or an error.
*
* @example
* const result = await aiClient.chat({
* messages: [{ role: 'user', content: 'Hello, AI!' }]
* });
* if (result.data) {
* console.log('AI response:', result.data.choices[0].message.content);
* } else {
* console.error('Error:', result.error);
* }
*/
chat: (request: AzionAIRequest, options?: AzionClientOptions$2) => Promise<AzionAIResult<AzionAIResponse>>;
/**
* Sends a streaming chat request to the AI service.
*
* @param {AzionAIRequest} request - The chat request to be sent.
* @param {AzionClientOptions} [options] - Additional options for the request.
* @returns {AsyncGenerator<AzionAIResult<AzionAIStreamResponse>>} An async generator that produces partial chat results.
*
* @example
* const stream = aiClient.streamChat({
* messages: [{ role: 'user', content: 'Tell me a story' }]
* });
* for await (const chunk of stream) {
* if (chunk.data) {
* console.log('AI chunk:', chunk.data.choices[0].delta.content);
* } else {
* console.error('Error:', chunk.error);
* }
* }
*/
streamChat: (request: AzionAIRequest, options?: AzionClientOptions$2) => AsyncGenerator<AzionAIResult<AzionAIStreamResponse>>;
}
/**
* Options for configuring the Azion client behavior.
*
* @property {boolean} [debug] - Enable debug mode for detailed logging.
* @property {boolean} [force] - Force the operation even if it might be destructive.
*
* @example
* const options: AzionClientOptions = {
* debug: true,
* force: false
* };
*/
type AzionClientOptions$2 = {
debug?: boolean;
force?: boolean;
};
declare enum BrowserCacheSettings {
HONOR = "honor",
OVERRIDE = "override",
IGNORE = "ignore"
}
declare enum CdnCacheSettings {
HONOR = "honor",
OVERRIDE = "override"
}
declare enum CacheByQueryString {
IGNORE = "ignore",
WHITELIST = "whitelist",
BLACKLIST = "blacklist",
ALL = "all"
}
declare enum CacheByCookies {
IGNORE = "ignore",
WHITELIST = "whitelist",
BLACKLIST = "blacklist",
ALL = "all"
}
declare enum AdaptiveDeliveryAction {
IGNORE = "ignore",
OPTIMIZE = "optimize"
}
interface ApiBaseCacheSettingPayload {
name: string;
browser_cache_settings?: BrowserCacheSettings;
browser_cache_settings_maximum_ttl?: number;
cdn_cache_settings?: CdnCacheSettings;
cdn_cache_settings_maximum_ttl?: number;
cache_by_query_string?: CacheByQueryString;
query_string_fields?: string[];
enable_query_string_sort?: boolean;
cache_by_cookies?: CacheByCookies;
cookie_names?: string[];
adaptive_delivery_action?: AdaptiveDeliveryAction;
device_group?: string[];
enable_caching_for_post?: boolean;
l2_caching_enabled?: boolean;
is_slice_configuration_enabled?: boolean;
is_slice_edge_caching_enabled?: boolean;
is_slice_l2_caching_enabled?: boolean;
slice_configuration_range?: number;
enable_caching_for_options?: boolean;
enable_stale_cache?: boolean;
l2_region?: string | null;
}
interface ApiCreateCacheSettingPayload extends ApiBaseCacheSettingPayload {
}
interface ApiCacheSetting extends ApiBaseCacheSettingPayload {
id: number;
}
interface ApiListCacheSettingsParams {
page?: number;
page_size?: number;
sort?: 'name' | 'id';
order?: 'asc' | 'desc';
}
interface ApiUpdateCacheSettingPayload extends Partial<ApiBaseCacheSettingPayload> {
}
type AzionCacheSetting = ApiCacheSetting;
interface ApiBaseDeviceGroupPayload {
name: string;
user_agent: string;
}
interface ApiCreateDeviceGroupPayload extends ApiBaseDeviceGroupPayload {
}
interface ApiListDeviceGroupsParams {
page?: number;
page_size?: number;
sort?: 'name' | 'id';
order?: 'asc' | 'desc';
}
interface ApiUpdateDeviceGroupPayload extends Partial<ApiBaseDeviceGroupPayload> {
}
interface AzionDeviceGroup {
id: number;
name: string;
user_agent: string;
}
interface ApiBaseFunctionInstancePayload {
name: string;
code: string;
language: 'JavaScript';
initiator_type: 'edge_application' | 'edge_firewall';
active: boolean;
json_args: Record<string, unknown>;
}
interface ApiCreateFunctionInstancePayload {
name: string;
edge_function_id: number;
args: Record<string, unknown>;
}
interface ApiFunctionInstance extends ApiBaseFunctionInstancePayload {
id: number;
}
interface ApiListFunctionInstancesParams {
page?: number;
page_size?: number;
sort?: 'name' | 'id';
order?: 'asc' | 'desc';
order_by?: string;
filter?: string;
}
interface ApiUpdateFunctionInstancePayload extends Partial<ApiBaseFunctionInstancePayload> {
}
type AzionFunctionInstance = ApiFunctionInstance;
declare enum DeliveryProtocol {
HTTP = "http",
HTTPS = "https",
HTTP_HTTPS = "http,https"
}
declare enum HttpPort {
PORT_80 = 80,
PORT_8008 = 8008,
PORT_8080 = 8080
}
declare enum HttpsPort {
PORT_443 = 443,
PORT_8443 = 8443,
PORT_9440 = 9440,
PORT_9441 = 9441,
PORT_9442 = 9442,
PORT_9443 = 9443
}
declare enum TlsVersion {
TLS_1_0 = "tls_1_0",
TLS_1_1 = "tls_1_1",
TLS_1_2 = "tls_1_2",
TLS_1_3 = "tls_1_3"
}
declare enum SupportedCiphers {
ALL = "all",
TLSv1_2_2018 = "TLSv1.2_2018",
TLSv1_2_2019 = "TLSv1.2_2019",
TLSv1_2_2021 = "TLSv1.2_2021",
TLSv1_3_2022 = "TLSv1.3_2022"
}
interface ApiBaseApplicationPayload {
name: string;
delivery_protocol?: DeliveryProtocol;
http3?: boolean;
http_port?: HttpPort[];
https_port?: HttpsPort[];
minimum_tls_version?: TlsVersion;
active?: boolean;
debug_rules?: boolean;
application_acceleration?: boolean;
caching?: boolean;
device_detection?: boolean;
edge_firewall?: boolean;
edge_functions?: boolean;
image_optimization?: boolean;
l2_caching?: boolean;
load_balancer?: boolean;
raw_logs?: boolean;
web_application_firewall?: boolean;
supported_ciphers?: SupportedCiphers;
}
interface ApiCreateApplicationPayload extends ApiBaseApplicationPayload {
}
interface ApiApplication extends ApiBaseApplicationPayload {
id: number;
}
interface ApiUpdateApplicationPayload extends Partial<ApiBaseApplicationPayload> {
}
interface ApiListOriginsParams {
page?: number;
page_size?: number;
sort?: 'name' | 'id';
order?: OrderDirection;
filter?: string;
}
declare enum OrderDirection {
ASC = "asc",
DESC = "desc"
}
declare enum OriginType {
SINGLE_ORIGIN = "single_origin",
LOAD_BALANCER = "load_balancer"
}
declare enum OriginProtocolPolicy {
PRESERVE = "preserve",
HTTP = "http",
HTTPS = "https"
}
declare enum ServerRole {
PRIMARY = "primary",
BACKUP = "backup"
}
interface Address {
address: string;
weight?: number | null;
server_role?: ServerRole;
is_active?: boolean;
}
interface ApiOrigin {
id: number;
origin_key: string;
name: string;
origin_type: OriginType;
addresses: Address[];
origin_protocol_policy: OriginProtocolPolicy;
is_origin_redirection_enabled: boolean;
host_header: string;
method: string;
origin_path: string;
connection_timeout: number;
timeout_between_bytes: number;
hmac_authentication: boolean;
hmac_region_name: string;
hmac_access_key: string;
hmac_secret_key: string;
}
type ApiCreateOriginPayload = Omit<ApiOrigin, 'id' | 'method'> & {
origin_path?: string;
hmac_authentication?: boolean;
hmac_region_name?: string;
hmac_access_key?: string;
hmac_secret_key?: string;
connection_timeout?: number;
timeout_between_bytes?: number;
};
type ApiUpdateOriginRequest = Partial<ApiCreateOriginPayload> & {
id: number;
};
type AzionOrigin = ApiOrigin;
interface Rule {
id: number;
name: string;
phase: 'request' | 'response';
behaviors: Behavior[];
criteria: Criterion[][];
is_active: boolean;
order: number;
description?: string;
}
interface Rule {
id: number;
name: string;
phase: 'request' | 'response';
behaviors: Behavior[];
criteria: Criterion[][];
is_active: boolean;
order: number;
description?: string;
}
interface Behavior {
name: string;
target?: string | null | BehaviorTarget;
}
interface Behavior {
name: string;
target?: string | null | BehaviorTarget;
}
interface BehaviorTarget {
captured_array: string;
subject: string;
regex: string;
}
interface BehaviorTarget {
captured_array: string;
subject: string;
regex: string;
}
interface Criterion {
variable: string;
operator: string;
conditional: 'if' | 'and' | 'or';
input_value: string;
}
interface Criterion {
variable: string;
operator: string;
conditional: 'if' | 'and' | 'or';
input_value: string;
}
interface ApiCreateRulePayload {
name: string;
phase: 'request' | 'response';
behaviors: Behavior[];
criteria: Criterion[][];
is_active?: boolean;
order?: number;
description?: string;
}
interface ApiCreateRulePayload {
name: string;
phase: 'request' | 'response';
behaviors: Behavior[];
criteria: Criterion[][];
is_active?: boolean;
order?: number;
description?: string;
}
interface ApiUpdateRulePayload extends Partial<ApiCreateRulePayload> {
}
interface ApiUpdateRulePayload extends Partial<ApiCreateRulePayload> {
}
interface ApiRuleResponse {
results: Rule;
schema_version: number;
}
interface ApiRuleResponse {
results: Rule;
schema_version: number;
}
interface ApiListRulesParams {
page?: number;
page_size?: number;
sort?: string;
order?: 'asc' | 'desc';
filter?: string;
}
interface ApiListRulesParams {
page?: number;
page_size?: number;
sort?: string;
order?: 'asc' | 'desc';
filter?: string;
}
interface ApiListRulesParams {
page?: number;
page_size?: number;
sort?: string;
order?: 'asc' | 'desc';
filter?: string;
}
type AzionRule = ApiRuleResponse['results'];
/**
* @fileoverview This module defines the types and interfaces used throughout the Azion Application SDK.
* It includes definitions for client options, response structures, and operation interfaces for various
* Azion Edge Application features such as cache settings, origins, rules, device groups, and functions.
* @module application/types
*/
/**
* Options for configuring the Azion client behavior.
*
* @interface AzionClientOptions
* @property {boolean} [debug] - Enable debug mode for detailed logging.
* @property {boolean} [force] - Force the operation even if it might be destructive.
*/
interface AzionClientOptions$1 {
debug?: boolean;
force?: boolean;
}
/**
* Options for retrieving a collection of Azion applications.
*
* @interface AzionApplicationCollectionOptions
* @property {number} [page] - The page number for pagination.
* @property {number} [page_size] - The number of items per page.
* @property {'name' | 'id'} [sort] - The field to sort the results by.
* @property {string} [order_by] - The order of the sorting (e.g., 'asc' or 'desc').
*/
interface AzionApplicationCollectionOptions {
page?: number;
page_size?: number;
sort?: 'name' | 'id';
order_by?: string;
}
/**
* Generic response structure for Azion API calls.
*
* @interface AzionApplicationResponse
* @template T - The type of data returned in the response.
* @property {T} [data] - The response data.
* @property {{ message: string; operation: string }} [error] - Error information if the call failed.
*/
interface AzionApplicationResponse<T> {
data?: T;
error?: {
message: string;
operation: string;
};
}
/**
* Generic response structure for Azion API calls returning collections.
*
* @interface AzionApplicationCollectionResponse
* @template T - The type of items in the collection.
* @property {{ count: number; total_pages: number; schema_version: number; links: { previous: string | null; next: string | null }; results: T[] }} [data] - The collection data.
* @property {{ message: string; operation: string }} [error] - Error information if the call failed.
*/
interface AzionApplicationCollectionResponse<T> {
data?: {
count: number;
total_pages: number;
schema_version: number;
links: {
previous: string | null;
next: string | null;
};
results: T[];
};
error?: {
message: string;
operation: string;
};
}
/**
* Interface for cache setting operations.
*
* @interface CacheOperations
*/
interface CacheOperations {
/**
* Creates a new cache setting.
*
* @function
* @name CacheOperations.createCacheSetting
* @param {Object} params - The parameters for creating a cache setting.
* @param {ApiCreateCacheSettingPayload} params.data - The data for the new cache setting.
* @returns {Promise<AzionApplicationResponse<AzionCacheSetting>>} A promise that resolves with the created cache setting data or an error.
*
* @example
* const { error, data } = await cacheOperations.createCacheSetting({
* data: {
* name: 'My Cache Setting',
* browser_cache_settings: 'override',
* cdn_cache_settings: 'override',
* cache_by_query_string: 'ignore',
* cookie_names: ['session_id'],
* enable_stale_cache: true
* },
* options: { debug: true }
* });
* if (error) {
* console.error('Error:', error);
* } else {
* console.log('Created cache setting:', data);
* }
*/
createCacheSetting: (params: {
data: ApiCreateCacheSettingPayload;
options?: AzionClientOptions$1;
}) => Promise<AzionApplicationResponse<AzionCacheSetting>>;
/**
* Retrieves a specific cache setting.
*
* @function
* @name CacheOperations.getCacheSetting
* @param {Object} params - The parameters for retrieving a cache setting.
* @param {number} params.cacheSettingId - The ID of the cache setting to retrieve.
* @returns {Promise<AzionApplicationResponse<AzionCacheSetting>>} A promise that resolves with the cache setting data or an error.
*
* @example
* const { error, data } = await cacheOperations.getCacheSetting({
* cacheSettingId: 123,
* options: { debug: true }
* });
* if (error) {
* console.error('Error:', error);
* } else {
* console.log('Retrieved cache setting:', data);
* }
*/
getCacheSetting: (params: {
cacheSettingId: number;
options?: AzionClientOptions$1;
}) => Promise<AzionApplicationResponse<AzionCacheSetting>>;
/**
* Retrieves a list of cache settings.
*
* @function
* @name CacheOperations.getCacheSettings
* @param {Object} params - The parameters for retrieving cache settings.
* @param {ApiListCacheSettingsParams} [params.params] - Optional parameters for filtering and pagination.
* @returns {Promise<AzionApplicationCollectionResponse<AzionCacheSetting>>} A promise that resolves with a collection of cache settings or an error.
*
* @example
* const { error, data } = await cacheOperations.getCacheSettings({
* params: { page: 1, page_size: 20 },
* options: { debug: true }
* });
* if (error) {
* console.error('Error:', error);
* } else {
* console.log('Retrieved cache settings:', data.results);
* }
*/
getCacheSettings: (params: {
params?: ApiListCacheSettingsParams;
options?: AzionClientOptions$1;
}) => Promise<AzionApplicationCollectionResponse<AzionCacheSetting>>;
/**
* Updates an existing cache setting.
*
* @function
* @name CacheOperations.up